KwidgetProcessor_Scaledadsr.cpp

Go to the documentation of this file.

namespace krotos
{
    KwidgetProcessor_Scaledadsr::KwidgetProcessor_Scaledadsr(Kwidget& owner) : KwidgetProcessor(owner)
    {
        using P = Parameters;
 
        addParameterAttachments({{P::Attack, [this](float x) { setAttack(x); }, 0},
                                 {P::Decay, [this](float x) { setDecay(x); }, 0},
                                 {P::Sustain, [this](float x) { setSustain(x); }, 2},
                                 {P::Release, [this](float x) { setRelease(x); }, 0},
                                 {P::Amount, [this](float x) { setAmount(x); }, 0}});
 
        addModulator(true);
    }
 
    void KwidgetProcessor_Scaledadsr::prepare(double sampleRate, int samplesPerBlock)
    {
        m_adsr.setSampleRate(sampleRate);
        updateParams();
 
        m_buffer.setSize(1, samplesPerBlock);
        getModulator(0)->setValues(m_buffer.getReadPointer(0), samplesPerBlock);
    }
 
    void KwidgetProcessor_Scaledadsr::process(AudioBuffer<float>& buffer)
    {
        auto numSamples = buffer.getNumSamples();
        auto numChannels = buffer.getNumChannels();
        auto bufferPtr = buffer.getArrayOfWritePointers();
 
        auto modulatorBufferPtr = m_buffer.getWritePointer(0);
 
        nextBlock(numSamples);
        if (m_amount == 0.0f)
        {
            for (int sampleIndex = 0; sampleIndex < numSamples; sampleIndex++)
            {
                nextSample();
 
                m_adsr.getNextSample();
 
                // Output the modulation signal
                modulatorBufferPtr[sampleIndex] = 0.0f; //* amp;
 
                // Modulate the audio data using the
                for (int channelIndex = 0; channelIndex < numChannels; channelIndex++)
                    bufferPtr[channelIndex][sampleIndex] *= 1.0f;
            }
        }
 
        else
        {
            for (int sampleIndex = 0; sampleIndex < numSamples; sampleIndex++)
            {
                nextSample();
 
                auto amp = m_adsr.getNextSample();
 
                // Output the modulation signal
                modulatorBufferPtr[sampleIndex] = amp * m_amount;
 
                // Modulate the audio data using the
                for (int channelIndex = 0; channelIndex < numChannels; channelIndex++)
                    bufferPtr[channelIndex][sampleIndex] *= amp * m_amount;
            }
        }
 
        if (!m_adsr.isActive() && !m_hasBeenReset) // If the ADSR has finished
        {
            reset();
            m_hasBeenReset = true;
        }
    }
 
    void KwidgetProcessor_Scaledadsr::noteOn(int midiNoteNumber, float /*velocity*/, int)
    {
        m_isDrone = (midiNoteNumber & MIDI_NOTE_FLAG_DRONE) != 0; // Keep a record of the type of event
 
        if (!m_adsr.isActive()) // If we are not already active
        {
            if (m_isDrone && ((midiNoteNumber & MIDI_NOTE_FLAG_DRONE_NOTEUP) != 0))
            {
                // Its a drone note-up event
                m_noteIsOn = false;
                m_adsr.noteOff();
            }
            else
            {
                // Its a note on event
                m_noteIsOn = true;
                m_adsr.noteOn();
                m_hasBeenReset = false;
            }
        }
    }
 
    void KwidgetProcessor_Scaledadsr::noteOff(float)
    {
        // If we were started as a drone, stop note can never switch us off, only startNote with stop flag
        if (!m_isDrone &&
            m_noteIsOn) // Checking m_noteIsOn prevents re-triggering of any already in-progress release - fix KST-1218
        {
            m_noteIsOn = false;
            m_adsr.noteOff();
        }
    }
 
    void KwidgetProcessor_Scaledadsr::reset()
    {
        m_noteIsOn = false;
        m_adsr.reset();
    }
 
    void KwidgetProcessor_Scaledadsr::noteCleared() { reset(); }
 
    void KwidgetProcessor_Scaledadsr::setAttack(float attack)
    {
        m_parameters.attack = attack;
        updateParams();
    }
    void KwidgetProcessor_Scaledadsr::setDecay(float decay)
    {
        m_parameters.decay = decay;
        updateParams();
    }
    void KwidgetProcessor_Scaledadsr::setSustain(float sustain)
    {
        m_parameters.sustain = sustain;
        updateParams();
    }
    void KwidgetProcessor_Scaledadsr::setRelease(float release)
    {
        m_parameters.release = release;
        updateParams();
    }
    void KwidgetProcessor_Scaledadsr::setAmount(float amount) { m_amount = amount; }
 
    void KwidgetProcessor_Scaledadsr::updateParams() { m_adsr.setParameters(m_parameters); }
 
} // namespace krotos