synthlabds.h

Go to the documentation of this file.

#pragma once

#include "pluginstructures.h"
#include "../../examples/synthlab_examples/synthengine.h"


// --------------------------------------
//  --- OPTIONAL SynthLab SDK File --- // 
//  -------------------------------------
// -----------------------------------------------------------------------------


const uint32_t CUSTOM_OPTION_MENU = 131072;
const uint32_t CUSTOM_KNOB_LABEL = 131073;
const uint32_t CUSTOM_KNOB_LABEL_INDEX = 131074;
const uint32_t TOTAL_CUSTOM_VIEWS = 64;
const uint32_t CUSTOM_BITS = 31;


struct CustomViewInfo
{
    void clear()
    {
        droplistMask = 0;
        droplistControl_ASPiK = nullptr;
        droplistControl_RAFX = nullptr;
        modKnobMask = 0;
        controlStringCount = 0;

        for (uint32_t i = 0; i < 4; i++)
        {
            modKnobLabel_RAFX[i] = nullptr;
            modKnobLabel_ASPiK[i] = nullptr;
        }
    }

    // --- need to allow BOTH RackAFX and the custom GUI to store info here
    uint32_t droplistMask = 0;
    ICustomView* droplistControl_RAFX = nullptr;
    ICustomView* droplistControl_ASPiK = nullptr;
    moodycamel::ReaderWriterQueue<std::vector<std::string>, 2> droplistDataQueue;

    uint32_t modKnobMask = 0;
    ICustomView* modKnobLabel_RAFX[4] = { nullptr, nullptr, nullptr, nullptr };
    ICustomView* modKnobLabel_ASPiK[4] = { nullptr, nullptr, nullptr, nullptr };
    moodycamel::ReaderWriterQueue<std::string, 2> modKnobLabelDataQueue[4];

    // --- for drop-list type controls
    uint32_t controlStringCount = 0;
};

struct moduleAuxParamSet
{
    moduleAuxParamSet(uint32_t _attValCoreMenu, uint32_t _attValWaveMenu, uint32_t _attValModKnobs,
        uint32_t _coreMenuCtrlID, uint32_t _waveMenuCtrlID,
        uint32_t _modKnob_A_CtrlID, uint32_t _modKnob_B_CtrlID,
        uint32_t _modKnob_C_CtrlID, uint32_t _modKnob_D_CtrlID)
        : attValCoreMenu(_attValCoreMenu)
        , attValWaveMenu(_attValWaveMenu)
        , attValModKnobs(_attValModKnobs)
        , coreMenuCtrlID(_coreMenuCtrlID)
        , waveMenuCtrlID(_waveMenuCtrlID)
        , modKnob_A_CtrlID(_modKnob_A_CtrlID)
        , modKnob_B_CtrlID(_modKnob_B_CtrlID)
        , modKnob_C_CtrlID(_modKnob_C_CtrlID)
        , modKnob_D_CtrlID(_modKnob_D_CtrlID) {}

    uint32_t attValCoreMenu = SynthLab::LFO1_SOURCE;
    uint32_t attValWaveMenu = SynthLab::LFO1_WAVEFORMS;
    uint32_t attValModKnobs = SynthLab::LFO1_MOD_KNOBS;

    uint32_t coreMenuCtrlID = 0;
    uint32_t waveMenuCtrlID = 0;
    uint32_t modKnob_A_CtrlID = 0;
    uint32_t modKnob_B_CtrlID = 0;
    uint32_t modKnob_C_CtrlID = 0;
    uint32_t modKnob_D_CtrlID = 0;
};

class DynamicStringManager
{
public:
    DynamicStringManager(std::shared_ptr<SynthLab::SynthEngine> _synthEngine, void* _pluginCore);
    virtual ~DynamicStringManager() {}
    

    bool setCustomUpdateCodes(uint32_t customUpdateCode_1, uint32_t customUpdateCode_2);
    bool isCustomViewDataQueueEnabled() const { return queueEnabler.load(std::memory_order_relaxed); }          
    void enableCustomViewDataQueue(bool value) { queueEnabler.store(value, std::memory_order_relaxed); }    
    bool haveCustomUpdates() const { return updateEnabler.load(std::memory_order_relaxed); }            
    void enableCustomUpdates(bool value) { updateEnabler.store(value, std::memory_order_relaxed); } 
    bool updateCustomView(uint32_t slot);
    bool setModKnobLabelView(uint32_t controlID, ICustomView* modKnobLabelControl, bool isRAFXView);
    bool setCustomDroplistView(uint32_t controlID, ICustomView* _droplistControl, bool isRAFXView, bool isCoreList);

    inline std::vector<std::string> getModuleCoreNames(uint32_t moduleType)
    {
        std::vector<std::string> names = synthEngine->getModuleCoreNames(moduleType);
        return names;
    }

    inline void clearCustomViewInfo()
    {
        for (uint32_t i = 0; i < TOTAL_CUSTOM_VIEWS; i++)
        {
            customViewInfo[i].clear();
        }
    }

protected:
    std::shared_ptr<SynthLab::SynthEngine> synthEngine = nullptr;
    void* pluginCore = nullptr;
    uint32_t customUpdateCode_1 = 0.0;
    CustomViewInfo customViewInfo[TOTAL_CUSTOM_VIEWS]; 


    inline int32_t customUpdateCodeToIndex(uint32_t code, uint32_t mask, bool upper32)
    {
        if ((code & mask) == 0)
            return -1;

        int32_t tz = SynthLab::countTrailingZero(mask);
        if (upper32)
            return 31 + tz;

        return tz;
    }

    inline int32_t customUpdateMaskToIndex(uint32_t mask, bool upper32)
    {
        int32_t tz = SynthLab::countTrailingZero(mask);
        if (upper32)
            return 31 + tz;

        return tz;
    }


    // --- helpers to prevent memory-creep
    std::atomic<bool> queueEnabler;         
    std::atomic<bool> updateEnabler;        

    inline void enqueueCustomData(uint32_t index)
    {
        if (!isCustomViewDataQueueEnabled()) return;

        if (customViewInfo[index].droplistControl_RAFX || customViewInfo[index].droplistControl_ASPiK)
        {
            uint32_t droplistMask = customViewInfo[index].droplistMask;
            
            // peeking is not allowed from the producer side!
            // if(!customViewInfo[index].droplistDataQueue.peek())
            size_t queueSize = customViewInfo[index].droplistDataQueue.size_approx();
            if (queueSize == 0)
            {
                customViewInfo[index].droplistDataQueue.enqueue(synthEngine->getModuleStrings(droplistMask));
            }
        }
        else
        {
            uint32_t modKnobMask = customViewInfo[index].modKnobMask;
            std::vector<std::string> knobLabels = synthEngine->getModKnobStrings(modKnobMask);
            uint32_t numLabels = knobLabels.size();
            numLabels = fmin(numLabels, 4);
            for (int i = 0; i < numLabels; i++)
            {
            //  if (!customViewInfo[index].modKnobLabelDataQueue[i].peek())
                size_t queueSize = customViewInfo[index].modKnobLabelDataQueue[i].size_approx();
                if (queueSize == 0)
                {
                    customViewInfo[index].modKnobLabelDataQueue[i].enqueue(knobLabels[i]);
                }
            }
        }
    }

    inline bool getWaveformStrings(uint32_t index, std::vector<std::string>& strings)
    {
        if (!customViewInfo[index].droplistControl_RAFX && !customViewInfo[index].droplistControl_ASPiK)
        {
            return false;
        }

        bool success = customViewInfo[index].droplistDataQueue.try_dequeue(strings);

        // --- pop all
        while (customViewInfo[index].droplistDataQueue.try_dequeue(strings))
            /* NOOP */;

        return success;
    }

    inline bool getModKnobLabel(uint32_t slot, uint32_t index, std::string& string)
    {
        if (!customViewInfo[slot].modKnobLabel_RAFX[index] && !customViewInfo[slot].modKnobLabel_ASPiK[index])
            return false;

        bool success = customViewInfo[slot].modKnobLabelDataQueue[index].try_dequeue(string);

        // --- pop all
        while (customViewInfo[slot].modKnobLabelDataQueue[index].try_dequeue(string))
            /* NOOP */;

        return success;
    }

};