ActiveSound.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "WorldCollision.h"
#include "Sound/SoundAttenuation.h"
#include "HAL/ThreadSafeBool.h"
#include "Audio.h"
#include "Audio/AudioDebug.h"
#include "AudioDynamicParameter.h"
#include "Components/AudioComponent.h"
#include "DSP/VolumeFader.h"
#include "IAudioExtensionPlugin.h"
#include "Sound/AudioVolume.h"
#include "Sound/SoundSourceBus.h"
#include "Sound/QuartzQuantizationUtilities.h"
 
class FAudioDevice;
class USoundBase;
class USoundSubmix;
class USoundSourceBus;
struct FSoundSubmixSendInfo;
struct FSoundSourceBusSendInfo;
struct FWaveInstance;
class USoundWave;
class USoundConcurrency;
struct FListener;
struct FAttenuationListenerData;
 
struct FAttenuationFocusData
{
    float Azimuth = 0.0f;
 
    float AbsoluteAzimuth = 0.0f;
 
    float FocusFactor = 1.0f;
 
    float DistanceScale = 1.0f;
 
    float PriorityScale = 1.0f;
 
    float PriorityHighest = 1.0f;
 
    float VolumeScale = 1.0f;
 
    bool bFirstFocusUpdate = true;
};
 
struct FSoundParseParameters
{
    // A collection of finish notification hooks
    FNotifyBufferFinishedHooks NotifyBufferFinishedHooks;
 
    // The Sound Class to use the settings of
    USoundClass* SoundClass;
 
    // The transform of the sound (scale is not used)
    FTransform Transform;
 
    // The speed that the sound is moving relative to the listener
    FVector Velocity;
 
    // The volume product of the sound
    float Volume;
 
    // The attenuation of the sound due to distance attenuation
    float DistanceAttenuation;
 
    // The attenuation of the sound due to occlusion attenuation
    float OcclusionAttenuation;
 
    // A volume scale on the sound specified by user
    float VolumeMultiplier;
 
    // Attack time of the source envelope follower
    int32 EnvelopeFollowerAttackTime;
 
    // Release time of the source envelope follower
    int32 EnvelopeFollowerReleaseTime;
 
    // The multiplier to apply if the sound class desires
    float InteriorVolumeMultiplier;
 
    // The priority of sound, which is the product of the component priority and the USoundBased priority
    float Priority;
 
    // The pitch scale factor of the sound
    float Pitch;
 
    // Time offset from beginning of sound to start at
    float StartTime;
 
    // At what distance from the source of the sound should spatialization begin 
    float NonSpatializedRadiusStart;
 
    // At what distance from the source the sound is fully non-spatialized
    float NonSpatializedRadiusEnd;
 
    // Which mode to use for non-spatialized radius
    ENonSpatializedRadiusSpeakerMapMode NonSpatializedRadiusMode;
 
    // The distance over which the sound is attenuated
    float AttenuationDistance;
 
    // The distance from the listener to the sound
    float ListenerToSoundDistance;
 
    // The distance from the listener to the sound (ignores attenuation settings)
    float ListenerToSoundDistanceForPanning;
 
    // The absolute azimuth angle of the sound relative to the forward listener vector (359 degrees to left, 1 degrees to right)
    float AbsoluteAzimuth;
 
    // The sound submix to use for the wave instance
    USoundSubmixBase* SoundSubmix;
 
    // The submix sends. 
    TArray<FSoundSubmixSendInfo> SoundSubmixSends;
    TArray<FAttenuationSubmixSendSettings> AttenuationSubmixSends;
 
    // The source bus sends to use
    TArray<FSoundSourceBusSendInfo> BusSends[(int32)EBusSendType::Count];
 
    // Reverb wet-level parameters
    EReverbSendMethod ReverbSendMethod;
    FVector2D ReverbSendLevelRange;
    FVector2D ReverbSendLevelDistanceRange;
    float ManualReverbSendLevel;
    FRuntimeFloatCurve CustomReverbSendCurve;
 
    // The distance between left and right channels when spatializing stereo assets
    float StereoSpread;
 
    // Which spatialization algorithm to use
    ESoundSpatializationAlgorithm SpatializationMethod;
 
    // Whether the spatialization plugin is an external send
    bool bSpatializationIsExternalSend;
 
    // What occlusion plugin source settings to use
    USpatializationPluginSourceSettingsBase* SpatializationPluginSettings;
 
    // What occlusion plugin source settings to use
    UOcclusionPluginSourceSettingsBase* OcclusionPluginSettings;
 
    // What reverb plugin source settings to use
    UReverbPluginSourceSettingsBase* ReverbPluginSettings;
 
    // What source data override plugin source settings to use
    USourceDataOverridePluginSourceSettingsBase* SourceDataOverridePluginSettings;
 
    // If using AudioLink, this allows the settings to be overriden.
    UAudioLinkSettingsAbstract* AudioLinkSettingsOverride = nullptr;
 
    // What source effect chain to use
    USoundEffectSourcePresetChain* SourceEffectChain;
 
    // The lowpass filter frequency to apply (if enabled)
    float LowPassFilterFrequency;
    
    // The highpass filter frequency to apply (if enabled)
    float HighPassFilterFrequency;
 
    // The lowpass filter frequency to apply due to distance attenuation
    float AttenuationLowpassFilterFrequency;
 
    // The highpass filter frequency to apply due to distance attenuation
    float AttenuationHighpassFilterFrequency;
 
    // The lowpass filter to apply if the sound is occluded
    float OcclusionFilterFrequency;
 
    // The lowpass filter to apply if the sound is inside an ambient zone
    float AmbientZoneFilterFrequency;
 
    uint32 bEnableBusSends : 1;
 
    uint32 bEnableBaseSubmix : 1;
 
    uint32 bEnableSubmixSends : 1;
 
    uint32 bEnableSourceDataOverride : 1;
 
    uint32 bEnableSendToAudioLink : 1;
 
    // Whether the sound should be spatialized
    uint8 bUseSpatialization:1;
 
    // Whether the sound should be seamlessly looped
    uint8 bLooping:1;
 
    // Whether we have enabled low-pass filtering of this sound
    uint8 bEnableLowPassFilter:1;
    
    // Whether we have enabled high-pass filtering of this sound
    uint8 bEnableHighPassFilter:1;
 
    // Whether this sound is occluded
    uint8 bIsOccluded:1;
 
    // Whether or not this sound is manually paused (i.e. not by application-wide pause)
    uint8 bIsPaused:1;
 
    // Whether or not this sound can re-trigger
    uint8 bEnableRetrigger : 1;
 
    // Whether or not to apply a =6 dB attenuation to stereo spatialization sounds
    uint8 bApplyNormalizationToStereoSounds:1;
 
    FSoundParseParameters()
        : SoundClass(nullptr)
        , Velocity(ForceInit)
        , Volume(1.f)
        , DistanceAttenuation(1.f)
        , OcclusionAttenuation(1.f)
        , VolumeMultiplier(1.f)
        , EnvelopeFollowerAttackTime(10)
        , EnvelopeFollowerReleaseTime(100)
        , InteriorVolumeMultiplier(1.f)
        , Pitch(1.f)
        , StartTime(-1.f)
        , NonSpatializedRadiusStart(0.0f)
        , NonSpatializedRadiusEnd(0.0f)
        , NonSpatializedRadiusMode(ENonSpatializedRadiusSpeakerMapMode::OmniDirectional)
        , AttenuationDistance(0.0f)
        , ListenerToSoundDistance(0.0f)
        , ListenerToSoundDistanceForPanning(0.0f)
        , AbsoluteAzimuth(0.0f)
        , SoundSubmix(nullptr)
        , ReverbSendMethod(EReverbSendMethod::Linear)
        , ReverbSendLevelRange(0.0f, 0.0f)
        , ReverbSendLevelDistanceRange(0.0f, 0.0f)
        , ManualReverbSendLevel(0.0f)
        , StereoSpread(0.0f)
        , SpatializationMethod(ESoundSpatializationAlgorithm::SPATIALIZATION_Default)
        , bSpatializationIsExternalSend(false)
        , SpatializationPluginSettings(nullptr)
        , OcclusionPluginSettings(nullptr)
        , ReverbPluginSettings(nullptr)
        , SourceDataOverridePluginSettings(nullptr)
        , AudioLinkSettingsOverride(nullptr)
        , SourceEffectChain(nullptr)
        , LowPassFilterFrequency(MAX_FILTER_FREQUENCY)
        , HighPassFilterFrequency(MIN_FILTER_FREQUENCY)
        , AttenuationLowpassFilterFrequency(MAX_FILTER_FREQUENCY)
        , AttenuationHighpassFilterFrequency(MIN_FILTER_FREQUENCY)
        , OcclusionFilterFrequency(MAX_FILTER_FREQUENCY)
        , AmbientZoneFilterFrequency(MAX_FILTER_FREQUENCY)
        , bEnableBusSends(false)
        , bEnableBaseSubmix(false)
        , bEnableSubmixSends(false)
        , bEnableSourceDataOverride(false)
        , bUseSpatialization(false)
        , bLooping(false)
        , bEnableLowPassFilter(false)
        , bEnableHighPassFilter(false)
        , bIsOccluded(false)
        , bIsPaused(false)
        , bEnableRetrigger(false)
        , bApplyNormalizationToStereoSounds(false)
    {
    }
};
 
struct FActiveSound : public ISoundModulatable
{
public:
 
    ENGINE_API FActiveSound();
    ENGINE_API FActiveSound(const FActiveSound&);
    ENGINE_API ~FActiveSound();
 
    static ENGINE_API FActiveSound* CreateVirtualCopy(const FActiveSound& ActiveSoundToCopy, FAudioDevice& AudioDevice);
 
private:
    TWeakObjectPtr<UWorld> World;
    uint32 WorldID;
 
    TObjectPtr<USoundBase> Sound;
    TObjectPtr<USoundEffectSourcePresetChain> SourceEffectChain;
    TObjectPtr<USoundAttenuation> SoundAttenuation;
 
    uint64 AudioComponentID;
    FName AudioComponentUserID;
    uint32 OwnerID;
 
    FName AudioComponentName;
    FName OwnerName;
 
    FObjectKey OwnerKey;
 
    uint32 PlayOrder;
 
public:
    uint32 GetObjectId() const override { return Sound ? Sound->GetUniqueID() : INDEX_NONE; }
    ENGINE_API int32 GetPlayCount() const override;
    uint32 GetPlayOrder() const { return PlayOrder; }
    bool IsPreviewSound() const override { return bIsPreviewSound; }
    ENGINE_API void Stop() override;
 
    uint32 GetInstanceID() const { return PlayOrder; }
 
    uint64 GetAudioComponentID() const { return AudioComponentID; }
    FName GetAudioComponentUserID() const { return AudioComponentUserID; }
    ENGINE_API void ClearAudioComponent();
    ENGINE_API void SetAudioComponent(const FActiveSound& ActiveSound);
    ENGINE_API void SetAudioComponent(const UAudioComponent& Component);
    ENGINE_API void SetOwner(const AActor* Owner);
    ENGINE_API FString GetAudioComponentName() const;
    ENGINE_API FString GetOwnerName() const;
 
    uint32 GetWorldID() const { return WorldID; }
    TWeakObjectPtr<UWorld> GetWeakWorld() const { return World; }
    UWorld* GetWorld() const
    {
        return World.Get();
    }
    ENGINE_API void SetWorld(UWorld* World);
 
    ENGINE_API void SetPitch(float Value);
    ENGINE_API void SetVolume(float Value);
 
    float GetPitch() const { return PitchMultiplier; }
 
    ENGINE_API float GetVolume() const;
 
    USoundBase* GetSound() const { return Sound; }
    ENGINE_API void SetSound(USoundBase* InSound);
 
    USoundEffectSourcePresetChain* GetSourceEffectChain() const { return SourceEffectChain ? ToRawPtr(SourceEffectChain) : ToRawPtr(Sound->SourceEffectChain); }
    
    ENGINE_API void SetSourceEffectChain(USoundEffectSourcePresetChain* InSourceEffectChain);
 
    ENGINE_API void SetSoundClass(USoundClass* SoundClass);
 
    ENGINE_API void SetAttenuationSettingsAsset(TObjectPtr<USoundAttenuation> InSoundAttenuation);
 
    ENGINE_API void SetAttenuationSettingsOverride(bool bInIsAttenuationSettingsOverridden);
 
    void SetAudioDevice(FAudioDevice* InAudioDevice)
    {
        AudioDevice = InAudioDevice;
    }
 
    void SetSourceListener(FSharedISourceBufferListenerPtr InListener, bool bShouldZeroBuffer)
    {
        SourceBufferListener = InListener;
        bShouldSourceBufferListenerZeroBuffer = bShouldZeroBuffer;
    }
 
    ENGINE_API int32 GetClosestListenerIndex() const;
 
    bool CanDelete() const { return !bAsyncOcclusionPending; }
 
    bool IsLooping() const { return Sound && Sound->IsLooping(); }
 
    bool IsOneShot() const { return !IsLooping(); }
 
    bool IsPlayingAudio() const { return bIsPlayingAudio; }
 
    ENGINE_API bool IsPlayWhenSilent() const;
 
    float GetConcurrencyPriority() const;
 
    EVirtualizationMode GetVirtualizationMode() const;
 
    void OverrideVirtualizationMode(EVirtualizationMode Mode);
 
    void ClearVirtualizationModeOverride();
 
    FAudioDevice* AudioDevice;
 
    TMap<FConcurrencyGroupID, FConcurrencySoundData> ConcurrencyGroupData;
 
    TSet<TObjectPtr<USoundConcurrency>> ConcurrencySet;
 
private:
    TObjectPtr<USoundClass> SoundClassOverride;
 
    TArray<FSoundSubmixSendInfo> SoundSubmixSendsOverride;
 
    TArray<FSoundSourceBusSendInfo> BusSendsOverride[(int32)EBusSendType::Count];
 
    TMap<UPTRINT, FWaveInstance*> WaveInstances;
 
    TSharedPtr<Audio::IParameterTransmitter> InstanceTransmitter;
 
    EVirtualizationMode VirtualizationModeOverride;
 
    uint8 bEnableVirtualizationModeOverride: 1;
 
public:
    Audio::IParameterTransmitter* GetTransmitter()
    {
        return InstanceTransmitter.Get();
    }
 
    const Audio::IParameterTransmitter* GetTransmitter() const
    {
        return InstanceTransmitter.Get();
    }
 
    void ClearTransmitter()
    {
        return InstanceTransmitter.Reset();
    }
 
    enum class EFadeOut : uint8
    {
        // Sound is not currently fading out
        None,
 
        // Client code (eg. AudioComponent) is requesting a fade out
        User,
 
        // The concurrency system is requesting a fade due to voice stealing
        Concurrency
    };
 
    uint8 bHasCheckedOcclusion:1;
 
    uint8 bAllowSpatialization:1;
 
    uint8 bHasAttenuationSettings:1;
 
    uint8 bShouldRemainActiveIfDropped:1;
 
    uint8 bFinished:1;
 
    uint8 bIsPaused:1;
 
    uint8 bShouldStopDueToMaxConcurrency:1;
 
    uint8 bHasVirtualized:1;
 
    uint8 bRadioFilterSelected:1;
 
    uint8 bApplyRadioFilter:1;
 
    uint8 bHandleSubtitles:1;
 
    uint8 bHasExternalSubtitles:1;
 
    uint8 bLocationDefined:1;
 
    uint8 bIgnoreForFlushing:1;
 
    uint8 bAlwaysPlay:1;
 
    uint8 bIsUISound: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 bGotInteriorSettings:1;
 
    uint8 bApplyInteriorVolumes:1;
 
#if !(NO_LOGGING || UE_BUILD_SHIPPING || UE_BUILD_TEST)
    uint8 bWarnedAboutOrphanedLooping:1;
#endif
 
    uint8 bEnableLowPassFilter : 1;
    
    uint8 bEnableHighPassFilter : 1;
 
    uint8 bUpdatePlayPercentage:1;
 
    uint8 bUpdateSingleEnvelopeValue:1;
 
    uint8 bUpdateMultiEnvelopeValue:1;
 
    uint8 bUpdatePlaybackTime:1;
 
    uint8 bIsPlayingAudio:1;
 
    uint8 bIsStopping:1;
 
    uint8 bHasActiveBusSendRoutingOverride : 1;
    uint8 bHasActiveMainSubmixOutputOverride : 1;
    uint8 bHasActiveSubmixSendRoutingOverride : 1;
 
    uint8 bEnableBusSendRoutingOverride : 1;
    uint8 bEnableMainSubmixOutputOverride : 1;
    uint8 bEnableSubmixSendRoutingOverride : 1;
 
    uint8 bIsFirstAttenuationUpdate : 1;
    uint8 bStartedWithinNonBinauralRadius : 1;
 
    uint8 bModulationRoutingUpdated : 1;
 
    uint8 bIsAttenuationSettingsOverridden : 1;
 
    uint8 UserIndex;
 
    EFadeOut FadeOut;
 
    FThreadSafeBool bIsOccluded;
 
    FThreadSafeBool bAsyncOcclusionPending;
 
    float PlaybackTime;
 
    float PlaybackTimeUnscaled;
 
    float PlaybackTimeNonVirtualized;
 
    float MinCurrentPitch;
    float RequestedStartTime;
 
    TSortedMap<UPTRINT, float> SeekRestartTimes;
    
    float VolumeMultiplier;
    float PitchMultiplier;
 
    float LowPassFilterFrequency;
    
    float HighPassFilterFrequency;
 
    Audio::FVolumeFader ComponentVolumeFader;
 
    FDynamicParameter CurrentOcclusionFilterFrequency;
 
    FDynamicParameter CurrentOcclusionVolumeAttenuation;
 
    float SubtitlePriority;
    
    float Priority;
 
    float VolumeConcurrency;
 
    float MaxSourceModulationValue;
    
    float OcclusionCheckInterval;
 
    float LastOcclusionCheckTime;
 
    float MaxDistance;
 
    FTransform Transform;
 
    FAttenuationFocusData FocusData;
 
    FVector LastLocation;
 
    FSoundAttenuationSettings AttenuationSettings;
 
    Audio::FQuartzQuantizedRequestData QuantizedRequestData;
 
    FSharedISourceBufferListenerPtr SourceBufferListener;
    bool bShouldSourceBufferListenerZeroBuffer = false;
 
    FInteriorSettings InteriorSettings;
    TArray<FAudioVolumeSubmixSendSettings> AudioVolumeSubmixSendSettings;
    TArray<FAudioVolumeSubmixSendSettings> PreviousAudioVolumeSubmixSendSettings;
 
    uint32 AudioVolumeID;
 
    // To remember where the volumes are interpolating to and from
    double LastUpdateTime;
    float SourceInteriorVolume;
    float SourceInteriorLPF;
    float CurrentInteriorVolume;
    float CurrentInteriorLPF;
 
    // Envelope follower attack and release time parameters
    int32 EnvelopeFollowerAttackTime;
    int32 EnvelopeFollowerReleaseTime;
 
    TMap<UPTRINT,uint32> SoundNodeOffsetMap;
    TArray<uint8> SoundNodeData;
 
    // Whether or not there are Source Bus Sends that have not been sent to the render thread
    bool bHasNewBusSends;
 
    // Bus send(s) that have not yet been sent to the render thread
    TArray<TTuple<EBusSendType, FSoundSourceBusSendInfo>> NewBusSends;
 
    FSoundModulationDefaultRoutingSettings ModulationRouting;
 
#if ENABLE_AUDIO_DEBUG
    FColor DebugColor;
#endif // ENABLE_AUDIO_DEBUG
 
    ENGINE_API void UpdateInterfaceParameters(const TArray<FListener>& InListeners);
 
    // Updates the wave instances to be played.
    ENGINE_API void UpdateWaveInstances(TArray<FWaveInstance*> &OutWaveInstances, const float DeltaTime);
 
    ENGINE_API FWaveInstance* FindWaveInstance(const UPTRINT WaveInstanceHash);
 
    ENGINE_API void RemoveWaveInstance(const UPTRINT WaveInstanceHash);
 
    const TMap<UPTRINT, FWaveInstance*>& GetWaveInstances() const
    {
        return WaveInstances;
    }
 
    ENGINE_API FWaveInstance& AddWaveInstance(const UPTRINT WaveInstanceHash);
 
    ENGINE_API void ApplyRadioFilter(const FSoundParseParameters& ParseParams);
 
    ENGINE_API float GetTotalConcurrencyVolumeScale() const;
 
    ENGINE_API void CollectAttenuationShapesForVisualization(TMultiMap<EAttenuationShape::Type, FBaseAttenuationSettings::AttenuationShapeDetails>& ShapeDetailsMap) const;
 
    friend FArchive& operator<<( FArchive& Ar, FActiveSound* ActiveSound );
 
    ENGINE_API void AddReferencedObjects( FReferenceCollector& Collector );
 
    ENGINE_API USoundClass* GetSoundClass() const;
 
    ENGINE_API USoundSubmixBase* GetSoundSubmix() const;
 
    ENGINE_API void GetSoundSubmixSends(TArray<FSoundSubmixSendInfo>& OutSends) const;
 
    ENGINE_API void GetBusSends(EBusSendType BusSendType, TArray<FSoundSourceBusSendInfo>& OutSends) const;
 
    ENGINE_API bool HasNewBusSends() const;
 
    ENGINE_API TArray< TTuple<EBusSendType, FSoundSourceBusSendInfo> > const & GetNewBusSends() const;
 
    ENGINE_API void ResetNewBusSends();
 
    /* Gives new Modulation Routing settings to the ActiveSound. This overwrites all previous Modulation Routing settings. */
    ENGINE_API void SetNewModulationRouting(const FSoundModulationDefaultRoutingSettings& NewRouting);
 
    /* Adds additional Modulators to the ActiveSound, if possible. 
     * This function forces the Destination's routing method to Union.
     * To replace existing modulators or set a different routing method, use SetNewModulationRouting.
     */
    ENGINE_API void AddModulationRouting(const TSet<TObjectPtr<USoundModulatorBase>>& NewModulators, EModulationDestination Destination);
 
    /* Removes given Modulators from the ActiveSound, if possible. */
    ENGINE_API void RemoveModulationRouting(const TSet<TObjectPtr<USoundModulatorBase>>& NewModulators, EModulationDestination Destination);
 
    ENGINE_API TArray<TSet<TObjectPtr<USoundModulatorBase>>> GetEffectiveVolumeModulators() const;
    
    /* Determines which of the provided listeners is the closest to the sound */
    ENGINE_API int32 FindClosestListener( const TArray<struct FListener>& InListeners ) const;
 
    /* Determines which listener is the closest to the sound */
    ENGINE_API int32 FindClosestListener() const;
 
    FSoundOwnerObjectID GetOwnerID() const { return OwnerID; }
 
    FObjectKey GetOwnerKey() const { return OwnerKey; }
 
    ENGINE_API void GetConcurrencyHandles(TArray<FConcurrencyHandle>& OutConcurrencyHandles) const;
 
    ENGINE_API bool GetConcurrencyFadeDuration(float& OutFadeDuration) const;
 
    static ENGINE_API void OcclusionTraceDone(const FTraceHandle& TraceHandle, FTraceDatum& TraceDatum);
 
    ENGINE_API void ParseAttenuation(FSoundParseParameters& OutParseParams, int32 ListenerIndex, const FSoundAttenuationSettings& InAttenuationSettings);
 
    ENGINE_API bool GetAlwaysPlay() const;
 
    ENGINE_API float GetHighestPriority(bool bIgnoreAlwaysPlay = false) const;
 
    ENGINE_API void SetSubmixSend(const FSoundSubmixSendInfo& SubmixSendInfo);
 
    ENGINE_API void SetSourceBusSend(EBusSendType BusSendType, const FSoundSourceBusSendInfo& SourceBusSendInfo);
 
    ENGINE_API void UpdateAttenuation(float DeltaTime, FSoundParseParameters& ParseParams, int32 ListenerIndex, const FSoundAttenuationSettings* SettingsAttenuationNode = nullptr);
 
    ENGINE_API void UpdateFocusData(float DeltaTime, const FAttenuationListenerData& ListenerData, FAttenuationFocusData* OutFocusData = nullptr);
 
    ENGINE_API void AddVolumeSubmixSends(FSoundParseParameters& ParseParams, EAudioVolumeLocationState LocationState);
 
private:
 
    struct FAsyncTraceDetails
    {
        Audio::FDeviceId AudioDeviceID;
        FActiveSound* ActiveSound;
    };
 
    static ENGINE_API TMap<FTraceHandle, FAsyncTraceDetails> TraceToActiveSoundMap;
 
    static ENGINE_API FTraceDelegate ActiveSoundTraceDelegate;
 
    mutable int32 ClosestListenerIndex = INDEX_NONE;
 
    void CacheClosestListener() const;
 
    friend class FAudioDevice;
 
    ENGINE_API void MarkPendingDestroy (bool bDestroyNow);
 
    bool IsStopping() const { return bIsStopping; }
 
    ENGINE_API bool UpdateStoppingSources(uint64 CurrentTick, bool bEnsureStopped);
 
    ENGINE_API void UpdateConcurrencyVolumeScalars(const float DeltaTime);
 
    ENGINE_API void CheckOcclusion(const FVector ListenerLocation, const FVector SoundLocation, const FSoundAttenuationSettings* AttenuationSettingsPtr);
 
    ENGINE_API void GatherInteriorData(FSoundParseParameters& ParseParams);
 
    ENGINE_API void HandleInteriorVolumes(FSoundParseParameters& ParseParams);
 
    ENGINE_API float GetAttenuationFrequency(const FSoundAttenuationSettings* InSettings, const FAttenuationListenerData& ListenerData, const FVector2D& FrequencyRange, const FRuntimeFloatCurve& CustomCurve);
};