className: bIsConstructibleWithSettingsAndArgs

code: static bIsConstructibleWithSettingsAndArgs = FConstructorTraits::bIsConstructibleWithSettingsAndArgs;


className: bIsDefaultConstructible

module: MetasoundGraphCore

code: static bIsDefaultConstructible = FConstructorTraits::bIsDefaultConstructible;


className: FConstructorTraits

description: Constructor traits for this arg type.

code: typedef TDataTypeConstructorTraits< DataType, ArgType > FConstructorTraits


description: Specialization for single arg. This terminates the variadic parameter unpacking by excluding the recursive declaration of TDataTypeVariantConstructorTraits<>

code: template<typename [DataType](API\Plugins\OptimusCore\DataType), typename ArgType> struct TDataTypeVariantConstructorTraits< DataType, ArgType >


className: bIsConstructibleWithThisArg

code: static constexpr bool bIsConstructibleWithThisArg = std::is_constructible<DataType, ThisArgType>::value;


className: bIsConstructibleWithSettingsAndThisArg

code: static constexpr bool bIsConstructibleWithSettingsAndThisArg = std::is_constructible<DataType, const FOperatorSettings&, ThisArgType>::value;


className: bIsConstructibleWithArgs

description: True if the DataType is default constructible or constructible with any of the variant types.

code: static constexpr bool bIsConstructibleWithArgs = bIsConstructibleWithThisArg || TDataTypeVariantFallbackHelper<DataType, VariantArgTypes...>::bIsConstructibleWithArgs;


code: static constexpr bool bIsConstructibleWithSettingsAndArgs = bIsConstructibleWithSettingsAndThisArg || TDataTypeVariantFallbackHelper<DataType, VariantArgTypes...>::bIsConstructibleWithSettingsAndArgs;


className: bIsConstructibleWithFallbackArg

description: True if the constructor accepts the fallback type.

code: static constexpr bool bIsConstructibleWithFallbackArg = FVariantPromoter::bIsValidType;


className: bPromotThisArgType

code: static constexpr bool bPromotThisArgType = bIsConstructibleWithThisArg || bIsConstructibleWithSettingsAndThisArg;


className: FallbackType

description: Fallback type to use if there is no other way to construct the object.


className: FVariantPromoter

code: typedef [TTypePromoter](API\Plugins\MetasoundGraphCore\TTypePromoter)< bPromotThisArgType, ThisArgType, typename [TDataTypeVariantFallbackHelper](API\Plugins\MetasoundGraphCore\TDataTypeVariantFallbackHelper)< [DataType](API\Plugins\OptimusCore\DataType), VariantArgTypes... >::[FallbackType](API\Plugins\MetasoundGraphCore\TDataTypeVariantFallbackHelper\FallbackType) > FVariantPromoter


className: TDataTypeVariantFallbackHelper

description: TDataTypeVariantFallbackHelper< DataType, ThisArgType >

code: template<typename [DataType](API\Plugins\OptimusCore\DataType), typename ThisArgType, typename... VariantArgTypes> struct TDataTypeVariantFallbackHelper


className: ArgElementType

code: typedef typename [TElementType](API\Plugins\MetasoundGraphCore\TElementType)< DesiredArgType >::Type ArgElementType


className: ArgType

code: typedef DesiredArgType ArgType


className: bCanCreateArrayElementsWithArg

description: Determine which elementwise construction methods are supported.

code: static constexpr bool bCanCreateArrayElementsWithArg = FDesiredConstructorTraits::bIsArrayConstructibleWithArgs || FDesiredConstructorTraits::bIsArrayConstructibleWithSettingsAndArgs;


className: bCanCreateArrayElementsWithSettings

code: static constexpr bool bCanCreateArrayElementsWithSettings = FDesiredConstructorTraits::bIsArrayConstructibleWithSettings;


className: bCanCreateWithArg

description: Determine which construction methods are supported.

code: static constexpr bool bCanCreateWithArg = FDesiredConstructorTraits::bIsConstructibleWithArgs || FDesiredConstructorTraits::bIsConstructibleWithSettingsAndArgs;


className: bCanCreateWithFallbackArg

code: static constexpr bool bCanCreateWithFallbackArg = FFallbackHelper::bIsConstructibleWithFallbackArg;


className: bCanCreateWithoutArg

code: static constexpr bool bCanCreateWithoutArg = FDesiredConstructorTraits::bIsConstructibleWithSettings || FDesiredConstructorTraits::bIsDefaultConstructible;


className: bCannotForwardToConstructor

code: static constexpr bool bCannotForwardToConstructor = !(bCanCreateWithArg || bCanCreateWithoutArg || bCanCreateWithFallbackArg || bCanCreateArrayElementsWithArg || bCanCreateArrayElementsWithDefaultConstructor);


className: bCreateArrayElementsWithSettings

code: static constexpr bool bCreateArrayElementsWithSettings = !(bCanCreateArrayElementsWithArg) && bCanCreateArrayElementsWithSettings;


code: static constexpr bool bCreateArrayElementsWithDefaultConstructor = !(bCanCreateArrayElementsWithArg || bCreateArrayElementsWithSettings) && bCanCreateArrayElementsWithDefaultConstructor;


code: static constexpr bool bCanCreateArrayElementsWithDefaultConstructor = FDesiredConstructorTraits::bIsArrayDefaultConstructible;


className: bCreateWithArg

code: static constexpr bool bCreateWithArg = !(bCreateArrayElementsWithArg || bCreateArrayElementsWithSettings || bCreateArrayElementsWithDefaultConstructor) && bCanCreateWithArg;


className: bCreateWithFallbackArg

code: static constexpr bool bCreateWithFallbackArg = !(bCreateArrayElementsWithArg || bCreateArrayElementsWithSettings || bCreateArrayElementsWithDefaultConstructor || bCreateWithArg || bCreateWithoutArg) && bCanCreateWithFallbackArg;


className: bCreateWithoutArg

code: static constexpr bool bCreateWithoutArg = !(bCreateArrayElementsWithArg || bCreateArrayElementsWithSettings || bCreateArrayElementsWithDefaultConstructor || bCreateWithArg) && bCanCreateWithoutArg;


className: ElementType

description: Determine types.

code: typedef typename [TElementType](API\Plugins\MetasoundGraphCore\TElementType)< [DataType](API\Plugins\OptimusCore\DataType) >::Type ElementType


className: bCreateArrayElementsWithArg

description: Determine which construction method to use.

code: static constexpr bool bCreateArrayElementsWithArg = bCanCreateArrayElementsWithArg;


className: FDesiredConstructorTraits

code: typedef [TDataTypeConstructorTraits](API\Plugins\MetasoundGraphCore\TDataTypeConstructorTraits)< [DataType](API\Plugins\OptimusCore\DataType), DesiredArgType > FDesiredConstructorTraits


className: FFallbackHelper

code: typedef [TDataTypeVariantFallbackHelper](API\Plugins\MetasoundGraphCore\TDataTypeVariantFallbackHelper)< [DataType](API\Plugins\OptimusCore\DataType), FirstVariantType, AdditionalVariantTypes... > FFallbackHelper


className: TDataTypeVariantParsing

description: TDataTypeVariantParsinginforms theTDataVariantFactoryInternalon which factory method to instantiate.

code: template<typename [DataType](API\Plugins\OptimusCore\DataType), typename DesiredArgType, typename FirstVariantType, typename... AdditionalVariantTypes> struct TDataTypeVariantParsing


description: Create a clone of this parameter reference.

code: virtual [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [IDataReference](API\Plugins\MetasoundGraphCore\IDataReference) > Clone() const


description: This should be used to construct a new DataType object and return thisTDataValueReferenceas a wrapper around it.

code: template<typename... ArgTypes> static [TDataValueReference](API\Plugins\MetasoundGraphCore\TDataValueReference)< [DataType](API\Plugins\OptimusCore\DataType) > CreateNew ( ArgTypes &&... Args )


code: const [DataType](API\Plugins\OptimusCore\DataType) * Get() const


description: Const access to the underlying parameter object.

code: const [DataType](API\Plugins\OptimusCore\DataType) * operator->() const


className: TDataValueReference::operator TDataReadReference< DataType >

description: Implicit conversion to a readable parameter.

code: operator TDataReadReference< DataType >() const


description: Enable assignment operator.

code: [TDataValueReference](API\Plugins\MetasoundGraphCore\TDataValueReference)< [DataType](API\Plugins\OptimusCore\DataType) > & operator= ( const [TDataValueReference](API\Plugins\MetasoundGraphCore\TDataValueReference)< [DataType](API\Plugins\OptimusCore\DataType) > & Other )


description: Enable move operator.

code: [TDataValueReference](API\Plugins\MetasoundGraphCore\TDataValueReference)< [DataType](API\Plugins\OptimusCore\DataType) > & operator= ( [TDataValueReference](API\Plugins\MetasoundGraphCore\TDataValueReference)< [DataType](API\Plugins\OptimusCore\DataType) > && Other )


code: const [DataType](API\Plugins\OptimusCore\DataType) & operator*() const


description: Constructor taking data reference. Used for casting.

code: TDataValueReference &40; const TDataReference< DataType > & InRef &41;


description: Enable move constructor

code: TDataValueReference ( [TDataValueReference](API\Plugins\MetasoundGraphCore\TDataValueReference)< [DataType](API\Plugins\OptimusCore\DataType) > && Other )


description: Enable copy constructor

code: TDataValueReference ( const [TDataValueReference](API\Plugins\MetasoundGraphCore\TDataValueReference)< [DataType](API\Plugins\OptimusCore\DataType) > & Other )


description: Construct operator with no arguments if the DataType has a default constructor.

code: template<typename... ArgTypes> TDataValueReference &40; EDataRefShouldConstruct InToken, ArgTypes &&... Args &41;


className: TDataValueReference

description: TDataValueReferencerepresents a constant value and provides read only access. ATDataValueReferencecan never change value.

code: template<typename DataType> class TDataValueReference : public [Metasound::TDataReference< DataType >](API\Plugins\MetasoundGraphCore\TDataReference)


className: TDataValueReferenceFactory

description: TDataValueReferenceFactoryprovides several factory methods for forwarding arguments from the factory method to the DataType constructor. SeeTDataFactoryfor more information on the provided factory methods.

code: template<typename [DataType](API\Plugins\OptimusCore\DataType)> struct TDataValueReferenceFactory : public [Metasound::TDataFactory< DataType, TDataValueReference< DataType > >](API\Plugins\MetasoundGraphCore\TDataFactory)


description: Note: In this implementation, all arguments are forwarded to CreatorType::CreateNew(...) and theTVariantis parsed as the `VariantType_.FOperatorSettingsare forwarded to CreatorType::CreateNew(...) if it is supported.

code: template<typename VariantParseType, typename VariantType, typename std::enable_if< VariantParseType::bCreateWithArg, int >::type> static auto CreateNewFromVariant ( const [FOperatorSettings](API\Plugins\MetasoundGraphCore\FOperatorSettings) & InSettings, const VariantType & InVariant )


className: TDataValueReferenceLiteralFactory

description: TDataValueReferenceLiteralFactoryprovides several factory methods for forwarding arguments from the factory method to the DataType constructor. SeeTDataFactoryfor more information on the provided factory methods.

code: template<typename [DataType](API\Plugins\OptimusCore\DataType)> struct TDataValueReferenceLiteralFactory : public [Metasound::TDataLiteralFactory< DataType, TDataValueReference< DataType > >](API\Plugins\MetasoundGraphCore\TDataLiteralFactory)


description: Note: In this implementation, the InVariant object is ignored.FOperatorSettingsare forwarded to CreatorType::CreateNew(...) if it is supported.

code: template<typename VariantParseType, typename VariantType, typename std::enable_if< VariantParseType::bCreateWithoutArg, int >::type> static auto CreateNewFromVariant ( const [FOperatorSettings](API\Plugins\MetasoundGraphCore\FOperatorSettings) & InSettings, const VariantType & InVariant )


description: Note: In this implementation, the InVariant object is an array of args where each array element is the constructor args for one resulting array element. Constructor args are forwarded to the element data type and the resulting object is placed in the output array.

code: template<typename VariantParseType, typename VariantType, typename std::enable_if< VariantParseType::bCreateArrayElementsWithArg, int >::type> static auto CreateNewFromVariant ( const [FOperatorSettings](API\Plugins\MetasoundGraphCore\FOperatorSettings) & InSettings, const VariantType & InVariant )


description: Note: In this implementation, the InVariant object is an array ofFLiteral::FNonewhere each array element simply denotes that a corresponding element should be constructed withFOperatorSettings.

code: template<typename VariantParseType, typename VariantType, typename std::enable_if< VariantParseType::bCreateArrayElementsWithSettings, int >::type> static auto CreateNewFromVariant ( const [FOperatorSettings](API\Plugins\MetasoundGraphCore\FOperatorSettings) & InSettings, const VariantType & InVariant )


description: Note: In this implementation, the InVariant object is an array ofFLiteral::FNonewhere each array element simply denotes that a corresponding element should be default constructed.

code: template<typename VariantParseType, typename VariantType, typename std::enable_if< VariantParseType::bCreateArrayElementsWithDefaultConstructor, int >::type> static auto CreateNewFromVariant ( const [FOperatorSettings](API\Plugins\MetasoundGraphCore\FOperatorSettings) & InSettings, const VariantType & InVariant )


description: Note: In this implementation, theTVariantis parsed as a fallback type.FOperatorSettingsare forwarded to CreatorType::CreateNew(...) if it is supported.

code: template<typename VariantParseType, typename VariantType, typename std::enable_if< VariantParseType::bCreateWithFallbackArg, int >::type> static auto CreateNewFromVariant ( const [FOperatorSettings](API\Plugins\MetasoundGraphCore\FOperatorSettings) & InSettings, const VariantType & InVariant )


description: Note: In this implementation signals a static error as not possible ways to construct that underlying object could be found.

code: template<typename VariantParseType, typename VariantType, typename std::enable_if< VariantParseType::bCannotForwardToConstructor, int >::type> static auto CreateNewFromVariant ( const [FOperatorSettings](API\Plugins\MetasoundGraphCore\FOperatorSettings) & InSettings, const VariantType & InVariant )


className: FInternalFactory

code: typedef [TDataFactoryInternal](API\Plugins\MetasoundGraphCore\TDataFactoryInternal)< [DataType](API\Plugins\OptimusCore\DataType), CreatorType > FInternalFactory


className: TDataVariantFactoryInternal

description: TDataVariantFactoryInternalprovides a unified interface for constructing objects using aFOperatorSettingsandTVariantarguments. The VariantParseType uses SFINAE to choose how to interpret theTVariantargument.

code: template<typename [DataType](API\Plugins\OptimusCore\DataType), typename CreatorType> struct TDataVariantFactoryInternal


description: Create a clone of this parameter reference.

code: virtual [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [IDataReference](API\Plugins\MetasoundGraphCore\IDataReference) > Clone() const


description: Non-const access to the underlying parameter object.

code: [DataType](API\Plugins\OptimusCore\DataType) * Get() const


description: This should be used to construct a new DataType object and return thisTDataWriteReferenceas a wrapper around it.

code: template<typename... ArgTypes> static [TDataWriteReference](API\Plugins\MetasoundGraphCore\TDataWriteReference)< [DataType](API\Plugins\OptimusCore\DataType) > CreateNew ( ArgTypes &&... Args )


code: [DataType](API\Plugins\OptimusCore\DataType) * operator->() const


className: TDataWriteReference::operator TDataReadReference< DataType >

description: Implicit conversion to a readable parameter.

code: operator TDataReadReference< DataType >() const


description: Enable assignment operator.

code: [TDataWriteReference](API\Plugins\MetasoundGraphCore\TDataWriteReference)< [DataType](API\Plugins\OptimusCore\DataType) > & operator= ( const [TDataWriteReference](API\Plugins\MetasoundGraphCore\TDataWriteReference)< [DataType](API\Plugins\OptimusCore\DataType) > & Other )


description: Enable move operator.

code: [TDataWriteReference](API\Plugins\MetasoundGraphCore\TDataWriteReference)< [DataType](API\Plugins\OptimusCore\DataType) > & operator= ( [TDataWriteReference](API\Plugins\MetasoundGraphCore\TDataWriteReference)< [DataType](API\Plugins\OptimusCore\DataType) > && Other )


code: [DataType](API\Plugins\OptimusCore\DataType) & operator*() const


description: Create a writable ref from a blank parameter ref. Should be done with care and understanding of side-effects of converting a ref to a writable ref.

code: TDataWriteReference &40; const TDataReference< DataType > & InDataReference &41;


description: Enable copy constructor

code: TDataWriteReference ( const [TDataWriteReference](API\Plugins\MetasoundGraphCore\TDataWriteReference)< [DataType](API\Plugins\OptimusCore\DataType) > & Other )


description: Enable move constructor

code: TDataWriteReference ( [TDataWriteReference](API\Plugins\MetasoundGraphCore\TDataWriteReference)< [DataType](API\Plugins\OptimusCore\DataType) > && Other )


description: Construct operator with no arguments if the DataType has a default constructor.

code: template<typename... ArgTypes> TDataWriteReference &40; EDataRefShouldConstruct InToken, ArgTypes &&... Args &41;


className: TDataWriteReference

description: TDataWriteReferenceprovides write access to a shared parameter reference.

code: template<typename DataType> class TDataWriteReference : public [Metasound::TDataReference< DataType >](API\Plugins\MetasoundGraphCore\TDataReference)


className: TDataWriteReferenceFactory

description: TDataWriteReferenceFactoryprovides several factory methods for forwarding arguments from the factory method to the DataType constructor. SeeTDataFactoryfor more information on the provided factory methods.

code: template<typename [DataType](API\Plugins\OptimusCore\DataType)> struct TDataWriteReferenceFactory : public [Metasound::TDataFactory< DataType, TDataWriteReference< DataType > >](API\Plugins\MetasoundGraphCore\TDataFactory)


className: TDataWriteReferenceLiteralFactory

description: TDataWriteReferenceLiteralFactoryprovides several factory methods for forwarding arguments from the factory method to the DataType constructor. SeeTDataFactoryfor more information on the provided factory methods.

code: template<typename [DataType](API\Plugins\OptimusCore\DataType)> struct TDataWriteReferenceLiteralFactory : public [Metasound::TDataLiteralFactory< DataType, TDataWriteReference< DataType > >](API\Plugins\MetasoundGraphCore\TDataLiteralFactory)


className: Type

code: typedef VarType Type


className: TElementType

description: TElementTypedetermines the element type of a container.

code: template<typename ContainterType> struct TElementType


className: TEnvironmentVariableTypeInfo

code: template<typename VarType> struct TEnvironmentVariableTypeInfo


className: TypePtr

code: static TypePtr;


className: TEnvironmentVariableTypeInfo< bool >

code: template<> struct TEnvironmentVariableTypeInfo< bool >


code: typedef double Type


className: TEnvironmentVariableTypeInfo< double >

code: template<> struct TEnvironmentVariableTypeInfo< double >


code: typedef float Type


className: TEnvironmentVariableTypeInfo< float >

code: template<> struct TEnvironmentVariableTypeInfo< float >


code: typedef FName Type


className: TEnvironmentVariableTypeInfo< FName >

code: template<> struct TEnvironmentVariableTypeInfo< FName >


code: typedef FString Type


className: TEnvironmentVariableTypeInfo< FString >

code: template<> struct TEnvironmentVariableTypeInfo< FString >


code: typedef int16 Type


className: TEnvironmentVariableTypeInfo< int16 >

code: template<> struct TEnvironmentVariableTypeInfo< int16 >


code: typedef int32 Type


className: TEnvironmentVariableTypeInfo< int32 >

code: template<> struct TEnvironmentVariableTypeInfo< int32 >


code: typedef int64 Type


className: TEnvironmentVariableTypeInfo< int8 >

code: template<> struct TEnvironmentVariableTypeInfo< int8 >


code: typedef uint16 Type


code: static TypePtr;


className: TEnvironmentVariableTypeInfo< int64 >

code: template<> struct TEnvironmentVariableTypeInfo< int64 >


className: TEnvironmentVariableTypeInfo< uint16 >

code: template<> struct TEnvironmentVariableTypeInfo< uint16 >


code: typedef uint32 Type


className: TEnvironmentVariableTypeInfo< uint32 >

code: template<> struct TEnvironmentVariableTypeInfo< uint32 >


code: typedef uint64 Type


className: TEnvironmentVariableTypeInfo< uint64 >

code: template<> struct TEnvironmentVariableTypeInfo< uint64 >


code: typedef uint8 Type


className: TEnvironmentVariableTypeInfo< uint8 >

code: template<> struct TEnvironmentVariableTypeInfo< uint8 >


className: TEnvironmentVariableTypeInfo< void >

description: Declare basic set of variable types.

code: template<> struct TEnvironmentVariableTypeInfo< void >


className: bIsExecutable

code: static constexpr bool bIsExecutable = false;


code: static void Execute ( const [DataType](API\Plugins\OptimusCore\DataType) & InData, const [DataType](API\Plugins\OptimusCore\DataType) & OutData )


code: static void ExecuteInline ( [DataType](API\Plugins\OptimusCore\DataType) & InData, bool bInUpdated )


className: TExecutableDataType

description: As a general rule, ExecutableDataTypes should be avoided whenever possible as they incur an undesired cost and are generally not typically necessary. This is primarily for the special case of trigger types, where state management cannot be avoided (or rather an avoidable design has yet to be formulated).

code: template<class [DataType](API\Plugins\OptimusCore\DataType)> struct TExecutableDataType


description: nullptr return values are valid and signal anIOperatorwhich does not need to be executed.


description: nullptr return values are valid and signal anIOperatorwhich does not need to be post executed.


description: nullptr return values are valid and signal anIOperatorwhich does not need to be reset.


className: TExecutableOperator

description:
Derived classes should inherit from this template class as well as implement a voidExecute()member function. class MyOperator : public TExecutableOperator{
  public:
  ...
  void Execute()
  {
  ...
  }
};

code: template<class DerivedOperatorType> class TExecutableOperator : public [Metasound::IOperator](API\Plugins\MetasoundGraphCore\IOperator)


code: virtual ~TExecutableOperator()


className: bCannotForwardToConstructor

code: static constexpr bool bCannotForwardToConstructor = !(bForwardSettingsAndArgs || bForwardArgs || bForwardSettings || bForwardNone);


className: bForwardArgs

code: static constexpr bool bForwardArgs = !bForwardSettingsAndArgs && TConstructorTraits::bIsConstructibleWithArgs;


className: bForwardNone

code: static constexpr bool bForwardNone = false;


className: bForwardSettingsAndArgs

code: static constexpr bool bForwardSettingsAndArgs = TConstructorTraits::bIsConstructibleWithSettingsAndArgs;


className: bForwardSettings

code: static constexpr bool bForwardSettings = false;


className: TConstructorTraits

code: typedef [TDataTypeConstructorTraits](API\Plugins\MetasoundGraphCore\TDataTypeConstructorTraits)< [DataType](API\Plugins\OptimusCore\DataType), ArgTypes... > TConstructorTraits


className: TExplicitArgsConstructorForwarding

description: Denotes that parameter pack arguments must be used in the constructor of theMetasoundData Type. The use of theFOperatorSettingsis optional.

code: template<typename [DataType](API\Plugins\OptimusCore\DataType), typename... ArgTypes> struct TExplicitArgsConstructorForwarding


code: static constexpr bool bForwardArgs = false;


className: TExplicitConstructorForwarding

description: Denotes that bothFOperatorSettingsand parameter pack arguments must be used in the constructor of theMetasoundData Type.

code: template<typename [DataType](API\Plugins\OptimusCore\DataType), typename... ArgTypes> struct TExplicitConstructorForwarding


code: static [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [IOperator](API\Plugins\MetasoundGraphCore\IOperator) > > CreateOperator ( const [FCreateOperatorParams](API\Plugins\MetasoundGraphCore\FCreateOperatorParams) & InParams, [FBuildErrorArray](API\Plugins\MetasoundGraphCore\FBuildErrorArray) & OutErrors )


description: Require staticTUniquePtrOperatorType::CreateOperator(const FCreateOperatorParams&, TArray>&) exists. Require static constFNodeClassMetadata& OperatorType::GetNodeInfo() exists.

code: static const [FNodeClassMetadata](API\Plugins\MetasoundGraphCore\FNodeClassMetadata) & GetNodeInfo()


className: Type

code: typedef OperatorType Type


className: TFacadeOperatorClass

description: TFacadeOperatorClassencapsulates an operator type and checks that the required static functions exist to build the facade operator class. It is required to call theFNodeFacadetemplate constructor.

code: template<typename OperatorType> struct TFacadeOperatorClass


className: TGetVertexAccess

description: Helper for getting a EVertexAccessType from a TData*Referenceobject.


code: TInputConstructorVertex()


code: template<typename... ArgTypes> TInputConstructorVertex ( const [FVertexName](API\Plugins\MetasoundGraphCore\FVertexName) & InVertexName, const [FDataVertexMetadata](API\Plugins\MetasoundGraphCore\FDataVertexMetadata) & InMetadata, ArgTypes &&... Args )


className: TInputConstructorVertex

description: Create aFInputDataVertexwith a templated MetaSound data type which only reads data at operator time.

code: template<typename [DataType](API\Plugins\OptimusCore\DataType)> class TInputConstructorVertex : public [Metasound::FInputDataVertex](API\Plugins\MetasoundGraphCore\FInputDataVertex)


code: template<typename... ArgTypes> TInputDataVertex ( const [FVertexName](API\Plugins\MetasoundGraphCore\FVertexName) & InVertexName, const [FDataVertexMetadata](API\Plugins\MetasoundGraphCore\FDataVertexMetadata) & InMetadata, ArgTypes &&... Args )


description: Deprecated*TInputDataVertexconstructor without explicit FDataVertexMatadata is deprecated. Use constructor which accepts TDataVertexMetadata

code: template<typename... ArgTypes> TInputDataVertex ( const [FVertexName](API\Plugins\MetasoundGraphCore\FVertexName) & InVertexName, const [FText](API\Runtime\Core\Internationalization\FText) & InDescription, ArgTypes &&... Args )


className: TInputDataVertex

description: Create aFInputDataVertexwith a templated MetaSound data type.

code: template<typename [DataType](API\Plugins\OptimusCore\DataType)> class TInputDataVertex : public [Metasound::FInputDataVertex](API\Plugins\MetasoundGraphCore\FInputDataVertex)


className: Value

code: static constexpr bool Value = false;


className: TIsArrayType

description: Determines whether a DataType is an array type.

code: template<typename [DataType](API\Plugins\OptimusCore\DataType)> struct TIsArrayType


description: If the function exists, then "Value" is true. Otherwise "Value" is false.

code: static constexpr bool Value = sizeof(Check<U>(0)) == sizeof(uint8_t);


className: TIsFactoryMethodDeclared

description: Helper template to determine whether a static class function is declared for a given template class.

code: template<typename U> class TIsFactoryMethodDeclared


className: TIsNodeInfoDeclared

code: template<typename U> class TIsNodeInfoDeclared


className: FConstructorTraits

code: typedef [DataFactoryPrivate::TDataTypeConstructorTraits](API\Plugins\MetasoundGraphCore\TDataTypeConstructorTraits)< [DataType](API\Plugins\OptimusCore\DataType), ArgTypes... > FConstructorTraits


description: True if the DataType supports a constructor which accepts andFOperatorSettingswith ArgTypes and/or just ArgTypes. False otherwise.

code: static constexpr bool Value = FConstructorTraits::bIsConstructibleWithArgs || FConstructorTraits::bIsConstructibleWithSettingsAndArgs || FConstructorTraits::bIsArrayConstructibleWithArgs || FConstructorTraits::bIsArrayConstructibleWithSettingsAndArgs;


className: TIsParsable

description: TIsParsable< DataType, FLiteral::FNone >

code: template<typename DataType, typename... ArgTypes> struct TIsParsable


code: typedef DataFactoryPrivate::TDataTypeConstructorTraits< DataType > FConstructorTraits


description: True if the DataType supports a constructor which accepts andFOperatorSettingsor default constructor.

code: static Value = FConstructorTraits::bIsConstructibleWithArgs || FConstructorTraits::bIsConstructibleWithSettingsAndArgs || FConstructorTraits::bIsArrayConstructibleWithArgs || FConstructorTraits::bIsArrayConstructibleWithSettingsAndArgs;


code: static constexpr bool Value = sizeof(Check<U>(0)) == sizeof(uint8);


description: Specialization forFLiteral::FNonearg type.

code: namespace TIsParsable< DataType, FLiteral { template<typename [DataType](API\Plugins\OptimusCore\DataType)> struct TIsParsable< DataType, FLiteral::FNone > }


className: TIsPostExecuteMethodDeclared

description: Helper template to determine whether a member function is declared for a given template class.

code: template<typename U> class TIsPostExecuteMethodDeclared


className: TIsResetMethodDeclared

code: template<typename U> class TIsResetMethodDeclared


className: TIsVariable

description: Template to determine if data type is a variable.

code: template<typename [DataType](API\Plugins\OptimusCore\DataType)> struct TIsVariable


className: TLiteralDefaultValueFromDecayed

code: template<typename... ArgTypes> struct TLiteralDefaultValueFromDecayed


code: static const ArgType & GetValue&40;&41;


code: template<typename ArgType> struct TLiteralDefaultValueFromDecayed< ArgType >


code: static FLiteral::FNone GetValue&40;&41;


code: namespace TLiteralDefaultValueFromDecayed< FLiteral { template<> struct TLiteralDefaultValueFromDecayed< FLiteral::FNone > }


code: static const FString & GetValue&40;&41;


code: template<> struct TLiteralDefaultValueFromDecayed< FString >


className: bIsParsableFromAnyLiteralType

code: static constexpr bool bIsParsableFromAnyLiteralType = TVariantConstructorTraits::bIsDefaultConstructible || TVariantConstructorTraits::bIsConstructibleWithSettings || TVariantConstructorTraits::bIsConstructibleWithArgs || TVariantConstructorTraits::bIsConstructibleWithSettingsAndArgs || bIsParseableFromAnyArrayLiteralType;


className: bIsParseableFromAnyArrayLiteralType

code: static constexpr bool bIsParseableFromAnyArrayLiteralType = TVariantConstructorTraits::bIsArrayDefaultConstructible || TVariantConstructorTraits::bIsArrayConstructibleWithSettings || TVariantConstructorTraits::bIsArrayConstructibleWithArgs || TVariantConstructorTraits::bIsArrayConstructibleWithSettingsAndArgs;


description:
Determines if a constructor for the DataType exists which accepts anFOperatorSettingswith the literals constructor arg type, and/or one that accepts the literal constructor arg type.
True if a constructor for the DataType exists which accepts anFOperatorSettingswith the literals constructor arg type, or one that accepts the literal constructor arg type. It returns False otherwise.

code: static const bool IsParsable ( const [FLiteral](API\Plugins\MetasoundGraphCore\FLiteral) & InLiteral )


className: TLiteralTraits

description: Determines whether a DataType supports construction using the given literal.

code: template<typename DataType> struct TLiteralTraits


className: TVariantConstructorTraits


className: TLiteralTypeInfo

code: template<typename... ArgTypes> struct TLiteralTypeInfo


description: Returns the associated ELiteralType for the C++ type provided in the TLiteralTypeInfo

code: static const ELiteralType GetLiteralArgTypeEnum&40;&41;


className: TLiteralTypeInfo<>

description: Provides literal type information for a given type.

code: template<> struct TLiteralTypeInfo<>


className: FDecayedType

code: typedef typename std::decay< ArgType >::type FDecayedType


code: static auto GetDefaultValue&40;&41;


className: TLiteralTypeInfo< ArgType >

code: template<typename ArgType> struct TLiteralTypeInfo< ArgType >


description: Create a clone of this environment variable.

code: virtual [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [IMetasoundEnvironmentVariable](API\Plugins\MetasoundGraphCore\IMetasoundEnvironmentVariable) > Clone() const


description: Get the name of this environment variable.

code: virtual const [FName](API\Runtime\Core\UObject\FName) & GetName() const


description: Get the type ID of this environment variable.


description: Get the current value.

code: const Type & GetValue() const


description: Set the current value.

code: void SetValue ( const Type & InValue )


description: Make sure the `Type_ has appropriate construction and copy characteristics. Construct an environment variable

code: template<typename... ArgTypes> TMetasoundEnvironmentVariable ( const [FName](API\Runtime\Core\UObject\FName) & InName, ArgTypes &&... Args )


className: TMetasoundEnvironmentVariable

code: template<typename Type> class TMetasoundEnvironmentVariable : public [Metasound::IMetasoundEnvironmentVariable](API\Plugins\MetasoundGraphCore\IMetasoundEnvironmentVariable)


code: TNodeFacade ( const [FNodeInitData](API\Plugins\MetasoundGraphCore\FNodeInitData) & InInitData )


className: TNodeFacade

description: TNodeFacadefurther reduces boilerplate code by allowing shorthand node implementations. in the form: TNodeFacade

code: template<typename OperatorType> class TNodeFacade : public [Metasound::FNodeFacade](API\Plugins\MetasoundGraphCore\FNodeFacade)


code: TOutputConstructorVertex()


code: template<typename... ArgTypes> TOutputConstructorVertex ( const [FVertexName](API\Plugins\MetasoundGraphCore\FVertexName) & InVertexName, const [FDataVertexMetadata](API\Plugins\MetasoundGraphCore\FDataVertexMetadata) & InMetadata, ArgTypes &&... Args )


className: TOutputConstructorVertex

description: Create aFOutputDataVertexwith a templated MetaSound data type which is only sets data at operator construction time.

code: template<typename [DataType](API\Plugins\OptimusCore\DataType)> class TOutputConstructorVertex : public [Metasound::FOutputDataVertex](API\Plugins\MetasoundGraphCore\FOutputDataVertex)


code: template<typename... ArgTypes> TOutputDataVertex ( const [FVertexName](API\Plugins\MetasoundGraphCore\FVertexName) & InVertexName, const [FDataVertexMetadata](API\Plugins\MetasoundGraphCore\FDataVertexMetadata) & InMetadata, ArgTypes &&... Args )


description: Deprecated*TOutputDataVertexconstructor without explicit FDataVertexMatadata is deprecated. Use constructor which accepts TDataVertexMetadata

code: template<typename... ArgTypes> TOutputDataVertex ( const [FVertexName](API\Plugins\MetasoundGraphCore\FVertexName) & InVertexName, const [FText](API\Runtime\Core\Internationalization\FText) & InDescription, ArgTypes &&... Args )


className: TOutputDataVertex

description: Create aFOutputDataVertexwith a templated MetaSound data type.

code: template<typename [DataType](API\Plugins\OptimusCore\DataType)> class TOutputDataVertex : public [Metasound::FOutputDataVertex](API\Plugins\MetasoundGraphCore\FOutputDataVertex)


className: TPostExecutableDataType

description: TPostExecutableDataType< FTrigger >

code: template<class [DataType](API\Plugins\OptimusCore\DataType)> struct TPostExecutableDataType


className: bIsPostExecutable

code: static constexpr bool bIsPostExecutable = false;


className: TPostExecuteFunctionAdapter

description: Note: This helper must be instantiated inside the functions and cannot be part of the `TExecutableOperator_ class definition as classes are not completely defined at the point in the compilation process when static constexpr class members are evaluated.

code: template<typename OperatorType> struct TPostExecuteFunctionAdapter


description: Returns anIOperator::FPostExecuteFunctionif the OperatorType has a PostExecute(...) class member function.


description: Returns anIOperator::FResetFunctionif the OperatorType has a Reset(...) class member function.


className: TResetFunctionAdapter

code: template<typename OperatorType> struct TResetFunctionAdapter


className: TSortedVertexNameMap

description: This template makes it convenient to create aTSortedMapwith an FVertexName while also avoiding compilation errors incurred from using theFNamedefault "less than" operator in theTSortedMapimplementation.

code: typedef [TSortedMap](API\Runtime\Core\Containers\TSortedMap)< [FVertexName](API\Plugins\MetasoundGraphCore\FVertexName), ValueType, FDefaultAllocator, [FNameFastLess](API\Runtime\Core\UObject\FNameFastLess) > TSortedVertexNameMap


className: Value

code: enum { Value = false }


className: TSpecializationHelper

description: Helper class to enforce specialization ofTDataReferenceTypeInfo

code: template<typename [DataType](API\Plugins\OptimusCore\DataType)> struct TSpecializationHelper


description: Helper class to ensure that DECLARE_METASOUND_ENVIRONMENT_VARIABLE is used.


className: bIsValidType

code: static constexpr bool bIsValidType = ValidType;


className: Type

code: typedef PreviousType Type


className: TTypePromoter

code: template<bool ValidType, typename ThisType, typename PreviousType> struct TTypePromoter


description: TTypePromoterpartial specialization for ValidType=false.

code: template<typename ThisType, typename PreviousType> struct TTypePromoter< false, ThisType, PreviousType >


code: static bIsValidType = !std::is_same<PreviousType, void>::value;


code: static bIsValidType = true;


code: typedef ThisType Type


className: TTypePromoter< true, ThisType >

description: TTypePromoterpartial specialization for ValidType=true and no PreviousType.

code: template<typename ThisType> struct TTypePromoter< true, ThisType >


className: FWriteReference

code: typedef [TDataWriteReference](API\Plugins\MetasoundGraphCore\TDataWriteReference)< [DataType](API\Plugins\OptimusCore\DataType) > FWriteReference


className: FReadReference

code: typedef [TDataReadReference](API\Plugins\MetasoundGraphCore\TDataReadReference)< [DataType](API\Plugins\OptimusCore\DataType) > FReadReference


code: void CopyReferencedData()


description: Get the current data reference.


code: void InitDataReference ( const [FOperatorSettings](API\Plugins\MetasoundGraphCore\FOperatorSettings) & InOperatorSettings )


description: Get the delayed data reference


code: void InitDelayedDataReference ( const [FOperatorSettings](API\Plugins\MetasoundGraphCore\FOperatorSettings) & InOperatorSettings )


code: bool RequiresDelayedDataCopy() const


code: void Reset ( const [FOperatorSettings](API\Plugins\MetasoundGraphCore\FOperatorSettings) & InOperatorSettings )


code: void SetDataReference ( [FReadReference](API\Plugins\MetasoundGraphCore\TVariable\FReadReference) InDataReference )


description: TTypePromoterpartial specialization for ValidType=true.

code: template<typename ThisType, typename PreviousType> struct TTypePromoter< true, ThisType, PreviousType >


code: TVariable ( [TVariable](API\Plugins\MetasoundGraphCore\TVariable) && )


code: TVariable ( const [TVariable](API\Plugins\MetasoundGraphCore\TVariable) & )


description: Create a delayed variable.

code: TVariable ( const [FLiteral](API\Plugins\MetasoundGraphCore\FLiteral) & InInitialValue, [MetasoundVariablePrivate::FConstructWithLiteral](API\Plugins\MetasoundGraphCore\FConstructWithLiteral) )


code: TVariableAccessorNode ( const [FNodeInitData](API\Plugins\MetasoundGraphCore\FNodeInitData) & InInitData )


className: TVariable

description: A MetaSound Variable contains a data reference's prior and current value.

code: template<typename [DataType](API\Plugins\OptimusCore\DataType)> struct TVariable


code: TVariableAccessorNode ( const [FVertexName](API\Plugins\MetasoundGraphCore\FVertexName) & InNodeName, const [FGuid](API\Runtime\Core\Misc\FGuid) & InInstanceID )


className: TVariableAccessorNode

description: FGetVariable node provides delay free, cpu free access to a set variable.

code: template<typename [DataType](API\Plugins\OptimusCore\DataType)> class TVariableAccessorNode : public [Metasound::FNodeFacade](API\Plugins\MetasoundGraphCore\FNodeFacade)


code: virtual void Bind ( [FVertexInterfaceData](API\Plugins\MetasoundGraphCore\FVertexInterfaceData) & InVertexData ) const


description: // Update MyBufferPtr in case AudioBuffer references a newFAudioBuffer. MyBufferPtr = AudioBuffer->GetData(); }

code: virtual void BindInputs ( [FInputVertexInterfaceData](API\Plugins\MetasoundGraphCore\FInputVertexInterfaceData) & InVertexData )


code: virtual void BindOutputs ( [FOutputVertexInterfaceData](API\Plugins\MetasoundGraphCore\FOutputVertexInterfaceData) & InVertexData )


className: FVariable

code: typedef [TVariable](API\Plugins\MetasoundGraphCore\TVariable)< [DataType](API\Plugins\OptimusCore\DataType) > FVariable


description: Note: IOperators which do not correctly implement BindInputs(...) and BindOutputs(...) will not function correctly with MetaSound operator caching and live auditioning in the MetaSound Builder BP API.

code: virtual [FDataReferenceCollection](API\Plugins\MetasoundGraphCore\FDataReferenceCollection) GetInputs() const


code: static const [FNodeClassMetadata](API\Plugins\MetasoundGraphCore\FNodeClassMetadata) & GetNodeInfo()


code: virtual [FDataReferenceCollection](API\Plugins\MetasoundGraphCore\FDataReferenceCollection) GetOutputs() const


code: TVariableAccessorOperator ( [TDataWriteReference](API\Plugins\MetasoundGraphCore\TDataWriteReference)< [FVariable](API\Plugins\MetasoundGraphCore\TVariableAccessorOperator\FVariable) > InVariable )


code: virtual ~TVariableAccessorOperator()


code: static [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [IOperator](API\Plugins\MetasoundGraphCore\IOperator) > CreateOperator ( const [FBuildOperatorParams](API\Plugins\MetasoundGraphCore\FBuildOperatorParams) & InParams, [FBuildResults](API\Plugins\MetasoundGraphCore\FBuildResults) & OutResults )


className: TVariableAccessorOperator

description: Operator for providing inline access to a variable

code: template<typename [DataType](API\Plugins\OptimusCore\DataType)> class TVariableAccessorOperator : public [Metasound::FNoOpOperator](API\Plugins\MetasoundGraphCore\FNoOpOperator)


code: TVariableDeferredAccessorNode ( const [FNodeInitData](API\Plugins\MetasoundGraphCore\FNodeInitData) & InInitData )


code: TVariableDeferredAccessorNode ( const [FVertexName](API\Plugins\MetasoundGraphCore\FVertexName) & InNodeName, const [FGuid](API\Runtime\Core\Misc\FGuid) & InInstanceID )


className: TVariableDeferredAccessorNode

description: TVariableDeferredAccessorNodeprovides access to the prior executions variable value. TVariableDeferredAccessorNodes must always be before TVariableMutatorNodes in the dependency order.

code: template<typename [DataType](API\Plugins\OptimusCore\DataType)> class TVariableDeferredAccessorNode : public [Metasound::FNodeFacade](API\Plugins\MetasoundGraphCore\FNodeFacade)


code: TVariableDeferredAccessorOperator ( [TDataWriteReference](API\Plugins\MetasoundGraphCore\TDataWriteReference)< [FVariable](API\Plugins\MetasoundGraphCore\TVariableDeferredAccessorOperato-\FVariable) > InVariable )


className: TVariableDeferredAccessorOperator

description: Operator for providing delayed access to a variable

code: template<typename [DataType](API\Plugins\OptimusCore\DataType)> class TVariableDeferredAccessorOperator : public [Metasound::FNoOpOperator](API\Plugins\MetasoundGraphCore\FNoOpOperator)


code: TVariableMutatorNode ( const [FVertexName](API\Plugins\MetasoundGraphCore\FVertexName) & InNodeName, const [FGuid](API\Runtime\Core\Misc\FGuid) & InInstanceID )


code: TVariableMutatorNode ( const [FNodeInitData](API\Plugins\MetasoundGraphCore\FNodeInitData) & InInitData )


className: TVariableMutatorNode

description: TVariableMutatorNodeallows variable values to be set.

code: template<typename [DataType](API\Plugins\OptimusCore\DataType)> class TVariableMutatorNode : public [Metasound::FNodeFacade](API\Plugins\MetasoundGraphCore\FNodeFacade)


code: virtual void Bind ( [FVertexInterfaceData](API\Plugins\MetasoundGraphCore\FVertexInterfaceData) & InVertexData ) const


code: virtual void BindInputs ( [FInputVertexInterfaceData](API\Plugins\MetasoundGraphCore\FInputVertexInterfaceData) & InVertexData )


code: virtual void BindOutputs ( [FOutputVertexInterfaceData](API\Plugins\MetasoundGraphCore\FOutputVertexInterfaceData) & InVertexData )


description: nullptr return values are valid and signal anIOperatorwhich does not need to be executed.


code: typedef [TVariable](API\Plugins\MetasoundGraphCore\TVariable)< [DataType](API\Plugins\OptimusCore\DataType) > FVariable


code: static const [FNodeClassMetadata](API\Plugins\MetasoundGraphCore\FNodeClassMetadata) & GetNodeInfo()


code: virtual [FDataReferenceCollection](API\Plugins\MetasoundGraphCore\FDataReferenceCollection) GetOutputs() const


description: nullptr return values are valid and signal anIOperatorwhich does not need to be post executed.


description: nullptr return values are valid and signal anIOperatorwhich does not need to be reset.


code: virtual [FDataReferenceCollection](API\Plugins\MetasoundGraphCore\FDataReferenceCollection) GetInputs() const


code: void Reset ( const [IOperator::FResetParams](API\Plugins\MetasoundGraphCore\IOperator\FResetParams) & InParams )


code: virtual ~TVariableMutatorOperator()


code: TVariableMutatorOperator ( [TDataWriteReference](API\Plugins\MetasoundGraphCore\TDataWriteReference)< [FVariable](API\Plugins\MetasoundGraphCore\TVariableMutatorOperator\FVariable) > InVariable, [TDataReadReference](API\Plugins\MetasoundGraphCore\TDataReadReference)< [DataType](API\Plugins\OptimusCore\DataType) > InData )


className: TVariableMutatorOperator

description: Operator for providing setting a variable

code: template<typename [DataType](API\Plugins\OptimusCore\DataType)> class TVariableMutatorOperator : public [Metasound::IOperator](API\Plugins\MetasoundGraphCore\IOperator)


description: Return a reference to the default operator factory.

code: virtual [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [IOperatorFactory](API\Plugins\MetasoundGraphCore\IOperatorFactory), ESPMode::ThreadSafe > GetDefaultOperatorFactory() const


code: TVariableNode ( const [FVertexName](API\Plugins\MetasoundGraphCore\FVertexName) & InNodeName, const [FGuid](API\Runtime\Core\Misc\FGuid) & InInstanceID, [FLiteral](API\Plugins\MetasoundGraphCore\FLiteral) && InLiteral )


className: TVariableNode

description: Variable nodes initialize variable values. The output of a VariableNode is aTVariable.

code: template<typename [DataType](API\Plugins\OptimusCore\DataType)> class TVariableNode : public [Metasound::FNode](API\Plugins\MetasoundGraphCore\FNode)


code: virtual ~TVariableOperator()


code: TVariableOperator ( const [FOperatorSettings](API\Plugins\MetasoundGraphCore\FOperatorSettings) & InOperatorSettings, const [FLiteral](API\Plugins\MetasoundGraphCore\FLiteral) & InLiteral )


className: TVariableOperator

code: template<typename [DataType](API\Plugins\OptimusCore\DataType)> class TVariableOperator : public [Metasound::FNoOpOperator](API\Plugins\MetasoundGraphCore\FNoOpOperator)


description: Add a vertex to the group.

code: void Add ( const VertexType & InVertex )


code: void Add ( VertexType && InVertex )


description: Iterator for ranged for loops.


description: Returns true if the group contains a vertex with a matching key.

code: bool Contains ( const [FVertexName](API\Plugins\MetasoundGraphCore\FVertexName) & InKey ) const


className: FContainerType

code: typedef [TArray](API\Runtime\Core\Containers\TArray)< VertexType > FContainerType


description: Find a vertex with a given VertexName

code: VertexType * Find ( const [FVertexName](API\Plugins\MetasoundGraphCore\FVertexName) & InKey )


description: Find a vertex with a given VertexName

code: const VertexType * Find ( const [FVertexName](API\Plugins\MetasoundGraphCore\FVertexName) & InKey ) const


description:
Return the sort order index of a vertex with the given name.
The index of the vertex. INDEX_NONE if the vertex does not exist.

code: int32 GetSortOrderIndex ( const [FVertexName](API\Plugins\MetasoundGraphCore\FVertexName) & InKey ) const


description: Returns the number of vertices in the group.

code: int32 Num() const


description: Return the vertex for a given vertex key.

code: const VertexType & operator[] ( const [FVertexName](API\Plugins\MetasoundGraphCore\FVertexName) & InName ) const


className: RangedForConstIteratorType


description: Remove a vertex by key.

code: bool Remove ( const [FVertexName](API\Plugins\MetasoundGraphCore\FVertexName) & InKey )


description: TVertexInterfaceGroupconstructor with variadic list of vertex models.

code: template<typename... VertexTypes> TVertexInterfaceGroup ( VertexTypes &&... InVertices )


className: TVertexInterfaceGroup

description: TVertexInterfaceGroups encapsulates multiple related data vertices. It requires that each vertex in the group have a unique FVertexName.

code: template<typename VertexType> class TVertexInterfaceGroup


className: TVertexInterfaceGroupData

code: template<typename VertexType> class TVertexInterfaceGroupData


description: Constructor used by theMetasoundFrontend.

module: MetasoundStandardNodes

code: FBPMToSecondsNode ( const [FNodeInitData](API\Plugins\MetasoundGraphCore\FNodeInitData) & InitData )


className: FBPMToSecondsNode

description: Calculates a beat time in seconds from the given BPM, beat multiplier and divisions of a whole note.

code: class FBPMToSecondsNode : public [Metasound::FNodeFacade](API\Plugins\MetasoundGraphCore\FNodeFacade)


className: FEnumEMusicalScale

description: Any desired additions to this Enum/list need to first be added to the EMusicalScale enum in MidiNoteQuantizer.h and defined in MidiNoteQuantizer.cpp in the TMapScaleDegreeSetMap static init


className: FEnumEnvelopePeakMode


className: FEnumEnvelopePeakModeWriteRef


className: FEnumEnvelopePeakModeInfo


className: FEnumMusicalScaleReadRef


className: FEnumMusicalScaleTypeInfo


className: FEnumMusicalScaleWriteRef


className: FEnumTriggerComparisonType


className: FEnumTriggerComparisonTypeInfo


className: FEnumTriggerComparisonTypeWriteRef


code: FEnvelopeFollowerNode ( const [FNodeInitData](API\Plugins\MetasoundGraphCore\FNodeInitData) & InitData )


className: FEnumTriggerComparisonTypeReadRef


className: FEnvelopeFollowerNode

description: Delays an audio buffer by a specified amount.

code: class FEnvelopeFollowerNode : public [Metasound::FNodeFacade](API\Plugins\MetasoundGraphCore\FNodeFacade)


className: FEnvelopePeakModeReadRef


description: Get the gain in decibels

code: float GetDecibels() const


className: DefaultGain

code: static constexpr const float DefaultGain = 1.0f;


description: Return the gain in LinearScale.

code: float GetLinear() const


className: FGain::operator float

description: Implicit operator used for math operations.

code: operator float() const


code: [FGain](API\Plugins\MetasoundStandardNodes\FGain) & operator+= ( const [FGain](API\Plugins\MetasoundStandardNodes\FGain) & InOther )


code: [FGain](API\Plugins\MetasoundStandardNodes\FGain) & operator/= ( const [FGain](API\Plugins\MetasoundStandardNodes\FGain) & InOther )


code: [FGain](API\Plugins\MetasoundStandardNodes\FGain) & operator*= ( const [FGain](API\Plugins\MetasoundStandardNodes\FGain) & InOther )


code: [FGain](API\Plugins\MetasoundStandardNodes\FGain) & operator-= ( const [FGain](API\Plugins\MetasoundStandardNodes\FGain) & InOther )


description: Set the gain in LinearScale

code: void SetLinear ( float InLinearScale )


description: Set the gain in decibels

code: void SetDecibels ( float InDecibels )


description: Construct gain of 1

code: FGain()


description: FGainconstructor used to pass in float literals from the metasound frontend.

code: FGain ( float InValue )


description: Construct a Gain with a given value and representation.

code: FGain ( float InValue, [EGainRepresentation](API\Plugins\MetasoundStandardNodes\Metasound__EGainRepresentation) InRep )


className: FGain

description: FGainrepresents a gain value. It provides clearly defined getters and setters as well as several convenience functions for converting gain to decibels.

code: class FGain


code: FLfoNode ( const [FNodeInitData](API\Plugins\MetasoundGraphCore\FNodeInitData) & InInitData )


code: virtual ~FLfoNode()


className: FLfoNode

code: class FLfoNode : public [Metasound::FNodeFacade](API\Plugins\MetasoundGraphCore\FNodeFacade)


description: Return writable audio buffer reference of center channel.


description: Return readable audio buffer reference of center channel.


className: Super

code: typedef [TStaticChannelAudioFormat](API\Plugins\MetasoundStandardNodes\TStaticChannelAudioFormat)< 1 > Super


description: Construct with a single writable audio buffer reference.

code: FMonoAudioFormat ( const [FAudioBufferWriteRef](API\Plugins\MetasoundGraphCore\FAudioBufferWriteRef) & InAudio )


className: FMonoAudioFormat

description: The audio buffer is a shared data references which can be accessed outside of theFMonoAudioFormat.

code: class FMonoAudioFormat : public [Metasound::TStaticChannelAudioFormat< 1 >](API\Plugins\MetasoundStandardNodes\TStaticChannelAudioFormat)


className: FMonoAudioFormatReadRef


className: FMonoAudioFormatTypeInfo


className: FMonoAudioFormatWriteRef


description: This array will haveGetNumChannels()elements.

code: const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const [FAudioBufferReadRef](API\Plugins\MetasoundGraphCore\FAudioBufferReadRef) > GetBuffers() const


code: const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const [FAudioBufferWriteRef](API\Plugins\MetasoundGraphCore\FAudioBufferWriteRef) > GetBuffers()


description: Return the maximum number of channels. Multichannel audio buffers cannot be resized after construction.

code: int32 GetMaxNumChannels() const


description: Disable move operator so channel count does not changeFMultichannelAudioFormat& operator=(FMultichannelAudioFormat&& Other) = delete; Return the number of audio channels.

code: int32 GetNumChannels() const


code: const [TArray](API\Runtime\Core\Containers\TArray)< [FAudioBufferWriteRef](API\Plugins\MetasoundGraphCore\FAudioBufferWriteRef) > & GetStorage()


code: const [TArray](API\Runtime\Core\Containers\TArray)< [FAudioBufferReadRef](API\Plugins\MetasoundGraphCore\FAudioBufferReadRef) > & GetStorage() const


description: Disable move constructor as incoming object should not be altered. FMultichannelAudioFormat(FMultichannelAudioFormat&& InOther) = delete;

code: [FMultichannelAudioFormat](API\Plugins\MetasoundStandardNodes\FMultichannelAudioFormat) & operator= ( const [FMultichannelAudioFormat](API\Plugins\MetasoundStandardNodes\FMultichannelAudioFormat) & Other )


code: FMultichannelAudioFormat()


description: This constructor accepts an array of writable audio buffer references. Each buffer in the array must contain equal number of frames.

code: FMultichannelAudioFormat ( [TArrayView](API\Runtime\Core\Containers\TArrayView)< const [FAudioBufferWriteRef](API\Plugins\MetasoundGraphCore\FAudioBufferWriteRef) > InWriteRefs )


description: FMultichannelAudioFormatConstructor.

code: FMultichannelAudioFormat ( int32 InNumFrames, int32 InNumChannels )


description: This constructor should only be used when it can be assured that the constructed object will not provide writable access to the passed in audio buffers.

code: FMultichannelAudioFormat &40; TArrayView< const FAudioBufferReadRef > InReadRefs &41;


description: Enable the copy constructor.

code: FMultichannelAudioFormat ( const [FMultichannelAudioFormat](API\Plugins\MetasoundStandardNodes\FMultichannelAudioFormat) & InOther )


description: FMultichannelAudioFormatConstructor used by the metasound frontend.

code: FMultichannelAudioFormat ( const [FOperatorSettings](API\Plugins\MetasoundGraphCore\FOperatorSettings) & InSettings, int32 InNumChannels )


className: FMultichannelAudioFormat

description: The audio buffers inFMultichannelAudioFormatare shared data references which can be accessed outside of theFMultichannelAudioFormat. All audio buffers within aFMultichannelAudioFormatobject must contain the same number of audio frames.

code: class FMultichannelAudioFormat : public [Metasound::IAudioDataType](API\Plugins\MetasoundGraphCore\IAudioDataType)


code: int32 GetDefaultSeed() const


code: FNoiseNode ( const [FNodeInitData](API\Plugins\MetasoundGraphCore\FNodeInitData) & InInitData )


code: FNoiseNode ( const [FVertexName](API\Plugins\MetasoundGraphCore\FVertexName) & InName, const [FGuid](API\Runtime\Core\Misc\FGuid) & InInstanceID, int32 InDefaultSeed )


className: FNoiseNode

code: class FNoiseNode : public [Metasound::FNodeFacade](API\Plugins\MetasoundGraphCore\FNodeFacade)


code: float GetDefaultGlideFactor() const


code: float GetDefaultFrequency() const


code: bool GetDefaultEnablement() const


description: Return a reference to the default operator factory.


code: float GetDefaultPhaseOffset() const


description:
Expresses whether a specific vertex interface is supported.
True if the interface is supported, false otherwise.

code: virtual bool IsVertexInterfaceSupported ( const [FVertexInterface](API\Plugins\MetasoundGraphCore\FVertexInterface) & InInterface ) const


description: Return the current vertex interface.

code: virtual const [FVertexInterface](API\Plugins\MetasoundGraphCore\FVertexInterface) & GetVertexInterface() const


description:
Set the vertex interface. If the vertex was successfully changed, returns true.
True on success, false otherwise.

code: virtual bool SetVertexInterface ( const [FVertexInterface](API\Plugins\MetasoundGraphCore\FVertexInterface) & InInterface )


code: FOscilatorNodeBase ( const [FVertexName](API\Plugins\MetasoundGraphCore\FVertexName) & InInstanceName, const [FGuid](API\Runtime\Core\Misc\FGuid) & InInstanceID, const [FNodeClassMetadata](API\Plugins\MetasoundGraphCore\FNodeClassMetadata) & InInfo, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [IOperatorFactory](API\Plugins\MetasoundGraphCore\IOperatorFactory), ESPMode::ThreadSafe > & InFactory, float InDefaultFrequency, float InDefaultGlideTime, bool bInDefaultEnablement )


className: FOscilatorNodeBase

code: class FOscilatorNodeBase : public [Metasound::FNode](API\Plugins\MetasoundGraphCore\FNode)

bDefaultEnablement

type: bool

DefaultFrequency

type: float

Factory

type: TSharedRef<IOp...

VertexInterface

type: FVertexInterfac...


className: FSampleCount

code: typedef int64 FSampleCount


description: Construct a sample counter with a sample count, time resolution, and sample rate.

code: static [FSampleCounter](API\Plugins\MetasoundStandardNodes\FSampleCounter) FromTime ( const [FTime](API\Plugins\MetasoundFrontend\FTime) & InTime, [FSampleRate](API\Plugins\MetasoundGraphCore\FSampleRate) InSampleRate )


description: Return the number of samples.


description: Return the number of samples which represent this time duration using a different sample rate.

code: [FSampleCount](API\Plugins\MetasoundStandardNodes\FSampleCount) GetNumSamples ( [FSampleRate](API\Plugins\MetasoundGraphCore\FSampleRate) InOtherSampleRate ) const


description: Returns sample rate


code: [FSampleCounter](API\Plugins\MetasoundStandardNodes\FSampleCounter) & operator= ( const [FSampleCounter](API\Plugins\MetasoundStandardNodes\FSampleCounter) & InRHS )


description: Set the number of samples.

code: void SetNumSamples ( [FSampleCount](API\Plugins\MetasoundStandardNodes\FSampleCount) InNumSamples )


description: Set the number of samples from time value (This is functionally discretization and will result in loss of precision)

code: void SetNumSamples ( const [FTime](API\Plugins\MetasoundFrontend\FTime) & InTime )


description: Set the sample rate of this object without changing the number of samples. This will result in the object representing a different amount of time.

code: void SetSampleRate ( [FSampleRate](API\Plugins\MetasoundGraphCore\FSampleRate) InSampleRate )


code: FSampleCounter ( const [FSampleCounter](API\Plugins\MetasoundStandardNodes\FSampleCounter) & InSampleCounter )


code: FSampleCounter ( [FSampleCount](API\Plugins\MetasoundStandardNodes\FSampleCount) InNumSamples, [FSampleRate](API\Plugins\MetasoundGraphCore\FSampleRate) InSampleRate )


className: FSampleCounter

code: class FSampleCounter


code: virtual TUniquePtr< IOperator > CreateOperator &40; const FBuildOperatorParams & InParams, FBuildResults & OutResults &41;


code: static const FNodeClassMetadata & GetNodeInfo&40;&41;


code: static const FVertexInterface & GetVertexInterface&40;&41;


className: FFactory

code: class FFactory : public Metasound::FOscilatorFactoryBase


code: FSawOscilatorNode ( const [FNodeInitData](API\Plugins\MetasoundGraphCore\FNodeInitData) & InInitData )


code: FSawOscilatorNode ( const [FVertexName](API\Plugins\MetasoundGraphCore\FVertexName) & InInstanceName, const [FGuid](API\Runtime\Core\Misc\FGuid) & InInstanceID, float InDefaultFrequency, float InDefautlGlideTime, bool bInDefaultEnablement )


className: FSawOscilatorNode

code: class FSawOscilatorNode : public [Metasound::FOscilatorNodeBase](API\Plugins\MetasoundStandardNodes\FOscilatorNodeBase)


code: FSineOscilatorNode ( const [FNodeInitData](API\Plugins\MetasoundGraphCore\FNodeInitData) & InInitData )


code: FSineOscilatorNode ( const [FVertexName](API\Plugins\MetasoundGraphCore\FVertexName) & InInstanceName, const [FGuid](API\Runtime\Core\Misc\FGuid) & InInstanceID, float InDefaultFrequency, float InDefautlGlideTime, bool bInDefaultEnablement )


className: FSineOscilatorNode

code: class FSineOscilatorNode : public [Metasound::FOscilatorNodeBase](API\Plugins\MetasoundStandardNodes\FOscilatorNodeBase)


code: FSquareOscilatorNode ( const [FNodeInitData](API\Plugins\MetasoundGraphCore\FNodeInitData) & InInitData )


code: FSquareOscilatorNode ( const [FVertexName](API\Plugins\MetasoundGraphCore\FVertexName) & InInstanceName, const [FGuid](API\Runtime\Core\Misc\FGuid) & InInstanceID, float InDefaultFrequency, float InDefautlGlideTime, bool bInDefaultEnablement )


className: FSquareOscilatorNode

code: class FSquareOscilatorNode : public [Metasound::FOscilatorNodeBase](API\Plugins\MetasoundStandardNodes\FOscilatorNodeBase)


description: Return writable audio buffer reference of left channel.


description: Return readable audio buffer reference of left channel.


description: Return writable audio buffer reference of right channel.


description: Return readable audio buffer reference of right channel.


code: typedef [TStaticChannelAudioFormat](API\Plugins\MetasoundStandardNodes\TStaticChannelAudioFormat)< 2 > Super


description: Construct with a two writable audio buffer reference.

code: FStereoAudioFormat ( const [FAudioBufferWriteRef](API\Plugins\MetasoundGraphCore\FAudioBufferWriteRef) & InLeftAudio, const [FAudioBufferWriteRef](API\Plugins\MetasoundGraphCore\FAudioBufferWriteRef) & InRightAudio )


className: FStereoAudioFormat

description: The audio buffers are shared data references which can be accessed outside of theFStereoAudioFormat.

code: class FStereoAudioFormat : public [Metasound::TStaticChannelAudioFormat< 2 >](API\Plugins\MetasoundStandardNodes\TStaticChannelAudioFormat)


className: FStereoAudioFormatReadRef


className: FStereoAudioFormatTypeInfo


className: FStereoAudioFormatWriteRef


code: FTriangleOscilatorNode ( const [FVertexName](API\Plugins\MetasoundGraphCore\FVertexName) & InInstanceName, const [FGuid](API\Runtime\Core\Misc\FGuid) & InInstanceID, float InDefaultFrequency, float InDefautlGlideTime, bool bInDefaultEnablement )


className: FTriangleOscilatorNode

code: class FTriangleOscilatorNode : public [Metasound::FOscilatorNodeBase](API\Plugins\MetasoundStandardNodes\FOscilatorNodeBase)


code: FTriggerRepeatNode ( const [FNodeInitData](API\Plugins\MetasoundGraphCore\FNodeInitData) & InInitData )


code: virtual ~FTriggerRepeatNode()


code: FTriggerToggleNode ( const [FNodeInitData](API\Plugins\MetasoundGraphCore\FNodeInitData) & InInitData )


className: FTriggerRepeatNode

code: class FTriggerRepeatNode : public [Metasound::FNodeFacade](API\Plugins\MetasoundGraphCore\FNodeFacade)


code: virtual ~FTriggerToggleNode()


code: FTriangleOscilatorNode ( const [FNodeInitData](API\Plugins\MetasoundGraphCore\FNodeInitData) & InInitData )


className: FTriggerToggleNode

code: class FTriggerToggleNode : public [Metasound::FNodeFacade](API\Plugins\MetasoundGraphCore\FNodeFacade)


description: Forward Declarations

code: namespace Metasound { enum EEnvelopePeakMode { Peak = 0, MeanSquared, RootMeanSquared, } }


description: Representation of a gain

code: namespace Metasound { enum EGainRepresentation { Linear, Decibels, } }


description: Forward Declarations

code: namespace Metasound { enum ETriggerComparisonType { Equals, NotEquals, LessThan, GreaterThan, LessThanOrEquals, GreaterThanOrEquals, } }


code: namespace Metasound { namespace RandomNodeNames { static const TCHAR * Metasound::RandomNodeNames::InputNextTriggerName = TEXT( "Next" ); } }


code: namespace Metasound { namespace RandomNodeNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::RandomNodeNames::InputNextTriggerTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Trigger to generate the next random integer." ), TEXT( "MetasoundStandardNodes" ), TEXT( "InputNextTrigger" "Tooltip" )); } }


code: namespace Metasound { namespace RandomNodeNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::RandomNodeNames::OutputOnNextTriggerTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Triggers when next is triggered." ), TEXT( "MetasoundStandardNodes" ), TEXT( "OutputOnNextTrigger" "Tooltip" )); } }


code: namespace Metasound { namespace RandomNodeNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::RandomNodeNames::OutputOnNextTriggerDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "On Next" ), TEXT( "MetasoundStandardNodes" ), TEXT( "OutputOnNextTrigger" "DisplayName" )); } }


code: namespace Metasound { namespace RandomNodeNames { static const TCHAR * Metasound::RandomNodeNames::OutputOnResetTriggerName = TEXT( "On Reset" ); } }


code: namespace Metasound { namespace RandomNodeNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::RandomNodeNames::OutputOnResetTriggerTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Triggers when reset is triggered." ), TEXT( "MetasoundStandardNodes" ), TEXT( "OutputOnResetTrigger" "Tooltip" )); } }


code: namespace Metasound { namespace RandomNodeNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::RandomNodeNames::OutputOnResetTriggerDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "On Reset" ), TEXT( "MetasoundStandardNodes" ), TEXT( "OutputOnResetTrigger" "DisplayName" )); } }


code: namespace Metasound { namespace RandomNodeNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::RandomNodeNames::OutputValueDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Value" ), TEXT( "MetasoundStandardNodes" ), TEXT( "OutputValue" "DisplayName" )); } }


code: namespace Metasound { namespace RandomNodeNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::RandomNodeNames::InputNextTriggerDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Next" ), TEXT( "MetasoundStandardNodes" ), TEXT( "InputNextTrigger" "DisplayName" )); } }


code: namespace Metasound { namespace RandomNodeNames { static const TCHAR * Metasound::RandomNodeNames::InputResetTriggerName = TEXT( "Reset" ); } }


code: namespace Metasound { namespace RandomNodeNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::RandomNodeNames::InputResetTriggerTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Trigger to reset the random sequence with the supplied seed. Useful to get randomized repetition." ), TEXT( "MetasoundStandardNodes" ), TEXT( "InputResetTrigger" "Tooltip" )); } }


code: namespace Metasound { namespace RandomNodeNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::RandomNodeNames::InputResetTriggerDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Reset" ), TEXT( "MetasoundStandardNodes" ), TEXT( "InputResetTrigger" "DisplayName" )); } }


code: namespace Metasound { namespace RandomNodeNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::RandomNodeNames::InputSeedDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Seed" ), TEXT( "MetasoundStandardNodes" ), TEXT( "InputSeed" "DisplayName" )); } }


code: namespace Metasound { namespace RandomNodeNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::RandomNodeNames::InputMinDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Min" ), TEXT( "MetasoundStandardNodes" ), TEXT( "InputMin" "DisplayName" )); } }


code: namespace Metasound { namespace RandomNodeNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::RandomNodeNames::InputMaxDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Max" ), TEXT( "MetasoundStandardNodes" ), TEXT( "InputMax" "DisplayName" )); } }


code: namespace Metasound { namespace RandomNodeNames { static const TCHAR * Metasound::RandomNodeNames::InputSeedName = TEXT( "Seed" ); } }


code: namespace Metasound { namespace RandomNodeNames { static const TCHAR * Metasound::RandomNodeNames::OutputOnNextTriggerName = TEXT( "On Next" ); } }


code: namespace Metasound { namespace RandomNodeNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::RandomNodeNames::InputSeedTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "The seed value to usefor the random node. Set to -1 to use a random seed." ), TEXT( "MetasoundStandardNodes" ), TEXT( "InputSeed" "Tooltip" )); } }


code: namespace Metasound { namespace RandomNodeNames { static const TCHAR * Metasound::RandomNodeNames::InputMinName = TEXT( "Min" ); } }


code: namespace Metasound { namespace RandomNodeNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::RandomNodeNames::InputMinTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Min random value." ), TEXT( "MetasoundStandardNodes" ), TEXT( "InputMin" "Tooltip" )); } }


code: namespace Metasound { namespace RandomNodeNames { static const TCHAR * Metasound::RandomNodeNames::InputMaxName = TEXT( "Max" ); } }


code: namespace Metasound { namespace RandomNodeNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::RandomNodeNames::InputMaxTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Max random value." ), TEXT( "MetasoundStandardNodes" ), TEXT( "InputMax" "Tooltip" )); } }


code: namespace Metasound { namespace RandomNodeNames { static const TCHAR * Metasound::RandomNodeNames::OutputValueName = TEXT( "Value" ); } }


code: namespace Metasound { namespace RandomNodeNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::RandomNodeNames::OutputValueTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "The randomly generated value." ), TEXT( "MetasoundStandardNodes" ), TEXT( "OutputValue" "Tooltip" )); } }


code: namespace Metasound { namespace TriggerAccumulatorVertexNames { static const TCHAR * Metasound::TriggerAccumulatorVertexNames::InputAutoResetName = TEXT( "Auto Reset" ); } }


code: namespace Metasound { namespace TriggerAccumulatorVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::TriggerAccumulatorVertexNames::InputAutoResetTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Input trigger resets the trigger accumulation count." ), TEXT( "MetasoundStandardNodes_AccumulatorNode" ), TEXT( "InputAutoReset" "Tooltip" )); } }


code: namespace Metasound { namespace TriggerCompareVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::TriggerCompareVertexNames::InputCompareTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Trigger to compare A and B." ), TEXT( "MetasoundStandardNodes_CompareNode" ), TEXT( "InputCompare" "Tooltip" )); } }


code: namespace Metasound { namespace TriggerCompareVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::TriggerCompareVertexNames::InputCompareDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Compare" ), TEXT( "MetasoundStandardNodes_CompareNode" ), TEXT( "InputCompare" "DisplayName" )); } }


code: namespace Metasound { namespace TriggerCompareVertexNames { static const TCHAR * Metasound::TriggerCompareVertexNames::InputParamAName = TEXT( "A" ); } }


code: namespace Metasound { namespace TriggerCompareVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::TriggerCompareVertexNames::InputParamATooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "The first value, A, to compare against." ), TEXT( "MetasoundStandardNodes_CompareNode" ), TEXT( "InputParamA" "Tooltip" )); } }


code: namespace Metasound { namespace TriggerCompareVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::TriggerCompareVertexNames::InputParamADisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "A" ), TEXT( "MetasoundStandardNodes_CompareNode" ), TEXT( "InputParamA" "DisplayName" )); } }


code: namespace Metasound { namespace TriggerCompareVertexNames { static const TCHAR * Metasound::TriggerCompareVertexNames::InputParamBName = TEXT( "B" ); } }


code: namespace Metasound { namespace TriggerCompareVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::TriggerCompareVertexNames::InputParamBTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "The first value, B, to compare against." ), TEXT( "MetasoundStandardNodes_CompareNode" ), TEXT( "InputParamB" "Tooltip" )); } }


code: namespace Metasound { namespace TriggerCompareVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::TriggerCompareVertexNames::InputParamBDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "B" ), TEXT( "MetasoundStandardNodes_CompareNode" ), TEXT( "InputParamB" "DisplayName" )); } }


code: namespace Metasound { namespace TriggerCompareVertexNames { static const TCHAR * Metasound::TriggerCompareVertexNames::InputCompareTypeName = TEXT( "Type" ); } }


code: namespace Metasound { namespace TriggerCompareVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::TriggerCompareVertexNames::InputCompareTypeTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "How to compare A and B." ), TEXT( "MetasoundStandardNodes_CompareNode" ), TEXT( "InputCompareType" "Tooltip" )); } }


code: namespace Metasound { namespace TriggerAccumulatorVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::TriggerAccumulatorVertexNames::InputAutoResetDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Auto Reset" ), TEXT( "MetasoundStandardNodes_AccumulatorNode" ), TEXT( "InputAutoReset" "DisplayName" )); } }


code: namespace Metasound { namespace TriggerCompareVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::TriggerCompareVertexNames::InputCompareTypeDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Type" ), TEXT( "MetasoundStandardNodes_CompareNode" ), TEXT( "InputCompareType" "DisplayName" )); } }


code: namespace Metasound { namespace TriggerCompareVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::TriggerCompareVertexNames::OutputOnTrueTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Output trigger for when the comparison is true." ), TEXT( "MetasoundStandardNodes_CompareNode" ), TEXT( "OutputOnTrue" "Tooltip" )); } }


code: namespace Metasound { namespace TriggerCompareVertexNames { static const TCHAR * Metasound::TriggerCompareVertexNames::OutputOnTrueName = TEXT( "True" ); } }


code: namespace Metasound { namespace TriggerCompareVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::TriggerCompareVertexNames::OutputOnTrueDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "True" ), TEXT( "MetasoundStandardNodes_CompareNode" ), TEXT( "OutputOnTrue" "DisplayName" )); } }


code: namespace Metasound { namespace TriggerCompareVertexNames { static const TCHAR * Metasound::TriggerCompareVertexNames::OutputOnFalseName = TEXT( "False" ); } }


code: namespace Metasound { namespace TriggerCompareVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::TriggerCompareVertexNames::OutputOnFalseTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Output trigger for when the comparison is false." ), TEXT( "MetasoundStandardNodes_CompareNode" ), TEXT( "OutputOnFalse" "Tooltip" )); } }


code: namespace Metasound { namespace TriggerCompareVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::TriggerCompareVertexNames::OutputOnFalseDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "False" ), TEXT( "MetasoundStandardNodes_CompareNode" ), TEXT( "OutputOnFalse" "DisplayName" )); } }


code: namespace Metasound { namespace TriggerAccumulatorVertexNames { static const TCHAR * Metasound::TriggerAccumulatorVertexNames::InputTriggerName = TEXT( "In {0}" ); } }


code: namespace Metasound { namespace TriggerAccumulatorVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::TriggerAccumulatorVertexNames::InputTriggerTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Trigger {0} input. All trigger inputs must be triggered before the output trigger is hit." ), TEXT( "MetasoundStandardNodes_AccumulatorNode" ), TEXT( "InputTrigger" "Tooltip" )); } }


code: namespace Metasound { namespace TriggerAccumulatorVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::TriggerAccumulatorVertexNames::InputTriggerDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "In {0}" ), TEXT( "MetasoundStandardNodes_AccumulatorNode" ), TEXT( "InputTrigger" "DisplayName" )); } }


code: namespace Metasound { namespace TriggerAccumulatorVertexNames { static const TCHAR * Metasound::TriggerAccumulatorVertexNames::AccumulateOutputOnTriggerName = TEXT( "Out" ); } }


code: namespace Metasound { namespace TriggerAccumulatorVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::TriggerAccumulatorVertexNames::AccumulateOutputOnTriggerTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Triggered when all input triggers have been triggered. Call Reset to reset the state or use \"Auto Reset\"." ), TEXT( "MetasoundStandardNodes_AccumulatorNode" ), TEXT( "AccumulateOutputOnTrigger" "Tooltip" )); } }


code: namespace Metasound { namespace TriggerAccumulatorVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::TriggerAccumulatorVertexNames::AccumulateOutputOnTriggerDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Out" ), TEXT( "MetasoundStandardNodes_AccumulatorNode" ), TEXT( "AccumulateOutputOnTrigger" "DisplayName" )); } }


code: namespace Metasound { namespace TriggerCompareVertexNames { static const TCHAR * Metasound::TriggerCompareVertexNames::InputCompareName = TEXT( "Compare" ); } }


code: namespace Metasound { namespace ValueVertexNames { static const TCHAR * Metasound::ValueVertexNames::InputSetTriggerName = TEXT( "Set" ); } }


code: namespace Metasound { namespace ValueVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ValueVertexNames::InputSetTriggerTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Trigger to write the set value to the output." ), TEXT( "MetasoundStandardNodes_ValueNode" ), TEXT( "InputSetTrigger" "Tooltip" )); } }


code: namespace Metasound { namespace ValueVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ValueVertexNames::InputTargetValueTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Value to immediately set the output to when triggered." ), TEXT( "MetasoundStandardNodes_ValueNode" ), TEXT( "InputTargetValue" "Tooltip" )); } }


code: namespace Metasound { namespace ValueVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ValueVertexNames::InputTargetValueDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Target Value" ), TEXT( "MetasoundStandardNodes_ValueNode" ), TEXT( "InputTargetValue" "DisplayName" )); } }


code: namespace Metasound { namespace ValueVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ValueVertexNames::OutputOnSetTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Triggered when the set input is triggered." ), TEXT( "MetasoundStandardNodes_ValueNode" ), TEXT( "OutputOnSet" "Tooltip" )); } }


code: namespace Metasound { namespace ValueVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ValueVertexNames::OutputOnSetDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "On Set" ), TEXT( "MetasoundStandardNodes_ValueNode" ), TEXT( "OutputOnSet" "DisplayName" )); } }


code: namespace Metasound { namespace ValueVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ValueVertexNames::OutputOnResetTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Triggered when the reset input is triggered." ), TEXT( "MetasoundStandardNodes_ValueNode" ), TEXT( "OutputOnReset" "Tooltip" )); } }


code: namespace Metasound { namespace ValueVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ValueVertexNames::OutputOnResetDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "On Reset" ), TEXT( "MetasoundStandardNodes_ValueNode" ), TEXT( "OutputOnReset" "DisplayName" )); } }


code: namespace Metasound { namespace ValueVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ValueVertexNames::OutputValueTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "The current output value." ), TEXT( "MetasoundStandardNodes_ValueNode" ), TEXT( "OutputValue" "Tooltip" )); } }


code: namespace Metasound { namespace ValueVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ValueVertexNames::OutputValueDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Output Value" ), TEXT( "MetasoundStandardNodes_ValueNode" ), TEXT( "OutputValue" "DisplayName" )); } }


code: namespace Metasound { namespace ValueVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ValueVertexNames::InputSetTriggerDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Set" ), TEXT( "MetasoundStandardNodes_ValueNode" ), TEXT( "InputSetTrigger" "DisplayName" )); } }


code: namespace Metasound { namespace ValueVertexNames { static const TCHAR * Metasound::ValueVertexNames::InputResetTriggerName = TEXT( "Reset" ); } }


code: namespace Metasound { namespace ValueVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ValueVertexNames::InputResetTriggerTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Trigger to reset the value to the initial value." ), TEXT( "MetasoundStandardNodes_ValueNode" ), TEXT( "InputResetTrigger" "Tooltip" )); } }


code: namespace Metasound { namespace ValueVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ValueVertexNames::InputResetTriggerDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Reset" ), TEXT( "MetasoundStandardNodes_ValueNode" ), TEXT( "InputResetTrigger" "DisplayName" )); } }


code: namespace Metasound { namespace ValueVertexNames { static const TCHAR * Metasound::ValueVertexNames::InputInitValueName = TEXT( "Init Value" ); } }


code: namespace Metasound { namespace ValueVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ValueVertexNames::InputInitValueTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Value to initialize the output value to." ), TEXT( "MetasoundStandardNodes_ValueNode" ), TEXT( "InputInitValue" "Tooltip" )); } }


code: namespace Metasound { namespace ValueVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ValueVertexNames::InputInitValueDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Init Value" ), TEXT( "MetasoundStandardNodes_ValueNode" ), TEXT( "InputInitValue" "DisplayName" )); } }


code: namespace Metasound { namespace ValueVertexNames { static const TCHAR * Metasound::ValueVertexNames::InputTargetValueName = TEXT( "Target Value" ); } }


code: namespace Metasound { namespace ValueVertexNames { static const TCHAR * Metasound::ValueVertexNames::OutputOnSetName = TEXT( "On Set" ); } }


code: namespace Metasound { namespace ValueVertexNames { static const TCHAR * Metasound::ValueVertexNames::OutputOnResetName = TEXT( "On Reset" ); } }


code: namespace Metasound { namespace ValueVertexNames { static const TCHAR * Metasound::ValueVertexNames::OutputValueName = TEXT( "Output Value" ); } }


code: static METASOUNDSTANDARDNODES_API const FText & GetTypeDisplayText&40;&41;


className: TypeId

code: static TypeId;


className: TypeName

code: static TypeName;


className: TypePtr

code: static TypePtr;


code: template<> struct TDataReferenceTypeInfo< FEnumTriggerComparisonType >


code: template<> struct TDataReferenceTypeInfo< FEnumEMusicalScale >


code: template<> struct TDataReferenceTypeInfo< FEnumEnvelopePeakMode >


description: TODO: currently unused. Commenting out to keep clean UX. DECLARE_METASOUND_DATA_REFERENCE_TYPES(FMultichannelAudioFormat, METASOUNDSTANDARDNODES_API, FMultichannelAudioFormatTypeInfo, FMultichannelAudioFormatReadRef, FMultichannelAudioFormatWriteRef);

code: template<> struct TDataReferenceTypeInfo< FMonoAudioFormat >


code: template<> struct TDataReferenceTypeInfo< FStereoAudioFormat >


description: Constructor used by theMetasoundFrontend.

code: TRandomNode ( const [FNodeInitData](API\Plugins\MetasoundGraphCore\FNodeInitData) & InInitData )


code: virtual ~TRandomNode()


className: TRandomNode

description: Generates a random float value when triggered.

code: template<typename ValueType> class TRandomNode : public [Metasound::FNodeFacade](API\Plugins\MetasoundGraphCore\FNodeFacade)


description: // Update MyBufferPtr in case AudioBuffer references a newFAudioBuffer. MyBufferPtr = AudioBuffer->GetData(); }

code: virtual void BindInputs ( [FInputVertexInterfaceData](API\Plugins\MetasoundGraphCore\FInputVertexInterfaceData) & InVertexData )


code: virtual void BindOutputs ( [FOutputVertexInterfaceData](API\Plugins\MetasoundGraphCore\FOutputVertexInterfaceData) & InVertexData )


code: static [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [IOperator](API\Plugins\MetasoundGraphCore\IOperator) > CreateOperator ( const [FCreateOperatorParams](API\Plugins\MetasoundGraphCore\FCreateOperatorParams) & InParams, [TArray](API\Runtime\Core\Containers\TArray)< [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [IOperatorBuildError](API\Plugins\MetasoundGraphCore\IOperatorBuildError) >> & OutErrors )


className: DefaultSeed

code: static constexpr int32 DefaultSeed = -1;


code: static const [FVertexInterface](API\Plugins\MetasoundGraphCore\FVertexInterface) & GetDefaultInterface()


description: Note: IOperators which do not correctly implement BindInputs(...) and BindOutputs(...) will not function correctly with MetaSound operator caching and live auditioning in the MetaSound Builder BP API.

code: virtual [FDataReferenceCollection](API\Plugins\MetasoundGraphCore\FDataReferenceCollection) GetInputs() const


code: static const [FNodeClassMetadata](API\Plugins\MetasoundGraphCore\FNodeClassMetadata) & GetNodeInfo()


code: virtual [FDataReferenceCollection](API\Plugins\MetasoundGraphCore\FDataReferenceCollection) GetOutputs() const


description: Externally visible initialize function.

code: void Reset ( const [IOperator::FResetParams](API\Plugins\MetasoundGraphCore\IOperator\FResetParams) & InParams )


code: TRandomNodeOperator ( const [FOperatorSettings](API\Plugins\MetasoundGraphCore\FOperatorSettings) & InSettings, [TDataReadReference](API\Plugins\MetasoundGraphCore\TDataReadReference)< [FTrigger](API\Plugins\MetasoundFrontend\FTrigger) > InNextTrigger, [TDataReadReference](API\Plugins\MetasoundGraphCore\TDataReadReference)< [FTrigger](API\Plugins\MetasoundFrontend\FTrigger) > InResetTrigger, [TDataReadReference](API\Plugins\MetasoundGraphCore\TDataReadReference)< int32 > InSeedValue )


code: TRandomNodeOperator ( const [FOperatorSettings](API\Plugins\MetasoundGraphCore\FOperatorSettings) & InSettings, [TDataReadReference](API\Plugins\MetasoundGraphCore\TDataReadReference)< [FTrigger](API\Plugins\MetasoundFrontend\FTrigger) > InNextTrigger, [TDataReadReference](API\Plugins\MetasoundGraphCore\TDataReadReference)< [FTrigger](API\Plugins\MetasoundFrontend\FTrigger) > InResetTrigger, [TDataReadReference](API\Plugins\MetasoundGraphCore\TDataReadReference)< int32 > InSeedValue, [TDataReadReference](API\Plugins\MetasoundGraphCore\TDataReadReference)< ValueType > InMinValue, [TDataReadReference](API\Plugins\MetasoundGraphCore\TDataReadReference)< ValueType > InMaxValue )


code: virtual ~TRandomNodeOperator()


className: TRandomNodeOperator

code: template<typename ValueType> class TRandomNodeOperator : public [Metasound::TExecutableOperator< TRandomNodeOperator< ValueType > >](API\Plugins\MetasoundGraphCore\TExecutableOperator)


className: TRandomNodeSpecialization

code: template<typename ValueType> struct TRandomNodeSpecialization


code: static TDataReadReference< bool > CreateMaxValueRef &40; const FDataReferenceCollection &, const FInputVertexInterface &, const FOperatorSettings & &41;


code: static TDataReadReference< bool > CreateMinValueRef &40; const FDataReferenceCollection &, const FInputVertexInterface &, const FOperatorSettings & &41;


code: static FName GetClassName&40;&41;


code: static bool GetDefaultMax&40;&41;


code: static bool GetDefaultMin&40;&41;


code: static FText GetDescription&40;&41;


code: static FText GetDisplayName&40;&41;


code: static bool GetNextValue &40; FRandomStream & InStream, bool, bool &41;


code: static bool HasRange&40;&41;


className: TRandomNodeSpecialization< bool >

code: template<> struct TRandomNodeSpecialization< bool >


code: static TDataReadReference< float > CreateMaxValueRef &40; const FDataReferenceCollection & InputCollection, const FInputVertexInterface & InputInterface, const FOperatorSettings & InOperatorSettings &41;


code: static TDataReadReference< float > CreateMinValueRef &40; const FDataReferenceCollection & InputCollection, const FInputVertexInterface & InputInterface, const FOperatorSettings & InOperatorSettings &41;


code: static float GetDefaultMax&40;&41;


code: static float GetDefaultMin&40;&41;


code: static float GetNextValue &40; FRandomStream & InStream, float InMin, float InMax &41;


className: TRandomNodeSpecialization< float >

code: template<> struct TRandomNodeSpecialization< float >


code: static TDataReadReference< FTime > CreateMaxValueRef &40; const FDataReferenceCollection & InputCollection, const FInputVertexInterface & InputInterface, const FOperatorSettings & InOperatorSettings &41;


code: static TDataReadReference< FTime > CreateMinValueRef &40; const FDataReferenceCollection & InputCollection, const FInputVertexInterface & InputInterface, const FOperatorSettings & InOperatorSettings &41;


code: static FTime GetNextValue &40; FRandomStream & InStream, FTime InMin, FTime InMax &41;


className: TRandomNodeSpecialization< FTime >

code: template<> struct TRandomNodeSpecialization< FTime >


code: static TDataReadReference< int32 > CreateMaxValueRef &40; const FDataReferenceCollection & InputCollection, const FInputVertexInterface & InputInterface, const FOperatorSettings & InOperatorSettings &41;


code: static TDataReadReference< int32 > CreateMinValueRef &40; const FDataReferenceCollection & InputCollection, const FInputVertexInterface & InputInterface, const FOperatorSettings & InOperatorSettings &41;


code: static FName GetClassName&40;&41;


code: static int32 GetDefaultMax&40;&41;


code: static int32 GetDefaultMin&40;&41;


code: static FText GetDescription&40;&41;


code: static FText GetDisplayName&40;&41;


code: static int32 GetNextValue &40; FRandomStream & InStream, int32 InMin, int32 InMax &41;


code: static bool HasRange&40;&41;


className: TRandomNodeSpecialization< int32 >

code: template<> struct TRandomNodeSpecialization< int32 >


description: Return an readable buffer reference for a specific channel.

code: template<int32 ChannelIndex> [FAudioBufferReadRef](API\Plugins\MetasoundGraphCore\FAudioBufferReadRef) GetBuffer() const


description: Return an writable buffer reference for a specific channel.

code: template<int32 ChannelIndex> [FAudioBufferWriteRef](API\Plugins\MetasoundGraphCore\FAudioBufferWriteRef) GetBuffer()


description: This array will haveGetNumChannels()elements.

code: const [TArrayView](API\Runtime\Core\Containers\TArrayView)< [FAudioBufferReadRef](API\Plugins\MetasoundGraphCore\FAudioBufferReadRef) > GetBuffers() const


code: const [TArrayView](API\Runtime\Core\Containers\TArrayView)< [FAudioBufferWriteRef](API\Plugins\MetasoundGraphCore\FAudioBufferWriteRef) > GetBuffers()


description: Return the maximum number of channels. static channel audio buffers cannot be resized after construction.

code: int32 GetMaxNumChannels() const


description: Return the number of audio channels.

code: int32 GetNumChannels() const


code: const [TArray](API\Runtime\Core\Containers\TArray)< [FAudioBufferWriteRef](API\Plugins\MetasoundGraphCore\FAudioBufferWriteRef) > GetStorage()


code: const [TArray](API\Runtime\Core\Containers\TArray)< [FAudioBufferReadRef](API\Plugins\MetasoundGraphCore\FAudioBufferReadRef) > GetStorage() const


className: NumChannels

code: static constexpr int32 NumChannels = TNumChannels;


description: TStaticChannelAudioFormatConstructor

code: TStaticChannelAudioFormat ( int32 InNumFrames )


code: TStaticChannelAudioFormat ( const [FOperatorSettings](API\Plugins\MetasoundGraphCore\FOperatorSettings) & InOperatorSettings )


description: TStaticChannelAudioFormatconstructor with an array of writable buffers.

code: TStaticChannelAudioFormat ( const [FAudioBufferWriteRef](API\Plugins\MetasoundGraphCore\FAudioBufferWriteRef)(&) InBuffers )


className: TStaticChannelAudioFormat

description: The audio buffers inFMultichannelAudioFormatare shared data references which can be accessed outside of theFMultichannelAudioFormat. All audio buffers within aFMultichannelAudioFormatobject must contain the same number of audio frames.

code: template<int32 TNumChannels> class TStaticChannelAudioFormat : public [Metasound::IAudioDataType](API\Plugins\MetasoundGraphCore\IAudioDataType)


code: TTriggerAccumulatorNode ( const [FNodeInitData](API\Plugins\MetasoundGraphCore\FNodeInitData) & InInitData )


code: virtual ~TTriggerAccumulatorNode()


className: TTriggerAccumulatorNode

description: Routes values from multiple input pins to a single output pin based on trigger inputs.

code: template<uint32 NumInputs> class TTriggerAccumulatorNode : public [Metasound::FNodeFacade](API\Plugins\MetasoundGraphCore\FNodeFacade)


code: virtual void BindInputs ( [FInputVertexInterfaceData](API\Plugins\MetasoundGraphCore\FInputVertexInterfaceData) & InVertexData )


code: virtual void BindOutputs ( [FOutputVertexInterfaceData](API\Plugins\MetasoundGraphCore\FOutputVertexInterfaceData) & InVertexData )


code: static [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [IOperator](API\Plugins\MetasoundGraphCore\IOperator) > CreateOperator ( const [FCreateOperatorParams](API\Plugins\MetasoundGraphCore\FCreateOperatorParams) & InParams, [TArray](API\Runtime\Core\Containers\TArray)< [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [IOperatorBuildError](API\Plugins\MetasoundGraphCore\IOperatorBuildError) >> & OutErrors )


code: static const [FVertexInterface](API\Plugins\MetasoundGraphCore\FVertexInterface) & GetDefaultInterface()


code: virtual [FDataReferenceCollection](API\Plugins\MetasoundGraphCore\FDataReferenceCollection) GetInputs() const


code: static const [FNodeClassMetadata](API\Plugins\MetasoundGraphCore\FNodeClassMetadata) & GetNodeInfo()


code: virtual [FDataReferenceCollection](API\Plugins\MetasoundGraphCore\FDataReferenceCollection) GetOutputs() const


code: void Reset ( const [IOperator::FResetParams](API\Plugins\MetasoundGraphCore\IOperator\FResetParams) & InParams )


code: void ResetTriggerState()


code: void TriggerOutputIfReady ( int32 InStartFrame )


code: TTriggerAccumulatorOperator ( const [FOperatorSettings](API\Plugins\MetasoundGraphCore\FOperatorSettings) & InSettings, const [FBoolReadRef](API\Plugins\MetasoundFrontend\FBoolReadRef) & bInAutoReset, const [TArray](API\Runtime\Core\Containers\TArray)< [FTriggerReadRef](API\Plugins\MetasoundFrontend\FTriggerReadRef) > && InInputTriggers )


code: virtual ~TTriggerAccumulatorOperator()