synthstructures.h

#ifndef __synthSruxt_h__
#define __synthSruxt_h__

#include <cmath>
#include <random>
#include <string>
#include <sstream>
#include <vector>
#include <stdint.h>
#include <memory>

#include "synthconstants.h"

#define _MATH_DEFINES_DEFINED

// -----------------------------
//  --- SynthLab SDK File --- // 
//  ----------------------------
// -----------------------------------------------------------------------------
namespace SynthLab
{ 
    struct XFadeData
    {
        // --- stereo input/output crossfader
        double linearGain[2] = { 0.0, 0.0 };        
        double constPwrGain[2] = { 0.0, 0.0 };      
        double squareLawGain[2] = { 0.0, 0.0 };     
        bool crossfadeFinished = false;             
    };


    struct MidiOutputData
    {
        MidiOutputData() {}

        // --- shared MIDI tables, via IMIDIData
        uint32_t globalMIDIData[kNumMIDIGlobals] = { 0 };   
        uint32_t ccMIDIData[kNumMIDICCs] = { 0 };           
    };

    struct WaveStringData
    {
        WaveStringData(uint32_t _coreIndex, uint32_t _coreWaveIndex)
            : coreIndex(_coreIndex)
            , coreWaveIndex(_coreWaveIndex) {}

        uint32_t coreIndex = 0;         
        uint32_t coreWaveIndex = 0;     
    };

    struct LookUpTable
    {
        LookUpTable(uint32_t _tableLength)
        {
            tableLength = _tableLength;
            table = new double[tableLength];
        }
        ~LookUpTable()
        {
            if (table) delete[] table;
        }
        uint32_t tableLength = 1024;
        double* table = nullptr;
    };


    struct PluginInfo
    {
        PluginInfo() {}

        PluginInfo& operator=(const PluginInfo& data)   // need this override for collections to work
        {
            if (this == &data)
                return *this;

            pathToDLL = data.pathToDLL; 

            return *this;
        }

        const char* pathToDLL;  
    };

    struct midiEvent
    {
        midiEvent() {}

        midiEvent(uint32_t _midiMessage,
            uint32_t _midiChannel,
            uint32_t _midiData1,
            uint32_t _midiData2,
            uint32_t _midiSampleOffset = 0)
            : midiMessage(_midiMessage)
            , midiChannel(_midiChannel)
            , midiData1(_midiData1)
            , midiData2(_midiData2)
            , midiSampleOffset(_midiSampleOffset) {}

        midiEvent& operator=(const midiEvent& data) // need this override for collections to work
        {
            if (this == &data)
                return *this;

            midiMessage = data.midiMessage;
            midiChannel = data.midiChannel;
            midiData1 = data.midiData1;
            midiData2 = data.midiData2;
            midiSampleOffset = data.midiSampleOffset;
            return *this;
        }

        uint32_t    midiMessage = 0;            
        uint32_t    midiChannel = 0;            
        uint32_t    midiData1 = 0;              
        uint32_t    midiData2 = 0;              
        uint32_t    midiSampleOffset = 0;       
    };

    struct MIDINoteEvent
    {
        // --- call with no params for default
        MIDINoteEvent(double _midiPitch = 0.0, uint32_t _midiNoteNumber = 0, uint32_t _midiNoteVelocity = 0)
            : midiPitch(_midiPitch)
            , midiNoteNumber(_midiNoteNumber)
            , midiNoteVelocity(_midiNoteVelocity) {}

        double midiPitch = 0.0;         
        uint32_t midiNoteNumber = 0;    
        uint32_t midiNoteVelocity = 0;  
    };
    struct GlideInfo
    {
        GlideInfo(uint32_t _startMIDINote, uint32_t _endMIDINote, double _glideTime_mSec, double _sampleRate)
            : startMIDINote(_startMIDINote)
            , endMIDINote(_endMIDINote)
            , glideTime_mSec(_glideTime_mSec)
            , sampleRate(_sampleRate) {}

        uint32_t startMIDINote = 0;     
        uint32_t endMIDINote = 0;       
        double glideTime_mSec = 0.0;    
        double sampleRate = 0.0;        
    };




    struct ModuleCoreData
    {
        // --- one droplist control, depending on type of module can contain max 8 slots
        const char* moduleStrings[MODULE_STRINGS] = { "","","","","","","","","","","","","","","","" };    
        int32_t uniqueIndexes[MODULE_STRINGS] = { -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 };        
        const char* modKnobStrings[MOD_KNOBS] = { "","","","" };        
    };

    //\struct MorphBankData
    //\ingroup SynthStructures
    //\brief
    //Information about a bank of wavetables that are used in the morphing wavetable core. 

    //\author Will Pirkle http://www.willpirkle.com
    //\remark This object is included in Designing Software Synthesizer Plugins in C++ 2nd Ed. by Will Pirkle
    //\version Revision : 1.0
    //\date Date : 2021 / 05 / 02
    //*/
    //struct MorphBankData
    //{
    //  std::string bankName = empty_string.c_str();    ///< one name for bank
    //  uint32_t numTables = 1;                         ///< number of wavetables in bank (up to 16)
    //  std::string tableNames[MODULE_STRINGS];         ///< names of wavetables
    //  int32_t tableIndexes[MODULE_STRINGS] = { -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 };         ///< unique indexes for faster lookup
    //  StaticTableSource wavetables[MODULE_STRINGS];
    //};

} // namespace

#endif /* defined(__synthDefs_h__) */