synthvoice.h

#ifndef __synthVoice_h__
#define __synthVoice_h__

// --- SynthLab only
#include "synthbase.h"
#include "synthfunctions.h"

namespace SynthLab
{
    struct SynthVoiceParameters
    {
        SynthVoiceParameters() {}

        // --- synth mode; engine has same variable
        uint32_t synthModeIndex = enumToInt(SynthMode::kMono);

        // --- synth mode; engine has same variable
        uint32_t filterModeIndex = enumToInt(FilterMode::kSeries);

        // --- portamento (glide)
        bool enablePortamento = false;// false;

        // --- glide time
        double glideTime_mSec = 0.0;

        // --- legato mode
        bool legatoMode = false;

        // --- unison Detune - each voice will be detuned differently
        double unisonDetuneCents = 0.0;
        double unisonStartPhase = 0.0;
        double unisonPan = 0.0;

        // --- add your module GUI parametrs here
    };

    // --- voice mode: note on or note off states
    enum class voiceState { kNoteOnState, kNoteOffState };

    class SynthVoice
    {
    public:
        SynthVoice(std::shared_ptr<MidiInputData> _midiInputData,
            std::shared_ptr<MidiOutputData> _midiOutputData,
            std::shared_ptr<SynthVoiceParameters> _parameters,
            std::shared_ptr<WavetableDatabase> _wavetableDatabase,
            std::shared_ptr<PCMSampleDatabase> _sampleDatabase,
            uint32_t _blockSize = 64);

        virtual ~SynthVoice() {} 

        virtual bool reset(double _sampleRate);
        virtual bool update();
        virtual bool render(SynthProcessInfo& synthProcessInfo);
        virtual bool processMIDIEvent(midiEvent& event);
        virtual bool initialize(const char* dllPath = nullptr);
        virtual bool doNoteOn(midiEvent& event);
        virtual bool doNoteOff(midiEvent& event);

        bool isVoiceActive() { return voiceIsActive; }

        voiceState getVoiceState() { return voiceNoteState; }

        // --- timestamps for determining note age;
        //     public because containing object needs to manipulate them
        uint32_t getTimestamp() { return timestamp; }       
        void incrementTimestamp() { timestamp++; }          
        void clearTimestamp() { timestamp = 0; }            

        // --- MIDI note stuff
        unsigned int getMIDINoteNumber() { return voiceMIDIEvent.midiData1; } 

        // --- voice steal
        unsigned int getStealMIDINoteNumber() { return voiceStealMIDIEvent.midiData1; } 
        bool voiceIsStealing() { return stealPending; } 

    protected:
        std::shared_ptr<SynthVoiceParameters> parameters = nullptr;

        // --- local storage
        double sampleRate = 0.0;
        uint32_t blockSize = 64;

        // --- interface pointer
        std::shared_ptr<MidiInputData> midiInputData = nullptr;         
        std::shared_ptr<MidiOutputData> midiOutputData = nullptr;   
        std::shared_ptr<WavetableDatabase> wavetableDatabase = nullptr; 
        std::shared_ptr<PCMSampleDatabase> sampleDatabase = nullptr;    

        std::shared_ptr<AudioBuffer> mixBuffers = nullptr; 
        void accumulateToMixBuffer(std::shared_ptr<AudioBuffer> oscBuffers, uint32_t samplesInBlock, double scaling); 
        void writeToMixBuffer(std::shared_ptr<AudioBuffer> oscBuffers, uint32_t samplesInBlock, double scaling); 

        // --- voice timestamp, for knowing the age of a voice
        uint32_t timestamp = 0;                     
        int32_t currentMIDINote = -1;               

        // --- note message state
        voiceState voiceNoteState = voiceState::kNoteOffState; 

        // --- per-voice stuff
        bool voiceIsActive = false; 
        midiEvent voiceMIDIEvent;   

        // --- for voice stealing
        bool stealPending = false;      
        midiEvent voiceStealMIDIEvent; 

        // ---- place your individual synth components here



    };

}
#endif /* defined(__synthVoice_h__) */