795 lines
30 KiB
C++
795 lines
30 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "CoreMinimal.h"
|
|
#include "Internationalization/Text.h"
|
|
#include "MetasoundExecutableOperator.h"
|
|
#include "MetasoundNodeRegistrationMacro.h"
|
|
#include "MetasoundDataTypeRegistrationMacro.h"
|
|
#include "MetasoundPrimitives.h"
|
|
#include "MetasoundStandardNodesCategories.h"
|
|
#include "MetasoundStandardNodesNames.h"
|
|
#include "MetasoundTrigger.h"
|
|
#include "MetasoundTime.h"
|
|
#include "MetasoundAudioBuffer.h"
|
|
#include "Internationalization/Text.h"
|
|
#include "DSP/BufferVectorOperations.h"
|
|
#include "DSP/Dsp.h"
|
|
#include "MetasoundParamHelper.h"
|
|
|
|
#define LOCTEXT_NAMESPACE "MetasoundStandardNodes_ADSR"
|
|
|
|
namespace Metasound
|
|
{
|
|
namespace ADSREnvelopeVertexNames
|
|
{
|
|
METASOUND_PARAM(InputAttackTrigger, "Trigger Attack", "Trigger to start the attack phase of the envelope generator.");
|
|
METASOUND_PARAM(InputReleaseTrigger, "Trigger Release", "Trigger to start the release phase of the envelope generator.");
|
|
|
|
METASOUND_PARAM(InputAttackTime, "Attack Time", "Attack time (seconds) of the envelope. Time to reach 1.0 in the envelope output.");
|
|
METASOUND_PARAM(InputDecayTime, "Decay Time", "Decay time (seconds) of the envelope. Time to reach the sustain level in the envelope output.");
|
|
METASOUND_PARAM(InputSustainLevel, "Sustain Level", "The sustain level (between 0.0 and 1.0).");
|
|
METASOUND_PARAM(InputReleaseTime, "Release Time", "Release time (seconds) of the envelope. Time to reach 0.0 in the envelope output.");
|
|
|
|
METASOUND_PARAM(InputAttackCurve, "Attack Curve", "The exponential curve factor of the attack. 1.0 = linear growth, < 1.0 logorithmic growth, > 1.0 exponential growth.");
|
|
METASOUND_PARAM(InputDecayCurve, "Decay Curve", "The exponential curve factor of the decay. 1.0 = linear decay, < 1.0 exponential decay, > 1.0 logorithmic decay.");
|
|
METASOUND_PARAM(InputReleaseCurve, "Release Curve", "The exponential curve factor of the release. 1.0 = linear release, < 1.0 exponential release, > 1.0 logorithmic release.");
|
|
|
|
METASOUND_PARAM(InputHardReset, "Hard Reset", "Set to true to always reset the envelope level to 0 when triggering.");
|
|
|
|
METASOUND_PARAM(OutputOnAttackTrigger, "On Attack Triggered", "Triggers when the envelope attack is triggered.");
|
|
METASOUND_PARAM(OutputOnDecayTrigger, "On Decay Triggered", "Triggers when the envelope decay begins and attack is finished.");
|
|
METASOUND_PARAM(OutputOnSustainTrigger, "On Sustain Triggered", "Triggers when the envelope sustain begins and attack is finished.");
|
|
METASOUND_PARAM(OutputOnReleaseTrigger, "On Release Triggered", "Triggers when the envelope release is triggered.");
|
|
METASOUND_PARAM(OutputOnDone, "On Done", "Triggers when the envelope finishes.");
|
|
METASOUND_PARAM(OutputEnvelopeValue, "Out Envelope", "The output value of the envelope.");
|
|
}
|
|
|
|
namespace ADSREnvelopeNodePrivate
|
|
{
|
|
struct FEnvState
|
|
{
|
|
// Where the envelope is. If INDEX_NONE, then the envelope is not triggered
|
|
int32 CurrentSampleIndex = INDEX_NONE;
|
|
|
|
// Number of samples for attack
|
|
int32 AttackSampleCount = 0;
|
|
|
|
// Number of samples for Decay
|
|
int32 DecaySampleCount = 0;
|
|
|
|
// Number of samples for Release
|
|
int32 ReleaseSampleCount = 0;
|
|
|
|
// Sustain level
|
|
float SustainLevel = 0.0f;
|
|
|
|
// Curve factors for attack/decay/release
|
|
float AttackCurveFactor = 0.0f;
|
|
float DecayCurveFactor = 0.0f;
|
|
float ReleaseCurveFactor = 0.0f;
|
|
|
|
Audio::FExponentialEase EnvEase;
|
|
|
|
// Where the envelope value was when it was triggered
|
|
float StartingEnvelopeValue = 0.0f;
|
|
float CurrentEnvelopeValue = 0.0f;
|
|
float EnvelopeValueAtReleaseStart = 0.0f;
|
|
bool bHardReset = false;
|
|
|
|
// If this is set, we are in release mode
|
|
bool bIsInRelease = false;
|
|
|
|
bool IsTriggered() const
|
|
{
|
|
return CurrentSampleIndex != INDEX_NONE;
|
|
}
|
|
|
|
void Reset()
|
|
{
|
|
CurrentSampleIndex = INDEX_NONE;
|
|
|
|
AttackSampleCount = 0;
|
|
DecaySampleCount = 0;
|
|
ReleaseSampleCount = 0;
|
|
|
|
SustainLevel = 0.0f;
|
|
|
|
AttackCurveFactor = 0.0f;
|
|
DecayCurveFactor = 0.0f;
|
|
ReleaseCurveFactor = 0.0f;
|
|
|
|
StartingEnvelopeValue = 0.0f;
|
|
CurrentEnvelopeValue = 0.0f;
|
|
EnvelopeValueAtReleaseStart = 0.0f;
|
|
|
|
bHardReset = false;
|
|
bIsInRelease = false;
|
|
|
|
EnvEase.Init(0.f, 0.1f);
|
|
}
|
|
};
|
|
|
|
|
|
struct FFloatADSREnvelope
|
|
{
|
|
static void GetInitialOutputEnvelope(float& OutputEnvelope)
|
|
{
|
|
OutputEnvelope = 0.f;
|
|
}
|
|
|
|
static float GetSampleRate(const FOperatorSettings& InOperatorSettings)
|
|
{
|
|
return InOperatorSettings.GetActualBlockRate();
|
|
}
|
|
|
|
static void GetNextEnvelopeOutput(FEnvState& InState, int32 StartFrame, int32 EndFrame, TArray<int32>& OutOnDecayFrames, TArray<int32>& OutOnSustainFrames, TArray<int32>& OutOnDoneFrames, float& OutEnvelopeValue)
|
|
{
|
|
// Don't need to do anything if we're not generating the envelope at the top of the block since this is a block-rate envelope
|
|
if (StartFrame > 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (InState.CurrentSampleIndex == INDEX_NONE)
|
|
{
|
|
OutEnvelopeValue = 0.0f;
|
|
return;
|
|
}
|
|
|
|
// If we are in the release state, jump forward in our sample count
|
|
if (InState.bIsInRelease)
|
|
{
|
|
int32 SampleStartOfRelease = InState.AttackSampleCount + InState.DecaySampleCount;
|
|
if (InState.CurrentSampleIndex < SampleStartOfRelease)
|
|
{
|
|
InState.EnvelopeValueAtReleaseStart = InState.CurrentEnvelopeValue;
|
|
InState.CurrentSampleIndex = InState.AttackSampleCount + InState.DecaySampleCount;
|
|
}
|
|
}
|
|
|
|
// We are in attack
|
|
if (InState.CurrentSampleIndex < InState.AttackSampleCount)
|
|
{
|
|
float AttackFraction = (float)++(InState.CurrentSampleIndex) / InState.AttackSampleCount;
|
|
float EnvValue = FMath::Pow(AttackFraction, InState.AttackCurveFactor);
|
|
float TargeEnvelopeValue = InState.StartingEnvelopeValue + (1.0f - InState.StartingEnvelopeValue) * EnvValue;
|
|
InState.EnvEase.SetValue(TargeEnvelopeValue, true /* bInit */);
|
|
InState.CurrentEnvelopeValue = InState.EnvEase.GetNextValue();
|
|
OutEnvelopeValue = InState.CurrentEnvelopeValue;
|
|
|
|
if (InState.CurrentSampleIndex == InState.AttackSampleCount)
|
|
{
|
|
OutOnDecayFrames.Add(0);
|
|
|
|
// Decay stage is skipped
|
|
if (InState.DecaySampleCount == 0)
|
|
{
|
|
OutOnSustainFrames.Add(0);
|
|
}
|
|
}
|
|
}
|
|
// We are in decay
|
|
else
|
|
{
|
|
// Sample count to the end of the decay phase
|
|
int32 DecayEnvSampleCount = (InState.AttackSampleCount + InState.DecaySampleCount);
|
|
if (InState.CurrentSampleIndex < DecayEnvSampleCount)
|
|
{
|
|
int32 SampleCountInDecayState = InState.CurrentSampleIndex++ - InState.AttackSampleCount;
|
|
float DecayFracton = (float)SampleCountInDecayState / InState.DecaySampleCount;
|
|
float TargetEnvelopeValue = 1.0f - (1.0f - InState.SustainLevel) * FMath::Pow(DecayFracton, InState.DecayCurveFactor);
|
|
InState.EnvEase.SetValue(TargetEnvelopeValue);
|
|
InState.CurrentEnvelopeValue = InState.EnvEase.GetNextValue();
|
|
OutEnvelopeValue = InState.CurrentEnvelopeValue;
|
|
|
|
if (InState.CurrentSampleIndex == DecayEnvSampleCount)
|
|
{
|
|
OutOnSustainFrames.Add(0);
|
|
}
|
|
}
|
|
// We are in sustain
|
|
else if (!InState.bIsInRelease)
|
|
{
|
|
InState.EnvEase.SetValue(InState.SustainLevel);
|
|
InState.CurrentEnvelopeValue = InState.EnvEase.GetNextValue();
|
|
OutEnvelopeValue = InState.CurrentEnvelopeValue;
|
|
InState.EnvelopeValueAtReleaseStart = OutEnvelopeValue;
|
|
}
|
|
// We are in release mode or finished
|
|
else
|
|
{
|
|
int32 ReleaseEnvSampleCount = (InState.AttackSampleCount + InState.DecaySampleCount + InState.ReleaseSampleCount);
|
|
// We are in release
|
|
if (InState.CurrentSampleIndex < ReleaseEnvSampleCount)
|
|
{
|
|
int32 SampleCountInReleaseState = InState.CurrentSampleIndex++ - InState.DecaySampleCount - InState.AttackSampleCount;
|
|
float ReleaseFraction = (float)SampleCountInReleaseState / InState.ReleaseSampleCount;
|
|
float TargetEnvelopeValue = InState.EnvelopeValueAtReleaseStart * (1.0f - FMath::Pow(ReleaseFraction, InState.ReleaseCurveFactor));
|
|
InState.EnvEase.SetValue(TargetEnvelopeValue);
|
|
InState.CurrentEnvelopeValue = InState.EnvEase.GetNextValue();
|
|
OutEnvelopeValue = InState.CurrentEnvelopeValue;
|
|
}
|
|
// We are done
|
|
else
|
|
{
|
|
InState.CurrentSampleIndex = INDEX_NONE;
|
|
OutEnvelopeValue = 0.0f;
|
|
OutOnDoneFrames.Add(EndFrame);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
struct FAudioADSREnvelope
|
|
{
|
|
static void GetInitialOutputEnvelope(FAudioBuffer& OutputEnvelope)
|
|
{
|
|
OutputEnvelope.Zero();
|
|
}
|
|
|
|
static float GetSampleRate(const FOperatorSettings& InOperatorSettings)
|
|
{
|
|
return InOperatorSettings.GetSampleRate();
|
|
}
|
|
|
|
static void GetNextEnvelopeOutput(FEnvState& InState, int32 StartFrame, int32 EndFrame, TArray<int32>& OutOnDecayFrames, TArray<int32>& OutOnSustainFrames, TArray<int32>& OutOnDoneFrames, FAudioBuffer& OutEnvelopeValue)
|
|
{
|
|
// If we are not active zero the buffer and early exit
|
|
if (InState.CurrentSampleIndex == INDEX_NONE)
|
|
{
|
|
OutEnvelopeValue.Zero();
|
|
return;
|
|
}
|
|
|
|
// If we are in the release state, jump forward in our sample count
|
|
if (InState.bIsInRelease)
|
|
{
|
|
int32 SampleStartOfRelease = InState.AttackSampleCount + InState.DecaySampleCount;
|
|
if (InState.CurrentSampleIndex <= SampleStartOfRelease)
|
|
{
|
|
InState.EnvelopeValueAtReleaseStart = InState.CurrentEnvelopeValue;
|
|
InState.CurrentSampleIndex = SampleStartOfRelease;
|
|
}
|
|
}
|
|
|
|
// Init the end attack and decay frames to the start frame. If we're not in these states, it'll just start loops at the start frame
|
|
// But we want to keep track of which frames we have finished previous envelope states so the next state can start rendering at the
|
|
// correct sample vs assume it's at the start of the block.
|
|
int32 EndAttackFrame = StartFrame;
|
|
int32 EndDecayFrame = StartFrame;
|
|
|
|
float* OutEnvPtr = OutEnvelopeValue.GetData();
|
|
int32 AttackSamplesLeft = InState.AttackSampleCount - InState.CurrentSampleIndex;
|
|
|
|
// We are in attack
|
|
if (AttackSamplesLeft > 0)
|
|
{
|
|
EndAttackFrame = FMath::Max(1, FMath::Min(StartFrame + AttackSamplesLeft, EndFrame));
|
|
for (int32 i = StartFrame; i < EndAttackFrame; ++i)
|
|
{
|
|
float AttackFraction = (float)++(InState.CurrentSampleIndex) / InState.AttackSampleCount;
|
|
float EnvValue = FMath::Pow(AttackFraction, InState.AttackCurveFactor);
|
|
OutEnvPtr[i] = InState.StartingEnvelopeValue + (1.0f - InState.StartingEnvelopeValue) * EnvValue;
|
|
}
|
|
|
|
InState.CurrentEnvelopeValue = OutEnvPtr[EndAttackFrame - 1];
|
|
InState.EnvEase.SetValue(InState.CurrentEnvelopeValue, true /* bInit */);
|
|
|
|
// We have finished our attack phase in this block
|
|
if (InState.CurrentSampleIndex == InState.AttackSampleCount)
|
|
{
|
|
OutOnDecayFrames.Add(EndAttackFrame);
|
|
|
|
// Decay Stage is Skipped
|
|
if (InState.DecaySampleCount == 0)
|
|
{
|
|
OutOnSustainFrames.Add(EndAttackFrame);
|
|
}
|
|
}
|
|
}
|
|
|
|
// We are now done with our attack and may need to immediately start rendering our decay block
|
|
if (EndAttackFrame < EndFrame)
|
|
{
|
|
int32 DecaySampelsFromStart = InState.AttackSampleCount + InState.DecaySampleCount;
|
|
int32 DecaySamplesLeft = DecaySampelsFromStart - InState.CurrentSampleIndex;
|
|
// We are in decay
|
|
if (DecaySamplesLeft > 0)
|
|
{
|
|
EndDecayFrame = FMath::Min(StartFrame + EndAttackFrame + DecaySamplesLeft, EndFrame);
|
|
|
|
for (int32 i = EndAttackFrame; i < EndDecayFrame; ++i)
|
|
{
|
|
int32 SampleCountInDecayState = InState.CurrentSampleIndex++ - InState.AttackSampleCount;
|
|
float DecayFracton = (float)SampleCountInDecayState / InState.DecaySampleCount;
|
|
float TargetEnvelopeValue = 1.0f - (1.0f - InState.SustainLevel) * FMath::Pow(DecayFracton, InState.DecayCurveFactor);
|
|
InState.EnvEase.SetValue(TargetEnvelopeValue);
|
|
InState.CurrentEnvelopeValue = InState.EnvEase.GetNextValue();
|
|
OutEnvPtr[i] = InState.CurrentEnvelopeValue;
|
|
}
|
|
|
|
// We have finished the decay phase in this block
|
|
if (InState.CurrentSampleIndex == DecaySampelsFromStart)
|
|
{
|
|
OutOnSustainFrames.Add(EndDecayFrame);
|
|
}
|
|
}
|
|
|
|
// if the end decay frame is not the end of this current render frame, we are in a post-decay mode
|
|
// could be in sustain or release, or we're done.
|
|
if (EndDecayFrame < EndFrame)
|
|
{
|
|
// If we're not in release mode, we're in sustain mode
|
|
if (!InState.bIsInRelease)
|
|
{
|
|
|
|
for (int32 i = EndDecayFrame; i < EndFrame; ++i)
|
|
{
|
|
InState.EnvEase.SetValue(InState.SustainLevel);
|
|
InState.CurrentEnvelopeValue = InState.EnvEase.GetNextValue();
|
|
InState.EnvelopeValueAtReleaseStart = InState.CurrentEnvelopeValue;
|
|
OutEnvPtr[i] = InState.CurrentEnvelopeValue;
|
|
}
|
|
}
|
|
// We're in release mode
|
|
else
|
|
{
|
|
int32 ReleaseSamplesLeft = (InState.AttackSampleCount + InState.DecaySampleCount + InState.ReleaseSampleCount) - InState.CurrentSampleIndex;
|
|
|
|
int32 EndReleaseFrame = FMath::Min(StartFrame + ReleaseSamplesLeft, EndFrame);
|
|
for (int32 i = EndDecayFrame; i < EndReleaseFrame; ++i)
|
|
{
|
|
int32 SampleCountInReleaseState = InState.CurrentSampleIndex++ - InState.DecaySampleCount - InState.AttackSampleCount;
|
|
float ReleaseFraction = (float)SampleCountInReleaseState / InState.ReleaseSampleCount;
|
|
float TargetEnvelopeValue = InState.EnvelopeValueAtReleaseStart * (1.0 - FMath::Pow(ReleaseFraction, InState.ReleaseCurveFactor));
|
|
InState.EnvEase.SetValue(TargetEnvelopeValue);
|
|
InState.CurrentEnvelopeValue = InState.EnvEase.GetNextValue();
|
|
OutEnvPtr[i] = InState.CurrentEnvelopeValue;
|
|
}
|
|
|
|
// We're now done, lets taper it off and finish things
|
|
if (EndReleaseFrame < EndFrame)
|
|
{
|
|
InState.EnvEase.SetValue(0.f);
|
|
for (int32 i = EndReleaseFrame; i < EndFrame; ++i)
|
|
{
|
|
InState.CurrentEnvelopeValue = InState.EnvEase.GetNextValue();
|
|
OutEnvPtr[i] = InState.CurrentEnvelopeValue;
|
|
|
|
// Envelope is done
|
|
if (InState.EnvEase.IsDone())
|
|
{
|
|
// Zero out the rest of the envelope
|
|
int32 NumSamplesLeft = EndFrame - i - 1;
|
|
if (NumSamplesLeft > 0)
|
|
{
|
|
FMemory::Memzero(&OutEnvPtr[i + 1], sizeof(float) * NumSamplesLeft);
|
|
}
|
|
|
|
InState.CurrentSampleIndex = INDEX_NONE;
|
|
OutOnDoneFrames.Add(i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
}
|
|
|
|
template<typename EnvelopeClass, typename ValueType>
|
|
class TADSREnvelopeNodeOperator : public TExecutableOperator<TADSREnvelopeNodeOperator<EnvelopeClass, ValueType>>
|
|
{
|
|
enum class ETriggerType : uint8
|
|
{
|
|
Attack,
|
|
Release,
|
|
None
|
|
};
|
|
|
|
struct FTriggerInfo
|
|
{
|
|
ETriggerType Type;
|
|
int32 FrameIndex;
|
|
};
|
|
|
|
struct FTriggerIterator
|
|
{
|
|
FTriggerIterator(const FTrigger& InAttackTrigger, const FTrigger& InReleaseTrigger, int32 InNumFramesPerBlock)
|
|
: AttackTrigger(InAttackTrigger)
|
|
, ReleaseTrigger(InReleaseTrigger)
|
|
, NumFramesPerBlock(InNumFramesPerBlock)
|
|
{
|
|
if (AttackTrigger.NumTriggeredInBlock() > 0)
|
|
{
|
|
NextAttackFrame = AttackTrigger[0];
|
|
AttackTriggerIndex++;
|
|
}
|
|
else
|
|
{
|
|
NextAttackFrame = NumFramesPerBlock;
|
|
}
|
|
|
|
if (ReleaseTrigger.NumTriggeredInBlock() > 0)
|
|
{
|
|
NextReleaseFrame = ReleaseTrigger[0];
|
|
ReleaseTriggerIndex++;
|
|
}
|
|
else
|
|
{
|
|
NextReleaseFrame = NumFramesPerBlock;
|
|
}
|
|
}
|
|
|
|
FTriggerInfo NextTrigger(bool EnvelopeIsTriggered)
|
|
{
|
|
FTriggerInfo Info;
|
|
|
|
// If attack and release triggers arrive on the same frame we will process the
|
|
// release first if the envelope is currently triggered, or process the attack first if
|
|
// the envelope is not alreay triggered. In fact, in this second case we could do NOTHING and
|
|
// "swallow" them both. Since we know that the attack will be followed immediately by a release.
|
|
// But we don't that as there may be nodes down the line watching the ADSR's output triggers
|
|
// and they may want to know about the attack and release even if they do cancel out.
|
|
if (NextAttackFrame == NextReleaseFrame && EnvelopeIsTriggered && NextReleaseFrame < NumFramesPerBlock)
|
|
{
|
|
Info.Type = ETriggerType::Release;
|
|
Info.FrameIndex = NextReleaseFrame;
|
|
|
|
if (ReleaseTriggerIndex < ReleaseTrigger.NumTriggeredInBlock())
|
|
{
|
|
NextReleaseFrame = ReleaseTrigger[ReleaseTriggerIndex];
|
|
ReleaseTriggerIndex++;
|
|
}
|
|
else
|
|
{
|
|
NextReleaseFrame = NumFramesPerBlock;
|
|
}
|
|
}
|
|
else if ((NextAttackFrame <= NextReleaseFrame) && (NextAttackFrame < NumFramesPerBlock))
|
|
{
|
|
Info.Type = ETriggerType::Attack;
|
|
Info.FrameIndex = NextAttackFrame;
|
|
|
|
if (AttackTriggerIndex < AttackTrigger.NumTriggeredInBlock())
|
|
{
|
|
NextAttackFrame = AttackTrigger[AttackTriggerIndex];
|
|
AttackTriggerIndex++;
|
|
}
|
|
else
|
|
{
|
|
NextAttackFrame = NumFramesPerBlock;
|
|
}
|
|
}
|
|
else if (NextReleaseFrame < NumFramesPerBlock)
|
|
{
|
|
Info.Type = ETriggerType::Release;
|
|
Info.FrameIndex = NextReleaseFrame;
|
|
|
|
if (ReleaseTriggerIndex < ReleaseTrigger.NumTriggeredInBlock())
|
|
{
|
|
NextReleaseFrame = ReleaseTrigger[ReleaseTriggerIndex];
|
|
ReleaseTriggerIndex++;
|
|
}
|
|
else
|
|
{
|
|
NextReleaseFrame = NumFramesPerBlock;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Info.Type = ETriggerType::None;
|
|
Info.FrameIndex = NumFramesPerBlock;
|
|
}
|
|
|
|
return Info;
|
|
}
|
|
|
|
private:
|
|
const FTrigger& AttackTrigger;
|
|
const FTrigger& ReleaseTrigger;
|
|
|
|
int32 NumFramesPerBlock = 0;
|
|
int32 AttackTriggerIndex = 0;
|
|
int32 NextAttackFrame = 0;
|
|
|
|
int32 ReleaseTriggerIndex = 0;
|
|
int32 NextReleaseFrame = 0;
|
|
};
|
|
|
|
public:
|
|
static const FVertexInterface& GetDefaultInterface()
|
|
{
|
|
using namespace ADSREnvelopeVertexNames;
|
|
|
|
static const FVertexInterface DefaultInterface(
|
|
FInputVertexInterface(
|
|
TInputDataVertex<FTrigger>(METASOUND_GET_PARAM_NAME_AND_METADATA(InputAttackTrigger)),
|
|
TInputDataVertex<FTrigger>(METASOUND_GET_PARAM_NAME_AND_METADATA(InputReleaseTrigger)),
|
|
TInputDataVertex<FTime>(METASOUND_GET_PARAM_NAME_AND_METADATA(InputAttackTime), 0.01f),
|
|
TInputDataVertex<FTime>(METASOUND_GET_PARAM_NAME_AND_METADATA(InputDecayTime), 0.2f),
|
|
TInputDataVertex<float>(METASOUND_GET_PARAM_NAME_AND_METADATA(InputSustainLevel), 0.5f),
|
|
TInputDataVertex<FTime>(METASOUND_GET_PARAM_NAME_AND_METADATA(InputReleaseTime), 1.0f),
|
|
TInputDataVertex<float>(METASOUND_GET_PARAM_NAME_AND_METADATA(InputAttackCurve), 1.0f),
|
|
TInputDataVertex<float>(METASOUND_GET_PARAM_NAME_AND_METADATA(InputDecayCurve), 1.0f),
|
|
TInputDataVertex<float>(METASOUND_GET_PARAM_NAME_AND_METADATA(InputReleaseCurve), 1.0f),
|
|
TInputDataVertex<bool>(METASOUND_GET_PARAM_NAME_AND_METADATA(InputHardReset), false)
|
|
),
|
|
FOutputVertexInterface(
|
|
TOutputDataVertex<FTrigger>(METASOUND_GET_PARAM_NAME_AND_METADATA(OutputOnAttackTrigger)),
|
|
TOutputDataVertex<FTrigger>(METASOUND_GET_PARAM_NAME_AND_METADATA(OutputOnDecayTrigger)),
|
|
TOutputDataVertex<FTrigger>(METASOUND_GET_PARAM_NAME_AND_METADATA(OutputOnSustainTrigger)),
|
|
TOutputDataVertex<FTrigger>(METASOUND_GET_PARAM_NAME_AND_METADATA(OutputOnReleaseTrigger)),
|
|
TOutputDataVertex<FTrigger>(METASOUND_GET_PARAM_NAME_AND_METADATA(OutputOnDone)),
|
|
TOutputDataVertex<ValueType>(METASOUND_GET_PARAM_NAME_AND_METADATA(OutputEnvelopeValue))
|
|
)
|
|
);
|
|
|
|
return DefaultInterface;
|
|
}
|
|
|
|
static const FNodeClassMetadata& GetNodeInfo()
|
|
{
|
|
auto CreateNodeClassMetadata = []() -> FNodeClassMetadata
|
|
{
|
|
const FName DataTypeName = GetMetasoundDataTypeName<ValueType>();
|
|
const FName OperatorName = "ADSR Envelope";
|
|
const FText NodeDisplayName = METASOUND_LOCTEXT_FORMAT("ADSREnvelopeDisplayNamePattern", "ADSR Envelope ({0})", GetMetasoundDataTypeDisplayText<ValueType>());
|
|
const FText NodeDescription = METASOUND_LOCTEXT("ADSREnevelopeDesc", "Generates an attack-decay-sustain-release envelope value output when triggered.");
|
|
const FVertexInterface NodeInterface = GetDefaultInterface();
|
|
|
|
const FNodeClassMetadata Metadata
|
|
{
|
|
FNodeClassName { "ADSR Envelope", OperatorName, DataTypeName },
|
|
1, // Major Version
|
|
0, // Minor Version
|
|
NodeDisplayName,
|
|
NodeDescription,
|
|
PluginAuthor,
|
|
PluginNodeMissingPrompt,
|
|
NodeInterface,
|
|
{ NodeCategories::Envelopes },
|
|
{ },
|
|
FNodeDisplayStyle()
|
|
};
|
|
|
|
return Metadata;
|
|
};
|
|
|
|
static const FNodeClassMetadata Metadata = CreateNodeClassMetadata();
|
|
return Metadata;
|
|
}
|
|
|
|
struct FOperatorArgs
|
|
{
|
|
const FBuildOperatorParams& BuildOperatorParams;
|
|
FTriggerReadRef TriggerAttackIn;
|
|
FTriggerReadRef TriggerReleaseIn;
|
|
FTimeReadRef AttackTime;
|
|
FTimeReadRef DecayTime;
|
|
FFloatReadRef SustainLevel;
|
|
FTimeReadRef ReleaseTime;
|
|
FFloatReadRef AttackCurveFactor;
|
|
FFloatReadRef DecayCurveFactor;
|
|
FFloatReadRef ReleaseCurveFactor;
|
|
FBoolReadRef bInHardReset;
|
|
};
|
|
static TUniquePtr<IOperator> CreateOperator(const FBuildOperatorParams& InParams, FBuildResults& OutResults)
|
|
{
|
|
using namespace ADSREnvelopeVertexNames;
|
|
|
|
const FInputVertexInterfaceData& InputData = InParams.InputData;
|
|
|
|
FOperatorArgs Args
|
|
{
|
|
InParams,
|
|
InputData.GetOrCreateDefaultDataReadReference<FTrigger>(METASOUND_GET_PARAM_NAME(InputAttackTrigger), InParams.OperatorSettings),
|
|
InputData.GetOrCreateDefaultDataReadReference<FTrigger>(METASOUND_GET_PARAM_NAME(InputReleaseTrigger), InParams.OperatorSettings),
|
|
InputData.GetOrCreateDefaultDataReadReference<FTime>(METASOUND_GET_PARAM_NAME(InputAttackTime), InParams.OperatorSettings),
|
|
InputData.GetOrCreateDefaultDataReadReference<FTime>(METASOUND_GET_PARAM_NAME(InputDecayTime), InParams.OperatorSettings),
|
|
InputData.GetOrCreateDefaultDataReadReference<float>(METASOUND_GET_PARAM_NAME(InputSustainLevel), InParams.OperatorSettings),
|
|
InputData.GetOrCreateDefaultDataReadReference<FTime>(METASOUND_GET_PARAM_NAME(InputReleaseTime), InParams.OperatorSettings),
|
|
InputData.GetOrCreateDefaultDataReadReference<float>(METASOUND_GET_PARAM_NAME(InputAttackCurve), InParams.OperatorSettings),
|
|
InputData.GetOrCreateDefaultDataReadReference<float>(METASOUND_GET_PARAM_NAME(InputDecayCurve), InParams.OperatorSettings),
|
|
InputData.GetOrCreateDefaultDataReadReference<float>(METASOUND_GET_PARAM_NAME(InputReleaseCurve), InParams.OperatorSettings),
|
|
InputData.GetOrCreateDefaultDataReadReference<bool>(METASOUND_GET_PARAM_NAME(InputHardReset), InParams.OperatorSettings)
|
|
};
|
|
|
|
return MakeUnique<TADSREnvelopeNodeOperator<EnvelopeClass, ValueType>>(Args);
|
|
}
|
|
|
|
TADSREnvelopeNodeOperator(const FOperatorArgs& InArgs)
|
|
: TriggerAttackIn(InArgs.TriggerAttackIn)
|
|
, TriggerReleaseIn(InArgs.TriggerReleaseIn)
|
|
, AttackTime(InArgs.AttackTime)
|
|
, DecayTime(InArgs.DecayTime)
|
|
, SustainLevel(InArgs.SustainLevel)
|
|
, ReleaseTime(InArgs.ReleaseTime)
|
|
, AttackCurveFactor(InArgs.AttackCurveFactor)
|
|
, DecayCurveFactor(InArgs.DecayCurveFactor)
|
|
, ReleaseCurveFactor(InArgs.ReleaseCurveFactor)
|
|
, bHardReset(InArgs.bInHardReset)
|
|
, OnDecayTrigger(TDataWriteReferenceFactory<FTrigger>::CreateExplicitArgs(InArgs.BuildOperatorParams.OperatorSettings))
|
|
, OnSustainTrigger(TDataWriteReferenceFactory<FTrigger>::CreateExplicitArgs(InArgs.BuildOperatorParams.OperatorSettings))
|
|
, OnDone(TDataWriteReferenceFactory<FTrigger>::CreateExplicitArgs(InArgs.BuildOperatorParams.OperatorSettings))
|
|
, OutputEnvelope(TDataWriteReferenceFactory<ValueType>::CreateExplicitArgs(InArgs.BuildOperatorParams.OperatorSettings))
|
|
{
|
|
Reset(InArgs.BuildOperatorParams);
|
|
}
|
|
|
|
virtual ~TADSREnvelopeNodeOperator() = default;
|
|
|
|
virtual void BindInputs(FInputVertexInterfaceData& InOutVertexData) override
|
|
{
|
|
using namespace ADSREnvelopeVertexNames;
|
|
|
|
InOutVertexData.BindReadVertex(METASOUND_GET_PARAM_NAME(InputAttackTrigger), TriggerAttackIn);
|
|
InOutVertexData.BindReadVertex(METASOUND_GET_PARAM_NAME(InputReleaseTrigger), TriggerReleaseIn);
|
|
InOutVertexData.BindReadVertex(METASOUND_GET_PARAM_NAME(InputAttackTime), AttackTime);
|
|
InOutVertexData.BindReadVertex(METASOUND_GET_PARAM_NAME(InputDecayTime), DecayTime);
|
|
InOutVertexData.BindReadVertex(METASOUND_GET_PARAM_NAME(InputSustainLevel), SustainLevel);
|
|
InOutVertexData.BindReadVertex(METASOUND_GET_PARAM_NAME(InputReleaseTime), ReleaseTime);
|
|
InOutVertexData.BindReadVertex(METASOUND_GET_PARAM_NAME(InputAttackCurve), AttackCurveFactor);
|
|
InOutVertexData.BindReadVertex(METASOUND_GET_PARAM_NAME(InputDecayCurve), DecayCurveFactor);
|
|
InOutVertexData.BindReadVertex(METASOUND_GET_PARAM_NAME(InputReleaseCurve), ReleaseCurveFactor);
|
|
InOutVertexData.BindReadVertex(METASOUND_GET_PARAM_NAME(InputHardReset), bHardReset);
|
|
}
|
|
|
|
virtual void BindOutputs(FOutputVertexInterfaceData& InOutVertexData) override
|
|
{
|
|
using namespace ADSREnvelopeVertexNames;
|
|
|
|
InOutVertexData.BindReadVertex(METASOUND_GET_PARAM_NAME(OutputOnAttackTrigger), TriggerAttackIn);
|
|
InOutVertexData.BindReadVertex(METASOUND_GET_PARAM_NAME(OutputOnDecayTrigger), OnDecayTrigger);
|
|
InOutVertexData.BindReadVertex(METASOUND_GET_PARAM_NAME(OutputOnSustainTrigger), OnSustainTrigger);
|
|
InOutVertexData.BindReadVertex(METASOUND_GET_PARAM_NAME(OutputOnReleaseTrigger), TriggerReleaseIn);
|
|
InOutVertexData.BindReadVertex(METASOUND_GET_PARAM_NAME(OutputOnDone), OnDone);
|
|
InOutVertexData.BindReadVertex(METASOUND_GET_PARAM_NAME(OutputEnvelopeValue), OutputEnvelope);
|
|
}
|
|
|
|
void UpdateParams()
|
|
{
|
|
float AttackTimeSeconds = AttackTime->GetSeconds();
|
|
float DecayTimeSeconds = DecayTime->GetSeconds();
|
|
float ReleaseTimeSeconds = ReleaseTime->GetSeconds();
|
|
EnvState.AttackSampleCount = FMath::Max(1, static_cast<int32>(SampleRate * FMath::Max(0.0f, AttackTimeSeconds)));
|
|
EnvState.DecaySampleCount = FMath::Max(0, static_cast<int32>(SampleRate * FMath::Max(0.0f, DecayTimeSeconds)));
|
|
EnvState.SustainLevel = FMath::Clamp(*SustainLevel, 0.0f, 1.0f);
|
|
EnvState.ReleaseSampleCount = FMath::Max(0, static_cast<int32>(SampleRate * FMath::Max(0.0f, ReleaseTimeSeconds)));
|
|
EnvState.AttackCurveFactor = FMath::Max(KINDA_SMALL_NUMBER, *AttackCurveFactor);
|
|
EnvState.DecayCurveFactor = FMath::Max(KINDA_SMALL_NUMBER, *DecayCurveFactor);
|
|
EnvState.ReleaseCurveFactor = FMath::Max(KINDA_SMALL_NUMBER, *ReleaseCurveFactor);
|
|
EnvState.bHardReset = *bHardReset;
|
|
}
|
|
|
|
void ProcessEnvelopeOutput(int32 InStartFrame, int32 InEndFrame)
|
|
{
|
|
TArray<int32> OnDecayFrames;
|
|
TArray<int32> OnSustainFrames;
|
|
TArray<int32> OnDoneFrames;
|
|
EnvelopeClass::GetNextEnvelopeOutput(EnvState, InStartFrame, InEndFrame, OnDecayFrames, OnSustainFrames, OnDoneFrames, *OutputEnvelope);
|
|
|
|
for (int32 OnDecayFrame : OnDecayFrames)
|
|
{
|
|
OnDecayTrigger->TriggerFrame(OnDecayFrame);
|
|
}
|
|
|
|
for (int32 OnSustainFrame : OnSustainFrames)
|
|
{
|
|
OnSustainTrigger->TriggerFrame(OnSustainFrame);
|
|
}
|
|
|
|
for (int32 OnDoneFrame : OnDoneFrames)
|
|
{
|
|
OnDone->TriggerFrame(OnDoneFrame);
|
|
}
|
|
}
|
|
|
|
void Reset(const IOperator::FResetParams& InParams)
|
|
{
|
|
NumFramesPerBlock = InParams.OperatorSettings.GetNumFramesPerBlock();
|
|
|
|
SampleRate = EnvelopeClass::GetSampleRate(InParams.OperatorSettings);
|
|
EnvelopeClass::GetInitialOutputEnvelope(*OutputEnvelope);
|
|
EnvState.Reset();
|
|
|
|
OnDecayTrigger->Reset();
|
|
OnSustainTrigger->Reset();
|
|
OnDone->Reset();
|
|
}
|
|
|
|
void Execute()
|
|
{
|
|
using namespace ADSREnvelopeNodePrivate;
|
|
|
|
OnDecayTrigger->AdvanceBlock();
|
|
OnSustainTrigger->AdvanceBlock();
|
|
OnDone->AdvanceBlock();
|
|
|
|
FTriggerIterator TriggerIter(*TriggerAttackIn, *TriggerReleaseIn, NumFramesPerBlock);
|
|
|
|
FTriggerInfo NextTrigger = TriggerIter.NextTrigger(EnvState.IsTriggered());
|
|
if (NextTrigger.FrameIndex > 0)
|
|
{
|
|
// Process envelope before receiving any triggers on this block
|
|
ProcessEnvelopeOutput(0, NextTrigger.FrameIndex);
|
|
}
|
|
|
|
while (NextTrigger.Type != ETriggerType::None)
|
|
{
|
|
FTriggerInfo CurrentTrigger = NextTrigger;
|
|
NextTrigger = TriggerIter.NextTrigger(EnvState.IsTriggered());
|
|
|
|
switch (CurrentTrigger.Type)
|
|
{
|
|
case ETriggerType::Attack:
|
|
// check for any updates to input params
|
|
UpdateParams();
|
|
// Set the sample index to the top of the envelope
|
|
EnvState.CurrentSampleIndex = 0;
|
|
EnvState.StartingEnvelopeValue = EnvState.bHardReset ? 0 : EnvState.CurrentEnvelopeValue;
|
|
EnvState.EnvEase.SetValue(EnvState.StartingEnvelopeValue, true /* bInit */);
|
|
EnvState.bIsInRelease = false;
|
|
|
|
break;
|
|
|
|
case ETriggerType::Release:
|
|
|
|
EnvState.bIsInRelease = true;
|
|
|
|
break;
|
|
|
|
default:
|
|
{
|
|
checkNoEntry();
|
|
}
|
|
}
|
|
|
|
ProcessEnvelopeOutput(CurrentTrigger.FrameIndex, NextTrigger.FrameIndex);
|
|
}
|
|
}
|
|
|
|
private:
|
|
FTriggerReadRef TriggerAttackIn;
|
|
FTriggerReadRef TriggerReleaseIn;
|
|
FTimeReadRef AttackTime;
|
|
FTimeReadRef DecayTime;
|
|
FFloatReadRef SustainLevel;
|
|
FTimeReadRef ReleaseTime;
|
|
FFloatReadRef AttackCurveFactor;
|
|
FFloatReadRef DecayCurveFactor;
|
|
FFloatReadRef ReleaseCurveFactor;
|
|
FBoolReadRef bHardReset;
|
|
|
|
FTriggerWriteRef OnDecayTrigger;
|
|
FTriggerWriteRef OnSustainTrigger;
|
|
FTriggerWriteRef OnDone;
|
|
TDataWriteReference<ValueType> OutputEnvelope;
|
|
|
|
// This will either be the block rate or sample rate depending on if this is block-rate or audio-rate envelope
|
|
float SampleRate = 0.0f;
|
|
int32 NumFramesPerBlock = 0;
|
|
|
|
ADSREnvelopeNodePrivate::FEnvState EnvState;
|
|
};
|
|
|
|
/** TADSREnvelopeNode
|
|
*
|
|
* Creates an Attack/Decay envelope node.
|
|
*/
|
|
template<typename EnvelopeClass, typename ValueType>
|
|
using TADSREnvelopeNode = TNodeFacade<TADSREnvelopeNodeOperator<EnvelopeClass, ValueType>>;
|
|
|
|
using FADSREnvelopeNodeFloat = TADSREnvelopeNode<ADSREnvelopeNodePrivate::FFloatADSREnvelope, float>;
|
|
METASOUND_REGISTER_NODE(FADSREnvelopeNodeFloat)
|
|
|
|
using FADSREnvelopeAudioBuffer = TADSREnvelopeNode<ADSREnvelopeNodePrivate::FAudioADSREnvelope, FAudioBuffer>;
|
|
METASOUND_REGISTER_NODE(FADSREnvelopeAudioBuffer)
|
|
}
|
|
|
|
#undef LOCTEXT_NAMESPACE
|