pluginstructures.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//    ASPiK Plugin Kernel File:  pluginstructures.h
//
// -----------------------------------------------------------------------------
#ifndef _pluginstructures_h
#define _pluginstructures_h

// --- support multichannel operation up to 128 channels
#define MAX_CHANNEL_COUNT 128

#include <string>
#include <sstream>
#include <vector>
#include <stdint.h>

#include "readerwriterqueue.h"
#include "atomicops.h"

class IGUIPluginConnector;
class IGUIWindowFrame;
class IGUIView;

#ifdef AUPLUGIN
#import <CoreFoundation/CoreFoundation.h>
#import <AudioUnit/AudioUnit.h>
#import <AudioToolbox/AudioToolbox.h>

typedef struct
{
    void* pWindow;
    float width;
    float height;
    AudioUnit au;
    IGUIWindowFrame* pGUIFrame;
    IGUIView* pGUIView;
} VIEW_STRUCT;
#endif


enum pluginType
{
    kFXPlugin,
    kSynthPlugin
};

enum aaxPlugInCategory
{
    aaxPlugInCategory_None              = 0x00000000,
    aaxPlugInCategory_EQ                = 0x00000001,   
    aaxPlugInCategory_Dynamics          = 0x00000002,   
    aaxPlugInCategory_PitchShift        = 0x00000004,   
    aaxPlugInCategory_Reverb            = 0x00000008,   
    aaxPlugInCategory_Delay             = 0x00000010,   
    aaxPlugInCategory_Modulation        = 0x00000020,   
    aaxPlugInCategory_Harmonic          = 0x00000040,   
    aaxPlugInCategory_NoiseReduction    = 0x00000080,   
    aaxPlugInCategory_Dither            = 0x00000100,   
    aaxPlugInCategory_SoundField        = 0x00000200,   
    aaxPlugInCategory_HWGenerators      = 0x00000400,   
    aaxPlugInCategory_SWGenerators      = 0x00000800,   
    aaxPlugInCategory_WrappedPlugin     = 0x00001000,   
    aaxPlugInCategory_Effect            = 0x00002000,   
};

enum channelFormat
{
    kCFNone,
    kCFMono,
    kCFStereo,
    kCFLCR,
    kCFLCRS,
    kCFQuad,
    kCF5p0,
    kCF5p1,
    kCF6p0,
    kCF6p1,
    kCF7p0Sony,
    kCF7p0DTS,
    kCF7p1Sony,
    kCF7p1DTS,
    kCF7p1Proximity,

    /* the following are NOT directly suppported by AAX/AU */
    kCF8p1,
    kCF9p0,
    kCF9p1,
    kCF10p0,
    kCF10p1,
    kCF10p2,
    kCF11p0,
    kCF11p1,
    kCF12p2,
    kCF13p0,
    kCF13p1,
    kCF22p2,
};

enum auxGUIIdentifier
{
    GUIKnobGraphic,
    GUI2SSButtonStyle,
    EnableMIDIControl,
    MIDIControlChannel,
    MIDIControlIndex,
    midiControlData,
    guiControlData
};

struct ResetInfo
{
    ResetInfo()
        : sampleRate(44100)
        , bitDepth(16) {}

    ResetInfo(double _sampleRate,
        uint32_t _bitDepth)
        : sampleRate(_sampleRate)
        , bitDepth(_bitDepth) {}

    double sampleRate = 0.0;    
    uint32_t bitDepth = 0;      
};

struct APISpecificInfo
{
    APISpecificInfo ()
    : aaxManufacturerID(0) /* change this in the plugin core constructor */
    , aaxProductID(0)      /* change this in the plugin core constructor */
    , aaxEffectID("")
    , aaxPluginCategoryCode(aaxPlugInCategory::aaxPlugInCategory_Effect)
    , fourCharCode(0)
    , vst3FUID("")
    , enableVST3SampleAccurateAutomation(0)
    , vst3SampleAccurateGranularity(1)
    , vst3BundleID("")
    , auBundleID("")
    {}

    uint32_t aaxManufacturerID = 0;         
    uint32_t aaxProductID = 0;              
    std::string aaxEffectID;                
    std::string aaxBundleID;                
    uint32_t aaxPluginCategoryCode = 0;     

    // --- common to AU and AAX
    int fourCharCode = 0;                   

    // --- VST3
    std::string vst3FUID;                               
    bool enableVST3SampleAccurateAutomation = false;    
    uint32_t vst3SampleAccurateGranularity = 1;         
    std::string vst3BundleID;                           

    // --- AU
    std::string auBundleID;         
    std::string auBundleName;       

 };

struct VectorJoystickData
{
    VectorJoystickData()
        : vectorA(0.0)
        , vectorB(0.0)
        , vectorC(0.0)
        , vectorD(0.0)
        , vectorACMix(0.0)
        , vectorBDMix(0.0) {}

    VectorJoystickData(double _vectorA, double _vectorB, double _vectorC, double _vectorD, double _vectorACMix, double _vectorBDMix)
        : vectorA(_vectorA)
        , vectorB(_vectorB)
        , vectorC(_vectorC)
        , vectorD(_vectorD)
        , vectorACMix(_vectorACMix)
        , vectorBDMix(_vectorBDMix) {}

    double vectorA = 0.0;   
    double vectorB = 0.0;   
    double vectorC = 0.0;   
    double vectorD = 0.0;   

    double vectorACMix = 0.0; 
    double vectorBDMix = 0.0; 
};

struct GUIParameter
{
    GUIParameter()
        : controlID(0)
        , actualValue(0.0)
        , useCustomData(0)
        , customData(0) {}

    uint32_t controlID = 0;     
    double actualValue = 0.0;   
    bool useCustomData = false; 

    // --- for custom drawing, or other custom data
    void* customData = nullptr; 
};

struct PresetParameter
{
    PresetParameter ()
    : controlID(0)
    , actualValue(0.0){}

    PresetParameter (uint32_t _controlID, double _actualValue)
    : controlID(_controlID)
    , actualValue(_actualValue){}

    uint32_t controlID = 0;     
    double actualValue = 0.0;   
};

struct PresetInfo
{
    PresetInfo(uint32_t _presetIndex, const char* _name)
    : presetIndex(_presetIndex)
    , presetName(_name) {}

    uint32_t presetIndex = 0;       
    std::string presetName;         

    std::vector<PresetParameter> presetParameters;  
};

struct GUIUpdateData
{
    uint32_t guiUpdateCode = -1; 

    // --- for control updates
    std::vector<GUIParameter> guiParameters; 

    // --- for custom draw updates (graphs, etc...)
    void* customData = nullptr; 

    // --- flag
    bool useCustomData = false; 
};

enum hostMessage { sendGUIUpdate, sendRAFXStatusWndText };

struct HostMessageInfo
{
    HostMessageInfo()
        : hostMessage(0){}

    uint32_t hostMessage;
    GUIParameter guiParameter;      /* for single param updates */

    // --- for GUI messages
    GUIUpdateData guiUpdateData;    /* for multiple param updates */
    std::string rafxStatusWndText;
};


struct ChannelIOConfig
{
    ChannelIOConfig ()
    : inputChannelFormat(kCFStereo)
    , outputChannelFormat(kCFStereo) {}

    ChannelIOConfig (uint32_t _inputChannelFormat,
                     uint32_t _outputChannelFormat)
    : inputChannelFormat(_inputChannelFormat)
    , outputChannelFormat(_outputChannelFormat){}

    uint32_t inputChannelFormat = kCFStereo;    
    uint32_t outputChannelFormat = kCFStereo;   

};

struct midiEvent
{
    midiEvent(uint32_t _midiMessage, uint32_t _midiChannel, uint32_t _midiData1, uint32_t _midiData2, uint32_t _midiSampleOffset)
        : midiMessage(_midiMessage)
        , midiChannel(_midiChannel)
        , midiData1(_midiData1)
        , midiData2(_midiData2)
        , midiSampleOffset(_midiSampleOffset)
    {
        midiPitchBendValue = 0;
        midiNormalizedPitchBendValue = 0.f;
        midiIsDirty = false;
    }

    midiEvent(uint32_t _midiMessage, uint32_t _midiChannel, uint32_t _midiData1, uint32_t _midiData2, uint32_t _midiSampleOffset, double _audioTimeStamp)
        : midiMessage(_midiMessage)
        , midiChannel(_midiChannel)
        , midiData1(_midiData1)
        , midiData2(_midiData2)
        , midiSampleOffset(_midiSampleOffset)
        , audioTimeStamp(_audioTimeStamp)
    {
        midiPitchBendValue = 0;
        midiNormalizedPitchBendValue = 0.f;
        midiIsDirty = false;
    }

    midiEvent ()
    : midiMessage(0)
    , midiChannel(0)
    , midiData1(0)
    , midiData2(0)
    , midiSampleOffset(0)
    , midiPitchBendValue(0)
    , midiNormalizedPitchBendValue(0)
    , midiIsDirty(0)
    , audioTimeStamp(0.0){}

    uint32_t    midiMessage = 0;            
    uint32_t    midiChannel = 0;            
    uint32_t    midiData1 = 0;              
    uint32_t    midiData2 = 0;              
    uint32_t    midiSampleOffset = 0;       
    int         midiPitchBendValue = 0;     
    float       midiNormalizedPitchBendValue = 0.0;
    bool        midiIsDirty = false;        
    double      audioTimeStamp = 0.0;       
};


enum messageType {
    PLUGINGUI_DIDOPEN,                       /* called after successful population of GUI frame, NOT called with GUI_USER_CUSTOMOPEN*/
    PLUGINGUI_WILLCLOSE,                     /* called before window is destroyed, NOT called with GUI_USER_CUSTOM_CLOSE */
    PLUGINGUI_TIMERPING,                    /* timer ping for custom views */
    PLUGINGUI_REGISTER_CUSTOMVIEW,          /* register a custom view */
    PLUGINGUI_DE_REGISTER_CUSTOMVIEW,       /* un-register a custom view */
    PLUGINGUI_REGISTER_SUBCONTROLLER,       /* register a subcontroller */
    PLUGINGUI_DE_REGISTER_SUBCONTROLLER,    /* un-register a subcontroller */
    PLUGINGUI_QUERY_HASUSERCUSTOM,          /* CUSTOM GUI - reply in bHasUserCustomView */
    PLUGINGUI_USER_CUSTOMOPEN,              /* CUSTOM GUI - create your custom GUI, you must supply the code */
    PLUGINGUI_USER_CUSTOMCLOSE,             /* CUSTOM GUI - destroy your custom GUI, you must supply the code */
    PLUGINGUI_USER_CUSTOMSYNC,              /* CUSTOM GUI - re-sync the GUI */
    PLUGINGUI_EXTERNAL_SET_NORMVALUE,       // for VST3??
    PLUGINGUI_EXTERNAL_SET_ACTUALVALUE,
    PLUGINGUI_EXTERNAL_GET_NORMVALUE,       /* currently not used */
    PLUGINGUI_EXTERNAL_GET_ACTUALVALUE,
    PLUGINGUI_PARAMETER_CHANGED,            /* for pluginCore->guiParameterChanged(nControlIndex, fValue); */
    PLUGIN_QUERY_DESCRIPTION,               /* fill in a Rafx2PluginDescriptor for host */
    PLUGIN_QUERY_PARAMETER,                 /* fill in a Rafx2PluginParameter for host inMessageData = index of parameter*/
    PLUGIN_QUERY_TRACKPAD_X,
    PLUGIN_QUERY_TRACKPAD_Y
};


struct MessageInfo
{
    MessageInfo ()
    : message(0)
    , inMessageData(0)
    , outMessageData(0){}

    MessageInfo (uint32_t _message)
    : message(_message)
     , inMessageData(0)
    , outMessageData(0)
    {}

    uint32_t message = 0;           
    void* inMessageData = nullptr;  
    void* outMessageData = nullptr; 

    std::string inMessageString;    
    std::string outMessageString;   
};

struct CreateGUIInfo
{
    CreateGUIInfo()
        : window(0)
        , guiPluginConnector(0)
        , guiWindowFrame(0)
        , width(0.0)
        , height(0.0)
    { }

    CreateGUIInfo(void* _window, IGUIPluginConnector* _guiPluginConnector, IGUIWindowFrame* _guiWindowFrame)
        : window(_window)
        , guiPluginConnector(_guiPluginConnector)
        , guiWindowFrame(_guiWindowFrame)
        , width(0.0)
        , height(0.0)
    { }

    void* window = nullptr;                             
    IGUIPluginConnector* guiPluginConnector = nullptr;  
    IGUIWindowFrame* guiWindowFrame;                    

    // --- returned
    double width = 0.0;     
    double height = 0.0;    
};

struct ParameterUpdateInfo
{
    ParameterUpdateInfo()
        : isSmoothing(0)
        , isVSTSampleAccurateUpdate(0)
        , loadingPreset(0)
        , boundVariableUpdate(0)
        , bufferProcUpdate(0)
        , applyTaper(1){}

    ParameterUpdateInfo(bool _isSmoothing, bool _isVSTSampleAccurateUpdate)
        : isSmoothing(_isSmoothing)
        , isVSTSampleAccurateUpdate(_isVSTSampleAccurateUpdate) {
        loadingPreset = false;
        boundVariableUpdate = false;
        bufferProcUpdate = false;
        applyTaper = true;
    }

    bool isSmoothing = false;               
    bool isVSTSampleAccurateUpdate = false; 
    bool loadingPreset = false;             
    bool boundVariableUpdate = false;       
    bool bufferProcUpdate = false;          
    bool applyTaper = true;                 
};

enum attributeType { isFloatAttribute, isDoubleAttribute, isIntAttribute, isUintAttribute, isBoolAttribute, isVoidPtrAttribute, isStringAttribute };

union attributeValue
{
    float f;
    double d;
    int n;
    unsigned int u;
    bool b;
    void* vp;
};

struct AuxParameterAttribute
{
    AuxParameterAttribute()
    : attributeID(0)
    { memset(&value, 0, sizeof(attributeValue)); }

    AuxParameterAttribute(uint32_t _attributeID)
        : attributeID(_attributeID) { }

    void reset(uint32_t _attributeID) { memset(&value, 0, sizeof(attributeValue));  attributeID = _attributeID; }

    void setFloatAttribute(float f) { value.f = f; }
    void setDoubleAttribute(double d) { value.d = d; }
    void setIntAttribute(int n) { value.n = n; }
    void setUintAttribute(unsigned int u) { value.u = u; }
    void setBoolAttribute(bool b) { value.b = b; }
    void setVoidPtrAttribute(void* vp) { value.vp = vp; }

    float getFloatAttribute( ) { return value.f; }
    double getDoubleAttribute( ) { return value.d; }
    int getIntAttribute( ) { return value.n; }
    unsigned int getUintAttribute( ) { return  value.u; }
    bool getBoolAttribute( ) { return value.b; }
    void* getVoidPtrAttribute( ) { return value.vp; }

    attributeValue value;   
    uint32_t attributeID;   
};

struct HostInfo
{
    // --- common to all APIs
    unsigned long long uAbsoluteFrameBufferIndex = 0;   
    double dAbsoluteFrameBufferTime = 0.0;              
    double dBPM = 0.0;                                  
    float fTimeSigNumerator = 0.f;                      
    uint32_t uTimeSigDenomintor = 0;                    

    // --- VST3 Specific: note these use same variable names as VST3::struct ProcessContext
    //     see ..\VST3 SDK\pluginterfaces\vst\ivstprocesscontext.h for information on decoding these
    //
    uint32_t state = 0;                 
    long long systemTime = 0;           
    double continousTimeSamples = 0.0;  
    double projectTimeMusic = 0.0;      
    double barPositionMusic = 0.0;      
    double cycleStartMusic = 0.0;       
    double cycleEndMusic = 0.0;         
    uint32_t samplesToNextClock = 0;    
    /*
     IF you need SMPTE information, you need to get the information yourself at the start of the process( ) function
     where the above values are filled out. See the variables here in VST3 SDK\pluginterfaces\vst\ivstprocesscontext.h:

     int32 smpteOffsetSubframes = 0;    // --- SMPTE (sync) offset in subframes (1/80 of frame)
     FrameRate frameRate;               // --- frame rate
     */

    // --- AU Specific
    //     see AUBase.h for definitions and information on decoding these
    //
    double dCurrentBeat = 0.0;                  
    bool bIsPlayingAU = false;                  
    bool bTransportStateChanged = false;        
    uint32_t nDeltaSampleOffsetToNextBeat = 0;  
    double dCurrentMeasureDownBeat = 0.0;       
    bool bIsCycling = false;                    
    double dCycleStartBeat = 0.0;               
    double dCycleEndBeat = 0.0;                 

    // --- AAX Specific
    //     see AAX_ITransport.h for definitions and information on decoding these
    bool bIsPlayingAAX = false;                 
    long long nTickPosition = 0;                
    bool bLooping = false;                      
    long long nLoopStartTick = 0;               
    long long nLoopEndTick = 0;                 
    /*
     NOTE: there are two optional functions that cause a performance hit in AAX; these are commented outs;
     if you decide to use them, you should re-locate them to a non-realtime thread. Use at your own risk!

     int32_t nBars = 0;
     int32_t nBeats = 0;
     int64_t nDisplayTicks = 0;
     int64_t nCustomTickPosition = 0;

     // --- There is a minor performance cost associated with using this API in Pro Tools. It should NOT be used excessively without need
     midiTransport->GetBarBeatPosition(&nBars, &nBeats, &nDisplayTicks, nAbsoluteSampleLocation);

     // --- There is a minor performance cost associated with using this API in Pro Tools. It should NOT be used excessively without need
     midiTransport->GetCustomTickPosition(&nCustomTickPosition, nAbsoluteSampleLocation);

     NOTE: if you need SMPTE or metronome information, you need to get the information yourself at the start of the ProcessAudio( ) function
              see AAX_ITransport.h for definitions and information on decoding these
     virtual    AAX_Result GetTimeCodeInfo(AAX_EFrameRate* oFrameRate, int32_t* oOffset) const = 0;
     virtual    AAX_Result GetFeetFramesInfo(AAX_EFeetFramesRate* oFeetFramesRate, int64_t* oOffset) const = 0;
     virtual AAX_Result IsMetronomeEnabled(int32_t* isEnabled) const = 0;
     */
};

class IMidiEventQueue;

struct ProcessBufferInfo
{
    ProcessBufferInfo(){}

    /*
    AAX -- MUST be float
    AU --- Float32
    RAFX2 --- float
    VST3 --- float OR double
     *  \brief Subscribes an audio input context field
     *
     *  Defines an audio in port for host-provided information in the algorithm's
     *  context structure.
     *
     *  - Data type: float**
     *  - Data kind: An array of float arrays, one for each input channel
     *
     */
    // --- audio inputs and outputs (arrays of channel-array pointers)
    float** inputs = nullptr;       
    float** outputs = nullptr;      
    float** auxInputs = nullptr;    
    float** auxOutputs = nullptr;   
    uint32_t numAudioInChannels = 0;        
    uint32_t numAudioOutChannels = 0;       
    uint32_t numAuxAudioInChannels = 0;     
    uint32_t numAuxAudioOutChannels = 0;    

    uint32_t numFramesToProcess = 0;        
    ChannelIOConfig channelIOConfig;        
    ChannelIOConfig auxChannelIOConfig;     

    // --- for future use, VCVRack
    float* controlSignalInputs = nullptr;   
    float* controlSignalOutputs = nullptr;  
    uint32_t numControlSignalInputs = 0;    
    uint32_t numControlSignalOutputs = 0;   

    // --- should make these const?
    HostInfo* hostInfo = nullptr;           
    IMidiEventQueue* midiEventQueue = nullptr;  
};

struct ProcessFrameInfo
{
    ProcessFrameInfo(){ }

    float* audioInputFrame = nullptr;       
    float* audioOutputFrame = nullptr;      
    float* auxAudioInputFrame = nullptr;    
    float* auxAudioOutputFrame = nullptr;   

    uint32_t numAudioInChannels = 0;        
    uint32_t numAudioOutChannels = 0;       
    uint32_t numAuxAudioInChannels = 0;     
    uint32_t numAuxAudioOutChannels = 0;    

    ChannelIOConfig channelIOConfig;    
    ChannelIOConfig auxChannelIOConfig; 
    uint32_t currentFrame = 0;          

    // --- for future use, VCVRack
    float* controlSignalInputs = nullptr;   
    float* controlSignalOutputs = nullptr;  
    uint32_t numControlSignalInputs = 0;    
    uint32_t numControlSignalOutputs = 0;   

    // --- should make these const?
    HostInfo* hostInfo = nullptr;           
    IMidiEventQueue* midiEventQueue = nullptr;  
};

struct AudioProcDescriptor
{
    AudioProcDescriptor ()
    : sampleRate(44100)
    , bitDepth(16){}

    AudioProcDescriptor (double _sampleRate,
                         uint32_t _bitDepth)
    : sampleRate(_sampleRate)
    , bitDepth(_bitDepth){}

    double sampleRate = 44100.0;    
    uint32_t bitDepth = 16;         
};


struct PluginDescriptor
{
    PluginDescriptor ()
    : pluginName("Long Plugin Name") // max 31 chars
    , shortPluginName("ShortPIName") // max 15 chars
    , vendorName("Plugin Developer")
    , pluginTypeCode(pluginType::kFXPlugin) // FX or synth
    , hasSidechain(0)
    , processFrames(1)                  /* default operation */
    , wantsMIDI(1)                      /* default operation */
    , hasCustomGUI(1)
    , latencyInSamples(0)
    , tailTimeInMSec(0)
    , infiniteTailVST3(0)
    , numSupportedIOCombinations(0)
    , supportedIOCombinations(0)
    , numSupportedAuxIOCombinations(0)
    , supportedAuxIOCombinations(0)
    {}

    // --- string descriptors
    std::string pluginName;         
    std::string shortPluginName;    
    std::string vendorName;         
    uint32_t pluginTypeCode = 0;    

    bool hasSidechain = false;      
    bool processFrames = true;      
    bool wantsMIDI = true;          
    bool hasCustomGUI = true;       
    uint32_t latencyInSamples = 0;  
    double tailTimeInMSec = 0.0;    
    bool infiniteTailVST3 = false;  

    uint32_t numSupportedIOCombinations = 0;    
    ChannelIOConfig* supportedIOCombinations;

    uint32_t numSupportedAuxIOCombinations = 0;
    ChannelIOConfig* supportedAuxIOCombinations;

    uint32_t getDefaultChannelIOConfigForChannelCount(uint32_t channelCount)
    {
        switch(channelCount)
        {
            case 0:
                return kCFNone;
            case 1:
                return kCFMono;
            case 2:
                return kCFStereo;
            case 3:
                return kCFLCR;
            case 4:
                return kCFQuad; // or kCFLCR
            case 5:
                return kCF5p0;
            case 6:
                return kCF5p1; // or kCF6p0
            case 7:
                return kCF6p1; // or kCF7p0Sony kCF7p0DTS
            case 8:
                return kCF7p1DTS; // or kCF7p1Sony or kCF7p1Proximity
            case 9:
                return kCF8p1; // or kCF9p0
            case 10:
                return kCF9p1; // or kCF10p0
            case 11:
                return kCF10p1;
            case 12:
                return kCF11p1; // or kCF10p2
            case 13:
                return kCF13p0; // or kCF12p2
            case 14:
                return kCF13p1;
            case 24:
                return kCF22p2;

            default:
                return 0;
        }
    }
    uint32_t getChannelCountForChannelIOConfig(uint32_t format)
    {
        switch(format)
        {
            case kCFNone:
                return 0;

            case kCFMono:
                return 1;
            case kCFStereo:
                return 2;
            case kCFLCR:
                return 3;

            case kCFQuad:
            case kCFLCRS:
                return 4;

            case kCF5p0:
                return 5;

            case kCF5p1:
            case kCF6p0:
                return 6;

            case kCF6p1:
            case kCF7p0Sony:
            case kCF7p0DTS:
                return 7;

            case kCF7p1Sony:
            case kCF7p1DTS:
            case kCF7p1Proximity:
                return 8;

            case kCF8p1:
            case kCF9p0:
                return 9;

            case kCF9p1:
            case kCF10p0:
                return 10;

            case kCF10p1:
                return 11;

            case kCF10p2:
            case kCF11p1:
                return 12;

            case kCF13p0:
            case kCF12p2:
                return 13;

            case kCF13p1:
                return 14;

            case kCF22p2:
                return 24;

            default:
                return 0;
        }
        return 0;
    }
};

struct JSControl
{
    JSControl() {}
    JSControl& operator=(const JSControl& aControl)
    {
        if (this == &aControl)
            return *this;

        trackpadIndex = aControl.trackpadIndex;
        midiControl = aControl.midiControl;
        midiControlCommand = aControl.midiControlCommand;
        midiControlName = aControl.midiControlName;
        midiControlChannel = aControl.midiControlChannel;
        joystickValue = aControl.joystickValue;
        korgVectorJoystickOrientation = aControl.korgVectorJoystickOrientation;
        enableParamSmoothing = aControl.enableParamSmoothing;
        smoothingTimeInMs = aControl.smoothingTimeInMs;
        return *this;
    }

    int32_t trackpadIndex = -1;         
    bool midiControl = false;           
    uint32_t midiControlCommand = 0;    
    uint32_t midiControlName = 0;       
    uint32_t midiControlChannel = 0;    
    double joystickValue = 0.0;         
    bool korgVectorJoystickOrientation = false; 
    bool enableParamSmoothing = false;  
    double smoothingTimeInMs = 0.0;     
};


// --------------------------------------------------------------------------------------------------------------------------- //
// --- INTERFACES
// --------------------------------------------------------------------------------------------------------------------------- //

class ICustomView
{
public:
    virtual void updateView() = 0;

    virtual void pushDataValue(double data) { }

    virtual void sendMessage(void* data) { }
};

class IGUIWindowFrame
{
public:
    virtual bool setWindowFrameSize(double left = 0, double top = 0, double right = 0, double bottom = 0) = 0;

    virtual bool getWindowFrameSize(double& left, double&  top, double&  right, double&  bottom) = 0;

    virtual void enableGUIDesigner(bool enable) { }
};

class IGUIView
{
public:
    virtual void setGUIWindowFrame(IGUIWindowFrame* frame) = 0;
};


class IGUIPluginConnector
{
public:
    virtual bool registerCustomView(std::string customViewName, ICustomView* customViewConnector) = 0;

    virtual bool deRegisterCustomView(ICustomView* customViewConnector) = 0;

    virtual bool guiDidOpen() = 0;

    virtual bool guiWillClose() = 0;

    virtual bool guiTimerPing() = 0;

    virtual bool registerSubcontroller(std::string subcontrollerName, ICustomView* customViewConnector) { return false; }

    virtual bool deRregisterSubcontroller(ICustomView* customViewConnector) { return false; }

    virtual uint32_t getNonBoundVariableCount() { return 0; }

    virtual uint32_t getNextNonBoundVariableTag(int startTag) { return -1; }

    virtual bool checkNonBoundValueChange(int tag, float normalizedValue) { return false; }

    virtual void checkSendUpdateGUI(int tag, float actualValue, bool loadingPreset, void* data1 = 0, void* data2 = 0) {}

    virtual void parameterChanged(int32_t controlID, double actualValue, double normalizedValue) {}

    virtual double getNormalizedPluginParameter(int32_t controlID) { return 0.0; }

    virtual void setNormalizedPluginParameter(int32_t controlID, double value) { }

    virtual double getActualPluginParameter(int32_t controlID) { return 0.0; }

    virtual void setActualPluginParameter(int32_t controlID, double value) { }

    virtual void beginParameterChangeGesture(int controlTag){ }

    virtual void endParameterChangeGesture(int controlTag){ }
};


class IPluginHostConnector
{
public:
    virtual void sendHostMessage(const HostMessageInfo& hostMessageInfo) = 0;
};

class IMidiEventQueue
{
public:
    virtual uint32_t getEventCount() = 0;

    virtual bool fireMidiEvents(uint32_t uSampleOffset) = 0;
};


class IParameterUpdateQueue
{
public:
    virtual uint32_t getParameterIndex() = 0;

    virtual bool getValueAtOffset(long int _sampleOffset, double _previousValue, double& _nextValue) = 0;

    virtual bool getNextValue(double& _nextValue) = 0;
};

// --------------------------------------------------------------------------------------------------------------------------- //
// --- HELPER FUNCTIONS
// --------------------------------------------------------------------------------------------------------------------------- //
inline std::string numberToString(unsigned int number)
{
    std::ostringstream strm;
    strm << number;
    std::string str = strm.str();
    return str;
}

inline std::string numberToString(int number)
{
    std::ostringstream strm;
    strm << number;
    std::string str = strm.str();
    return str;
}

inline std::string numberToString(float number)
{
    std::ostringstream strm;
    strm << number;
    std::string str = strm.str();
    return str;
}

inline std::string numberToString(double number)
{
    std::ostringstream strm;
    strm << number;
    std::string str = strm.str();
    return str;
}

inline std::string boolToStdString(bool value)
{
    std::string returnString;
    if (value) returnString.assign("true");
    else returnString.assign("false");
    return returnString;
}


#endif //_pluginstructures_h