AudioComponent.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "Audio.h"
#include "Audio/SoundParameterControllerInterface.h"
#include "Components/SceneComponent.h"
#include "CoreMinimal.h"
#include "Engine/EngineTypes.h"
#include "IAudioParameterTransmitter.h"
#include "Math/RandomStream.h"
#include "Misc/TransactionallySafeCriticalSection.h"
#include "Quartz/AudioMixerQuantizedCommands.h"
#include "Sound/QuartzQuantizationUtilities.h"
#include "Sound/QuartzSubscription.h"
#include "Sound/SoundAttenuation.h"
#include "Sound/SoundModulationDestination.h"
#include "Sound/SoundSubmixSend.h"
#include "Sound/SoundSourceBusSend.h"
#include "UObject/ObjectMacros.h"
 
#include "AudioComponent.generated.h"
 
 
// Forward Declarations
class FAudioDevice;
class ISourceBufferListener;
class UAudioComponent;
class USoundBase;
class USoundClass;
class USoundConcurrency;
class USoundEffectSourcePresetChain;
class USoundWave;
struct FAudioComponentParam;
using FSharedISourceBufferListenerPtr = TSharedPtr<ISourceBufferListener, ESPMode::ThreadSafe>;
 
 
// Enum describing the audio component play state
UENUM(BlueprintType)
enum class EAudioComponentPlayState : uint8
{
    // If the sound is playing (i.e. not fading in, not fading out, not paused)
    Playing,
 
    // If the sound is not playing
    Stopped, 
 
    // If the sound is playing but paused
    Paused,
 
    // If the sound is playing and fading in
    FadingIn,
 
    // If the sound is playing and fading out
    FadingOut,
 
    Count UMETA(Hidden)
};
 
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnAudioFinished);
 
DECLARE_MULTICAST_DELEGATE_OneParam(FOnAudioFinishedNative, UAudioComponent*);
 
DECLARE_DYNAMIC_DELEGATE_TwoParams(FOnQueueSubtitles, const TArray<struct FSubtitleCue>&, Subtitles, float, CueDuration);
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnAudioPlayStateChanged, EAudioComponentPlayState, PlayState);
 
DECLARE_MULTICAST_DELEGATE_TwoParams(FOnAudioPlayStateChangedNative, const UAudioComponent*, EAudioComponentPlayState);
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnAudioVirtualizationChanged, bool, bIsVirtualized);
 
DECLARE_MULTICAST_DELEGATE_TwoParams(FOnAudioVirtualizationChangedNative, const UAudioComponent*, bool);
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnAudioPlaybackPercent, const USoundWave*, PlayingSoundWave, const float, PlaybackPercent);
 
DECLARE_MULTICAST_DELEGATE_ThreeParams(FOnAudioPlaybackPercentNative, const UAudioComponent*, const USoundWave*, const float);
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnAudioSingleEnvelopeValue, const class USoundWave*, PlayingSoundWave, const float, EnvelopeValue);
 
DECLARE_MULTICAST_DELEGATE_ThreeParams(FOnAudioSingleEnvelopeValueNative, const UAudioComponent*, const USoundWave*, const float);
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams(FOnAudioMultiEnvelopeValue, const float, AverageEnvelopeValue, const float, MaxEnvelope, const int32, NumWaveInstances);
 
DECLARE_MULTICAST_DELEGATE_FourParams(FOnAudioMultiEnvelopeValueNative, const UAudioComponent*, const float, const float, const int32);
 
 
 
UENUM(BlueprintType)
enum class EAudioFaderCurve : uint8
{
    // Linear Fade
    Linear,
 
    // Logarithmic Fade
    Logarithmic,
 
    // S-Curve, Sinusoidal Fade
    SCurve UMETA(DisplayName = "Sin (S-Curve)"),
 
    // Equal Power, Sinusoidal Fade
    Sin UMETA(DisplayName = "Sin (Equal Power)"),
 
    Count UMETA(Hidden)
};
 
USTRUCT()
struct UE_DEPRECATED(5.0, "FAudioComponentParam has been deprecated, use FAudioParameter") FAudioComponentParam : public FAudioParameter
{
    GENERATED_BODY()
 
    // DEPRECATED
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=AudioComponentParam)
    TObjectPtr<USoundWave> SoundWaveParam = nullptr;
};
 
UCLASS(BlueprintType, MinimalAPI)
class UInitialActiveSoundParams : public UObject
{
    GENERATED_UCLASS_BODY()
 
    // Collection of parameters to be sent to the active sound
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Audio")
    TArray<FAudioParameter> AudioParams;
 
    void Reset(int32 ReserveSize = 0)
    {
        AudioParams.Reset(ReserveSize);
    }
};
 
UCLASS(ClassGroup=(Audio, Common), HideCategories=(Object, ActorComponent, Physics, Rendering, Mobility, LOD), ShowCategories=Trigger, meta=(BlueprintSpawnableComponent), MinimalAPI)
class UAudioComponent : public USceneComponent, public ISoundParameterControllerInterface, public FQuartzTickableObject
{
    GENERATED_UCLASS_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Sound)
    TObjectPtr<USoundBase> Sound;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Parameters, meta = (DisplayAfter = "bDisableParameterUpdatesWhilePlaying"))
    TArray<FAudioParameter> DefaultParameters;
 
    UPROPERTY(Transient)
    TArray<FAudioParameter> InstanceParameters;
 
    UPROPERTY(EditAnywhere, Category = Sound, AdvancedDisplay)
    TObjectPtr<USoundClass> SoundClassOverride;
 
    UPROPERTY()
    uint8 bAutoDestroy:1;
 
    UPROPERTY()
    uint8 bStopWhenOwnerDestroyed:1;
 
    UPROPERTY()
    uint8 bShouldRemainActiveIfDropped:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Attenuation)
    uint8 bAllowSpatialization:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, BlueprintSetter = SetOverrideAttenuation, Category = Attenuation)
    uint8 bOverrideAttenuation:1;
 
    UFUNCTION(BlueprintSetter)
    ENGINE_API void SetOverrideAttenuation(bool bInOverrideAttenuation);
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Subtitles, meta = (InlineEditConditionToggle))
    uint8 bOverrideSubtitlePriority:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Sound, AdvancedDisplay)
    uint8 bIsUISound : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Sound, meta = (InlineEditConditionToggle, DisplayAfter = "PitchMultiplier"))
    uint8 bEnableLowPassFilter : 1;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Sound, meta = (InlineEditConditionToggle, DisplayAfter = "LowPassFilterFrequency"))
    uint8 bEnableHighPassFilter : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Sound, meta = (InlineEditConditionToggle, DisplayAfter = "HighPassFilterFrequency"))
    uint8 bOverridePriority:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Subtitles)
    uint8 bSuppressSubtitles:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Sound, meta = (DisplayName = "Play Multiple Instances", DisplayAfter = "Priority"))
    uint8 bCanPlayMultipleInstances:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Parameters)
    uint8 bDisableParameterUpdatesWhilePlaying : 1;
 
    uint8 bPreviewComponent:1;
 
    uint8 bIgnoreForFlushing:1;
 
    uint8 bAlwaysPlay:1;
 
    uint8 bIsMusic:1;
 
    uint8 bReverb:1;
 
    uint8 bCenterChannelOnly:1;
 
    uint8 bIsPreviewSound:1;
 
#if WITH_EDITORONLY_DATA
    uint8 bIsDryPreviewPlayback : 1;
#endif //WITH_EDITORONLY_DATA
 
    uint8 bIsPaused:1;
 
    uint8 bIsVirtualized:1;
 
    uint8 bIsFadingOut:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Attachment)
    uint8 bAutoManageAttachment:1;
 
private:
    uint8 bDidAutoAttach : 1;
 
public:
    uint32 AudioDeviceID;
 
    UPROPERTY()
    FName AudioComponentUserID;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Randomization|Pitch", meta = (DisplayName = "Pitch (Min)"))
    float PitchModulationMin;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Randomization|Pitch", meta = (DisplayName = "Pitch (Max)"))
    float PitchModulationMax;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Randomization|Volume", meta = (DisplayName = "Volume (Min)"))
    float VolumeModulationMin;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Randomization|Volume", meta = (DisplayName = "Volume (Max)"))
    float VolumeModulationMax;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Sound, meta = (DisplayAfter = "Sound"))
    float VolumeMultiplier;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Analysis, meta = (ClampMin = "0", UIMin = "0"))
    int32 EnvelopeFollowerAttackTime;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Analysis, meta = (ClampMin = "0", UIMin = "0"))
    int32 EnvelopeFollowerReleaseTime;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Sound, meta = (ClampMin = "0.0", UIMin = "0.0", EditCondition = "bOverridePriority", DisplayAfter = "HighPassFilterFrequency"))
    float Priority;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Subtitles, meta = (ClampMin = "0.0", UIMin = "0.0", EditCondition = "bOverrideSubtitlePriority", DisplayAfter = "SuppressSubtitles"))
    float SubtitlePriority;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Sound, meta = (DisplayAfter = "CanPlayMultipleInstances"))
    TObjectPtr<USoundEffectSourcePresetChain> SourceEffectChain;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    float VolumeWeightedPriorityScale_DEPRECATED;
 
    UPROPERTY()
    float HighFrequencyGainMultiplier_DEPRECATED;
#endif
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Sound, meta = (DisplayAfter = "VolumeMultiplier"))
    float PitchMultiplier;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Sound, meta = (ClampMin = "0.0", UIMin = "0.0", EditCondition = "bEnableLowPassFilter", DisplayAfter = "PitchMultiplier"))
    float LowPassFilterFrequency;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Sound, meta = (ClampMin = "0.0", UIMin = "0.0", EditCondition = "bEnableHighPassFilter", DisplayAfter = "LowPassFilterFrequency"))
    float HighPassFilterFrequency;
 
    int32 ActiveCount;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Attenuation, BlueprintSetter = SetAttenuationSettings, meta = (EditCondition = "!bOverrideAttenuation", DisplayAfter = "bOverrideAttenuation", EditConditionHides))
    TObjectPtr<USoundAttenuation> AttenuationSettings;
 
    UFUNCTION(BlueprintSetter)
    ENGINE_API void SetAttenuationSettings(USoundAttenuation* InAttenuationSettings);
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Attenuation, BlueprintSetter = SetAttenuationOverrides, meta = (EditCondition = "bOverrideAttenuation", DisplayAfter = "bOverrideAttenuation", EditConditionHides))
    struct FSoundAttenuationSettings AttenuationOverrides;
 
    UFUNCTION(BlueprintSetter)
    ENGINE_API void SetAttenuationOverrides(const FSoundAttenuationSettings& InAttenuationOverrides);
 
    UPROPERTY()
    TObjectPtr<USoundConcurrency> ConcurrencySettings_DEPRECATED;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Concurrency)
    TSet<TObjectPtr<USoundConcurrency>> ConcurrencySet;
 
    UPROPERTY(EditAnywhere, config, Category = Occlusion)
    float OcclusionCheckInterval;
 
    float TimeAudioComponentPlayed;
 
    float FadeInTimeDuration;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Attachment, meta = (EditCondition = "bAutoManageAttachment"))
    EAttachmentRule AutoAttachLocationRule;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Attachment, meta = (EditCondition = "bAutoManageAttachment"))
    EAttachmentRule AutoAttachRotationRule;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Attachment, meta = (EditCondition = "bAutoManageAttachment"))
    EAttachmentRule AutoAttachScaleRule;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Modulation)
    FSoundModulationDefaultRoutingSettings ModulationRouting;
 
    UPROPERTY(BlueprintAssignable)
    FOnAudioPlayStateChanged OnAudioPlayStateChanged;
 
    FOnAudioPlayStateChangedNative OnAudioPlayStateChangedNative;
 
    UPROPERTY(BlueprintAssignable)
    FOnAudioVirtualizationChanged OnAudioVirtualizationChanged;
 
    FOnAudioVirtualizationChangedNative OnAudioVirtualizationChangedNative;
 
    UPROPERTY(BlueprintAssignable)
    FOnAudioFinished OnAudioFinished;
 
    FOnAudioFinishedNative OnAudioFinishedNative;
 
    UPROPERTY(BlueprintAssignable)
    FOnAudioPlaybackPercent OnAudioPlaybackPercent;
 
    FOnAudioPlaybackPercentNative OnAudioPlaybackPercentNative;
 
    UPROPERTY(BlueprintAssignable)
    FOnAudioSingleEnvelopeValue OnAudioSingleEnvelopeValue;
 
    FOnAudioSingleEnvelopeValueNative OnAudioSingleEnvelopeValueNative;
 
    UPROPERTY(BlueprintAssignable)
    FOnAudioMultiEnvelopeValue OnAudioMultiEnvelopeValue;
 
    FOnAudioMultiEnvelopeValueNative OnAudioMultiEnvelopeValueNative;
 
    UPROPERTY()
    FOnQueueSubtitles OnQueueSubtitles;
 
    // Set what sound is played by this component
    UFUNCTION(BlueprintCallable, Category="Audio|Components|Audio")
    ENGINE_API void SetSound(USoundBase* NewSound);
 
    UFUNCTION(BlueprintCallable, Category="Audio|Components|Audio", meta=(AdvancedDisplay = 1))
    ENGINE_API virtual void FadeIn(float FadeInDuration, float FadeVolumeLevel = 1.0f, float StartTime = 0.0f, const EAudioFaderCurve FadeCurve = EAudioFaderCurve::Linear);
 
    UFUNCTION(BlueprintCallable, Category="Audio|Components|Audio", meta = (AdvancedDisplay = 1))
    ENGINE_API virtual  void FadeOut(float FadeOutDuration, float FadeVolumeLevel, const EAudioFaderCurve FadeCurve = EAudioFaderCurve::Linear);
 
    UFUNCTION(BlueprintCallable, Category="Audio|Components|Audio")
    ENGINE_API virtual void Play(float StartTime = 0.0f);
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio", meta = (WorldContext = "WorldContextObject", AdvancedDisplay = "3", UnsafeDuringActorConstruction = "true", Keywords = "play", AutoCreateRefTerm = "InDelegate"))
    ENGINE_API virtual void PlayQuantized(
          const UObject* WorldContextObject
        , UPARAM(ref) UQuartzClockHandle*& InClockHandle
        , UPARAM(ref) FQuartzQuantizationBoundary& InQuantizationBoundary
        , const FOnQuartzCommandEventBP& InDelegate
        , float InStartTime = 0.f
        , float InFadeInDuration = 0.f
        , float InFadeVolumeLevel = 1.f
        , EAudioFaderCurve InFadeCurve = EAudioFaderCurve::Linear
    );
 
    // Sets a named Boolean
    UFUNCTION(BlueprintCallable, meta = (DisplayName = "Set Boolean Parameter"), Category = "Audio|Parameter")
    virtual void SetBoolParameter(FName InName, bool InBool) override
    {
        return ISoundParameterControllerInterface::SetBoolParameter(InName, InBool);
    }
 
    // Sets a named Int32
    UFUNCTION(BlueprintCallable, meta = (DisplayName = "Set Integer Parameter"), Category = "Audio|Parameter")
    virtual void SetIntParameter(FName InName, int32 InInt) override
    {
        return ISoundParameterControllerInterface::SetIntParameter(InName, InInt);
    }
 
    // Sets a named Float
    UFUNCTION(BlueprintCallable, meta = (DisplayName = "Set Float Parameter"), Category = "Audio|Parameter")
    virtual void SetFloatParameter(FName InName, float InFloat) override
    {
        return ISoundParameterControllerInterface::SetFloatParameter(InName, InFloat);
    }
 
    ENGINE_API virtual void ResetParameters() override;
 
 
    static ENGINE_API uint64 AudioComponentIDCounter;
    static ENGINE_API TMap<uint64, UAudioComponent*> AudioIDToComponentMap;
    static ENGINE_API FTransactionallySafeCriticalSection AudioIDToComponentMapLock;
 
private:
    // Data to hold pending quartz commands 
    struct FAudioComponentPendingQuartzCommandData
    {
        FQuartzQuantizationBoundary AnticipatoryBoundary;
        FOnQuartzCommandEventBP Delegate;
        float StartTime{ 0.0f };
        float FadeDuration{ 0.0f };
        float FadeVolume{ 0.0f };
        EAudioFaderCurve FadeCurve{ EAudioFaderCurve::Linear };
        uint32 CommandID{ (uint32)INDEX_NONE };
        TWeakObjectPtr<UQuartzClockHandle> ClockHandle;
        bool bHasBeenStoppedWhileQueued{ false };
    };
 
    TArray<FAudioComponentPendingQuartzCommandData> PendingQuartzCommandData;
 
public:
    //For if this is being played through a sound queued through Quartz
    ENGINE_API virtual void PlayQueuedQuantizedInternal(const UObject* WorldContextObject, FAudioComponentCommandInfo InCommandInfo);
 
    UFUNCTION(BlueprintCallable, Category="Audio|Components|Audio")
    ENGINE_API virtual void Stop();
 
    UFUNCTION(BlueprintCallable, Category="Audio|Components|Audio")
    ENGINE_API void StopDelayed(float DelayTime);
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio")
    ENGINE_API void SetPaused(bool bPause);
 
    UFUNCTION(BlueprintCallable, Category="Audio|Components|Audio")
    ENGINE_API virtual bool IsPlaying() const override;
 
    UFUNCTION(BlueprintCallable, Category="Audio|Components|Audio")
    ENGINE_API bool IsVirtualized() const;
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio")
    ENGINE_API EAudioComponentPlayState GetPlayState() const;
 
    UFUNCTION(BlueprintCallable, Category="Audio|Components|Audio")
    ENGINE_API void AdjustVolume(float AdjustVolumeDuration, float AdjustVolumeLevel, const EAudioFaderCurve FadeCurve = EAudioFaderCurve::Linear);
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Parameter")
    ENGINE_API void SetWaveParameter(FName InName, USoundWave* InWave);
 
    UFUNCTION(BlueprintCallable, Category="Audio|Components|Audio")
    ENGINE_API void SetVolumeMultiplier(float NewVolumeMultiplier);
 
    UFUNCTION(BlueprintCallable, Category="Audio|Components|Audio")
    ENGINE_API void SetPitchMultiplier(float NewPitchMultiplier);
 
    UFUNCTION(BlueprintCallable, Category="Audio|Components|Audio")
    ENGINE_API void SetUISound(bool bInUISound);
 
    UFUNCTION(BlueprintCallable, Category="Audio|Components|Audio")
    ENGINE_API void AdjustAttenuation(const FSoundAttenuationSettings& InAttenuationSettings);
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio")
    ENGINE_API void SetSubmixSend(USoundSubmixBase* Submix, float SendLevel);
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio")
    ENGINE_API void SetSourceBusSendPreEffect(USoundSourceBus* SoundSourceBus, float SourceBusSendLevel);
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio")
    ENGINE_API void SetSourceBusSendPostEffect(USoundSourceBus* SoundSourceBus, float SourceBusSendLevel);
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio")
    ENGINE_API void SetAudioBusSendPreEffect(UAudioBus* AudioBus, float AudioBusSendLevel);
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio")
    ENGINE_API void SetAudioBusSendPostEffect(UAudioBus* AudioBus, float AudioBusSendLevel);
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio")
    ENGINE_API void SetLowPassFilterEnabled(bool InLowPassFilterEnabled);
    
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio")
    ENGINE_API void SetHighPassFilterEnabled(bool InHighPassFilterEnabled);
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio")
    ENGINE_API void SetLowPassFilterFrequency(float InLowPassFilterFrequency);
    
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio")
    ENGINE_API void SetHighPassFilterFrequency(float InHighPassFilterFrequency);
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio")
    ENGINE_API void SetOutputToBusOnly(bool bInOutputToBusOnly);
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio")
    ENGINE_API bool HasCookedFFTData() const;
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio")
    ENGINE_API bool HasCookedAmplitudeEnvelopeData() const;
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio")
    ENGINE_API bool GetCookedFFTData(const TArray<float>& FrequenciesToGet, TArray<FSoundWaveSpectralData>& OutSoundWaveSpectralData);
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio")
    ENGINE_API bool GetCookedFFTDataForAllPlayingSounds(TArray<FSoundWaveSpectralDataPerSound>& OutSoundWaveSpectralData);
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio", DisplayName = "Get Cooked Amplitude Envelope Data")
    ENGINE_API bool GetCookedEnvelopeData(float& OutEnvelopeData);
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio", DisplayName="Get Cooked Amplitude Envelope Data For All Playing Sounds")
    ENGINE_API bool GetCookedEnvelopeDataForAllPlayingSounds(TArray<FSoundWaveEnvelopeDataPerSound>& OutEnvelopeData);
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio", DisplayName = "Set Modulation Routing")
    ENGINE_API void SetModulationRouting(const TSet<USoundModulatorBase*>& Modulators, const EModulationDestination Destination, const EModulationRouting RoutingMethod = EModulationRouting::Inherit);
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio", DisplayName = "Add Modulation Routing")
    ENGINE_API void AddModulationRouting(const TSet<USoundModulatorBase*>& Modulators, const EModulationDestination Destination);
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio", DisplayName = "Remove Modulation Routing")
    ENGINE_API void RemoveModulationRouting(const TSet<USoundModulatorBase*>& Modulators, const EModulationDestination Destination);
 
    UFUNCTION(BlueprintPure, Category = "Audio|Components|Audio", DisplayName = "Get Modulators")
    ENGINE_API UPARAM(DisplayName = "Modulators") TSet<USoundModulatorBase*> GetModulators(const EModulationDestination Destination);
 
    static ENGINE_API void PlaybackCompleted(uint64 AudioComponentID, bool bFailedToStart);
 
 
    bool GetDisableParameterUpdatesWhilePlaying() const override { return static_cast<bool>(bDisableParameterUpdatesWhilePlaying); }
 
private:
    ENGINE_API void PlaybackCompleted(bool bFailedToStart);
 
    ENGINE_API bool IsInAudibleRange(float* OutMaxDistance) const;
 
    ENGINE_API void SetBusSendEffectInternal(USoundSourceBus* InSourceBus, UAudioBus* InAudioBus, float SendLevel, EBusSendType InBusSendType);
 
    ENGINE_API void BroadcastPlayState();
 
    ENGINE_API float GetAudioTimeSeconds() const;
 
public:
    ENGINE_API void SetFadeInComplete();
 
    ENGINE_API void SetIsVirtualized(bool bInIsVirtualized);
 
    ENGINE_API void SetSourceBufferListener(const FSharedISourceBufferListenerPtr& InSourceBufferListener, bool bShouldZeroBufferAfter);
    
    const FSharedISourceBufferListenerPtr& GetSourceBufferListener() const { return SourceBufferListener; }
 
    //~ Begin UObject Interface.
#if WITH_EDITOR
    ENGINE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
#endif // WITH_EDITOR
    ENGINE_API virtual FString GetDetailedInfoInternal() const override;
    ENGINE_API virtual void PostLoad() override;
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
    ENGINE_API virtual void BeginDestroy() override;
    //~ End UObject Interface.
 
    //~ Begin USceneComponent Interface
    ENGINE_API virtual void Activate(bool bReset=false) override;
    ENGINE_API virtual void Deactivate() override;
    ENGINE_API virtual void OnUpdateTransform(EUpdateTransformFlags UpdateTransformFlags, ETeleportType Teleport = ETeleportType::None) override;
    ENGINE_API virtual FBoxSphereBounds CalcBounds(const FTransform& LocalToWorld) const override;
    //~ End USceneComponent Interface
 
    //~ Begin ActorComponent Interface.
    ENGINE_API virtual void OnRegister() override;
    ENGINE_API virtual void OnUnregister() override;
    ENGINE_API virtual const UObject* AdditionalStatObject() const override;
    ENGINE_API virtual bool IsReadyForOwnerToAutoDestroy() const override;
    ENGINE_API virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
    //~ End ActorComponent Interface.
 
    ENGINE_API void AdjustVolumeInternal(float AdjustVolumeDuration, float AdjustVolumeLevel, bool bIsFadeOut, EAudioFaderCurve FadeCurve);
 
    ENGINE_API const FSoundAttenuationSettings* GetAttenuationSettingsToApply() const;
    ENGINE_API const TObjectPtr<USoundAttenuation> GetAttenuationSettingsAsset() const;
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio", meta = (DisplayName = "Get Attenuation Settings To Apply", ScriptName="GetAttenuationSettingsToApply"))
    ENGINE_API bool BP_GetAttenuationSettingsToApply(FSoundAttenuationSettings& OutAttenuationSettings);
 
    ENGINE_API void CollectAttenuationShapesForVisualization(TMultiMap<EAttenuationShape::Type, FBaseAttenuationSettings::AttenuationShapeDetails>& ShapeDetailsMap) const;
 
    uint64 GetAudioComponentID() const { return AudioComponentID; }
 
    FName GetAudioComponentUserID() const { return AudioComponentUserID; }
 
    static ENGINE_API UAudioComponent* GetAudioComponentFromID(uint64 AudioComponentID);
 
    // Sets the audio thread playback time as used by the active sound playing this audio component
    // Will be set if the audio component is using baked FFT or envelope following data so as to be able to feed that data to BP based on playback time
    ENGINE_API void SetPlaybackTimes(const TMap<uint32, float>& InSoundWavePlaybackTimes);
 
    ENGINE_API void SetSourceEffectChain(USoundEffectSourcePresetChain* InSourceEffectChain);
 
    ENGINE_API FAudioDevice* GetAudioDevice() const override;
    TArray<FAudioParameter>& GetInstanceParameters() override { return InstanceParameters; }
    uint64 GetInstanceOwnerID() const override { return AudioComponentID; }
    uint32 GetLastPlayOrder() const { return LastSoundPlayOrder; }
    USoundBase* GetSound() override { return Sound; }
 
    ENGINE_API virtual FName GetFNameForStatID() const override;
 
public:
 
    UPROPERTY(VisibleInstanceOnly, BlueprintReadWrite, Category=Attachment, meta=(EditCondition="bAutoManageAttachment"))
    TWeakObjectPtr<USceneComponent> AutoAttachParent;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Attachment, meta=(EditCondition="bAutoManageAttachment"))
    FName AutoAttachSocketName;
 
    struct PlayInternalRequestData
    {
        // start time
        float StartTime = 0.0f;
 
        // fade data
        float FadeInDuration = 0.0f;
        float FadeVolumeLevel = 1.0f;
        EAudioFaderCurve FadeCurve = EAudioFaderCurve::Linear;
 
        // Quantized event data
        Audio::FQuartzQuantizedRequestData QuantizedRequestData;
    };
    
private:
 
    uint64 AudioComponentID;
    uint32 LastSoundPlayOrder = 0;
 
    float RetriggerTimeSinceLastUpdate;
    float RetriggerUpdateInterval;
 
    FVector SavedAutoAttachRelativeLocation;
    FRotator SavedAutoAttachRelativeRotation;
    FVector SavedAutoAttachRelativeScale3D;
 
    struct FSoundWavePlaybackTimeData
    {
        USoundWave* SoundWave;
        float PlaybackTime;
 
        // Cached indices to boost searching cooked data indices
        uint32 LastEnvelopeCookedIndex;
        uint32 LastFFTCookedIndex;
 
        FSoundWavePlaybackTimeData()
            : SoundWave(nullptr)
            , PlaybackTime(0.0f)
            , LastEnvelopeCookedIndex(INDEX_NONE)
            , LastFFTCookedIndex(INDEX_NONE)
        {}
 
        FSoundWavePlaybackTimeData(USoundWave* InSoundWave)
            : SoundWave(InSoundWave)
            , PlaybackTime(0.0f)
            , LastEnvelopeCookedIndex(INDEX_NONE)
            , LastFFTCookedIndex(INDEX_NONE)
        {}
    };
    // The current playback times of sound waves in this audio component
    TMap<uint32, FSoundWavePlaybackTimeData> SoundWavePlaybackTimes;
 
    ENGINE_API void CancelAutoAttachment(bool bDetachFromParent, const UWorld* MyWorld);
    
    FSharedISourceBufferListenerPtr SourceBufferListener;
    bool bShouldSourceBufferListenerZeroBuffer = false;
 
    TArray<FSoundSubmixSendInfo> PendingSubmixSends;
 
    struct FPendingSourceBusSendInfo
    {
        EBusSendType BusSendType = EBusSendType::PreEffect;
        FSoundSourceBusSendInfo BusSendInfo;
    };
 
    TArray<FPendingSourceBusSendInfo> PendingBusSends;
 
protected:
 
    ENGINE_API void PlayInternal(const PlayInternalRequestData& InPlayRequestData, USoundBase * InSoundOverride = nullptr);
 
#if WITH_EDITORONLY_DATA
    ENGINE_API void UpdateSpriteTexture();
#endif
 
    // Used for processing queue commands
    //~ Begin FQuartzTickableObject
    ENGINE_API virtual void ProcessCommand(const Audio::FQuartzQueueCommandData& InQueueCommandData) override;
    //~ End FQuartzTickableObject
 
    FRandomStream RandomStream;
};