SynthComponent.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "AudioMixerTypes.h"
#include "Components/AudioComponent.h"
#include "CoreMinimal.h"
#include "Engine/EngineTypes.h"
#include "IAudioExtensionPlugin.h"
#include "Sound/SoundWaveProcedural.h"
#include "Sound/SoundGenerator.h"
#include "UObject/ObjectMacros.h"
 
#include "SynthComponent.generated.h"
 
#define SYNTH_GENERATOR_TEST_TONE 0
 
#if SYNTH_GENERATOR_TEST_TONE
#include "DSP/SinOsc.h"
#endif
 
class UAudioBus;
class USoundSourceBus;
 
class IAudioBufferListener
{
public:
    virtual void OnGeneratedBuffer(const float* AudioBuffer, const int32 NumSamples, const int32 NumChannels) = 0;
};
 
class USynthComponent;
class USoundConcurrency;
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnSynthEnvelopeValue, const float, EnvelopeValue);
 
DECLARE_MULTICAST_DELEGATE_TwoParams(FOnSynthEnvelopeValueNative, const class UAudioComponent*, const float);
 
 
UCLASS(MinimalAPI)
class USynthSound : public USoundWaveProcedural
{
    GENERATED_UCLASS_BODY()
 
    AUDIOMIXER_API void Init(USynthComponent* InSynthComponent, const int32 InNumChannels, const int32 SampleRate, const int32 InCallbackSize);
    AUDIOMIXER_API void StartOnAudioDevice(FAudioDevice* InAudioDevice);
 
    AUDIOMIXER_API virtual void OnBeginGenerate() override;
    AUDIOMIXER_API virtual int32 OnGeneratePCMAudio(TArray<uint8>& OutAudio, int32 NumSamples) override;
    AUDIOMIXER_API virtual void OnEndGenerate() override;
    AUDIOMIXER_API virtual Audio::EAudioMixerStreamDataFormat::Type GetGeneratedPCMDataFormat() const override;
    AUDIOMIXER_API virtual ISoundGeneratorPtr CreateSoundGenerator(const FSoundGeneratorInitParams& InParams) override;
protected:
    UPROPERTY()
    TWeakObjectPtr<USynthComponent> OwningSynthComponent = nullptr;
 
    TArray<float> FloatBuffer;
 
public:
    USynthComponent* GetOwningSynthComponent()
    {
        return OwningSynthComponent.Get();
    }
    
    TWeakObjectPtr<USynthComponent>& GetOwningSynthComponentPtr()
    {
        return OwningSynthComponent;
    }
};
 
UCLASS(abstract, ClassGroup = Synth, hidecategories = (Object, ActorComponent, Physics, Rendering, Mobility, LOD), MinimalAPI)
class USynthComponent : public USceneComponent
{
    GENERATED_BODY()
 
public:
    AUDIOMIXER_API USynthComponent(const FObjectInitializer& ObjectInitializer);
 
    //~ Begin USceneComponent Interface
    AUDIOMIXER_API virtual void Activate(bool bReset = false) override;
    AUDIOMIXER_API virtual void Deactivate() override;
    //~ End USceneComponent Interface
 
    //~ Begin ActorComponent Interface.
    AUDIOMIXER_API virtual void OnRegister() override;
    AUDIOMIXER_API virtual void OnUnregister() override;
    AUDIOMIXER_API virtual bool IsReadyForOwnerToAutoDestroy() const override;
    AUDIOMIXER_API virtual void EndPlay(const EEndPlayReason::Type Reason) override;
    //~ End ActorComponent Interface.
 
    //~ Begin UObject Interface.
#if WITH_EDITOR
    AUDIOMIXER_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
#endif // WITH_EDITOR
 
#if WITH_EDITORONLY_DATA
    AUDIOMIXER_API virtual void PostLoad() override;
#endif //WITH_EDITORONLY_DATA
 
    AUDIOMIXER_API virtual void Serialize(FArchive& Ar) override;
    //~ End UObject Interface
 
    // Starts the synth generating audio.
    UFUNCTION(BlueprintCallable, Category = "Synth|Components|Audio")
    AUDIOMIXER_API void Start();
 
    // Stops the synth generating audio.
    UFUNCTION(BlueprintCallable, Category = "Synth|Components|Audio")
    AUDIOMIXER_API void Stop();
 
    UFUNCTION(BlueprintCallable, Category = "Synth|Components|Audio")
    AUDIOMIXER_API bool IsPlaying() const;
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio")
    AUDIOMIXER_API void SetVolumeMultiplier(float VolumeMultiplier);
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio")
    AUDIOMIXER_API void SetSubmixSend(USoundSubmixBase* Submix, float SendLevel);
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio")
    AUDIOMIXER_API void SetSourceBusSendPreEffect(USoundSourceBus* SoundSourceBus, float SourceBusSendLevel);
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio")
    AUDIOMIXER_API void SetSourceBusSendPostEffect(USoundSourceBus* SoundSourceBus, float SourceBusSendLevel);
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio")
    AUDIOMIXER_API void SetAudioBusSendPreEffect(UAudioBus* AudioBus, float AudioBusSendLevel);
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio")
    AUDIOMIXER_API void SetAudioBusSendPostEffect(UAudioBus* AudioBus, float AudioBusSendLevel);
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio")
    AUDIOMIXER_API void SetLowPassFilterEnabled(bool InLowPassFilterEnabled);
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio")
    AUDIOMIXER_API virtual void SetLowPassFilterFrequency(float InLowPassFilterFrequency);
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio")
    AUDIOMIXER_API void SetOutputToBusOnly(bool bInOutputToBusOnly);
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio")
    AUDIOMIXER_API void FadeIn(float FadeInDuration, float FadeVolumeLevel = 1.0f, float StartTime = 0.0f, const EAudioFaderCurve FadeCurve = EAudioFaderCurve::Linear) const;
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio")
    AUDIOMIXER_API void FadeOut(float FadeOutDuration, float FadeVolumeLevel, const EAudioFaderCurve FadeCurve = EAudioFaderCurve::Linear) const;
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio")
    AUDIOMIXER_API void AdjustVolume(float AdjustVolumeDuration, float AdjustVolumeLevel, const EAudioFaderCurve FadeCurve = EAudioFaderCurve::Linear) const;
 
    UFUNCTION(BlueprintCallable, Category = "Audio|Components|Audio", DisplayName = "Set Modulation Routing")
    AUDIOMIXER_API void SetModulationRouting(const TSet<USoundModulatorBase*>& Modulators, const EModulationDestination Destination, const EModulationRouting RoutingMethod = EModulationRouting::Inherit);
    
    UFUNCTION(BlueprintPure, Category = "Audio|Components|Audio", DisplayName = "Get Modulators")
    AUDIOMIXER_API UPARAM(DisplayName = "Modulators") TSet<USoundModulatorBase*> GetModulators(const EModulationDestination Destination);
 
    UPROPERTY()
    uint8 bAutoDestroy : 1;
 
    UPROPERTY()
    uint8 bStopWhenOwnerDestroyed : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Attenuation)
    uint8 bAllowSpatialization : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Attenuation)
    uint8 bOverrideAttenuation : 1;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    uint32 bOutputToBusOnly_DEPRECATED : 1;
#endif //WITH_EDITORONLY_DATA
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Effects)
    uint32 bEnableBusSends : 1;
 
    UPROPERTY(EditAnywhere, Category = Effects)
    uint32 bEnableBaseSubmix : 1;
 
    UPROPERTY(EditAnywhere, Category = Effects, meta = (DisplayAfter = "SoundSubmixObject"))
    uint32 bEnableSubmixSends : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Attenuation, meta = (EditCondition = "!bOverrideAttenuation"))
    TObjectPtr<class USoundAttenuation> AttenuationSettings;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Attenuation, meta = (EditCondition = "bOverrideAttenuation"))
    struct FSoundAttenuationSettings AttenuationOverrides;
 
    UPROPERTY()
    TObjectPtr<USoundConcurrency> ConcurrencySettings_DEPRECATED;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Concurrency)
    TSet<TObjectPtr<USoundConcurrency>> ConcurrencySet;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Modulation)
    FSoundModulationDefaultRoutingSettings ModulationRouting;
 
    UPROPERTY(EditAnywhere, Category = SoundClass)
    TObjectPtr<USoundClass> SoundClass;
 
    UPROPERTY(EditAnywhere, Category = Effects)
    TObjectPtr<USoundEffectSourcePresetChain> SourceEffectChain;
 
    UPROPERTY(EditAnywhere, Category = Effects, meta = (EditCondition = "bEnableBaseSubmix", DisplayName = "Base Submix"))
    TObjectPtr<USoundSubmixBase> SoundSubmix;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Effects, meta = (EditCondition = "bEnableSubmixSends"))
    TArray<FSoundSubmixSendInfo> SoundSubmixSends;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Effects, meta = (DisplayName = "Post-Effect Bus Sends", EditCondition = "bEnableBusSends"))
    TArray<FSoundSourceBusSendInfo> BusSends;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Effects, meta = (DisplayName = "Pre-Effect Bus Sends", EditCondition = "bEnableBusSends"))
    TArray<FSoundSourceBusSendInfo> PreEffectBusSends;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Sound)
    uint8 bIsUISound : 1;
 
    UPROPERTY()
    uint8 bIsPreviewSound : 1;
 
    uint8 bAlwaysPlay : 1;
 
    AUDIOMIXER_API void Initialize(int32 SampleRateOverride = INDEX_NONE);
 
    AUDIOMIXER_API void CreateAudioComponent();
 
    AUDIOMIXER_API UAudioComponent* GetAudioComponent();
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Sound, meta = (ClampMin = "0", UIMin = "0"))
    int32 EnvelopeFollowerAttackTime;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Sound, meta = (ClampMin = "0", UIMin = "0"))
    int32 EnvelopeFollowerReleaseTime;
 
    UPROPERTY(BlueprintAssignable)
    FOnSynthEnvelopeValue OnAudioEnvelopeValue;
 
    FOnSynthEnvelopeValueNative OnAudioEnvelopeValueNative;
 
    AUDIOMIXER_API void OnAudioComponentEnvelopeValue(const UAudioComponent* AudioComponent, const USoundWave* SoundWave, const float EnvelopeValue);
 
    // Adds and removes audio buffer listener
    AUDIOMIXER_API void AddAudioBufferListener(IAudioBufferListener* InAudioBufferListener);
    AUDIOMIXER_API void RemoveAudioBufferListener(IAudioBufferListener* InAudioBufferListener);
 
    AUDIOMIXER_API virtual USoundClass* GetSoundClass();
 
    AUDIOMIXER_API virtual void BeginDestroy() override;
 
protected:
 
    // Method to execute parameter changes on game thread in audio render thread
    AUDIOMIXER_API void SynthCommand(TFunction<void()> Command);
 
    // Called when synth is created.
    virtual bool Init(int32& SampleRate) { return true; }
 
    UE_DEPRECATED(4.26, "Use OnBeginGenerate to get a callback before audio is generating on the audio render thread")
    virtual void OnStart() {}
 
    UE_DEPRECATED(4.26, "Use OnEndGenerate to get a callback when audio stops generating on the audio render thread")
    virtual void OnStop() {}
 
    // Called when the synth component begins generating audio in render thread
    virtual void OnBeginGenerate() {}
 
    // Called when the synth has finished generating audio on the render thread
    virtual void OnEndGenerate() {}
 
    // Called when more audio is needed to be generated
    // This method of generating audio is soon to be deprecated. For all new synth components, create an FSoundGenerator instance and implement CreateSoundGenerator method to create an instance.
    virtual int32 OnGenerateAudio(float* OutAudio, int32 NumSamples) { return 0; }
 
    // Implemented by the synth component to create a generator object instead of generating audio directly on the synth component.
    // This method prevents UObjects from having to exist in the audio render thread.
    virtual ISoundGeneratorPtr CreateSoundGenerator(const FSoundGeneratorInitParams& InParams) { return nullptr; }
 
    // Called by procedural sound wave
    // Returns the number of samples actually generated
    AUDIOMIXER_API int32 OnGeneratePCMAudio(float* GeneratedPCMData, int32 NumSamples);
 
    // Gets the audio device associated with this synth component
    AUDIOMIXER_API FAudioDevice* GetAudioDevice() const;
 
    // Can be set by the derived class, defaults to 2
    int32 NumChannels;
 
    // Can be set by the derived class- sets the preferred callback size for the synth component.
    int32 PreferredBufferLength;
 
private:
    // Creates the synth component's sound generator, calls into overridden client code to create the instance.
    AUDIOMIXER_API ISoundGeneratorPtr CreateSoundGeneratorInternal(const FSoundGeneratorInitParams& InParams);
 
    UPROPERTY(Transient)
    TObjectPtr<USynthSound> Synth;
 
    UPROPERTY(Transient)
    TObjectPtr<UAudioComponent> AudioComponent;
 
    AUDIOMIXER_API void PumpPendingMessages();
 
#if SYNTH_GENERATOR_TEST_TONE
    Audio::FSineOsc TestSineLeft;
    Audio::FSineOsc TestSineRight;
#endif
 
    // Whether or not synth is playing
    bool bIsSynthPlaying;
    bool bIsInitialized;
 
    TQueue<TFunction<void()>> CommandQueue;
 
    // Synth component's handle to its sound generator instance.
    // used to forward BP functions to the instance directly.
    ISoundGeneratorPtr SoundGenerator;
 
    friend class USynthSound;
};