analogegcore.h

#pragma once

#include "synthbase.h"
#include "synthfunctions.h"

// -----------------------------
//  --- SynthLab SDK File --- // 
//  ----------------------------
// -----------------------------------------------------------------------------
namespace SynthLab
{
    class AnalogEGCore : public ModuleCore
    {
    public:
        AnalogEGCore();                 /* C-TOR */
        
        virtual ~AnalogEGCore() {}      /* D-TOR */

        virtual bool reset(CoreProcData& processInfo) override;
        virtual bool update(CoreProcData& processInfo) override;
        virtual bool render(CoreProcData& processInfo) override;
        virtual bool doNoteOn(CoreProcData& processInfo) override;
        virtual bool doNoteOff(CoreProcData& processInfo) override;

        virtual int32_t getState() override { return enumToInt(state); }
        virtual bool shutdown() override;
        virtual void setSustainOverride(bool b) override;

    protected:
        bool noteOff = false;       
        bool retriggered = false;   
        double lastTriggerMod = 0.0;

        // --- index of contour
        double sustainLevel = 1.0;      
        double attackTime_mSec = 1.0;   
        double decayTime_mSec = 1.0;    
        double releaseTime_mSec = 1.0;  

        inline void calcAttackCoeff(double attackTime, double attackTimeScalar = 1.0)
        {
            // --- store for comparing so don't need to waste cycles on updates
            attackTime_mSec = attackTime;

            // --- samples for the exponential rate
            double samples = sampleRate*((attackTime_mSec*attackTimeScalar) / 1000.0);

            // --- coeff and base for iterative exponential calculation
            attackCoeff = exp(-log((1.0 + attackTCO) / attackTCO) / samples);
            attackOffset = (1.0 + attackTCO)*(1.0 - attackCoeff);
        }

        inline void calcDecayCoeff(double decayTime, double decayTimeScalar = 1.0)
        {
            // --- store for comparing so don't need to waste cycles on updates
            decayTime_mSec = decayTime;

            // --- samples for the exponential rate
            double samples = sampleRate*((decayTime_mSec*decayTimeScalar) / 1000.0);

            // --- coeff and base for iterative exponential calculation
            decayCoeff = exp(-log((1.0 + decayTCO) / decayTCO) / samples);
            decayOffset = (sustainLevel - decayTCO)*(1.0 - decayCoeff);
        }

        void calcReleaseCoeff(double releaseTime, double releaseTimeScalar = 1.0)
        {
            // --- store for comparing so don't need to waste cycles on updates
            releaseTime_mSec = releaseTime;

            // --- samples for the exponential rate
            double samples = sampleRate*((releaseTime_mSec*releaseTimeScalar) / 1000.0);

            // --- coeff and base for iterative exponential calculation
            releaseCoeff = exp(-log((1.0 + releaseTCO) / releaseTCO) / samples);
            releaseOffset = -releaseTCO*(1.0 - releaseCoeff);
        }

        // --- sample rate for time calculations
        double sampleRate = 0.0;            

        // --- the current output of the EG
        double envelopeOutput = 0.0;        


        //--- Coefficient, offset and TCO values
        //    for each state
        double attackCoeff = 0.0;   
        double attackOffset = 0.0;  
        double attackTCO = 0.0;     

        double decayCoeff = 0.0;    
        double decayOffset = 0.0;   
        double decayTCO = 0.0;      

        double releaseCoeff = 0.0;  
        double releaseOffset = 0.0; 
        double releaseTCO = 0.0;    

        // --- for sustain pedal input; these two bools keep track of the override, 
        //     and eventual release when the sus pedal is released after user released key
        bool sustainOverride = false;       
        bool releasePending = false;        

        // --- inc value for shutdown
        double incShutdown = 0.0;           

        // --- stage variable
        EGState state = EGState::kOff;      
    };



} // namespace