className: IInterfaceRegistryEntry

code: class IInterfaceRegistryEntry


module: MetasoundFrontend

code: namespace Metasound { namespace Frontend { void Metasound::Frontend::GatherRequiredEnvironmentVariables ( const [FMetasoundFrontendClass](API\Plugins\MetasoundFrontend\FMetasoundFrontendClass) & InClass, [TArray](API\Runtime\Core\Containers\TArray)< [FMetasoundFrontendClassEnvironmentVariable](API\Plugins\MetasoundFrontend\FMetasoundFrontendClassEnvironme-) > & OutEnvironmentVariables ) } }


description: Returns information describing connectability between this output and the supplied input.

code: [FConnectability](API\Plugins\MetasoundFrontend\FConnectability) CanConnectTo ( const [IInputController](API\Plugins\MetasoundFrontend\IInputController) & InController ) const


description:
Connects this output and the supplied input.
True on success, false on failure.

code: bool Connect ( [IInputController](API\Plugins\MetasoundFrontend\IInputController) & InController )


description:
Connects this output to the input using a converter node.
True on success, false on failure.

code: bool ConnectWithConverterNode ( [IInputController](API\Plugins\MetasoundFrontend\IInputController) & InController, const [FConverterNodeInfo](API\Plugins\MetasoundFrontend\FConverterNodeInfo) & InNodeClassName )


description:
Disconnects this output from the input.
True on success, false on failure.

code: bool Disconnect ( [IInputController](API\Plugins\MetasoundFrontend\IInputController) & InController )


description: Returns the currently connected output. If this input is not connected, the returned handle will be invalid.

code: [TArray](API\Runtime\Core\Containers\TArray)< [FConstInputHandle](API\Plugins\MetasoundFrontend\FConstInputHandle) > GetConstConnectedInputs() const


description: Returns the data type name associated with this output.

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


description: Returns the human readable name associated with this output.


description: Returns all metadata associated with this output.

code: const [FMetasoundFrontendVertexMetadata](API\Plugins\MetasoundFrontend\FMetasoundFrontendVertexMetadata) & GetMetadata() const


description: Returns a FNodeHandle to the node which owns this output.


description: Returns the name associated with this output.

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


description: Returns a FConstNodeHandle to the node which owns this output.


description: Returns the ID of the node which owns this output.


description: Returns the tooltip associated with this output.

code: const [FText](API\Runtime\Core\Internationalization\FText) & GetTooltip() const


description: Returns the vertex access type.


description: Return true if the input is connect to an output.

code: bool IsConnected() const


description: Returns true if the output connections can be directly modified by a user. Returns false otherwise.

code: bool IsConnectionUserModifiable() const


description: Returns true if the controller is in a valid state.

code: bool IsValid() const


description: This should only be used as a means of fixing up vertex names for document model versioning transform(s).

code: void SetName ( const [FVertexName](API\Plugins\MetasoundGraphCore\FVertexName) & InName )


code: virtual ~IOutputController()


className: IOutputController

description: AnIOutputControllerprovides methods for querying and manipulating a metasound output vertex.

code: class IOutputController : public [TSharedFromThis< IOutputController >](API\Runtime\Core\Templates\TSharedFromThis), public [Metasound::Frontend::IDocumentAccessor](API\Plugins\MetasoundFrontend\IDocumentAccessor)


code: [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [IOutputStorage](API\Plugins\MetasoundFrontend\IOutputStorage) > Clone() const


code: virtual ~IOutputStorage()


className: IOutputStorage

code: class IOutputStorage


className: IParameterAssignmentFunction

code: typedef [TUniqueFunction](API\Runtime\Core\Templates\TUniqueFunction)< void(const void *, void *)> IParameterAssignmentFunction


code: IReceiver ( [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< [IDataChannel](API\Plugins\MetasoundFrontend\IDataChannel), ESPMode::ThreadSafe > InDataChannel, [FName](API\Runtime\Core\UObject\FName) DataType )


className: IReceiver

description: This is a handle to something that will retrieve a datatype. Intentionally opaque- to use, one will need to callIReceiver::GetAs>().

code: class IReceiver : public [Metasound::IDataTransmissionBase](API\Plugins\MetasoundFrontend\IDataTransmissionBase)

DataChannel

type: TSharedPtr<IDa...


description: Find all FMetasoundFrontendClasses. (Optional) Include all versions (i.e. deprecated classes and versions of classes that are not the highest major version).

code: [TArray](API\Runtime\Core\Containers\TArray)< [FMetasoundFrontendClass](API\Plugins\MetasoundFrontend\FMetasoundFrontendClass) > FindAllClasses ( bool bInIncludeAllVersions )


description: Returns array with all registered interfaces. Optionally, include interface versions that are not the highest version.

code: [TArray](API\Runtime\Core\Containers\TArray)< [FMetasoundFrontendInterface](API\Plugins\MetasoundFrontend\FMetasoundFrontendInterface) > FindAllInterfaces ( bool bInIncludeAllVersions )


code: [TArray](API\Runtime\Core\Containers\TArray)< [FMetasoundFrontendVersion](API\Plugins\MetasoundFrontend\FMetasoundFrontendVersion) > FindAllRegisteredInterfacesWithName ( [FName](API\Runtime\Core\UObject\FName) InInterfaceName )


description: Find all classes with the given ClassName. (Optional) Sort matches based on version.

code: [TArray](API\Runtime\Core\Containers\TArray)< [FMetasoundFrontendClass](API\Plugins\MetasoundFrontend\FMetasoundFrontendClass) > FindClassesWithName ( const [FMetasoundFrontendClassName](API\Plugins\MetasoundFrontend\FMetasoundFrontendClassName) & InName, bool bInSortByVersion )


description: Find the class with the given ClassName & Major Version. Returns false if not found, true if found.

code: bool FindClassWithHighestMinorVersion ( const [FMetasoundFrontendClassName](API\Plugins\MetasoundFrontend\FMetasoundFrontendClassName) & InName, int32 InMajorVersion, [FMetasoundFrontendClass](API\Plugins\MetasoundFrontend\FMetasoundFrontendClass) & OutClass )


code: bool FindInterfaceWithHighestVersion ( [FName](API\Runtime\Core\UObject\FName) InInterfaceName, [FMetasoundFrontendInterface](API\Plugins\MetasoundFrontend\FMetasoundFrontendInterface) & OutInterface )


description: Find the highest version of a class with the given ClassName. Returns false if not found, true if found.

code: bool FindClassWithHighestVersion ( const [FMetasoundFrontendClassName](API\Plugins\MetasoundFrontend\FMetasoundFrontendClassName) & InName, [FMetasoundFrontendClass](API\Plugins\MetasoundFrontend\FMetasoundFrontendClass) & OutClass )


description: Deprecated* UseISearchEngine::FindUClassDefaultInterfaceVersionsusing TopLevelAssetPath instead.

code: [TArray](API\Runtime\Core\Containers\TArray)< [FMetasoundFrontendInterface](API\Plugins\MetasoundFrontend\FMetasoundFrontendInterface) > FindUClassDefaultInterfaces ( [FName](API\Runtime\Core\UObject\FName) InUClassName )


description: Returns all interfaces that are to be added to a given document when it is initialized on an object with the given class

code: [TArray](API\Runtime\Core\Containers\TArray)< [FMetasoundFrontendVersion](API\Plugins\MetasoundFrontend\FMetasoundFrontendVersion) > FindUClassDefaultInterfaceVersions ( const [FTopLevelAssetPath](API\Runtime\CoreUObject\UObject\FTopLevelAssetPath) & InUClassPath )


description: Return an instance of a search engine.

code: static [ISearchEngine](API\Plugins\MetasoundFrontend\ISearchEngine) & Get()


description: Updates internal state to speed up queries.

code: void Prime()


className: ISearchEngine

description: Interface for frontend search engine. A frontend search engine provides a simple interface for common frontend queries. It also serves as an opportunity to cache queries to reduce CPU load.

code: class ISearchEngine


code: int64 GetPayloadID() const


code: virtual ~ISearchEngine()


code: ISender ( [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< [IDataChannel](API\Plugins\MetasoundFrontend\IDataChannel), ESPMode::ThreadSafe > InDataChannel, [FName](API\Runtime\Core\UObject\FName) DataType )


description: Constructs the value with a literal and pushes to data channel.

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


description: Returns the accessor nodes associated with this variable.


className: ISender

description: This is a handle to something that will retrieve a datatype. Intentionally opaque- to use, one will need to callISender::GetAs>().

code: class ISender : public [Metasound::IDataTransmissionBase](API\Plugins\MetasoundFrontend\IDataTransmissionBase)


code: [TArray](API\Runtime\Core\Containers\TArray)< [FConstNodeHandle](API\Plugins\MetasoundFrontend\FConstNodeHandle) > FindAccessorNodes() const


description: Returns the deferred accessor nodes associated with this variable.


code: [TArray](API\Runtime\Core\Containers\TArray)< [FConstNodeHandle](API\Plugins\MetasoundFrontend\FConstNodeHandle) > FindDeferredAccessorNodes() const


description: Returns the mutator node associated with this variable.


description: Returns the data type name associated with this variable.

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


description: Returns the human readable description associated with this variable.


description: Returns the human readable name associated with this variable.


description: Returns the variable ID.


description: Returns the value for the given variable instance if set.

code: const [FMetasoundFrontendLiteral](API\Plugins\MetasoundFrontend\FMetasoundFrontendLiteral) & GetLiteral() const


description: Returns the name associated with this variable.

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


description: Returns aFGraphHandleto the node which owns this variable.


description: Returns a FConstGraphHandle to the node which owns this variable.


description: Returns true if the controller is in a valid state.

code: bool IsValid() const


description: Sets the human readable description associated with this variable.

code: void SetDescription ( const [FText](API\Runtime\Core\Internationalization\FText) & InDescription )


description: Sets the human readable name associated with this variable.

code: void SetDisplayName ( const [FText](API\Runtime\Core\Internationalization\FText) & InDisplayName )


description: Sets the value for the given variable instance

code: bool SetLiteral ( const [FMetasoundFrontendLiteral](API\Plugins\MetasoundFrontend\FMetasoundFrontendLiteral) & InLiteral )


description: Sets the name associated with this variable.

code: void SetName ( const [FName](API\Runtime\Core\UObject\FName) & InName )


code: virtual ~IVariableController()


className: IVariableController

code: class IVariableController : public [TSharedFromThis< IVariableController >](API\Runtime\Core\Templates\TSharedFromThis), public [Metasound::Frontend::IDocumentAccessor](API\Plugins\MetasoundFrontend\IDocumentAccessor)


className: LexToString

code: const TCHAR * LexToString ( [EMetasoundFrontendClassType](API\Plugins\MetasoundFrontend\EMetasoundFrontendClassType) InClassType )


code: const TCHAR * LexToString ( [EMetasoundFrontendVertexAccessType](API\Plugins\MetasoundFrontend\EMetasoundFrontendVertexAccessTy-) InVertexAccess )


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


code: namespace Metasound { namespace ArrayNodeRandomGetVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeRandomGetVertexNames::InputTriggerNextValueTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Trigger to get the next value in the randomized array." ), TEXT( "MetasoundFrontend" ), TEXT( "InputTriggerNextValue" "Tooltip" )); } }


code: namespace Metasound { namespace ArrayNodeRandomGetVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeRandomGetVertexNames::InputWeightsTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Input array of weights to usefor random selection. Will repeat ifthis array is shorter than the input array to select from." ), TEXT( "MetasoundFrontend" ), TEXT( "InputWeights" "Tooltip" )); } }


code: namespace Metasound { namespace ArrayNodeRandomGetVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeRandomGetVertexNames::InputWeightsDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Weights" ), TEXT( "MetasoundFrontend" ), TEXT( "InputWeights" "DisplayName" )); } }


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


code: namespace Metasound { namespace ArrayNodeRandomGetVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeRandomGetVertexNames::InputSeedTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Seed to usefor the random shuffle." ), TEXT( "MetasoundFrontend" ), TEXT( "InputSeed" "Tooltip" )); } }


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


code: namespace Metasound { namespace ArrayNodeRandomGetVertexNames { static const TCHAR * Metasound::ArrayNodeRandomGetVertexNames::InputNoRepeatOrderName = TEXT( "No Repeats" ); } }


code: namespace Metasound { namespace ArrayNodeRandomGetVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeRandomGetVertexNames::InputNoRepeatOrderTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "The number of elements to track to avoid repeating in a row." ), TEXT( "MetasoundFrontend" ), TEXT( "InputNoRepeatOrder" "Tooltip" )); } }


code: namespace Metasound { namespace ArrayNodeRandomGetVertexNames { static const TCHAR * Metasound::ArrayNodeRandomGetVertexNames::InputEnableSharedStateName = TEXT( "Enable Shared State" ); } }


code: namespace Metasound { namespace ArrayNodeRandomGetVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeRandomGetVertexNames::InputNoRepeatOrderDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "No Repeats" ), TEXT( "MetasoundFrontend" ), TEXT( "InputNoRepeatOrder" "DisplayName" )); } }


code: namespace Metasound { namespace ArrayNodeRandomGetVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeRandomGetVertexNames::InputTriggerNextValueDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Next" ), TEXT( "MetasoundFrontend" ), TEXT( "InputTriggerNextValue" "DisplayName" )); } }


code: namespace Metasound { namespace ArrayNodeRandomGetVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeRandomGetVertexNames::InputEnableSharedStateTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Set to enabled to share state across instances of this MetaSound." ), TEXT( "MetasoundFrontend" ), TEXT( "InputEnableSharedState" "Tooltip" )); } }


code: namespace Metasound { namespace ArrayNodeRandomGetVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeRandomGetVertexNames::InputEnableSharedStateDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Enable Shared State" ), TEXT( "MetasoundFrontend" ), TEXT( "InputEnableSharedState" "DisplayName" )); } }


code: namespace Metasound { namespace ArrayNodeRandomGetVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeRandomGetVertexNames::OutputTriggerOnNextDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "On Next" ), TEXT( "MetasoundFrontend" ), TEXT( "OutputTriggerOnNext" "DisplayName" )); } }


code: namespace Metasound { namespace ArrayNodeRandomGetVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeRandomGetVertexNames::OutputTriggerOnNextTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Triggers when the \"Next\" input is triggered." ), TEXT( "MetasoundFrontend" ), TEXT( "OutputTriggerOnNext" "Tooltip" )); } }


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


code: namespace Metasound { namespace ArrayNodeRandomGetVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeRandomGetVertexNames::OutputTriggerOnResetTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Triggers when the \"Shuffle\" input is triggered or if the array is auto-shuffled." ), TEXT( "MetasoundFrontend" ), TEXT( "OutputTriggerOnReset" "Tooltip" )); } }


code: namespace Metasound { namespace ArrayNodeRandomGetVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeRandomGetVertexNames::OutputTriggerOnResetDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "On Reset" ), TEXT( "MetasoundFrontend" ), TEXT( "OutputTriggerOnReset" "DisplayName" )); } }


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


code: namespace Metasound { namespace ArrayNodeRandomGetVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeRandomGetVertexNames::ShuffleOutputValueTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Value of the current shuffled element." ), TEXT( "MetasoundFrontend" ), TEXT( "ShuffleOutputValue" "Tooltip" )); } }


code: namespace Metasound { namespace ArrayNodeRandomGetVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeRandomGetVertexNames::ShuffleOutputValueDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Value" ), TEXT( "MetasoundFrontend" ), TEXT( "ShuffleOutputValue" "DisplayName" )); } }


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


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


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


code: namespace Metasound { namespace ArrayNodeShuffleVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeShuffleVertexNames::InputTriggerNextTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Trigger to get the next value in the shuffled array." ), TEXT( "MetasoundFrontend" ), TEXT( "InputTriggerNext" "Tooltip" )); } }


code: namespace Metasound { namespace ArrayNodeShuffleVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeShuffleVertexNames::InputTriggerNextDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Next" ), TEXT( "MetasoundFrontend" ), TEXT( "InputTriggerNext" "DisplayName" )); } }


code: namespace Metasound { namespace ArrayNodeShuffleVertexNames { static const TCHAR * Metasound::ArrayNodeShuffleVertexNames::InputTriggerShuffleName = TEXT( "Shuffle" ); } }


code: namespace Metasound { namespace ArrayNodeShuffleVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeShuffleVertexNames::InputTriggerShuffleTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Trigger to shuffle the array manually." ), TEXT( "MetasoundFrontend" ), TEXT( "InputTriggerShuffle" "Tooltip" )); } }


code: namespace Metasound { namespace ArrayNodeShuffleVertexNames { static const TCHAR * Metasound::ArrayNodeShuffleVertexNames::InputTriggerResetName = TEXT( "Reset Seed" ); } }


code: namespace Metasound { namespace ArrayNodeShuffleVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeShuffleVertexNames::InputTriggerShuffleDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Shuffle" ), TEXT( "MetasoundFrontend" ), TEXT( "InputTriggerShuffle" "DisplayName" )); } }


code: namespace Metasound { namespace ArrayNodeShuffleVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeShuffleVertexNames::InputTriggerResetTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Trigger to reset the random seed stream of the shuffle node." ), TEXT( "MetasoundFrontend" ), TEXT( "InputTriggerReset" "Tooltip" )); } }


code: namespace Metasound { namespace ArrayNodeShuffleVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeShuffleVertexNames::InputTriggerResetDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Reset Seed" ), TEXT( "MetasoundFrontend" ), TEXT( "InputTriggerReset" "DisplayName" )); } }


code: namespace Metasound { namespace ArrayNodeShuffleVertexNames { static const TCHAR * Metasound::ArrayNodeShuffleVertexNames::InputShuffleArrayName = TEXT( "In Array" ); } }


code: namespace Metasound { namespace ArrayNodeRandomGetVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeRandomGetVertexNames::InputTriggerResetSeedTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Trigger to reset the seed for the randomized array." ), TEXT( "MetasoundFrontend" ), TEXT( "InputTriggerResetSeed" "Tooltip" )); } }


code: namespace Metasound { namespace ArrayNodeShuffleVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeShuffleVertexNames::InputShuffleArrayTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Input Array." ), TEXT( "MetasoundFrontend" ), TEXT( "InputShuffleArray" "Tooltip" )); } }


code: namespace Metasound { namespace ArrayNodeShuffleVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeShuffleVertexNames::InputShuffleArrayDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "In Array" ), TEXT( "MetasoundFrontend" ), TEXT( "InputShuffleArray" "DisplayName" )); } }


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


code: namespace Metasound { namespace ArrayNodeShuffleVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeShuffleVertexNames::InputShuffleSeedTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Seed to usefor the the random shuffle." ), TEXT( "MetasoundFrontend" ), TEXT( "InputShuffleSeed" "Tooltip" )); } }


code: namespace Metasound { namespace ArrayNodeShuffleVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeShuffleVertexNames::InputShuffleSeedDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Seed" ), TEXT( "MetasoundFrontend" ), TEXT( "InputShuffleSeed" "DisplayName" )); } }


code: namespace Metasound { namespace ArrayNodeShuffleVertexNames { static const TCHAR * Metasound::ArrayNodeShuffleVertexNames::InputAutoShuffleName = TEXT( "Auto Shuffle" ); } }


code: namespace Metasound { namespace ArrayNodeShuffleVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeShuffleVertexNames::InputAutoShuffleTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Set to true to automatically shuffle when the array has been read." ), TEXT( "MetasoundFrontend" ), TEXT( "InputAutoShuffle" "Tooltip" )); } }


code: namespace Metasound { namespace ArrayNodeShuffleVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeShuffleVertexNames::InputAutoShuffleDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Auto Shuffle" ), TEXT( "MetasoundFrontend" ), TEXT( "InputAutoShuffle" "DisplayName" )); } }


code: namespace Metasound { namespace ArrayNodeShuffleVertexNames { static const TCHAR * Metasound::ArrayNodeShuffleVertexNames::InputShuffleEnableSharedStateName = TEXT( "Enable Shared State" ); } }


code: namespace Metasound { namespace ArrayNodeShuffleVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeShuffleVertexNames::InputShuffleEnableSharedStateTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Set to enabled shared state across instances of this metasound." ), TEXT( "MetasoundFrontend" ), TEXT( "InputShuffleEnableSharedState" "Tooltip" )); } }


code: namespace Metasound { namespace ArrayNodeRandomGetVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeRandomGetVertexNames::InputTriggerResetSeedDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Reset" ), TEXT( "MetasoundFrontend" ), TEXT( "InputTriggerResetSeed" "DisplayName" )); } }


code: namespace Metasound { namespace ArrayNodeShuffleVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeShuffleVertexNames::InputShuffleEnableSharedStateDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Enable Shared State" ), TEXT( "MetasoundFrontend" ), TEXT( "InputShuffleEnableSharedState" "DisplayName" )); } }


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


code: namespace Metasound { namespace ArrayNodeShuffleVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeShuffleVertexNames::OutputTriggerOnNextTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Triggers when the \"Next\" input is triggered." ), TEXT( "MetasoundFrontend" ), TEXT( "OutputTriggerOnNext" "Tooltip" )); } }


code: namespace Metasound { namespace ArrayNodeShuffleVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeShuffleVertexNames::OutputTriggerOnNextDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "On Next" ), TEXT( "MetasoundFrontend" ), TEXT( "OutputTriggerOnNext" "DisplayName" )); } }


code: namespace Metasound { namespace ArrayNodeShuffleVertexNames { static const TCHAR * Metasound::ArrayNodeShuffleVertexNames::OutputTriggerOnShuffleName = TEXT( "On Shuffle" ); } }


code: namespace Metasound { namespace ArrayNodeShuffleVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeShuffleVertexNames::OutputTriggerOnShuffleTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Triggers when the \"Shuffle\" input is triggered or if the array is auto-shuffled." ), TEXT( "MetasoundFrontend" ), TEXT( "OutputTriggerOnShuffle" "Tooltip" )); } }


code: namespace Metasound { namespace ArrayNodeShuffleVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeShuffleVertexNames::OutputTriggerOnShuffleDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "On Shuffle" ), TEXT( "MetasoundFrontend" ), TEXT( "OutputTriggerOnShuffle" "DisplayName" )); } }


code: namespace Metasound { namespace ArrayNodeShuffleVertexNames { static const TCHAR * Metasound::ArrayNodeShuffleVertexNames::OutputTriggerOnResetSeedName = TEXT( "On Reset Seed" ); } }


code: namespace Metasound { namespace ArrayNodeShuffleVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeShuffleVertexNames::OutputTriggerOnResetSeedTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Triggers when the \"Reset Seed\" input is triggered." ), TEXT( "MetasoundFrontend" ), TEXT( "OutputTriggerOnResetSeed" "Tooltip" )); } }


code: namespace Metasound { namespace ArrayNodeShuffleVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeShuffleVertexNames::OutputTriggerOnResetSeedDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "On Reset Seed" ), TEXT( "MetasoundFrontend" ), TEXT( "OutputTriggerOnResetSeed" "DisplayName" )); } }


code: namespace Metasound { namespace ArrayNodeRandomGetVertexNames { static const TCHAR * Metasound::ArrayNodeRandomGetVertexNames::InputRandomArrayName = TEXT( "In Array" ); } }


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


code: namespace Metasound { namespace ArrayNodeShuffleVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeShuffleVertexNames::OutputShuffledValueTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Value of the current shuffled element." ), TEXT( "MetasoundFrontend" ), TEXT( "OutputShuffledValue" "Tooltip" )); } }


code: namespace Metasound { namespace ArrayNodeShuffleVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeShuffleVertexNames::OutputShuffledValueDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Value" ), TEXT( "MetasoundFrontend" ), TEXT( "OutputShuffledValue" "DisplayName" )); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const TCHAR * Metasound::ArrayNodeVertexNames::InputInitialArrayName = TEXT("Array"); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeVertexNames::InputInitialArrayTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Initial Array" ), TEXT( "MetasoundFrontend" ), TEXT( "InitialArrayTooltip" )); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeVertexNames::InputInitialArrayDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Init Array" ), TEXT( "MetasoundFrontend" ), TEXT( "InitialArrayDisplayName" )); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeVertexNames::InputArrayDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Array" ), TEXT( "MetasoundFrontend" ), TEXT( "InputArray" "DisplayName" )); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeVertexNames::InputLeftArrayTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Input Left Array." ), TEXT( "MetasoundFrontend" ), TEXT( "InputLeftArray" "Tooltip" )); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const TCHAR * Metasound::ArrayNodeVertexNames::InputRightArrayName = TEXT( "Right Array" ); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeVertexNames::InputLeftArrayDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Left Array" ), TEXT( "MetasoundFrontend" ), TEXT( "InputLeftArray" "DisplayName" )); } }


code: namespace Metasound { namespace ArrayNodeRandomGetVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeRandomGetVertexNames::InputRandomArrayTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Input array to randomized." ), TEXT( "MetasoundFrontend" ), TEXT( "InputRandomArray" "Tooltip" )); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeVertexNames::InputRightArrayTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Input Right Array." ), TEXT( "MetasoundFrontend" ), TEXT( "InputRightArray" "Tooltip" )); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeVertexNames::InputRightArrayDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Right Array" ), TEXT( "MetasoundFrontend" ), TEXT( "InputRightArray" "DisplayName" )); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const TCHAR * Metasound::ArrayNodeVertexNames::InputTriggerGetName = TEXT( "Trigger" ); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeVertexNames::InputTriggerGetTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Trigger to get value." ), TEXT( "MetasoundFrontend" ), TEXT( "InputTriggerGet" "Tooltip" )); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeVertexNames::InputTriggerGetDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Trigger" ), TEXT( "MetasoundFrontend" ), TEXT( "InputTriggerGet" "DisplayName" )); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeVertexNames::InputTriggerSetTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Trigger to set value." ), TEXT( "MetasoundFrontend" ), TEXT( "InputTriggerSet" "Tooltip" )); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const TCHAR * Metasound::ArrayNodeVertexNames::InputTriggerSetName = TEXT( "Trigger" ); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeVertexNames::InputTriggerSetDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Trigger" ), TEXT( "MetasoundFrontend" ), TEXT( "InputTriggerSet" "DisplayName" )); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeVertexNames::InputIndexDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Index" ), TEXT( "MetasoundFrontend" ), TEXT( "InputIndex" "DisplayName" )); } }


code: namespace Metasound { namespace ArrayNodeRandomGetVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeRandomGetVertexNames::InputRandomArrayDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "In Array" ), TEXT( "MetasoundFrontend" ), TEXT( "InputRandomArray" "DisplayName" )); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const TCHAR * Metasound::ArrayNodeVertexNames::InputStartIndexName = TEXT( "Start Index" ); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeVertexNames::InputStartIndexTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "First index to include." ), TEXT( "MetasoundFrontend" ), TEXT( "InputStartIndex" "Tooltip" )); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeVertexNames::InputStartIndexDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Start Index" ), TEXT( "MetasoundFrontend" ), TEXT( "InputStartIndex" "DisplayName" )); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeVertexNames::InputEndIndexTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Last index to include." ), TEXT( "MetasoundFrontend" ), TEXT( "InputEndIndex" "Tooltip" )); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeVertexNames::InputEndIndexDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "End Index" ), TEXT( "MetasoundFrontend" ), TEXT( "InputEndIndex" "DisplayName" )); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeVertexNames::InputValueDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Value" ), TEXT( "MetasoundFrontend" ), TEXT( "InputValue" "DisplayName" )); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeVertexNames::OutputNumDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Num" ), TEXT( "MetasoundFrontend" ), TEXT( "OutputNum" "DisplayName" )); } }


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


code: namespace Metasound { namespace ArrayNodeVertexNames { static const TCHAR * Metasound::ArrayNodeVertexNames::OutputArrayConcatName = TEXT( "Array" ); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeVertexNames::OutputArrayConcatTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Array after concatenation." ), TEXT( "MetasoundFrontend" ), TEXT( "OutputArrayConcat" "Tooltip" )); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeVertexNames::OutputArrayConcatDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Array" ), TEXT( "MetasoundFrontend" ), TEXT( "OutputArrayConcat" "DisplayName" )); } }


code: namespace Metasound { namespace ArrayNodeRandomGetVertexNames { static const TCHAR * Metasound::ArrayNodeRandomGetVertexNames::InputWeightsName = TEXT( "Weights" ); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeVertexNames::OutputArraySetTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Array after setting." ), TEXT( "MetasoundFrontend" ), TEXT( "OutputArraySet" "Tooltip" )); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeVertexNames::OutputArraySetDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Array" ), TEXT( "MetasoundFrontend" ), TEXT( "OutputArraySet" "DisplayName" )); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const TCHAR * Metasound::ArrayNodeVertexNames::OutputArraySubsetName = TEXT( "Array" ); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeVertexNames::OutputArraySubsetTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Subset of input array." ), TEXT( "MetasoundFrontend" ), TEXT( "OutputArraySubset" "Tooltip" )); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeVertexNames::OutputArraySubsetDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Array" ), TEXT( "MetasoundFrontend" ), TEXT( "OutputArraySubset" "DisplayName" )); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const TCHAR * Metasound::ArrayNodeVertexNames::InputArrayName = TEXT( "Array" ); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeVertexNames::InputArrayTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Input Array." ), TEXT( "MetasoundFrontend" ), TEXT( "InputArray" "Tooltip" )); } }


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


code: namespace Metasound { namespace ArrayNodeVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeVertexNames::OutputValueTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Value of element at array index." ), TEXT( "MetasoundFrontend" ), TEXT( "OutputValue" "Tooltip" )); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const TCHAR * Metasound::ArrayNodeVertexNames::OutputArraySetName = TEXT( "Array" ); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const TCHAR * Metasound::ArrayNodeVertexNames::InputLeftArrayName = TEXT( "Left Array" ); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const TCHAR * Metasound::ArrayNodeVertexNames::InputIndexName = TEXT( "Index" ); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeVertexNames::InputIndexTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Index in Array." ), TEXT( "MetasoundFrontend" ), TEXT( "InputIndex" "Tooltip" )); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const TCHAR * Metasound::ArrayNodeVertexNames::InputEndIndexName = TEXT( "End Index" ); } }


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


code: namespace Metasound { namespace ArrayNodeVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeVertexNames::InputValueTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Value to set." ), TEXT( "MetasoundFrontend" ), TEXT( "InputValue" "Tooltip" )); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const TCHAR * Metasound::ArrayNodeVertexNames::OutputNumName = TEXT( "Num" ); } }


code: namespace Metasound { namespace ArrayNodeVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ArrayNodeVertexNames::OutputNumTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Number of elements in the array." ), TEXT( "MetasoundFrontend" ), TEXT( "OutputNum" "Tooltip" )); } }


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


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


description: This function uses theFTransmissionAddress::GetAddressType()method to determine whether the cast is legal. Each subclass ofFTransmissionAddressMUSTprovide a unique address type to protect against invalid casts.

code: namespace Metasound { template<typename DerivedAddressType> const DerivedAddressType * Metasound::CastAddressType ( const [FTransmissionAddress](API\Plugins\MetasoundFrontend\FTransmissionAddress) & InOther ) }


description: For generic senders for copyable types:

code: namespace Metasound { template<typename TDataType, typename [TEnableIf](API\Runtime\Core\Templates\TEnableIf)< [TIsDerivedFrom](API\Runtime\Core\Templates\TIsDerivedFrom)< TDataType, IAudioDataType >::Value, bool >::Type> [TSenderPtr](API\Plugins\MetasoundFrontend\TSenderPtr)< TDataType > Metasound::Downcast ( [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [ISender](API\Plugins\MetasoundFrontend\ISender) > && InPtr ) }


description: For generic receivers for copyable types:

code: namespace Metasound { template<typename TDataType, typename [TEnableIf](API\Runtime\Core\Templates\TEnableIf)< [TIsDerivedFrom](API\Runtime\Core\Templates\TIsDerivedFrom)< TDataType, IAudioDataType >::Value, bool >::Type> [TReceiverPtr](API\Plugins\MetasoundFrontend\TReceiverPtr)< TDataType > Metasound::Downcast ( [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [IReceiver](API\Plugins\MetasoundFrontend\IReceiver) > && InPtr ) }


code: namespace Metasound { void Metasound::Execute() }


code: namespace Metasound { namespace Frontend { template<typename ToAccessPtrType, typename FromAccessPtrType> ToAccessPtrType Metasound::Frontend::ConstCastAccessPtr ( const FromAccessPtrType & InAccessPtr ) } }


code: namespace Metasound { namespace Frontend { enum EInvalidEdgeReason { None = 0, MismatchedAccessType, MismatchedDataType, MissingInput, MissingOutput, COUNT, } } }


description:
Generates a newFMetasoundFrontendClassfrom a NodeType
FrontendClass for natively-defined node.

code: namespace Metasound { namespace Frontend { template<typename NodeType> [FMetasoundFrontendClass](API\Plugins\MetasoundFrontend\FMetasoundFrontendClass) Metasound::Frontend::GenerateClass() } }


description:
Generates a newFMetasoundFrontendClassfrom Node init data
FrontendClass for natively-defined node.

code: namespace Metasound { namespace Frontend { template<typename NodeType> [FMetasoundFrontendClass](API\Plugins\MetasoundFrontend\FMetasoundFrontendClass) Metasound::Frontend::GenerateClass ( const [FNodeInitData](API\Plugins\MetasoundGraphCore\FNodeInitData) & InNodeInitData ) } }


code: namespace Metasound { namespace Frontend { template<typename AccessPtrType, typename Type> AccessPtrType Metasound::Frontend::MakeAccessPtr ( const [FAccessPoint](API\Plugins\MetasoundFrontend\FAccessPoint) & InAccessPoint, Type & InRef ) } }


code: namespace Metasound { virtual [FDataReferenceCollection](API\Plugins\MetasoundGraphCore\FDataReferenceCollection) Metasound::GetInputs() const }


code: namespace Metasound { virtual [FDataReferenceCollection](API\Plugins\MetasoundGraphCore\FDataReferenceCollection) Metasound::GetOutputs() const }


code: namespace Metasound { uint32 Metasound::GetTypeHash ( const [Metasound::FTransmissionAddress](API\Plugins\MetasoundFrontend\FTransmissionAddress) & ) }


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


code: namespace Metasound { namespace MetasoundArrayNodesPrivate { template<typename ArrayType, typename std::enable_if< TArrayNodeSupport< ArrayType >::bIsArrayGetSupported, bool >::type> bool Metasound::MetasoundArrayNodesPrivate::RegisterArrayGetNode() } }


code: namespace Metasound { namespace LiteralNodeNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::LiteralNodeNames::OutputValueTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Value" ), TEXT( "MetasoundLiteralNode" ), TEXT( "OutputValue" "Tooltip" )); } }


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


code: namespace Metasound { template<typename TDataType, typename [TEnableIf](API\Runtime\Core\Templates\TEnableIf)< std::is_copy_constructible< TDataType >::value &&![TIsDerivedFrom](API\Runtime\Core\Templates\TIsDerivedFrom)< TDataType, IAudioDataType >::Value, bool >::Type> [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [IDataChannel](API\Plugins\MetasoundFrontend\IDataChannel), ESPMode::ThreadSafe > Metasound::MakeDataChannel ( const [FOperatorSettings](API\Plugins\MetasoundGraphCore\FOperatorSettings) & InSettings ) }


code: namespace Metasound { namespace MetasoundArrayNodesPrivate { template<typename ArrayType, typename std::enable_if< TArrayNodeSupport< ArrayType >::bIsArraySetSupported, bool >::type> bool Metasound::MetasoundArrayNodesPrivate::RegisterArraySetNode() } }


description: Creates the FDataTypeRegistryInfo for a data type.

code: namespace Metasound { namespace MetasoundDataTypeRegistrationPrivate { template<typename TDataType, ELiteralType PreferredArgType, typename UClassToUse> [Frontend::FDataTypeRegistryInfo](API\Plugins\MetasoundFrontend\FDataTypeRegistryInfo) Metasound::MetasoundDataTypeRegistrationPrivate::CreateDataTypeInfo() } }


description:
Returns an IEnumDataTypeInterface pointer for the data type. If the data type has no IEnumDataTypeInterface, the returned pointer will be invalid.
A shared pointer to the IEnumDataTypeInterface. If the TDataType does not have an IEnumDataTypeInterface, returns an invalid pointer.

code: namespace Metasound { namespace MetasoundDataTypeRegistrationPrivate { template<typename TDataType> [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< [Frontend::IEnumDataTypeInterface](API\Plugins\MetasoundFrontend\IEnumDataTypeInterface) > Metasound::MetasoundDataTypeRegistrationPrivate::GetEnumDataTypeInterface() } }


description:
Registers a data type with the MetaSound Frontend. This allows the data type to be used in Input and Output nodes by informing the Frontend how to instantiate an instance.
True on success, false on failure.

code: namespace Metasound { namespace MetasoundDataTypeRegistrationPrivate { template<typename TDataType, ELiteralType PreferredArgType, typename UClassToUse> bool Metasound::MetasoundDataTypeRegistrationPrivate::RegisterDataTypeWithFrontendInternal() } }


description:
Registers an array of a data type with the MetaSound Frontend. This allows an array of the data type to be used in Input, Output, Send and Receive nodes by informing the Frontend how to instantiate an instance.
True on success, false on failure.

code: namespace Metasound { namespace MetasoundDataTypeRegistrationPrivate { template<typename TDataType, ELiteralType PreferredArgType> bool Metasound::MetasoundDataTypeRegistrationPrivate::RegisterDataTypeArrayWithFrontend() } }


code: namespace Metasound { namespace MetasoundArrayNodesPrivate { template<typename ArrayType, typename std::enable_if< TArrayNodeSupport< ArrayType >::bIsArraySubsetSupported, bool >::type> bool Metasound::MetasoundArrayNodesPrivate::RegisterArraySubsetNode() } }


code: namespace Metasound { namespace MetasoundArrayNodesPrivate { template<typename ArrayType, typename std::enable_if< TArrayNodeSupport< ArrayType >::bIsArrayConcatSupported, bool >::type> bool Metasound::MetasoundArrayNodesPrivate::RegisterArrayConcatNode() } }


code: namespace Metasound { namespace MetasoundArrayNodesPrivate { template<typename ArrayType, typename std::enable_if< TArrayNodeSupport< ArrayType >::bIsArrayNumSupported, bool >::type> bool Metasound::MetasoundArrayNodesPrivate::RegisterArrayNumNode() } }


code: namespace Metasound { namespace MetasoundArrayNodesPrivate { template<typename ArrayType, typename std::enable_if< TArrayNodeSupport< ArrayType >::bIsArrayShuffleSupported, bool >::type> bool Metasound::MetasoundArrayNodesPrivate::RegisterArrayShuffleNode() } }


code: namespace Metasound { namespace MetasoundArrayNodesPrivate { template<typename ArrayType, typename std::enable_if< TArrayNodeSupport< ArrayType >::bIsArrayRandomGetSupported, bool >::type> bool Metasound::MetasoundArrayNodesPrivate::RegisterArrayRandomGetNode() } }


description: This utility function can be used to optionally check to see if we can transmit a data type, and autogenerate send and receive nodes for that datatype.

code: namespace Metasound { namespace MetasoundDataTypeRegistrationPrivate { template<typename TDataType, typename [TEnableIf](API\Runtime\Core\Templates\TEnableIf)< TIsTransmittable< TDataType >::Value, bool >::Type> void Metasound::MetasoundDataTypeRegistrationPrivate::AttemptToRegisterSendAndReceiveNodes() } }


description: This utility function can be used to check to see if we can static cast between two types, and autogenerate a node for that static cast.

code: namespace Metasound { namespace MetasoundDataTypeRegistrationPrivate { template<typename TFromDataType, typename TToDataType, typename std::enable_if< TIsAutoConvertible< TFromDataType, TToDataType >::Value, bool >::type> void Metasound::MetasoundDataTypeRegistrationPrivate::AttemptToRegisterConverter() } }


description: Here we attempt to infer and autogenerate conversions for basic datatypes.

code: namespace Metasound { namespace MetasoundDataTypeRegistrationPrivate { template<typename TDataType> void Metasound::MetasoundDataTypeRegistrationPrivate::RegisterConverterNodes() } }


code: namespace Metasound { namespace ReceiveNodeInfo { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ReceiveNodeInfo::DefaultDataInputDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Default" ), TEXT( "MetasoundFrontend" ), TEXT( "DefaultDataInput" "DisplayName" )); } }


code: namespace Metasound { namespace ReceiveNodeInfo { static const TCHAR * Metasound::ReceiveNodeInfo::AddressInputName = TEXT( "Address" ); } }


code: namespace Metasound { namespace ReceiveNodeInfo { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ReceiveNodeInfo::AddressInputTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Address" ), TEXT( "MetasoundFrontend" ), TEXT( "AddressInput" "Tooltip" )); } }


code: namespace Metasound { namespace ReceiveNodeInfo { static const TCHAR * Metasound::ReceiveNodeInfo::DefaultDataInputName = TEXT( "Default" ); } }


code: namespace Metasound { namespace ReceiveNodeInfo { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ReceiveNodeInfo::AddressInputDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Address" ), TEXT( "MetasoundFrontend" ), TEXT( "AddressInput" "DisplayName" )); } }


code: namespace Metasound { namespace ReceiveNodeInfo { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ReceiveNodeInfo::DefaultDataInputTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Default" ), TEXT( "MetasoundFrontend" ), TEXT( "DefaultDataInput" "Tooltip" )); } }


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


code: namespace Metasound { namespace ReceiveNodeInfo { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ReceiveNodeInfo::OutputTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Out" ), TEXT( "MetasoundFrontend" ), TEXT( "Output" "Tooltip" )); } }


code: namespace Metasound { namespace ReceiveNodeInfo { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::ReceiveNodeInfo::OutputDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Out" ), TEXT( "MetasoundFrontend" ), TEXT( "Output" "DisplayName" )); } }


description: Registers all available array nodes which can be instantiated for the given ArrayType. Some nodes cannot be instantiated due to limitations of the array elements.

code: namespace Metasound { template<typename ArrayType> bool Metasound::RegisterArrayNodes() }


description:
Registers a data type with the MetaSound Frontend. This allows the data type to be used in Input, Output, Send and Receive nodes by informing the Frontend how to instantiate an instance.
True on success, false on failure.

code: namespace Metasound { template<typename TDataType, ELiteralType PreferredArgType, typename UClassToUse> bool Metasound::RegisterDataTypeWithFrontend() }


code: namespace Metasound { template<typename FNodeType> bool Metasound::RegisterNodeWithFrontend ( const [Metasound::FNodeClassMetadata](API\Plugins\MetasoundGraphCore\FNodeClassMetadata) & InMetadata ) }


code: namespace Metasound { template<typename FNodeType> bool Metasound::RegisterNodeWithFrontend() }


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


code: namespace Metasound { namespace SendVertexNames { static const TCHAR * Metasound::SendVertexNames::AddressInputName = TEXT( "Address" ); } }


code: namespace Metasound { namespace SendVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::SendVertexNames::AddressInputTooltip = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Address" ), TEXT( "MetasoundFrontend" ), TEXT( "AddressInput" "Tooltip" )); } }


code: namespace Metasound { namespace SendVertexNames { static const [FText](API\Runtime\Core\Internationalization\FText) Metasound::SendVertexNames::AddressInputDisplayName = FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Address" ), TEXT( "MetasoundFrontend" ), TEXT( "AddressInput" "DisplayName" )); } }


description: Executable DataTypes require a copy of the output to operate on whereas non-executable types do not. Avoid copy by assigning to reference for non-executable types.

code: namespace Metasound { Metasound::TExecutableLiteralOperator ( const [FOperatorSettings](API\Plugins\MetasoundGraphCore\FOperatorSettings) & InSettings, const [FLiteral](API\Plugins\MetasoundGraphCore\FLiteral) & InLiteral ) }


description: Deprecated* The TLiteralOperator will be removed.

code: namespace Metasound { template<typename [DataType](API\Plugins\OptimusCore\DataType)> Metasound::TLiteralOperator ( [TDataValueReference](API\Plugins\MetasoundGraphCore\TDataValueReference)< [DataType](API\Plugins\OptimusCore\DataType) > InValue ) }


code: namespace Metasound { virtual Metasound::~TExecutableLiteralOperator() }


code: namespace Metasound { virtual Metasound::~TLiteralOperator() }


className: ClassName

code: static const [FMetasoundFrontendClassName](API\Plugins\MetasoundFrontend\FMetasoundFrontendClassName) ClassName { "UE", "Reroute", "" };


code: static [FMetasoundFrontendNodeInterface](API\Plugins\MetasoundFrontend\FMetasoundFrontendNodeInterface) CreateNodeInterfaceFromDataType ( [FName](API\Runtime\Core\UObject\FName) InDataType )


description: Generates node transform that can cache document state for use when individually preprocessing nodes.

code: virtual [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [INodeTransform](API\Plugins\MetasoundFrontend\INodeTransform) > GenerateNodeTransform ( [FMetasoundFrontendDocument](API\Plugins\MetasoundFrontend\FMetasoundFrontendDocument) & InDocument ) const


description: Returns the class definition for the given node class template.

code: virtual const [FMetasoundFrontendClass](API\Plugins\MetasoundFrontend\FMetasoundFrontendClass) & GetFrontendClass() const


code: static const [FNodeRegistryKey](API\Plugins\MetasoundFrontend\FNodeRegistryKey) & GetRegistryKey()


description: Returns the version of the given node class template.

code: virtual const [FMetasoundFrontendVersion](API\Plugins\MetasoundFrontend\FMetasoundFrontendVersion) & GetVersion() const


description: Returns whether or not the given node template has the necessary required connections to be preprocessed (editor only).

code: virtual bool HasRequiredConnections ( [FConstNodeHandle](API\Plugins\MetasoundFrontend\FConstNodeHandle) InNodeHandle ) const


description: Given the provided node interface, returns whether or not it conforms to an expected format that can be successfully manipulated by a generated node template preprocessor.

code: virtual bool IsValidNodeInterface ( const [FMetasoundFrontendNodeInterface](API\Plugins\MetasoundFrontend\FMetasoundFrontendNodeInterface) & InNodeInterface ) const


className: Version

code: static const [FMetasoundFrontendVersion](API\Plugins\MetasoundFrontend\FMetasoundFrontendVersion) Version { ClassName.GetFullName(), { 1, 0 } };


code: virtual ~FRerouteNodeTemplate()


className: FRerouteNodeTemplate

code: class FRerouteNodeTemplate : public [Metasound::Frontend::INodeTemplate](API\Plugins\MetasoundFrontend\INodeTemplate)


className: RegisterConversionNode

code: template<typename TNodeType, typename TFromType, typename TToType> bool RegisterConversionNode ( const [Metasound::FVertexName](API\Plugins\MetasoundGraphCore\FVertexName) & FromPin, const [Metasound::FVertexName](API\Plugins\MetasoundGraphCore\FVertexName) & ToPin, const [Metasound::FNodeClassMetadata](API\Plugins\MetasoundGraphCore\FNodeClassMetadata) & InNodeMetadata )


className: EConstCast

code: enum EConstCast { Tag, }


className: EDerivedCopy

code: enum EDerivedCopy { Tag, }


className: FallbackObject

code: static Type FallbackObject = Type();


description: Returns a pointer to the accessible object. If the object is inaccessible, a nullptr is returned.

code: Type * Get() const


className: ObjectType

code: typedef Type ObjectType


description: Returns an access pointer to a member of the wrapped object.

code: template<typename AccessPtrType, typename FunctionType> AccessPtrType GetMemberAccessPtr ( FunctionType InGetMember ) const


code: [TAccessPtr](API\Plugins\MetasoundFrontend\TAccessPtr)< Type > & operator= ( const [TAccessPtr](API\Plugins\MetasoundFrontend\TAccessPtr)< Type > & InOther )


code: [TAccessPtr](API\Plugins\MetasoundFrontend\TAccessPtr) & operator= ( [TAccessPtr](API\Plugins\MetasoundFrontend\TAccessPtr)< Type > && InOther )


code: TAccessPtr ( const [TAccessPtr](API\Plugins\MetasoundFrontend\TAccessPtr)< Type > & InOther )


code: TAccessPtr ( [TAccessPtr](API\Plugins\MetasoundFrontend\TAccessPtr)< Type > && InOther )


code: TAccessPtr ( [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< Type *()> InGetObject )


description: Creates a access pointer using an access token.

code: TAccessPtr ( [TWeakPtr](API\Runtime\Core\Templates\TWeakPtr)< [FTokenType](API\Plugins\MetasoundFrontend\TAccessPtr\FTokenType) > AccessToken, Type & InRef )


description: Creates an access pointer from another using a const casts.

code: template<typename OtherType> TAccessPtr ( const [TAccessPtr](API\Plugins\MetasoundFrontend\TAccessPtr)< OtherType > & InOther, EConstCast InTag )


description: Creates an access pointer from another using a static cast.

code: template<typename OtherType, typename> TAccessPtr ( const [TAccessPtr](API\Plugins\MetasoundFrontend\TAccessPtr)< OtherType > & InOther, EDerivedCopy InTag )


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


className: TAccessPtr

description: If theTAccessPtr's underlying object is accessed when the pointer is invalid, a fallback object will be returned.

code: template<typename Type> class TAccessPtr

CachedObjectPtr

type: Type *

GetObject

type: TFunction< Type...


code: virtual ~TArrayConcatNode()


className: TArrayConcatNode

code: template<typename ArrayType> class TArrayConcatNode : 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 )


className: ElementType

code: typedef typename [MetasoundArrayNodesPrivate::TArrayElementType](API\Plugins\MetasoundFrontend\TArrayElementType)< ArrayType >::Type ElementType


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: FArrayDataReadReference

code: typedef [TDataReadReference](API\Plugins\MetasoundGraphCore\TDataReadReference)< ArrayType > FArrayDataReadReference


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


className: FArrayDataWriteReference

code: typedef [TDataWriteReference](API\Plugins\MetasoundGraphCore\TDataWriteReference)< ArrayType > FArrayDataWriteReference


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


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: virtual [FDataReferenceCollection](API\Plugins\MetasoundGraphCore\FDataReferenceCollection) GetOutputs() const


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


code: TArrayConcatOperator ( [TDataReadReference](API\Plugins\MetasoundGraphCore\TDataReadReference)< [FTrigger](API\Plugins\MetasoundFrontend\FTrigger) > InTrigger, [FArrayDataReadReference](API\Plugins\MetasoundFrontend\TArrayConcatOperator\FArrayDataReadReference) InLeftArray, [FArrayDataReadReference](API\Plugins\MetasoundFrontend\TArrayConcatOperator\FArrayDataReadReference) InRightArray )


code: virtual ~TArrayConcatOperator()


className: TArrayConcatOperator

description: TArrayConcatOperatorconcatenates two arrays on trigger.

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


className: TArrayElementType

description: Retrieve the ElementType from an ArrayType.

code: template<typename ArrayType> struct TArrayElementType


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


code: virtual ~TArrayGetNode()


className: TArrayGetNode

code: template<typename ArrayType> class TArrayGetNode : 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: typedef typename [MetasoundArrayNodesPrivate::TArrayElementType](API\Plugins\MetasoundFrontend\TArrayElementType)< ArrayType >::Type ElementType


code: typedef [TDataReadReference](API\Plugins\MetasoundGraphCore\TDataReadReference)< ArrayType > FArrayDataReadReference


className: FInitParams

code: struct FInitParams

Array

type: FArrayDataReadR...

GraphName

type: FString

Index

type: TDataReadRefere...


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


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: TArrayGetOperator ( const [FOperatorSettings](API\Plugins\MetasoundGraphCore\FOperatorSettings) & InSettings, [FInitParams](API\Plugins\MetasoundFrontend\TArrayGetOperator\FInitParams) && InParams )


code: virtual ~TArrayGetOperator()


className: TArrayGetOperator

description: TArrayGetOperatorcopies a value from the array to the output when a trigger occurs. Initially, the output value is default constructed and will remain that way until until a trigger is encountered.

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


className: bEnabled

code: static constexpr bool bEnabled = TEnableArrayNodes<ElementType>::Value;


className: bIsArrayConcatSupported

description: Elements must be copy constructible.

code: static constexpr bool bIsArrayConcatSupported = bEnabled && std::is_copy_constructible<ElementType>::value;


className: bIsArrayGetSupported

description: Element must be default parsable to create get operator because a value must be returned even if the index is invalid. Also values are assigned by copy.

code: static constexpr bool bIsArrayGetSupported = bEnabled && bIsElementParsableAndAssignable;


className: bIsArrayNumSupported

description: Array num is supported for all array types.

code: static constexpr bool bIsArrayNumSupported = bEnabled;


className: bIsArrayRandomGetSupported

description: Random get is supported for all types that get is supported for.

code: static constexpr bool bIsArrayRandomGetSupported = bEnabled && bIsElementParsableAndAssignable;


className: bIsArraySetSupported

description: Element must be copy assignable to set the value.

code: static constexpr bool bIsArraySetSupported = bEnabled && std::is_copy_assignable<ElementType>::value && std::is_copy_constructible<ElementType>::value;


className: bIsArrayShuffleSupported

description: Array shuffle is supported for all types that get is supported for.

code: static constexpr bool bIsArrayShuffleSupported = bEnabled && bIsElementParsableAndAssignable;


className: bIsArraySubsetSupported

description: Elements must be copy constructible.

code: static constexpr bool bIsArraySubsetSupported = bEnabled && std::is_copy_constructible<ElementType>::value;


className: bIsElementParsableAndAssignable

code: static constexpr bool bIsElementParsableAndAssignable = TIsParsable<ElementType>::Value && std::is_copy_assignable<ElementType>::value;


className: ElementType

code: typedef typename [MetasoundArrayNodesPrivate::TArrayElementType](API\Plugins\MetasoundFrontend\TArrayElementType)< ArrayType >::Type ElementType


className: TArrayNodeSupport

description: Some ArrayNodes require that the array elements have certain properties such as default element constructors, element copy constructors, etc.

code: template<typename ArrayType> struct TArrayNodeSupport


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


code: virtual ~TArrayNumNode()


className: TArrayNumNode

code: template<typename ArrayType> class TArrayNumNode : 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 )


className: FArrayDataReadReference

code: typedef [TDataReadReference](API\Plugins\MetasoundGraphCore\TDataReadReference)< ArrayType > FArrayDataReadReference


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: TArrayNumOperator ( [FArrayDataReadReference](API\Plugins\MetasoundFrontend\TArrayNumOperator\FArrayDataReadReference) InArray )


code: virtual ~TArrayNumOperator()


className: TArrayNumOperator

description: TArrayNumOperatorgets the number of elements in an Array. The operator uses theFNodeFacadeand defines the vertex, metadata and vertex interface statically on the operator class.

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


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


code: virtual ~TArrayRandomGetNode()


className: TArrayRandomGetNode

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


code: typedef typename [MetasoundArrayNodesPrivate::TArrayElementType](API\Plugins\MetasoundFrontend\TArrayElementType)< ArrayType >::Type ElementType


className: FArrayWeightReadReference

code: typedef [TDataReadReference](API\Plugins\MetasoundGraphCore\TDataReadReference)< [TArray](API\Runtime\Core\Containers\TArray)< float >> FArrayWeightReadReference


className: FElementTypeWriteReference


code: bool UseSharedState() const


className: WeightsArrayType

code: typedef [TArray](API\Runtime\Core\Containers\TArray)< float > WeightsArrayType


code: TArrayRandomGetOperator ( const [FCreateOperatorParams](API\Plugins\MetasoundGraphCore\FCreateOperatorParams) & InParams, const [FTriggerReadRef](API\Plugins\MetasoundFrontend\FTriggerReadRef) & InTriggerNext, const [FTriggerReadRef](API\Plugins\MetasoundFrontend\FTriggerReadRef) & InTriggerReset, const [FArrayDataReadReference](API\Plugins\MetasoundFrontend\TArrayRandomGetOperator\FArrayDataReadReference) & InInputArray, const [TDataReadReference](API\Plugins\MetasoundGraphCore\TDataReadReference)< [WeightsArrayType](API\Plugins\MetasoundFrontend\TArrayRandomGetOperator\WeightsArrayType) > & InInputWeightsArray, const [FInt32ReadRef](API\Plugins\MetasoundFrontend\FInt32ReadRef) & InSeedValue, const [FInt32ReadRef](API\Plugins\MetasoundFrontend\FInt32ReadRef) & InNoRepeatOrder, const [FBoolReadRef](API\Plugins\MetasoundFrontend\FBoolReadRef) & bInEnableSharedState )


className: TArrayRandomGetOperator

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


code: virtual ~TArrayRandomGetOperator()


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


code: virtual ~TArraySetNode()


className: TArraySetNode

code: template<typename ArrayType> class TArraySetNode : 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: typedef [TDataReadReference](API\Plugins\MetasoundGraphCore\TDataReadReference)< ArrayType > FArrayDataReadReference


className: FArrayDataWriteReference

code: typedef [TDataWriteReference](API\Plugins\MetasoundGraphCore\TDataWriteReference)< ArrayType > FArrayDataWriteReference


className: FInitParams

code: struct FInitParams

Array

type: FArrayDataWrite...


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: virtual ~TArraySetOperator()


className: TArraySetOperator

description: TArraySetOperatorsets an element in an array to a specific value.

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


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


code: virtual ~TArrayShuffleNode()


className: TArrayShuffleNode

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


code: typedef typename [MetasoundArrayNodesPrivate::TArrayElementType](API\Plugins\MetasoundFrontend\TArrayElementType)< ArrayType >::Type ElementType


code: TArraySetOperator ( const [FOperatorSettings](API\Plugins\MetasoundGraphCore\FOperatorSettings) & InSettings, [FInitParams](API\Plugins\MetasoundFrontend\TArraySetOperator\FInitParams) && InParams )


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


code: TArrayShuffleOperator ( const [FCreateOperatorParams](API\Plugins\MetasoundGraphCore\FCreateOperatorParams) & InParams, const [TDataReadReference](API\Plugins\MetasoundGraphCore\TDataReadReference)< [FTrigger](API\Plugins\MetasoundFrontend\FTrigger) > & InTriggerNext, const [TDataReadReference](API\Plugins\MetasoundGraphCore\TDataReadReference)< [FTrigger](API\Plugins\MetasoundFrontend\FTrigger) > & InTriggerShuffle, const [TDataReadReference](API\Plugins\MetasoundGraphCore\TDataReadReference)< [FTrigger](API\Plugins\MetasoundFrontend\FTrigger) > & InTriggerReset, const [FArrayDataReadReference](API\Plugins\MetasoundFrontend\TArrayShuffleOperator\FArrayDataReadReference) & InInputArray, const [TDataReadReference](API\Plugins\MetasoundGraphCore\TDataReadReference)< int32 > & InSeedValue, const [TDataReadReference](API\Plugins\MetasoundGraphCore\TDataReadReference)< bool > & bInAutoShuffle, const [TDataReadReference](API\Plugins\MetasoundGraphCore\TDataReadReference)< bool > & bInEnableSharedState )


code: virtual ~TArrayShuffleOperator()


className: TArrayShuffleOperator

description: TArrayShuffleOperatorshuffles an array on trigger and outputs values sequentially on "next". It avoids repeating shuffled elements and supports auto-shuffling.

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


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


className: TArraySubsetNode

code: template<typename ArrayType> class TArraySubsetNode : 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: typedef [TDataReadReference](API\Plugins\MetasoundGraphCore\TDataReadReference)< ArrayType > FArrayDataReadReference


code: typedef [TDataWriteReference](API\Plugins\MetasoundGraphCore\TDataWriteReference)< ArrayType > FArrayDataWriteReference


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 ~TArraySubsetNode()


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


code: TArraySubsetOperator ( [TDataReadReference](API\Plugins\MetasoundGraphCore\TDataReadReference)< [FTrigger](API\Plugins\MetasoundFrontend\FTrigger) > InTrigger, [FArrayDataReadReference](API\Plugins\MetasoundFrontend\TArraySubsetOperator\FArrayDataReadReference) InInputArray, [TDataReadReference](API\Plugins\MetasoundGraphCore\TDataReadReference)< int32 > InStartIndex, [TDataReadReference](API\Plugins\MetasoundGraphCore\TDataReadReference)< int32 > InEndIndex, [TDataWriteReference](API\Plugins\MetasoundGraphCore\TDataWriteReference)< ArrayType > InOutputArray )


code: virtual ~TArraySubsetOperator()


className: TArraySubsetOperator

description: TArraySubsetOperatorslices an array on trigger.

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


code: virtual [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [IReceiver](API\Plugins\MetasoundFrontend\IReceiver) > ConstructNewReceiverImplementation ( const [FReceiverInitParams](API\Plugins\MetasoundFrontend\FReceiverInitParams) & InitParams )


code: virtual [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [ISender](API\Plugins\MetasoundFrontend\ISender) > ConstructNewSenderImplementation ( const [FSenderInitParams](API\Plugins\MetasoundFrontend\FSenderInitParams) & InitParams )


code: virtual int64 CreateNewPayloadID()


code: virtual bool IsEmpty() const


className: MaxChannels

code: static const int32 MaxChannels = 8;


code: virtual void PopOpaque ( [IReceiver](API\Plugins\MetasoundFrontend\IReceiver) & InReceiver )


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


code: virtual bool PushOpaque ( [ISender](API\Plugins\MetasoundFrontend\ISender) & InSender )


className: TAudioDataChannel

code: template<typename TDataType> class TAudioDataChannel : public [Metasound::IDataChannel](API\Plugins\MetasoundFrontend\IDataChannel)


className: BufferResizeThreshold

code: static constexpr float BufferResizeThreshold = 2.0f;


code: bool Pop ( TDataType & OutElement )


code: TAudioReceiver ( const [FReceiverInitParams](API\Plugins\MetasoundFrontend\FReceiverInitParams) & InitParams, [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< [IDataChannel](API\Plugins\MetasoundFrontend\IDataChannel), ESPMode::ThreadSafe > InDataChannel, [TArray](API\Runtime\Core\Containers\TArray)< [Audio::FPatchOutputStrongPtr](API\Runtime\Engine\FPatchOutputStrongPtr) > && Outputs )


className: TAudioReceiver

code: template<typename TDataType> class TAudioReceiver : public [Metasound::IReceiver](API\Plugins\MetasoundFrontend\IReceiver)


code: virtual int64 GetPayloadID() const


code: bool Push ( const TDataType & InElement )


description: Constructs the value with a literal and pushes to data channel.

code: virtual bool PushLiteral ( const [FLiteral](API\Plugins\MetasoundGraphCore\FLiteral) & InLiteral )


description: Resets the delay for this sender.

code: bool SetDelay ( float InSeconds )


code: TAudioSender ( const [FSenderInitParams](API\Plugins\MetasoundFrontend\FSenderInitParams) & InitParams, [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< [IDataChannel](API\Plugins\MetasoundFrontend\IDataChannel), ESPMode::ThreadSafe > InDataChannel, [TArray](API\Runtime\Core\Containers\TArray)< [Audio::FPatchInput](API\Runtime\SignalProcessing\DSP\FPatchInput) > && Inputs )


className: TAudioSender

description: AUDIO SPECIALIZATIONS:

code: template<typename TDataType> class TAudioSender : public [Metasound::ISender](API\Plugins\MetasoundFrontend\ISender)


description: Return a reference to the default operator factory.


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


code: static const [FVertexName](API\Plugins\MetasoundGraphCore\FVertexName) & GetInputName()


code: static const [FVertexName](API\Plugins\MetasoundGraphCore\FVertexName) & GetOutputName()


description: Return the current vertex interface.

code: virtual const [FVertexInterface](API\Plugins\MetasoundGraphCore\FVertexInterface) & GetVertexInterface() 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:
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: TAutoConverterNode ( const [FNodeInitData](API\Plugins\MetasoundGraphCore\FNodeInitData) & InInitData )


code: virtual ~TAutoConverterNode()


className: TAutoConverterNode

description: This convenience node can be registered and will invoke static_cast(FromDataType) every time it is executed, with a special case for enum <-> int32 conversions.

code: template<typename FromDataType, typename ToDataType> class TAutoConverterNode : public [Metasound::FNode](API\Plugins\MetasoundGraphCore\FNode)


code: virtual [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [IReceiver](API\Plugins\MetasoundFrontend\IReceiver) > ConstructNewReceiverImplementation ( const [FReceiverInitParams](API\Plugins\MetasoundFrontend\FReceiverInitParams) & InitParams )


code: virtual [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [ISender](API\Plugins\MetasoundFrontend\ISender) > ConstructNewSenderImplementation ( const [FSenderInitParams](API\Plugins\MetasoundFrontend\FSenderInitParams) & InitParams )


code: virtual int64 CreateNewPayloadID()


code: virtual int64 GetPayloadID() const


code: virtual bool IsEmpty() const


code: virtual void PopOpaque ( [IReceiver](API\Plugins\MetasoundFrontend\IReceiver) & InReceiver )


code: virtual bool PushLiteral ( const [FLiteral](API\Plugins\MetasoundGraphCore\FLiteral) & InParam )


code: virtual bool PushOpaque ( [ISender](API\Plugins\MetasoundFrontend\ISender) & InSender )


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


className: TCopyableDataChannel

description: Generic templated implementation ofIDataChannelthat can use for any copyable type.

code: template<typename TDataType> class TCopyableDataChannel : public [Metasound::IDataChannel](API\Plugins\MetasoundFrontend\IDataChannel)


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


className: TypeName

code: static TypeName;


code: template<> struct TDataReferenceTypeInfo< FMetasoundParameterStorageWrapper >


className: TDataReferenceTypeInfo< bool >

code: template<> struct TDataReferenceTypeInfo< bool >


className: TDataReferenceTypeInfo< float >

code: template<> struct TDataReferenceTypeInfo< float >


className: TDataReferenceTypeInfo< FSendAddress >

code: template<> struct TDataReferenceTypeInfo< FSendAddress >


className: TDataReferenceTypeInfo< FString >

code: template<> struct TDataReferenceTypeInfo< FString >


className: TDataReferenceTypeInfo< FTime >

code: template<> struct TDataReferenceTypeInfo< FTime >


className: TDataReferenceTypeInfo< FTrigger >

code: template<> struct TDataReferenceTypeInfo< FTrigger >


className: bIsParsableWithDeprecatedPtr

code: static constexpr bool bIsParsableWithDeprecatedPtr = TIsParsable<DataType, DataFactoryPrivate::ProxyDataPtrType_DEPRECATED>::Value;


className: TDataReferenceTypeInfo< int32 >

code: template<> struct TDataReferenceTypeInfo< int32 >


className: bIsParsableWithSharedProxyPtr

code: static constexpr bool bIsParsableWithSharedProxyPtr = TIsParsable<DataType, TSharedPtr<Audio::IProxyData>>::Value;


className: bOnlySupportsDeprecatedProxyPtr

code: static constexpr bool bOnlySupportsDeprecatedProxyPtr = bIsParsableWithDeprecatedPtr && !bIsParsableWithSharedProxyPtr;


className: TDataTypeProxyConstructorDeprecation

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


className: Value

code: static constexpr bool Value = true;


className: TEnableArrayNodes

code: template<typename... ElementType> struct TEnableArrayNodes


className: TEnableAutoArrayTypeRegistration

description: TEnableAutoArrayTypeRegistration< WaveTable::FWaveTable >

code: template<typename... Type> struct TEnableAutoArrayTypeRegistration


className: TEnableAutoConverterNodeRegistration

description: Enables or disables automatic registration of auto conversion nodes given a MetaSound data type.Bydefault this is true, and all data types will have associated conversion nodes registered based upon the data types supported constructors and implicit conversions.

code: template<typename... Type> struct TEnableAutoConverterNodeRegistration


className: TEnableConstructorVertex

description: Enables or disables using a data type in constructor vertices.Bydefault this is true and all data types that support copy assignment and copy construction.

code: template<typename... Type> struct TEnableConstructorVertex


className: TEnableTransmission

description: Determines whether send/receive nodes are enabled for a specific data type.

code: template<typename DataType> struct TEnableTransmission


className: TEnableTransmissionNodeRegistration

description: Enables or disables send and receive node registration for a given MetaSound data type.Bydefault this is true and all data types supported by the transmission system will have associated send and receive nodes.

code: template<typename... Type> struct TEnableTransmissionNodeRegistration


description: Bydefault, all registered MetaSound data types are variables.


className: TEnableVariables

description: Allow or disallow types to be registered as MetaSound Variables.

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


className: bHasWarnedNameToEnumConversionFailure

code: static bool bHasWarnedNameToEnumConversionFailure = false;


code: static constexpr bool EnumTypeIsSupported()


description: Return all possible Names.

code: static [TArray](API\Runtime\Core\Containers\TArray)< [FName](API\Runtime\Core\UObject\FName) > GetAllNames()


className: InnerType

code: typedef EnumType InnerType


description: Convert from Name to EnumValue (if possible).

code: static [TOptional](API\Runtime\Core\IO\TOptional)< EnumType > NameToEnum ( [FName](API\Runtime\Core\UObject\FName) InValue )


className: TEnum::operator EnumType

description: Conversion operator to automatically convert this to its underlying enum type.

code: operator EnumType() const


className: SerializedType

code: typedef int32 SerializedType


description: Convert from EnumValue toFName(if possible).

code: static [TOptional](API\Runtime\Core\IO\TOptional)< [FName](API\Runtime\Core\UObject\FName) > ToName ( EnumType InValue )


className: UnderlyingType

code: typedef std::underlying_type_t< EnumType > UnderlyingType


description: Default.

code: TEnum ( EnumType InValue )


description: From Int32 (this is the common path from a Literal).

code: TEnum ( int32 InIntValue )


description: From Name.

code: TEnum ( [FName](API\Runtime\Core\UObject\FName) InValueName )


description: Slow, construct fromFStringtoFName.

code: TEnum ( const [FString](API\Runtime\Core\Containers\FString) & InString )


description: Convert to itsFName(if possible).

code: [TOptional](API\Runtime\Core\IO\TOptional)< [FName](API\Runtime\Core\UObject\FName) > ToName() const


className: TEnum

description: MetasoundEnum Wrapper

code: template<typename EnumType, EnumType DefaultValue> class TEnum


className: TEnumEntry::operator TEnumEntry< int32 >

description: Allow implicit conversion to int32 entry.

code: operator TEnumEntry< int32 >() const


className: TEnumEntry

description: Struct to hold each of the entries of the Enum.

code: template<typename T> struct TEnumEntry

DisplayName

type: FText

Name

type: FName

Value

type: T


className: TEnumStringHelper

description: MetasoundEnum String Helper

code: template<typename T> struct TEnumStringHelper : public [Metasound::TEnumStringHelperBase< TEnumStringHelper< T >, T >](API\Plugins\MetasoundFrontend\TEnumStringHelperBase)


description: Give a Name "EMyEnum::One", convert that to a Enum Value.

code: static [TOptional](API\Runtime\Core\IO\TOptional)< EnumType > FromName ( const [FName](API\Runtime\Core\UObject\FName) InName )


description: Return all possible names.

code: static [TArray](API\Runtime\Core\Containers\TArray)< [FName](API\Runtime\Core\UObject\FName) > GetAllNames()


description: Give a enum value e.g. 'EMyEnum::One', convert that to a Name (if its valid)


className: TEnumStringHelperBase

description: CRTP base class for Enum String Helper type. Provides common code for all specializations.

code: template<typename Derived, typename EnumType> struct TEnumStringHelperBase


className: bIsEnum

code: static constexpr bool bIsEnum = false;


className: DefaultValue

code: static constexpr int32 DefaultValue = 0;


code: typedef int32 InnerType


className: TEnumTraits

code: template<typename T> struct TEnumTraits


code: void TriggerDeprecationMessage()


code: TExecutableDataTypeDeprecation()


className: TExecutableDataTypeDeprecation

description: ExecutableDataTypes are deprecated in 5.3 in favor of TPostExecutableDataTypes. This class triggers a deprecation warning when aTExecutableDataTypeis registered.

code: template<typename DataType> struct TExecutableDataTypeDeprecation


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 void Execute ( [IOperator](API\Plugins\MetasoundGraphCore\IOperator) * InOperator )


className: FDataWriteReference

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


className: FDataWriteReferenceFactory


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 reset.