synthlabparams.h

#pragma once

#include <array>

// -----------------------------
//  --- SynthLab SDK File --- // 
//  ----------------------------
// -----------------------------------------------------------------------------
namespace SynthLab
{
    #define enumToInt(ENUM) static_cast<int>(ENUM)

    inline double semitonesBetweenFreqs(double startFrequency, double endFrequency)
    {
        return log2(endFrequency / startFrequency)*12.0;
    }


    const uint32_t MONO_INPUT = 1;
    const uint32_t MONO_OUTPUT = 1;
    const uint32_t STEREO_INPUTS = 2;
    const uint32_t STEREO_OUTPUTS = 2;

    struct OscParameters
    {
        OscParameters() {}

        // --- bank index
        uint32_t waveIndex = 0;             

        // --- tuning
        double octaveDetune = 0.0;          
        double coarseDetune = 0.0;          
        double fineDetune = 0.0;            
        double unisonDetuneCents = 0.0;     
        double oscSpecificDetune = 0.0;     

        // --- mod and output
        double outputAmplitude_dB = 0.0;    
        double oscillatorShape = 0.0;       
        double hardSyncRatio = 1.00;        
        double panValue = 0.00;             
        double phaseModIndex = 1.0;         
        double shape = 0.0;                 
        double modKnobValue[4] = { 0.5, 0.0, 0.0, 0.0 }; 
        uint32_t moduleIndex = 0;           
        bool forceLoop = false;             
    };



    // --- mod knobs, other knob controls
    const double OSC_FMIN = MIDI_NOTE_0_FREQ;
    const double OSC_FMAX = 20480.0;
    const uint32_t OSC_INPUTS = 1; // FM audio inputs
    const uint32_t OSC_OUTPUTS = 2;// dual-mono output

    // --- modulation min/max
    const double WT_OSC_MIN = MIDI_NOTE_0_FREQ;
    const double WT_OSC_MAX = 20480.0;
    const uint32_t WT_OSC_INPUTS = 1; // FM audio inputs
    const uint32_t WT_OSC_OUTPUTS = 2;// dual-mono output

    struct WTOscParameters
    {
        WTOscParameters() {}

        // --- bank index
        uint32_t waveIndex = 0;             

        // --- tuning
        double octaveDetune = 0.0;          
        double coarseDetune = 0.0;          
        double fineDetune = 0.0;            
        double unisonDetuneCents = 0.0;     
        double oscSpecificDetune = 0.0;     

        // --- mod and output
        double outputAmplitude_dB = 0.0;    
        double oscillatorShape = 0.0;       
        double hardSyncRatio = 1.00;        
        double panValue = 0.00;             
        double phaseModIndex = 1.0;         
        double modKnobValue[4] = { 0.5, 0.0, 0.0, 0.0 }; 
        uint32_t moduleIndex = 0;           
        bool forceLoop = false;             
    };

    
    struct WSOscParameters
    {
        WSOscParameters() {}

        // --- tuning
        double detuneSemis[8] = { 0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0 };                    // --- fine tune for unison
        double detuneCents[8] = { 0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0 };                    // --- fine tune for unison
        double oscillatorShape[8] = { 0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0 };                // [-1, +1]
        double hardSyncRatio[8] = { 1.00,1.00,1.00,1.00,1.00,1.00,1.00,1.00 };          // [1, +4]
        double morphIntensity[8] = { 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00 };  // [0, +1]
        double panValue[8] = { 0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0 };                       // [-1, +1]

        bool doubleOscillator = true;// false;
        int32_t soloWaveWSIndex = -1;
    };



    // --- mod knobs, other knob controls
    const double VA_OSC_MIN = MIDI_NOTE_0_FREQ;
    const double VA_OSC_MAX = 20480.0;
    const uint32_t VA_OSC_INPUTS = 0; // no audio inputs
    const uint32_t VA_OSC_OUTPUTS = 2;// dual-mono output
    const double VA_MIN_PW = 0.5;
    const double VA_MAX_PW = 0.95;
    const double PW_MOD_RANGE = (VA_MAX_PW - VA_MIN_PW);
    const double HALF_PW_MOD_RANGE = PW_MOD_RANGE / 2.0;

    // --- VA Oscillator Waveforms
    enum class VAWaveform { kSawAndSquare, kSawtooth, kSquare };

    struct VA1Coeffs
    {
        // --- filter coefficients
        double alpha = 0.0;         
        double beta = 1.0;          
    };

    struct VAOscParameters
    {
        VAOscParameters() {}

        // --- two waveforms
        uint32_t waveIndex = enumToInt(VAWaveform::kSawAndSquare);

        // ---  detuning values
        double octaveDetune = 0.0;          
        double coarseDetune = 0.0;          
        double fineDetune = 0.0;            

        double unisonDetune = 0.0;          

        double pulseWidth_Pct = 50.0;       
        double outputAmplitude_dB = 0.0;    

        double oscillatorShape = 0.0;       
        double hardSyncRatio = 1.00;        
        double panValue = 0.00;             
        double phaseModIndex = 1.0;         
        double waveformMix = 0.5;           

        double modKnobValue[4] = { 0.5, 0.0, 0.0, 0.0 };
        uint32_t moduleIndex = 0;           
    };



    const double PCM_OSC_MIN = MIDI_NOTE_0_FREQ;
    const double PCM_OSC_MAX = 20480.0;
    const uint32_t SMPL_OSC_INPUTS = 0;
    const uint32_t SMPL_OSC_OUTPUTS = 2;// dual-mono or stereo output

    struct PCMOscParameters
    {
    public:
        // ---  index within bank
        uint32_t waveIndex = 0;             

                                            // ---  detuning values
        double octaveDetune = 0.0;          
        double coarseDetune = 0.0;          
        double fineDetune = 0.0;            

                                            // --- this is a root-detuner for unison mode (could combine with detuneCents but would become tangled)
        double unisonDetune = 0.0;          
        double outputAmplitude_dB = 0.0;    

        double oscillatorShape = 0.0;       
        double hardSyncRatio = 1.00;        
        double phaseModIndex = 1.0;         
        double freqModIndex = 1.0;          
        double panValue = 0.0;              
        double modKnobValue[4] = { 0.5, 0.0, 0.0, 0.0 };    
        uint32_t moduleIndex = 0;   
    };


    const double KS_OSC_MIN = MIDI_NOTE_0_FREQ;
    const double KS_OSC_MAX = 20480.0;
    const uint32_t KS_OSC_INPUTS = 0;
    const uint32_t KS_OSC_OUTPUTS = 2;// dual-mono or stereo output
    const double MAX_KSO_ATTACK_MSEC = 500.0;
    const double MAX_KSO_HOLD_MSEC = 2000.0;
    const double MAX_KSO_RELEASE_MSEC = 5000.0;

    struct KSOscParameters
    {
        KSOscParameters() {}

        // ---  index within bank
        uint32_t algorithmIndex = 0;        

        double attackTime_mSec = 0.0;       
        double holdTime_mSec = 0.0;         
        double releaseTime_mSec = 0.0;      

                                            // ---  detuning values
        double octaveDetune = 0.0;          
        double coarseDetune = 0.0;          
        double fineDetune = 0.0;            
        double unisonDetune = 0.0;          
        double outputAmplitude_dB = 0.0;    

        double oscillatorShape = 0.0;       
        double hardSyncRatio = 1.00;        
        double phaseModIndex = 1.0;         
        double freqModIndex = 1.0;          
        double panValue = 0.0;              
        double decay = 0.9;                 
        uint32_t  pluckPosition = 1;        
        double modKnobValue[4] = { 0.5, 0.0, 0.0, 0.0 }; 
        uint32_t moduleIndex = 0;   
    };

    struct ModSource
    {
        ModSource() {}
        ModSource& operator=(const ModSource& params)
        {
            if (this == &params)
                return *this;

            intensity = params.intensity;

            return *this;
        }

        // --- fast clearing of array
        void clear() {
            intensity = 1.0;
        }

        // --- intensity only 
        double intensity = 1.0; 
    };

    struct ModDestination
    {
        ModDestination() { clear(); }
        ModDestination& operator=(const ModDestination& params)
        {
            if (this == &params)
                return *this;

            memcpy(channelEnable, params.channelEnable, MAX_MODULATION_CHANNELS * sizeof(uint32_t));
            memcpy(channelIntensity, params.channelIntensity, MAX_MODULATION_CHANNELS * sizeof(double));

            memcpy(channelHardwire, params.channelHardwire, MAX_MODULATION_CHANNELS * sizeof(bool));
            memcpy(hardwireIntensity, params.hardwireIntensity, MAX_MODULATION_CHANNELS * sizeof(double));

            intensity = params.intensity;
            defautValue = params.defautValue;

            enableChannelIntensity = params.enableChannelIntensity;
            priorityModulation = params.priorityModulation;

            return *this;
        }

        // --- fast clearing of array
        void clear() {
            memset(channelEnable, 0, MAX_MODULATION_CHANNELS * sizeof(uint32_t));
            memset(channelIntensity, 0, MAX_MODULATION_CHANNELS * sizeof(double));
            memset(channelHardwire, 0, MAX_MODULATION_CHANNELS * sizeof(bool));
            memset(hardwireIntensity, 0, MAX_MODULATION_CHANNELS * sizeof(double));
            intensity = 1.0;
        }

        // --- channel enable and intensity controls
        uint32_t channelEnable[MAX_MODULATION_CHANNELS];    
        double channelIntensity[MAX_MODULATION_CHANNELS];   

        bool channelHardwire[MAX_MODULATION_CHANNELS];      
        double hardwireIntensity[MAX_MODULATION_CHANNELS];  

        // --- use separate intensities for each channel
        bool enableChannelIntensity = false;                

        double intensity = 1.0;             
        double defautValue = 0.0;           
        bool priorityModulation = false;    
    };


    struct ModMatrixParameters
    {
        ModMatrixParameters() {}
        ModMatrixParameters& operator=(const ModMatrixParameters& params)   // need this override for collections to work
        {
            if (this == &params)
                return *this;

            modSourceRows = params.modSourceRows;
            modDestinationColumns = params.modDestinationColumns;

            return *this;
        }

        std::shared_ptr<std::array<ModSource, kNumberModSources>> modSourceRows = std::make_shared<std::array<ModSource, kNumberModSources>>();
        
        std::shared_ptr<std::array<ModDestination, kNumberModDestinations>> modDestinationColumns = std::make_shared<std::array<ModDestination, kNumberModDestinations>>();

        void setMM_SourceIntensity(uint32_t destination, double intensity)
        {
            modSourceRows->at(destination).intensity = intensity;
        }

        void setMM_ChannelEnable(uint32_t source, uint32_t destination, bool enable)
        {
            modDestinationColumns->at(destination).channelEnable[source] = enable;
        }

        void setMM_HardwireEnable(uint32_t source, uint32_t destination, bool enable)
        {
            modDestinationColumns->at(destination).channelHardwire[source] = enable;
        }

        void setMM_ChannelIntensity(uint32_t source, uint32_t destination, double intensity)
        {
            modDestinationColumns->at(destination).channelIntensity[source] = intensity;
        }

        void setMM_DestHardwireIntensity(uint32_t source, uint32_t destination, double intensity)
        {
            modDestinationColumns->at(destination).hardwireIntensity[source] = intensity;
        }

        void setMM_DestIntensity(uint32_t destination, double intensity)
        {
            modDestinationColumns->at(destination).intensity = intensity;
        }

        void setMM_DestDefaultValue(uint32_t destination, double defaultValue)
        {
            modDestinationColumns->at(destination).defautValue = defaultValue;
        }

        void setMM_DestHighPriority(uint32_t destination, bool _priorityModulation)
        {
            modDestinationColumns->at(destination).priorityModulation = _priorityModulation;
        }

        void setMM_HardwiredRouting(uint32_t source, uint32_t destination, double intensity = 1.0)
        {
            setMM_ChannelEnable(source, destination, true);
            setMM_HardwireEnable(source, destination, true);
            setMM_DestIntensity(destination, intensity);
            setMM_DestHardwireIntensity(source, destination, intensity);
        }
    };


    const uint32_t NOISE_OSC_INPUTS = 0; // no audio inputs
    const uint32_t NOISE_OSC_OUTPUTS = 2;// dual-mono output

    // --- Noise Oscillator Waveforms
    enum class NoiseWaveform { kWhiteNoise, kPinkNoise, kGaussWhiteNoise };

    struct NoiseOscillatorParameters
    {
        NoiseOscillatorParameters(){}
        NoiseOscillatorParameters& operator=(const NoiseOscillatorParameters& params)
        {
            if (this == &params)
                return *this;

            waveform = params.waveform;
            outputAmplitude_dB = params.outputAmplitude_dB;

            return *this;
        }

        // --- two waveforms
        NoiseWaveform waveform = NoiseWaveform::kWhiteNoise; 
        double outputAmplitude_dB = 0.0;                     
    };



    const double freqModLow = 20.0;
    const double freqModHigh = 18000.0; // -- this is reduced from 20480.0 only for self oscillation at upper frequency range
    const double freqModSemitoneRange = semitonesBetweenFreqs(freqModLow, freqModHigh);
    const uint32_t FILTER_AUDIO_INPUTS = 2;
    const uint32_t FILTER_AUDIO_OUTPUTS = 2;
    enum class FilterModel { kFirstOrder, kSVF, kKorg35, kMoog, kDiode };
    enum { FLT1, FLT2, FLT3, FLT4 };
    const int MOOG_SUBFILTERS = 4;
    const int DIODE_SUBFILTERS = 4;
    const int KORG_SUBFILTERS = 3;
    enum class VAFilterAlgorithm {
        kBypassFilter, kLPF1, kHPF1, kAPF1, kSVF_LP, kSVF_HP, kSVF_BP, kSVF_BS, kKorg35_LP, kKorg35_HP, kMoog_LP1, kMoog_LP2, kMoog_LP3, kMoog_LP4, kDiode_LP4
    };
    enum class BQFilterAlgorithm {
        kBypassFilter, k1PLPF, k1PHPF, kLPF2, kHPF2
    };


    struct FilterParameters
    {
        // --- use with strongly typed enums
        int32_t filterIndex = 0;    

        double fc = 1000.0;                 
        double Q = 1.0;                     
        double filterOutputGain_dB = 0.0;   
        double filterDrive = 1.0;           
        double bassGainComp = 0.0;          
        bool analogFGN = true;              

        // --- key tracking
        bool enableKeyTrack = false;        
        double keyTrackSemis = 0.0;         

        // --- Mod Knobs and core support
        double modKnobValue[4] = { 0.5, 0.0, 0.0, 0.0 }; 
        uint32_t moduleIndex = 0;   
    };



    enum { kEGNormalOutput, kEGBiasedOutput, kNumEGOutputs }; 
    enum class EGState { kOff, kDelay, kAttack, kHold, kDecay, kSlope, kSustain, kRelease, kShutdown };
    enum class AnalogEGContour { kADSR, kAR };  //  --- indexes match modulecore strings
    enum class DXEGContour { kADSlSR, kADSlR }; //  --- indexes match modulecore strings
    const double MAX_EG_VALUE = 1.0;

    struct EGParameters
    {
        EGParameters() {}
        int32_t egContourIndex = 0;     

        // --- modes
        bool resetToZero = false;               
        bool legatoMode = false;                
        bool velocityToAttackScaling = false;   
        bool noteNumberToDecayScaling = false;  

        //--- ADSR times from user
        double attackTime_mSec = 250.0;     
        double decayTime_mSec = 1000.0;     
        double slopeTime_mSec = 0.0;        
        double releaseTime_mSec = 3000.0;   
        
        // --- for DXEG 
        double startLevel = 0.0;    
        double endLevel = 0.0;      
        double decayLevel = 0.707;  
        double sustainLevel = 0.707;
        double curvature = 0.0;     

        // --- mod knobs
        double modKnobValue[4] = { 0.5, 0.0, 0.0, 0.0 }; 
        uint32_t moduleIndex = 0;   // core
    };


    struct ExciterParameters
    {
        ExciterParameters& operator=(const ExciterParameters& data)
        {
            if (this == &data)
                return *this;

            attackTime_mSec = data.attackTime_mSec;
            holdTime_mSec = data.holdTime_mSec;
            releaseTime_mSec = data.releaseTime_mSec;
            return *this;
        }

        double attackTime_mSec = 1000.0;    
        double holdTime_mSec = 5000.0;      
        double releaseTime_mSec = 2500.0;   
    };


    const double FM_OSC_MIN = MIDI_NOTE_0_FREQ;
    const double FM_OSC_MAX = 20480.0;
    const uint32_t FM_OSC_INPUTS = 0; // FM audio inputs
    const uint32_t FM_OSC_OUTPUTS = 2;// dual-mono output

    struct FMOperatorParameters
    {
        FMOperatorParameters() {}

        // --- bank index
        uint32_t waveIndex = 0;             

        // --- tuning
        double octaveDetune = 0.0;          
        double coarseDetune = 0.0;          
        double fineDetune = 0.0;            
        double unisonDetune = 0.0;          

        // --- mod and output
        double outputAmplitude_dB = 0.0;    
        double oscillatorShape = 0.0;       
        double panValue = 0.00;             
        double phaseModIndex = 0.0;         
        double modKnobValue[4] = { 0.5, 0.0, 0.0, 0.0 };
        uint32_t moduleIndex = 0;           

        // --- FM Operator only
        EGParameters dxEGParameters;        
        double ratio = 1.0;                 
    };


    const uint32_t DCA_AUDIO_INPUTS = 2; // stereo/dual mono
    const uint32_t DCA_AUDIO_OUTPUTS = 2;// stereo


    struct DCAParameters
    {
        DCAParameters() {}

        // --- individual parameters
        double gainValue_dB = 0.0;      
        double panValue = 0.0;          
        double ampEGIntensity = 1.0;    
        double ampModIntensity = 1.0;   
        double panModIntensity = 1.0;   
        uint32_t moduleIndex = 0;       
    };


    const double LFO_FCMOD_MIN = 0.02;
    const double LFO_FCMOD_MAX = 200.0;
    const double LFO_RANGE = ((LFO_FCMOD_MAX - LFO_FCMOD_MIN));
    const double LFO_HALF_RANGE = LFO_RANGE / 2.0;
    const double MAX_LFO_DELAY_MSEC = 5000.0;
    const double MAX_LFO_FADEIN_MSEC = 5000.0;

    // --- 8 basic waveforms, plus exensions
    enum class LFOWaveform {
        kTriangle, kSin, kRampUp, kRampDown,
        kExpRampUp, kExpRampDn, kExpTriangle, kSquare,
        kRSH, kPluck
    };
    // --- 3 fms
    const uint32_t NUM_FMLFO_OPS = 3;
    enum class FMLFOWaveform { kFM2, kFM3A, kFM3B };
    enum class LFOMode { kSync, kOneShot, kFreeRun };
    // --- array locations in mod output
    enum {
        kLFONormalOutput,
        kLFOInvertedOutput,
        kUnipolarFromMin,
        kUnipolarFromMax,
        kNumLFOOutputs
    };

    struct LFOParameters
    {
        int32_t waveformIndex = 0;      
        int32_t modeIndex = 0;          
        double frequency_Hz = 0.5;      
        double outputAmplitude = 1.0;   
        uint32_t quantize = 0;          
        double modKnobValue[4] = { 0.5, 0.0, 0.0, 0.0 }; 
        uint32_t moduleIndex = 0;       
    };



    const uint32_t DELAY_AUDIO_INPUTS = 2;
    const uint32_t DELAY_AUDIO_OUTPUTS = 2;

    struct AudioDelayParameters
    {
        AudioDelayParameters() {}
        AudioDelayParameters& operator=(const AudioDelayParameters& params) // need this override for collections to work
        {
            if (this == &params)
                return *this;

            wetLevel_dB = params.wetLevel_dB;
            dryLevel_dB = params.dryLevel_dB;
            feedback_Pct = params.feedback_Pct;
            leftDelay_mSec = params.leftDelay_mSec;
            rightDelay_mSec = params.rightDelay_mSec;

            return *this;
        }

        // --- individual parameters
        double wetLevel_dB = -3.0;          
        double dryLevel_dB = -3.0;          
        double feedback_Pct = 0.0;          
        double leftDelay_mSec = 2000.0;     
        double rightDelay_mSec = 2000.0;    
    };
} // namespace