IAudioParameterInterfaceRegistry.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "AudioParameter.h"
#include "AudioParameterControllerInterface.h"
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "Containers/Set.h"
#include "HAL/Platform.h"
#include "Internationalization/Text.h"
#include "Misc/AssertionMacros.h"
#include "Templates/Function.h"
#include "Templates/SharedPointer.h"
#include "Templates/UniquePtr.h"
#include "UObject/Class.h"
#include "UObject/NameTypes.h"
 
 
namespace Audio
{
    // Forward Declarations
    class IAudioParameterInterfaceRegistry;
 
    // Interface for parameterizing data provided to or coming from an executable audio unit
    // (ex. Sound like a MetaSoundSource, arbitrary DSP graph like a MetaSoundPatch, etc.).
    // Can be used generically for processing either logically at a control or Game Thread
    // tick rate (ex. SoundCues), or by an underlying DSP operation via the Audio Render
    // Thread or delegated task (ex. MetaSounds, custom SoundGenerator, etc.)
    struct FParameterInterface
    {
        // Version of interface (higher numbers are more recent)
        struct FVersion
        {
            const int32 Major = 1;
            const int32 Minor = 0;
        };
 
        // Input of interface
        struct FInput
        {
            // Name to be displayed in editor or tools
            const FText DisplayName;
 
            // Description to be displayed in editor or tools
            const FText Description;
 
            // FName describing the type of the data.  May be
            // interpreted solely by a plugin or implementation
            // (ex. MetaSounds).  If blank, type is assumed to be
            // that described by the InitValue AudioParameter's
            // corresponding ParamType. If provided, DataType
            // must be constructible using the InitValue.
            const FName DataType;
 
            // Initial value of the given parameter
            const FAudioParameter InitValue;
 
            // Text to display in the editor or tools if the consuming
            // system of the given input parameter is not implemented (to avoid
            // passing data using the parameter system when not operated on).
            const FText RequiredText;
 
            // Visual sort order of the given input with respect to other inputs either
            // within the given interface or listed among other unrelated inputs.
            const int32 SortOrderIndex = 0;
        };
 
        // Output of interface
        struct FOutput
        {
            // Name to be displayed in editor or tools
            const FText DisplayName;
 
            // Description to be displayed in editor or tools
            const FText Description;
 
            // FName describing the type of the data.  May be
            // interpreted solely by a plugin or implementation
            // (ex. MetaSounds).  If blank, type is assumed to be
            // that described by ParamType.
            const FName DataType;
 
            // Name of output parameter used as a runtime identifier
            const FName ParamName;
 
            // Text to display in the editor or tools if the consuming
            // system of the given input parameter is not implemented (to avoid
            // passing data using the parameter system when not operated on).
            const FText RequiredText = FText();
 
            // Type of output parameter used as a runtime identifier if unspecified by the DataType.
            const EAudioParameterType ParamType = EAudioParameterType::None;
 
            // Visual sort order of the given input with respect to other outputs either
            // within the given interface or listed among other unrelated outputs.
            const int32 SortOrderIndex = 0;
        };
 
        // Read-only variable that cannot be modified by the sound instance,
        // and maybe shared amongst instances.
        struct FEnvironmentVariable
        {
            // Name to be displayed in editor or tools
            const FText DisplayName;
 
            // Description to be displayed in editor or tools
            const FText Description;
 
            // FName describing the type of the data.  May be
            // interpreted solely by a plugin or implementation
            // (ex. MetaSounds).  If blank, type is assumed to be
            // that described by ParamType.
            const FName DataType;
 
            // Name of variable used as a runtime identifier
            const FName ParamName;
 
            // Type of variable used as a runtime identifier if unspecified by the DataType.
            const EAudioParameterType ParamType = EAudioParameterType::None;
        };
 
        // Options used to restrict a corresponding UClass that interface may be applied to.
        struct FClassOptions
        {
            // Path to restricted UClass
            const FTopLevelAssetPath ClassPath;
 
            // Whether or not the class may be directly modifiable on an asset implementing
            // the given interface (added, removed, etc.)
            const bool bIsModifiable = true;
 
            // Whether or not the interface should be immediately added to the given class
            // type on creation.
            const bool bIsDefault = false;
        };
 
        FParameterInterface() = default;
 
        // Constructor used for parameter interface not limited to any particular UClass types
        AUDIOEXTENSIONS_API FParameterInterface(FName InName, const FVersion& InVersion);
 
        UE_DEPRECATED(5.3, "Set UClassOptions to determine what options apply for a given UClass (if any).")
        AUDIOEXTENSIONS_API FParameterInterface(FName InName, const FVersion& InVersion, const UClass& InClass);
 
        // Returns name of interface
        AUDIOEXTENSIONS_API FName GetName() const;
 
        // Returns version of interface
        AUDIOEXTENSIONS_API const FVersion& GetVersion() const;
 
        UE_DEPRECATED(5.3, "Use FParameterInterface::FindSupportedUClasses instead")
        AUDIOEXTENSIONS_API const UClass& GetType() const;
 
        AUDIOEXTENSIONS_API TArray<const UClass*> FindSupportedUClasses() const;
 
        // If specified, options used to restrict a corresponding UClass that interface may be
        // applied to.  If unspecified, interface is assumed to be applicable to any arbitrary UClass.
        AUDIOEXTENSIONS_API const TArray<FClassOptions>& GetUClassOptions() const;
 
        // Returns read-only array of inputs
        AUDIOEXTENSIONS_API const TArray<FInput>& GetInputs() const;
 
        // Returns read-only array of outputs
        AUDIOEXTENSIONS_API const TArray<FOutput>& GetOutputs() const;
 
        // Returns read-only array of environment variables
        AUDIOEXTENSIONS_API const TArray<FEnvironmentVariable>& GetEnvironment() const;
 
    private:
        FName NamePrivate;
        FVersion VersionPrivate;
 
    protected:
        TArray<FInput> Inputs;
        TArray<FOutput> Outputs;
        TArray<FEnvironmentVariable> Environment;
        TArray<FClassOptions> UClassOptions;
    };
    using FParameterInterfacePtr = TSharedPtr<FParameterInterface, ESPMode::ThreadSafe>;
 
    // Registry of engine-defined audio parameter interfaces, used to parameterize data provided
    // to or coming from an executable audio unit (ex. Sound like a MetaSoundSource, arbitrary DSP
    // graph like a MetaSoundPatch, etc.).
    class IAudioParameterInterfaceRegistry
    {
        static AUDIOEXTENSIONS_API TUniquePtr<IAudioParameterInterfaceRegistry> Instance;
 
    public:
        static AUDIOEXTENSIONS_API IAudioParameterInterfaceRegistry& Get();
 
        virtual ~IAudioParameterInterfaceRegistry() = default;
 
        // Iterate all registered interfaces
        virtual void IterateInterfaces(TFunction<void(FParameterInterfacePtr)> InFunction) const = 0;
 
        // Execute a given function when an interface is registered
        virtual void OnRegistration(TUniqueFunction<void(FParameterInterfacePtr)>&& InFunction) = 0;
 
        // Registers an interface
        virtual void RegisterInterface(FParameterInterfacePtr InInterface) = 0;
 
    protected:
        TSet<FParameterInterfacePtr> Interfaces;
        TUniqueFunction<void(FParameterInterfacePtr)> RegistrationFunction;
    };
} // namespace Audio