Module.hpp

Go to the documentation of this file.

#pragma once
#include <vector>
 
#include <jansson.h>
 
#include <common.hpp>
#include <string.hpp>
#include <plugin/Model.hpp>
#include <engine/Param.hpp>
#include <engine/Port.hpp>
#include <engine/Light.hpp>
#include <engine/ParamQuantity.hpp>
#include <engine/PortInfo.hpp>
#include <engine/LightInfo.hpp>
 
 
namespace rack {
 
 
namespace plugin {
struct Model;
}
 
 
namespace engine {
 
 
struct Module {
    struct Internal;
    Internal* internal;
 
    plugin::Model* model = NULL;
 
    int64_t id = -1;
 
    std::vector<Param> params;
    std::vector<Input> inputs;
    std::vector<Output> outputs;
    std::vector<Light> lights;
 
    std::vector<ParamQuantity*> paramQuantities;
    std::vector<PortInfo*> inputInfos;
    std::vector<PortInfo*> outputInfos;
    std::vector<LightInfo*> lightInfos;
 
    struct Expander {
        int64_t moduleId = -1;
        Module* module = NULL;
        void* producerMessage = NULL;
        void* consumerMessage = NULL;
        bool messageFlipRequested = false;
 
        void requestMessageFlip() {
            messageFlipRequested = true;
        }
    };
 
    Expander leftExpander;
    Expander rightExpander;
 
    struct BypassRoute {
        int inputId = -1;
        int outputId = -1;
    };
    std::vector<BypassRoute> bypassRoutes;
 
    Module();
    DEPRECATED Module(int numParams, int numInputs, int numOutputs, int numLights = 0) : Module() {
        config(numParams, numInputs, numOutputs, numLights);
    }
    virtual ~Module();
 
    void config(int numParams, int numInputs, int numOutputs, int numLights = 0);
 
    template <class TParamQuantity = ParamQuantity>
    TParamQuantity* configParam(int paramId, float minValue, float maxValue, float defaultValue, std::string name = "", std::string unit = "", float displayBase = 0.f, float displayMultiplier = 1.f, float displayOffset = 0.f) {
        assert(paramId < (int) params.size() && paramId < (int) paramQuantities.size());
        if (paramQuantities[paramId])
            delete paramQuantities[paramId];
 
        TParamQuantity* q = new TParamQuantity;
        q->ParamQuantity::module = this;
        q->ParamQuantity::paramId = paramId;
        q->ParamQuantity::minValue = minValue;
        q->ParamQuantity::maxValue = maxValue;
        q->ParamQuantity::defaultValue = defaultValue;
        q->ParamQuantity::name = name;
        q->ParamQuantity::unit = unit;
        q->ParamQuantity::displayBase = displayBase;
        q->ParamQuantity::displayMultiplier = displayMultiplier;
        q->ParamQuantity::displayOffset = displayOffset;
        paramQuantities[paramId] = q;
 
        Param* p = &params[paramId];
        p->value = q->getDefaultValue();
        return q;
    }
 
    template <class TSwitchQuantity = SwitchQuantity>
    TSwitchQuantity* configSwitch(int paramId, float minValue, float maxValue, float defaultValue, std::string name = "", std::vector<std::string> labels = {}) {
        TSwitchQuantity* sq = configParam<TSwitchQuantity>(paramId, minValue, maxValue, defaultValue, name);
        sq->ParamQuantity::snapEnabled = true;
        sq->ParamQuantity::smoothEnabled = false;
        sq->SwitchQuantity::labels = labels;
        return sq;
    }
 
    template <class TSwitchQuantity = SwitchQuantity>
    TSwitchQuantity* configButton(int paramId, std::string name = "") {
        TSwitchQuantity* sq = configParam<TSwitchQuantity>(paramId, 0.f, 1.f, 0.f, name);
        sq->ParamQuantity::snapEnabled = true;
        sq->ParamQuantity::smoothEnabled = false;
        sq->ParamQuantity::randomizeEnabled = false;
        return sq;
    }
 
    template <class TPortInfo = PortInfo>
    TPortInfo* configInput(int portId, std::string name = "") {
        assert(portId < (int) inputs.size() && portId < (int) inputInfos.size());
        if (inputInfos[portId])
            delete inputInfos[portId];
 
        TPortInfo* info = new TPortInfo;
        info->PortInfo::module = this;
        info->PortInfo::type = Port::INPUT;
        info->PortInfo::portId = portId;
        info->PortInfo::name = name;
        inputInfos[portId] = info;
        return info;
    }
 
    template <class TPortInfo = PortInfo>
    TPortInfo* configOutput(int portId, std::string name = "") {
        assert(portId < (int) outputs.size() && portId < (int) outputInfos.size());
        if (outputInfos[portId])
            delete outputInfos[portId];
 
        TPortInfo* info = new TPortInfo;
        info->PortInfo::module = this;
        info->PortInfo::type = Port::OUTPUT;
        info->PortInfo::portId = portId;
        info->PortInfo::name = name;
        outputInfos[portId] = info;
        return info;
    }
 
    template <class TLightInfo = LightInfo>
    TLightInfo* configLight(int lightId, std::string name = "") {
        assert(lightId < (int) lights.size() && lightId < (int) lightInfos.size());
        if (lightInfos[lightId])
            delete lightInfos[lightId];
 
        TLightInfo* info = new TLightInfo;
        info->LightInfo::module = this;
        info->LightInfo::lightId = lightId;
        info->LightInfo::name = name;
        lightInfos[lightId] = info;
        return info;
    }
 
    void configBypass(int inputId, int outputId) {
        assert(inputId < (int) inputs.size());
        assert(outputId < (int) outputs.size());
        // Check that output is not yet routed
        for (BypassRoute& br : bypassRoutes) {
            // Prevent unused variable warning for compilers that ignore assert()
            (void) br;
            assert(br.outputId != outputId);
        }
 
        BypassRoute br;
        br.inputId = inputId;
        br.outputId = outputId;
        bypassRoutes.push_back(br);
    }
 
    std::string createPatchStorageDirectory();
    std::string getPatchStorageDirectory();
 
    plugin::Model* getModel() {
        return model;
    }
    int64_t getId() {
        return id;
    }
    int getNumParams() {
        return params.size();
    }
    Param& getParam(int index) {
        return params[index];
    }
    int getNumInputs() {
        return inputs.size();
    }
    Input& getInput(int index) {
        return inputs[index];
    }
    int getNumOutputs() {
        return outputs.size();
    }
    Output& getOutput(int index) {
        return outputs[index];
    }
    int getNumLights() {
        return lights.size();
    }
    Light& getLight(int index) {
        return lights[index];
    }
    ParamQuantity* getParamQuantity(int index) {
        return paramQuantities[index];
    }
    PortInfo* getInputInfo(int index) {
        return inputInfos[index];
    }
    PortInfo* getOutputInfo(int index) {
        return outputInfos[index];
    }
    LightInfo* getLightInfo(int index) {
        return lightInfos[index];
    }
    Expander& getLeftExpander() {
        return leftExpander;
    }
    Expander& getRightExpander() {
        return rightExpander;
    }
    Expander& getExpander(uint8_t side) {
        return side ? rightExpander : leftExpander;
    }
 
    // Virtual methods
 
    struct ProcessArgs {
        float sampleRate;
        float sampleTime;
        int64_t frame;
    };
    virtual void process(const ProcessArgs& args) {
        step();
    }
 
    virtual void step() {}
 
    virtual void processBypass(const ProcessArgs& args);
 
    virtual json_t* toJson();
    virtual void fromJson(json_t* rootJ);
 
    virtual json_t* paramsToJson();
    virtual void paramsFromJson(json_t* rootJ);
 
    virtual json_t* dataToJson() {
        return NULL;
    }
    virtual void dataFromJson(json_t* rootJ) {}
 
    // Events
 
    // All of these events are thread-safe with process().
 
    struct AddEvent {};
    virtual void onAdd(const AddEvent& e) {
        // Call deprecated event method by default
        onAdd();
    }
 
    struct RemoveEvent {};
    virtual void onRemove(const RemoveEvent& e) {
        // Call deprecated event method by default
        onRemove();
    }
 
    struct BypassEvent {};
    virtual void onBypass(const BypassEvent& e) {}
 
    struct UnBypassEvent {};
    virtual void onUnBypass(const UnBypassEvent& e) {}
 
    struct PortChangeEvent {
        bool connecting;
        Port::Type type;
        int portId;
    };
    virtual void onPortChange(const PortChangeEvent& e) {}
 
    struct SampleRateChangeEvent {
        float sampleRate;
        float sampleTime;
    };
    virtual void onSampleRateChange(const SampleRateChangeEvent& e) {
        // Call deprecated event method by default
        onSampleRateChange();
    }
 
    struct ExpanderChangeEvent {
        uint8_t side;
    };
    virtual void onExpanderChange(const ExpanderChangeEvent& e) {}
 
    struct ResetEvent {};
    virtual void onReset(const ResetEvent& e);
 
    struct RandomizeEvent {};
    virtual void onRandomize(const RandomizeEvent& e);
 
    struct SaveEvent {};
    virtual void onSave(const SaveEvent& e) {}
 
    struct SetMasterEvent {};
    virtual void onSetMaster(const SetMasterEvent& e) {}
 
    struct UnsetMasterEvent {};
    virtual void onUnsetMaster(const UnsetMasterEvent& e) {}
 
    virtual void onAdd() {}
    virtual void onRemove() {}
    virtual void onReset() {}
    virtual void onRandomize() {}
    virtual void onSampleRateChange() {}
 
    bool isBypassed();
    PRIVATE void setBypassed(bool bypassed);
    PRIVATE const float* meterBuffer();
    PRIVATE int meterLength();
    PRIVATE int meterIndex();
    PRIVATE void doProcess(const ProcessArgs& args);
    PRIVATE static void jsonStripIds(json_t* rootJ);
    PRIVATE void setExpanderModule(Module* module, uint8_t side);
};
 
 
} // namespace engine
} // namespace rack