SoundBase.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
 
#include "AudioDefines.h"
#include "AudioPropertiesSheetAssetBase.h"
#include "CoreMinimal.h"
#include "Sound/SoundTimecodeOffset.h"
#include "SoundConcurrency.h"
#include "UObject/Object.h"
#include "UObject/ObjectMacros.h"
#include "Interfaces/Interface_AssetUserData.h"
 
#include "SoundBase.generated.h"
 
 
// Forward Declarations
namespace Audio
{
    class IParameterTransmitter;
    struct FParameterInterface;
    struct FParameterTransmitterInitParams;
    using FDeviceId = uint32;;
    using FParameterInterfacePtr = TSharedPtr<FParameterInterface, ESPMode::ThreadSafe>;
} // namespace Audio
 
class ISoundGenerator;
class UAssetUserData;
class UAudioPropertiesSheetAssetBase;
class UAudioPropertiesBindings;
class USoundAttenuation;
class USoundClass;
class USoundEffectSourcePreset;
class USoundEffectSourcePresetChain;
class USoundSourceBus;
class USoundSubmix;
class USoundSubmixBase;
class USoundWave;
enum class EBusSendType : uint8;
namespace EMaxConcurrentResolutionRule { enum Type : int; }
struct FActiveSound;
struct FAudioParameter;
struct FSoundAttenuationSettings;
struct FSoundGeneratorInitParams;
struct FSoundParseParameters;
struct FSoundSourceBusSendInfo;
struct FSoundSubmixSendInfo;
struct FWaveInstance;
typedef TSharedPtr<ISoundGenerator, ESPMode::ThreadSafe> ISoundGeneratorPtr;
 
UENUM(BlueprintType)
enum class EVirtualizationMode : uint8
{
    Disabled,
 
    PlayWhenSilent,
 
    Restart,
 
    SeekRestart UE_EXPERIMENTAL(5.6, "This virtualization mode is experimental and may not function as expected in all use cases.")
};
 
UENUM(BlueprintType)
enum class EUseSubmixOnPreviewMode : uint8
{
    UseEditorPreference,
    UseSubmixesOnPreview,
    PlayPreviewsWithoutSubmixes
};
 
// This struct allows us to modify the transient editor properties and minimize impact on the properties
USTRUCT()
struct FSoundBaseEditorData
{
    GENERATED_BODY()
 
public:
    UPROPERTY(EditAnywhere, Transient, SkipSerialization, Category = Developer, meta = (DisplayName = "Use Submixes on preview"))
    EUseSubmixOnPreviewMode OverrideUseSubmixesOnPreview = EUseSubmixOnPreviewMode::UseEditorPreference;
};
 
 
UCLASS(config=Engine, hidecategories=Object, abstract, editinlinenew, BlueprintType, MinimalAPI)
class USoundBase : public UObject, public IAudioPropertiesSheetAssetUserInterface, public IInterface_AssetUserData
{
 
private:
    GENERATED_UCLASS_BODY()
 
public:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Sound, meta = (DisplayName = "Class"), AssetRegistrySearchable)
    TObjectPtr<USoundClass> SoundClassObject;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(EditAnywhere, Transient, SkipSerialization, Category = Developer, meta = (DisplayName = "Editor Data", ShowOnlyInnerProperties))
    FSoundBaseEditorData EditorData;
#endif //WITH_EDITORONLY_DATA
 
    UPROPERTY(EditAnywhere, Category = Developer, meta = (DisplayName = "Enable Attenuation Debug"))
    uint8 bDebug : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Voice Management|Concurrency")
    uint8 bOverrideConcurrency : 1;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    uint8 bOutputToBusOnly_DEPRECATED : 1;
#endif //WITH_EDITORONLY_DATA
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Effects|Source")
    uint8 bEnableBusSends : 1;
 
    UPROPERTY(EditAnywhere, Category = "Effects|Submix")
    uint8 bEnableBaseSubmix : 1;
 
    UPROPERTY(EditAnywhere, Category = "Effects|Submix", meta = (DisplayAfter = "SoundSubmixObject"))
    uint8 bEnableSubmixSends : 1;
 
    UPROPERTY()
    uint8 bHasDelayNode : 1;
 
    UPROPERTY()
    uint8 bHasConcatenatorNode : 1;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    uint8 bHasVirtualizeWhenSilent_DEPRECATED : 1;
#endif // WITH_EDITORONLY_DATA
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Voice Management|Priority")
    uint8 bBypassVolumeScaleForPriority : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Voice Management")
    EVirtualizationMode VirtualizationMode;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    TEnumAsByte<EMaxConcurrentResolutionRule::Type> MaxConcurrentResolutionRule_DEPRECATED;
#endif // WITH_EDITORONLY_DATA
 
    TMap<Audio::FDeviceId, int32> CurrentPlayCount;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    TObjectPtr<USoundConcurrency> SoundConcurrencySettings_DEPRECATED;
#endif // WITH_EDITORONLY_DATA
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Voice Management|Concurrency", meta = (EditCondition = "!bOverrideConcurrency"))
    TSet<TObjectPtr<USoundConcurrency>> ConcurrencySet;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Voice Management|Concurrency", meta = (EditCondition = "bOverrideConcurrency"))
    FSoundConcurrencySettings ConcurrencyOverrides;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    int32 MaxConcurrentPlayCount_DEPRECATED;
#endif
 
    UPROPERTY(Category = Developer, AssetRegistrySearchable, VisibleAnywhere, BlueprintReadOnly)
    float Duration;
 
    UPROPERTY(Category = Developer, AssetRegistrySearchable, VisibleAnywhere, BlueprintReadOnly)
    float MaxDistance;
 
    UPROPERTY(Category = Developer, AssetRegistrySearchable, VisibleAnywhere, BlueprintReadOnly)
    float TotalSamples;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Voice Management|Priority", meta = (ClampMin = "0.0", UIMin = "0.0", ClampMax = "100.0", UIMax = "100.0"))
    float Priority;
 
    UPROPERTY(EditAnywhere, Category = Attenuation, meta = (EditCondition = "IsAttenuationSettingsEditable"))
    TObjectPtr<USoundAttenuation> AttenuationSettings;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Effects|Submix", meta = (DisplayName = "Base Submix", EditCondition = "bEnableBaseSubmix"))
    TObjectPtr<USoundSubmixBase> SoundSubmixObject;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Effects|Submix", meta = (DisplayName = "Submix Sends", EditCondition = "bEnableSubmixSends"))
    TArray<FSoundSubmixSendInfo> SoundSubmixSends;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Effects|Source")
    TObjectPtr<USoundEffectSourcePresetChain> SourceEffectChain;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Effects|Source", meta = (DisplayName = "Post-Effect Bus Sends", EditCondition = "bEnableBusSends"))
    TArray<FSoundSourceBusSendInfo> BusSends;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Effects|Source", meta = (DisplayName = "Pre-Effect Bus Sends", EditCondition = "bEnableBusSends"))
    TArray<FSoundSourceBusSendInfo> PreEffectBusSends;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Instanced, Category = Advanced)
    TArray<TObjectPtr<UAssetUserData>> AssetUserData;
 
#if WITH_EDITORONLY_DATA    
    UPROPERTY(EditAnywhere, Category = AudioProperties)
    TObjectPtr<UAudioPropertiesSheetAssetBase> AudioPropertiesSheet;
 
    // //~ Begin IAudioPropertiesSheetAssetUserInterface
    ENGINE_API virtual void AllowPropertyParsing(const FProperty& TargetProperty) override;
    ENGINE_API virtual void IgnorePropertyParsing(const FProperty& PropertyToIgnore) override;
    ENGINE_API virtual bool ShouldParseProperty(const FProperty& TargetProperty) const override;
    //~ End IAudioPropertiesSheetAssetUserInterface
#endif
 
private:
    UPROPERTY()
    FSoundTimecodeOffset TimecodeOffset;
 
    //Property Sheets support
    void InjectPropertySheet();
    void BindToPropertySheetChanges();
    void UnbindFromPropertySheetChanges();
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    TArray<FName> LocalAudioProperties;
#endif
 
public:
    //~ Begin UObject Interface.
#if WITH_EDITORONLY_DATA
    ENGINE_API virtual void PostLoad() override;
#endif
    ENGINE_API virtual bool CanBeClusterRoot() const override;
    ENGINE_API virtual bool CanBeInCluster() const override;
    ENGINE_API virtual void PreSave(FObjectPreSaveContext SaveContext) override;
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
 
#if WITH_EDITOR
    ENGINE_API virtual void PostEditChangeProperty(struct FPropertyChangedEvent& PropertyChangedEvent) override;
    ENGINE_API virtual void PreEditChange(FProperty* PropertyAboutToChange) override;
#endif
 
    //~ End UObject interface.
 
    ENGINE_API virtual bool IsPlayable() const;
 
    ENGINE_API virtual bool SupportsSubtitles() const;
 
    ENGINE_API virtual bool HasAttenuationNode() const;
 
    ENGINE_API virtual const FSoundAttenuationSettings* GetAttenuationSettingsToApply() const;
 
    ENGINE_API virtual float GetMaxDistance() const;
 
    ENGINE_API virtual float GetDuration() const;
 
    ENGINE_API bool HasDelayNode() const;
 
    ENGINE_API bool HasConcatenatorNode() const;
 
    ENGINE_API virtual bool IsPlayWhenSilent() const;
 
    ENGINE_API virtual float GetVolumeMultiplier();
    ENGINE_API virtual float GetPitchMultiplier();
 
    virtual float GetSubtitlePriority() const { return DEFAULT_SUBTITLE_PRIORITY; };
 
    ENGINE_API virtual bool ShouldApplyInteriorVolumes();
 
    virtual class UCurveTable* GetCurveData() const { return nullptr; }
 
    ENGINE_API virtual bool IsLooping() const;
 
    ENGINE_API virtual bool IsOneShot() const;
 
    virtual bool IsProcedurallyGenerated() const { return false; }
 
    virtual void Parse( class FAudioDevice* AudioDevice, const UPTRINT NodeWaveInstanceHash, FActiveSound& ActiveSound, const FSoundParseParameters& ParseParams, TArray<FWaveInstance*>& WaveInstances ) { }
 
    ENGINE_API virtual USoundClass* GetSoundClass() const;
 
    ENGINE_API virtual USoundSubmixBase* GetSoundSubmix() const;
 
    ENGINE_API void GetSoundSubmixSends(TArray<FSoundSubmixSendInfo>& OutSends) const;
 
    ENGINE_API void GetSoundSourceBusSends(EBusSendType BusSendType, TArray<FSoundSourceBusSendInfo>& OutSends) const;
 
    ENGINE_API void GetConcurrencyHandles(TArray<FConcurrencyHandle>& OutConcurrencyHandles) const;
 
    ENGINE_API float GetPriority() const;
    ENGINE_API virtual bool GetSoundWavesWithCookedAnalysisData(TArray<USoundWave*>& OutSoundWaves);
 
    virtual bool HasCookedFFTData() const { return false; }
    virtual bool HasCookedAmplitudeEnvelopeData() const { return false; }
 
    //~ Begin IInterface_AssetUserData Interface
    ENGINE_API virtual void AddAssetUserData(UAssetUserData* InUserData) override;
    ENGINE_API virtual void RemoveUserDataOfClass(TSubclassOf<UAssetUserData> InUserDataClass) override;
    ENGINE_API virtual UAssetUserData* GetAssetUserDataOfClass(TSubclassOf<UAssetUserData> InUserDataClass) override;
    ENGINE_API virtual const TArray<UAssetUserData*>* GetAssetUserDataArray() const override;
    //~ End IInterface_AssetUserData Interface
 
    ENGINE_API virtual void InitParameters(TArray<FAudioParameter>& ParametersToInit, FName InFeatureName = NAME_None);
 
    virtual void InitResources() { }
 
    virtual bool ImplementsParameterInterface(Audio::FParameterInterfacePtr InParameterInterface) const { return false; }
 
    virtual ISoundGeneratorPtr CreateSoundGenerator(const FSoundGeneratorInitParams& InParams) { return nullptr; }
    
    virtual ISoundGeneratorPtr CreateSoundGenerator(const FSoundGeneratorInitParams& InParams, TArray<FAudioParameter>&& InDefaultParameters) { return CreateSoundGenerator(InParams); }
 
    ENGINE_API virtual TSharedPtr<Audio::IParameterTransmitter> CreateParameterTransmitter(Audio::FParameterTransmitterInitParams&& InParams) const;
 
    ENGINE_API virtual bool IsParameterValid(const FAudioParameter& InParameter) const;
 
    virtual bool GetAllDefaultParameters(TArray<FAudioParameter>& OutParameters) const { return false; }
 
    UE_DEPRECATED(5.7, "This is no longer used.") virtual bool EnableSubmixSendsOnPreview() const { return false; }
 
    UFUNCTION()
    virtual bool IsAttenuationSettingsEditable() const { return true; }
 
#if WITH_EDITORONLY_DATA
    ENGINE_API void SetTimecodeOffset(const FSoundTimecodeOffset& InTimecodeOffset);
    ENGINE_API TOptional<FSoundTimecodeOffset> GetTimecodeOffset() const;
 
#endif //WITH_EDITORONLY_DATA
 
protected:
    ENGINE_API virtual float ComputeMaxDistance() const;
};