DISTRHO
/
Cardinal
mirror of https://github.com/DISTRHO/Cardinal.git
1
0
Fork 0
Code Issues 0 Releases 18 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1018 Commits
6 Branches
64MB
Tree: 4f2550df5c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '4f2550df5c'
${ noResults }
Cardinal/lv2export/includes/rack.hpp

1104 lines
31KB
Raw Blame History 

  1. /*

  2.  * DISTRHO Cardinal Plugin

  3.  * Copyright (C) 2021-2022 Filipe Coelho <falktx@falktx.com>

  4.  *

  5.  * This program is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU General Public License as

  7.  * published by the Free Software Foundation; either version 3 of

  8.  * the License, or any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the LICENSE file.

  16.  */

  17. 

  18. /**

  19.  * This file contains a substantial amount of code from VCVRack, adjusted for inline use

  20.  * Copyright (C) 2016-2021 VCV.

  21.  *

  22.  * This program is free software: you can redistribute it and/or

  23.  * modify it under the terms of the GNU General Public License as

  24.  * published by the Free Software Foundation; either version 3 of

  25.  * the License, or (at your option) any later version.

  26.  */

  27. 

  28. #pragma once

  29. 

  30. #include <cmath>

  31. #include <cstdlib>

  32. #include <cstring>

  33. 

  34. #include <algorithm>

  35. #include <list>

  36. #include <memory>

  37. #include <string>

  38. #include <vector>

  39. 

  40. struct NVGcolor { float a; };

  41. struct NVGpaint {};

  42. 

  43. inline NVGcolor nvgRGB(int r, int g, int b) { return {}; }

  44. inline NVGcolor nvgRGBA(int r, int g, int b, int a) { return {}; }

  45. inline NVGcolor nvgRGBf(float r, float g, float b) { return {}; }

  46. inline NVGcolor nvgRGBAf(float r, float g, float b, float a) { return {}; }

  47. inline void nvgBeginPath(void* vg) {}

  48. inline void nvgFillColor(void* vg, NVGcolor) {}

  49. inline void nvgFillPaint(void* vg, NVGpaint) {}

  50. inline void nvgFill(void* vg) {}

  51. inline void nvgStrokeColor(void* vg, NVGcolor) {}

  52. inline void nvgStrokeWidth(void* vg, float) {}

  53. inline void nvgStroke(void* vg) {}

  54. inline void nvgRect(void* vg, float a, float b, float c, float d) {}

  55. inline void nvgImageSize(void*, int, void*, void*) {}

  56. inline NVGpaint nvgImagePattern(void*, float, float, float, float, float, int handle, float) { return {}; }

  57. 

  58. struct json_t {};

  59. json_t* json_integer(int) { return NULL; }

  60. json_t* json_object() { return NULL; }

  61. json_t* json_object_get(json_t*, const char*) { return NULL; }

  62. int json_integer_value(json_t*) { return 0; }

  63. void json_object_set_new(json_t*, const char*, json_t*) {}

  64. 

  65. namespace rack {

  66. 

  67. struct Quantity {

  68.     virtual ~Quantity() {}

  69.     virtual void setValue(float value) {}

  70.     virtual float getValue() { return 0.f; }

  71.     virtual float getMinValue() { return 0.f; }

  72.     virtual float getMaxValue() { return 1.f; }

  73.     virtual float getDefaultValue() { return 0.f; }

  74. // 	virtual float getDisplayValue();

  75. // 	virtual void setDisplayValue(float displayValue);

  76. // 	virtual int getDisplayPrecision();

  77. // 	virtual std::string getDisplayValueString();

  78. // 	virtual void setDisplayValueString(std::string s);

  79.     virtual std::string getLabel() { return ""; }

  80.     virtual std::string getUnit() { return ""; }

  81. // 	virtual std::string getString();

  82. // 	virtual void reset();

  83. // 	virtual void randomize();

  84. // 	bool isMin();

  85. // 	bool isMax();

  86. // 	void setMin();

  87. // 	void setMax();

  88. // 	void toggle();

  89. // 	void moveValue(float deltaValue);

  90. // 	float getRange();

  91. // 	bool isBounded();

  92. // 	float toScaled(float value);

  93. // 	float fromScaled(float scaledValue);

  94. // 	void setScaledValue(float scaledValue);

  95. // 	float getScaledValue();

  96. // 	void moveScaledValue(float deltaScaledValue);

  97. };

  98. 

  99. namespace ui {

  100. struct Menu;

  101. }

  102. 

  103. namespace math {

  104. 

  105. inline int clamp(int x, int a, int b) {

  106.     return std::max(std::min(x, b), a);

  107. }

  108. 

  109. inline float clamp(float x, float a = 0.f, float b = 1.f) {

  110.     return std::fmax(std::fmin(x, b), a);

  111. }

  112. 

  113. struct Vec {

  114.     float x = 0.f;

  115.     float y = 0.f;

  116.     Vec() {}

  117.     Vec(float xy) : x(xy), y(xy) {}

  118.     Vec(float x, float y) : x(x), y(y) {}

  119.     Vec neg() const { return Vec(-x, -y); }

  120.     Vec plus(Vec b) const { return Vec(x + b.x, y + b.y); }

  121.     Vec minus(Vec b) const { return Vec(x - b.x, y - b.y); }

  122.     Vec mult(float s) const { return Vec(x * s, y * s); }

  123.     Vec mult(Vec b) const { return Vec(x * b.x, y * b.y); }

  124. };

  125. 

  126. struct Rect {

  127.     Vec pos;

  128.     Vec size;

  129. };

  130. 

  131. } // namespace math

  132. 

  133. namespace engine {

  134. 

  135. static constexpr const int PORT_MAX_CHANNELS = 16;

  136. 

  137. struct Module;

  138. 

  139. struct Engine {

  140.     float getSampleRate() { return sampleRate; }

  141.     // custom

  142.     float sampleRate = 0.f;

  143. };

  144. 

  145. struct Light {

  146.     float value = 0.f;

  147.     void setBrightness(float brightness) {

  148.         value = brightness;

  149.     }

  150.     float getBrightness() {

  151.         return value;

  152.     }

  153.     void setBrightnessSmooth(float brightness, float deltaTime, float lambda = 30.f) {

  154.         if (brightness < value) {

  155.             // Fade out light

  156.             value += (brightness - value) * lambda * deltaTime;

  157.         }

  158.         else {

  159.             // Immediately illuminate light

  160.             value = brightness;

  161.         }

  162.     }

  163.     void setSmoothBrightness(float brightness, float deltaTime) {

  164.         setBrightnessSmooth(brightness, deltaTime);

  165.     }

  166.     void setBrightnessSmooth(float brightness, int frames = 1) {

  167.         setBrightnessSmooth(brightness, frames / 44100.f);

  168.     }

  169. };

  170. 

  171. struct Param {

  172.     float value = 0.f;

  173.     float getValue() { return value; }

  174.     void setValue(float value) { this->value = value; }

  175. };

  176. 

  177. struct Port {

  178.     union {

  179.         float voltages[PORT_MAX_CHANNELS] = {};

  180.         float value;

  181.     };

  182.     union {

  183.         uint8_t channels = 0;

  184.         uint8_t active;

  185.     };

  186.     Light plugLights[3];

  187.     enum Type {

  188.         INPUT,

  189.         OUTPUT,

  190.     };

  191. 

  192.     void setVoltage(float voltage, int channel = 0) { voltages[channel] = voltage; }

  193.     float getVoltage(int channel = 0) { return voltages[channel]; }

  194.     float getPolyVoltage(int channel) { return isMonophonic() ? getVoltage(0) : getVoltage(channel); }

  195. 

  196.     float getNormalVoltage(float normalVoltage, int channel = 0) { return isConnected() ? getVoltage(channel) : normalVoltage; }

  197. 

  198.     float getNormalPolyVoltage(float normalVoltage, int channel) { return isConnected() ? getPolyVoltage(channel) : normalVoltage; }

  199. 

  200.     float* getVoltages(int firstChannel = 0) { return &voltages[firstChannel]; }

  201. 

  202.     void readVoltages(float* v) {

  203.         for (int c = 0; c < channels; c++) {

  204.             v[c] = voltages[c];

  205.         }

  206.     }

  207. 

  208.     void writeVoltages(const float* v) {

  209.         for (int c = 0; c < channels; c++) {

  210.             voltages[c] = v[c];

  211.         }

  212.     }

  213. 

  214.     void clearVoltages() {

  215.         for (int c = 0; c < channels; c++) {

  216.             voltages[c] = 0.f;

  217.         }

  218.     }

  219. 

  220.     float getVoltageSum() {

  221.         float sum = 0.f;

  222.         for (int c = 0; c < channels; c++) {

  223.             sum += voltages[c];

  224.         }

  225.         return sum;

  226.     }

  227. 

  228.     float getVoltageRMS() {

  229.         if (channels == 0) {

  230.             return 0.f;

  231.         }

  232.         else if (channels == 1) {

  233.             return std::fabs(voltages[0]);

  234.         }

  235.         else {

  236.             float sum = 0.f;

  237.             for (int c = 0; c < channels; c++) {

  238.                 sum += std::pow(voltages[c], 2);

  239.             }

  240.             return std::sqrt(sum);

  241.         }

  242.     }

  243. 

  244. //     template <typename T>

  245. //     T getVoltageSimd(int firstChannel) {

  246. //         return T::load(&voltages[firstChannel]);

  247. //     }

  248. // 

  249. //     template <typename T>

  250. //     T getPolyVoltageSimd(int firstChannel) {

  251. //         return isMonophonic() ? getVoltage(0) : getVoltageSimd<T>(firstChannel);

  252. //     }

  253. // 

  254. //     template <typename T>

  255. //     T getNormalVoltageSimd(T normalVoltage, int firstChannel) {

  256. //         return isConnected() ? getVoltageSimd<T>(firstChannel) : normalVoltage;

  257. //     }

  258. // 

  259. //     template <typename T>

  260. //     T getNormalPolyVoltageSimd(T normalVoltage, int firstChannel) {

  261. //         return isConnected() ? getPolyVoltageSimd<T>(firstChannel) : normalVoltage;

  262. //     }

  263. // 

  264. //     template <typename T>

  265. //     void setVoltageSimd(T voltage, int firstChannel) {

  266. //         voltage.store(&voltages[firstChannel]);

  267. //     }

  268. 

  269.     void setChannels(int channels) {

  270.         if (this->channels == 0) {

  271.             return;

  272.         }

  273.         for (int c = channels; c < this->channels; c++) {

  274.             voltages[c] = 0.f;

  275.         }

  276.         if (channels == 0) {

  277.             channels = 1;

  278.         }

  279.         this->channels = channels;

  280.     }

  281. 

  282.     int getChannels() { return channels; }

  283.     bool isConnected() { return channels > 0; }

  284.     bool isMonophonic() { return channels == 1; }

  285.     bool isPolyphonic() { return channels > 1; }

  286.     float normalize(float normalVoltage) { return getNormalVoltage(normalVoltage); }

  287. };

  288. 

  289. struct Output : Port {};

  290. 

  291. struct Input : Port {};

  292. 

  293. struct PortInfo {

  294.     Module* module = NULL;

  295.     Port::Type type = Port::INPUT;

  296.     int portId = -1;

  297.     std::string name;

  298.     std::string description;

  299.     virtual ~PortInfo() {}

  300.     virtual std::string getName() {

  301.         if (name == "")

  302.             return std::string("#") + std::to_string(portId + 1);

  303.         return name;

  304.     }

  305.     std::string getFullName() {

  306.         std::string name = getName();

  307.         name += " ";

  308.         name += (type == Port::INPUT) ? "input" : "output";

  309.         return name;

  310.     }

  311.     virtual std::string getDescription() { return description; }

  312. };

  313. 

  314. struct ParamQuantity : Quantity {

  315.     Module* module = NULL;

  316.     int paramId = -1;

  317.     float minValue = 0.f;

  318.     float maxValue = 1.f;

  319.     float defaultValue = 0.f;

  320.     std::string name;

  321.     std::string unit;

  322.     float displayBase = 0.f;

  323.     float displayMultiplier = 1.f;

  324.     float displayOffset = 0.f;

  325.     int displayPrecision = 5;

  326.     std::string description;

  327.     bool resetEnabled = true;

  328.     bool randomizeEnabled = true;

  329.     bool smoothEnabled = false;

  330.     bool snapEnabled = false;

  331. 

  332. //     Param* getParam();

  333. //     /** If smoothEnabled is true, requests to the engine to smoothly move to a target value each sample. */

  334. //     void setSmoothValue(float value);

  335. //     float getSmoothValue();

  336. 

  337. //     void setValue(float value) override;

  338. //     float getValue() override;

  339.     float getMinValue() override { return minValue; }

  340.     float getMaxValue() override { return maxValue; }

  341.     float getDefaultValue() override { return defaultValue; }

  342. //     float getDisplayValue() override;

  343. //     void setDisplayValue(float displayValue) override;

  344. //     std::string getDisplayValueString() override;

  345. //     void setDisplayValueString(std::string s) override;

  346. //     int getDisplayPrecision() override;

  347. //     std::string getLabel() override;

  348. //     std::string getUnit() override;

  349. //     void reset() override;

  350. //     void randomize() override;

  351. 

  352.     virtual std::string getDescription() { return description; }

  353. 

  354. //     virtual json_t* toJson();

  355. //     virtual void fromJson(json_t* rootJ);

  356. };

  357. 

  358. struct SwitchQuantity : ParamQuantity {

  359. //     std::vector<std::string> labels;

  360. //     std::string getDisplayValueString() override;

  361. //     void setDisplayValueString(std::string s) override;

  362. };

  363. 

  364. struct Module {

  365.     std::vector<Param> params;

  366.     std::vector<Input> inputs;

  367.     std::vector<Output> outputs;

  368.     std::vector<Light> lights;

  369.     std::vector<ParamQuantity*> paramQuantities;

  370.     std::vector<PortInfo*> inputInfos;

  371.     std::vector<PortInfo*> outputInfos;

  372. //     std::vector<LightInfo*> lightInfos;

  373. 

  374.     virtual ~Module() {

  375.         for (ParamQuantity* paramQuantity : paramQuantities) {

  376.             if (paramQuantity)

  377.                 delete paramQuantity;

  378.         }

  379.         for (PortInfo* inputInfo : inputInfos) {

  380.             if (inputInfo)

  381.                 delete inputInfo;

  382.         }

  383.         for (PortInfo* outputInfo : outputInfos) {

  384.             if (outputInfo)

  385.                 delete outputInfo;

  386.         }

  387. //         for (LightInfo* lightInfo : lightInfos) {

  388. //             if (lightInfo)

  389. //                 delete lightInfo;

  390. //         }

  391.     }

  392. 

  393.     void config(int numParams, int numInputs, int numOutputs, int numLights = 0) {

  394. //         // This method should only be called once.

  395. //         assert(params.empty() && inputs.empty() && outputs.empty() && lights.empty() && paramQuantities.empty());

  396.         params.resize(numParams);

  397.         inputs.resize(numInputs);

  398.         outputs.resize(numOutputs);

  399.         lights.resize(numLights);

  400.         paramQuantities.resize(numParams);

  401.         for (int i = 0; i < numParams; i++) {

  402.             configParam(i, 0.f, 1.f, 0.f);

  403.         }

  404.         inputInfos.resize(numInputs);

  405.         for (int i = 0; i < numInputs; i++) {

  406.             configInput(i);

  407.         }

  408.         outputInfos.resize(numOutputs);

  409.         for (int i = 0; i < numOutputs; i++) {

  410.             configOutput(i);

  411.         }

  412. //         lightInfos.resize(numLights);

  413.     } 

  414. 

  415.     template <class TParamQuantity = ParamQuantity>

  416.     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) {

  417. //         assert(paramId < (int) params.size() && paramId < (int) paramQuantities.size());

  418.         if (paramQuantities[paramId])

  419.             delete paramQuantities[paramId];

  420. 

  421.         TParamQuantity* q = new TParamQuantity;

  422.         q->ParamQuantity::module = this;

  423.         q->ParamQuantity::paramId = paramId;

  424.         q->ParamQuantity::minValue = minValue;

  425.         q->ParamQuantity::maxValue = maxValue;

  426.         q->ParamQuantity::defaultValue = defaultValue;

  427.         q->ParamQuantity::name = name;

  428.         q->ParamQuantity::unit = unit;

  429.         q->ParamQuantity::displayBase = displayBase;

  430.         q->ParamQuantity::displayMultiplier = displayMultiplier;

  431.         q->ParamQuantity::displayOffset = displayOffset;

  432.         paramQuantities[paramId] = q;

  433. 

  434.         Param* p = &params[paramId];

  435.         p->value = q->getDefaultValue();

  436.         return q;

  437.     }

  438. 

  439.     template <class TSwitchQuantity = SwitchQuantity>

  440.     TSwitchQuantity* configSwitch(int paramId, float minValue, float maxValue, float defaultValue, std::string name = "", std::vector<std::string> labels = {}) {

  441.         TSwitchQuantity* sq = configParam<TSwitchQuantity>(paramId, minValue, maxValue, defaultValue, name);

  442.         sq->labels = labels;

  443.         return sq;

  444.     }

  445. 

  446.     template <class TSwitchQuantity = SwitchQuantity>

  447.     TSwitchQuantity* configButton(int paramId, std::string name = "") {

  448.         TSwitchQuantity* sq = configParam<TSwitchQuantity>(paramId, 0.f, 1.f, 0.f, name);

  449.         sq->randomizeEnabled = false;

  450.         return sq;

  451.     }

  452. 

  453.     template <class TPortInfo = PortInfo>

  454.     TPortInfo* configInput(int portId, std::string name = "") {

  455. //         assert(portId < (int) inputs.size() && portId < (int) inputInfos.size());

  456.         if (inputInfos[portId])

  457.             delete inputInfos[portId];

  458. 

  459.         TPortInfo* info = new TPortInfo;

  460.         info->PortInfo::module = this;

  461.         info->PortInfo::type = Port::INPUT;

  462.         info->PortInfo::portId = portId;

  463.         info->PortInfo::name = name;

  464.         inputInfos[portId] = info;

  465.         return info;

  466.     }

  467. 

  468.     template <class TPortInfo = PortInfo>

  469.     TPortInfo* configOutput(int portId, std::string name = "") {

  470. //         assert(portId < (int) outputs.size() && portId < (int) outputInfos.size());

  471.         if (outputInfos[portId])

  472.             delete outputInfos[portId];

  473. 

  474.         TPortInfo* info = new TPortInfo;

  475.         info->PortInfo::module = this;

  476.         info->PortInfo::type = Port::OUTPUT;

  477.         info->PortInfo::portId = portId;

  478.         info->PortInfo::name = name;

  479.         outputInfos[portId] = info;

  480.         return info;

  481.     }

  482. 

  483. //     template <class TLightInfo = LightInfo>

  484. //     TLightInfo* configLight(int lightId, std::string name = "") {

  485. //         assert(lightId < (int) lights.size() && lightId < (int) lightInfos.size());

  486. //         if (lightInfos[lightId])

  487. //             delete lightInfos[lightId];

  488. // 

  489. //         TLightInfo* info = new TLightInfo;

  490. //         info->LightInfo::module = this;

  491. //         info->LightInfo::lightId = lightId;

  492. //         info->LightInfo::name = name;

  493. //         lightInfos[lightId] = info;

  494. //         return info;

  495. //     }

  496. 

  497.     void configBypass(int inputId, int outputId) {

  498. //         assert(inputId < (int) inputs.size());

  499. //         assert(outputId < (int) outputs.size());

  500. //         // Check that output is not yet routed

  501. //         for (BypassRoute& br : bypassRoutes) {

  502. //             assert(br.outputId != outputId);

  503. //         }

  504. // 

  505. //         BypassRoute br;

  506. //         br.inputId = inputId;

  507. //         br.outputId = outputId;

  508. //         bypassRoutes.push_back(br);

  509.     }

  510. 

  511.     int getNumParams() { return params.size(); }

  512.     Param& getParam(int index) { return params[index]; }

  513.     int getNumInputs() { return inputs.size(); }

  514.     Input& getInput(int index) { return inputs[index]; }

  515.     int getNumOutputs() { return outputs.size(); }

  516.     Output& getOutput(int index) { return outputs[index]; }

  517.     int getNumLights() { return lights.size(); }

  518.     Light& getLight(int index) { return lights[index]; }

  519.     ParamQuantity* getParamQuantity(int index) { return paramQuantities[index]; }

  520.     PortInfo* getInputInfo(int index) { return inputInfos[index]; }

  521.     PortInfo* getOutputInfo(int index) { return outputInfos[index]; }

  522. //     LightInfo* getLightInfo(int index) { return lightInfos[index]; }

  523. 

  524.     struct ProcessArgs {

  525.         float sampleRate;

  526.         float sampleTime;

  527.         int64_t frame;

  528.     };

  529.     virtual void process(const ProcessArgs& args) {

  530.         step();

  531.     }

  532.     virtual void step() {}

  533. 

  534.     // virtual void processBypass(const ProcessArgs& args);

  535. 

  536.     // virtual json_t* toJson();

  537.     // virtual void fromJson(json_t* rootJ);

  538. 

  539.     /** Serializes the "params" object. */

  540.     // virtual json_t* paramsToJson();

  541.     // virtual void paramsFromJson(json_t* rootJ);

  542. 

  543.     virtual json_t* dataToJson() { return NULL; }

  544.     virtual void dataFromJson(json_t* rootJ) {}

  545. 

  546.     struct SampleRateChangeEvent {

  547.         float sampleRate;

  548.         float sampleTime;

  549.     };

  550.     virtual void onSampleRateChange(const SampleRateChangeEvent& e) {

  551.         onSampleRateChange();

  552.     }

  553. 

  554.     struct ResetEvent {};

  555.     virtual void onReset(const ResetEvent& e) {} // TODO

  556. 

  557.     virtual void onAdd() {}

  558.     virtual void onRemove() {}

  559.     virtual void onReset() {}

  560.     virtual void onRandomize() {}

  561.     virtual void onSampleRateChange() {}

  562. 

  563.     // private

  564.     void doProcess(const ProcessArgs& args) {

  565. //         if (!internal->bypassed)

  566.             process(args);

  567. //         else

  568. //             processBypass(args);

  569.  

  570. //         if (args.frame % PORT_DIVIDER == 0) {

  571. //             float portTime = args.sampleTime * PORT_DIVIDER;

  572. //             for (Input& input : inputs) {

  573. //                 Port_step(&input, portTime);

  574. //             }

  575. //             for (Output& output : outputs) {

  576. //                 Port_step(&output, portTime);

  577. //             }

  578. //         }

  579.     }

  580. };

  581. 

  582. } // namespace engine

  583. 

  584. namespace widget {

  585. 

  586. struct BaseEvent {

  587. };

  588. 

  589. struct Widget {

  590.     math::Rect box;

  591.     Widget* parent = NULL;

  592.     std::list<Widget*> children;

  593.     bool visible = true;

  594.     bool requestedDelete = false;

  595. 

  596.     using BaseEvent = widget::BaseEvent;

  597. 

  598.     struct ActionEvent : BaseEvent {};

  599.     virtual void onAction(const ActionEvent& e) {}

  600. 

  601.     struct ChangeEvent : BaseEvent {};

  602.     virtual void onChange(const ChangeEvent& e) {}

  603. 

  604.     bool hasChild(Widget* child) { return false; }

  605.     void addChild(Widget* child) {}

  606.     void addChildBottom(Widget* child) {}

  607.     void addChildBelow(Widget* child, Widget* sibling) {}

  608.     void addChildAbove(Widget* child, Widget* sibling) {}

  609.     void removeChild(Widget* child) {}

  610.     void clearChildren() {}

  611.     virtual void step() {}

  612.     struct DrawArgs {

  613.         void* vg = NULL;

  614.         math::Rect clipBox;

  615.         void* fb = NULL;

  616.     };

  617. 	virtual void draw(const DrawArgs& args);

  618. };

  619. 

  620. struct OpaqueWidget : Widget {

  621. };

  622. 

  623. struct SvgWidget : Widget {

  624.     void wrap() {}

  625.     void setSvg(void* svg) {}

  626. };

  627. 

  628. struct TransparentWidget : Widget {

  629. };

  630. 

  631. } // namespace widget

  632. 

  633. namespace app {

  634. 

  635. static constexpr const float RACK_GRID_WIDTH = 15;

  636. static constexpr const float RACK_GRID_HEIGHT = 380;

  637. // static constexpr const math::Vec RACK_GRID_SIZE = math::Vec(RACK_GRID_WIDTH, RACK_GRID_HEIGHT);

  638. // static constexpr const math::Vec RACK_OFFSET = RACK_GRID_SIZE.mult(math::Vec(2000, 100));

  639. 

  640. struct CircularShadow : widget::TransparentWidget {

  641.     float blurRadius;

  642.     float opacity;

  643. };

  644. 

  645. struct LightWidget : widget::TransparentWidget {

  646.     NVGcolor bgColor, color, borderColor;

  647. };

  648. 

  649. struct ModuleWidget : widget::OpaqueWidget {

  650. //     plugin::Model* model = NULL;

  651.     engine::Module* module = NULL;

  652.     void setModel(void*) {}

  653.     void setModule(void*) {}

  654.     void setPanel(void*) {}

  655.     void addParam(void*) {}

  656.     void addInput(void*) {}

  657.     void addOutput(void*) {}

  658. 	virtual void appendContextMenu(ui::Menu* menu) {}

  659. };

  660. 

  661. struct MultiLightWidget : LightWidget {

  662. //     std::vector<NVGcolor> baseColors;

  663. //     int getNumColors();

  664.     void addBaseColor(NVGcolor baseColor) {}

  665. //     void setBrightnesses(const std::vector<float>& brightnesses);

  666. };

  667. 

  668. struct ModuleLightWidget : MultiLightWidget {

  669. //     engine::Module* module = NULL;

  670. //     int firstLightId = -1;

  671. //     ModuleLightWidget();

  672. //     ~ModuleLightWidget();

  673. //     engine::Light* getLight(int colorId);

  674. //     engine::LightInfo* getLightInfo();

  675. //     void createTooltip();

  676. //     void destroyTooltip();

  677. };

  678. 

  679. struct ParamWidget : widget::OpaqueWidget {

  680.     engine::Module* module = NULL;

  681.     int paramId = -1;

  682.     virtual void initParamQuantity() {}

  683.     engine::ParamQuantity* getParamQuantity() { return module ? module->paramQuantities[paramId] : NULL; }

  684.     void createTooltip() {}

  685.     void destroyTooltip() {}

  686.     void createContextMenu();

  687.     virtual void appendContextMenu(void* menu) {}

  688.     void resetAction();

  689. };

  690. 

  691. struct PortWidget : widget::OpaqueWidget {

  692. };

  693. 

  694. struct Knob : ParamWidget {

  695.     bool horizontal = false;

  696.     bool smooth = true;

  697.     bool snap = false;

  698.     float speed = 1.f;

  699.     bool forceLinear = false;

  700.     float minAngle = -M_PI;

  701.     float maxAngle = M_PI;

  702. };

  703. 

  704. struct SliderKnob : Knob {

  705. };

  706. 

  707. struct Switch : ParamWidget {

  708.     bool momentary = false;

  709. };

  710. 

  711. struct SvgKnob : Knob {

  712.     CircularShadow* shadow;

  713.     void setSvg(void* svg) {}

  714. };

  715. 

  716. struct SvgPanel : widget::Widget {

  717. //     widget::FramebufferWidget* fb;

  718. //     widget::SvgWidget* sw;

  719. //     PanelBorder* panelBorder;

  720.     void setBackground(void* svg) {}

  721. };

  722. 

  723. struct SvgPort : PortWidget {

  724. //     widget::FramebufferWidget* fb;

  725.     CircularShadow* shadow;

  726. //     widget::SvgWidget* sw;

  727.     void setSvg(void* svg) {}

  728. };

  729. 

  730. struct SvgScrew : widget::Widget {

  731. //     widget::FramebufferWidget* fb;

  732.     widget::SvgWidget* sw;

  733.     void setSvg(void* svg) {}

  734. };

  735. 

  736. struct SvgSlider : app::SliderKnob {

  737. //     widget::FramebufferWidget* fb;

  738.     widget::SvgWidget* background;

  739. //     widget::SvgWidget* handle;

  740.     math::Vec minHandlePos, maxHandlePos;

  741.     void setBackgroundSvg(void* svg) {}

  742.     void setHandleSvg(void* svg) {}

  743.     void setHandlePos(math::Vec minHandlePos, math::Vec maxHandlePos) {}

  744.     void setHandlePosCentered(math::Vec minHandlePosCentered, math::Vec maxHandlePosCentered) {}

  745. };

  746. 

  747. struct SvgSwitch : Switch {

  748. // 	widget::FramebufferWidget* fb;

  749. // 	CircularShadow* shadow;

  750. // 	widget::SvgWidget* sw;

  751. // 	std::vector<std::shared_ptr<window::Svg>> frames;

  752.     bool latch = false;

  753.     void addFrame(void* svg) {}

  754. };

  755. 

  756. } // namespace app

  757. 

  758. namespace asset {

  759. 

  760. const char* plugin(void* instance, const char* path) {

  761.     return NULL;

  762. }

  763. 

  764. } // namespace asset

  765. 

  766. namespace componentlibrary {

  767. 

  768. static constexpr const NVGcolor SCHEME_LIGHT_GRAY = {};

  769. 

  770. template <typename TBase = app::ModuleLightWidget>

  771. struct TSvgLight : TBase {

  772. //     widget::FramebufferWidget* fb;

  773. //     widget::SvgWidget* sw;

  774.     void setSvg(void* svg) {}

  775. };

  776. using SvgLight = TSvgLight<>;

  777. 

  778. template <typename TBase = app::ModuleLightWidget>

  779. struct TGrayModuleLightWidget : TBase {

  780. };

  781. using GrayModuleLightWidget = TGrayModuleLightWidget<>;

  782. 

  783. template <typename TBase = GrayModuleLightWidget>

  784. struct TWhiteLight : TBase {

  785. };

  786. using WhiteLight = TWhiteLight<>;

  787. 

  788. template <typename TBase = GrayModuleLightWidget>

  789. struct TRedLight : TBase {

  790. };

  791. using RedLight = TRedLight<>;

  792. 

  793. template <typename TBase = GrayModuleLightWidget>

  794. struct TGreenLight : TBase {

  795. };

  796. using GreenLight = TGreenLight<>;

  797. 

  798. template <typename TBase = GrayModuleLightWidget>

  799. struct TBlueLight : TBase {

  800. };

  801. using BlueLight = TBlueLight<>;

  802. 

  803. template <typename TBase = GrayModuleLightWidget>

  804. struct TYellowLight : TBase {

  805. };

  806. using YellowLight = TYellowLight<>;

  807. 

  808. template <typename TBase = GrayModuleLightWidget>

  809. struct TGreenRedLight : TBase {

  810. };

  811. using GreenRedLight = TGreenRedLight<>;

  812. 

  813. template <typename TBase = GrayModuleLightWidget>

  814. struct TRedGreenBlueLight : TBase {

  815. };

  816. using RedGreenBlueLight = TRedGreenBlueLight<>;

  817. 

  818. template <typename TBase>

  819. struct LargeLight : TSvgLight<TBase> {

  820. };

  821. 

  822. template <typename TBase>

  823. struct MediumLight : TSvgLight<TBase> {

  824. };

  825. 

  826. template <typename TBase>

  827. struct SmallLight : TSvgLight<TBase> {

  828. };

  829. 

  830. template <typename TBase>

  831. struct TinyLight : TSvgLight<TBase> {

  832. };

  833. 

  834. struct ScrewBlack : app::SvgScrew {

  835. };

  836. 

  837. } // namespace componentlibrary

  838. 

  839. namespace dsp {

  840.     

  841. inline float sinc(float x) {

  842.     if (x == 0.f)

  843.         return 1.f;

  844.     x *= M_PI;

  845.     return std::sin(x) / x;

  846. }

  847. 

  848. // template <typename T>

  849. // T sinc(T x) {

  850. //     T zeromask = (x == 0.f);

  851. //     x *= M_PI;

  852. //     x = simd::sin(x) / x;

  853. //     return simd::ifelse(zeromask, 1.f, x);

  854. // }

  855. 

  856. template <typename T>

  857. inline T blackmanHarris(T p) {

  858.     return

  859.       + T(0.35875)

  860.       - T(0.48829) * std::cos(2 * T(M_PI) * p)

  861.       + T(0.14128) * std::cos(4 * T(M_PI) * p)

  862.       - T(0.01168) * std::cos(6 * T(M_PI) * p);

  863. }

  864. 

  865. inline void blackmanHarrisWindow(float* x, int len) {

  866.     for (int i = 0; i < len; i++) {

  867.         x[i] *= blackmanHarris(float(i) / (len - 1));

  868.     }

  869. }

  870. 

  871. inline void boxcarLowpassIR(float* out, int len, float cutoff = 0.5f) {

  872.     for (int i = 0; i < len; i++) {

  873.         float t = i - (len - 1) / 2.f;

  874.         out[i] = 2 * cutoff * sinc(2 * cutoff * t);

  875.     }

  876. }

  877. 

  878. template <int OVERSAMPLE, int QUALITY, typename T = float>

  879. struct Decimator {

  880.     T inBuffer[OVERSAMPLE * QUALITY];

  881.     float kernel[OVERSAMPLE * QUALITY];

  882.     int inIndex;

  883.     Decimator(float cutoff = 0.9f) {

  884.         boxcarLowpassIR(kernel, OVERSAMPLE * QUALITY, cutoff * 0.5f / OVERSAMPLE);

  885.         blackmanHarrisWindow(kernel, OVERSAMPLE * QUALITY);

  886.         reset();

  887.     }

  888.     void reset() {

  889.         inIndex = 0;

  890.         std::memset(inBuffer, 0, sizeof(inBuffer));

  891.     }

  892.     T process(T* in) {

  893.         std::memcpy(&inBuffer[inIndex], in, OVERSAMPLE * sizeof(T));

  894.         inIndex += OVERSAMPLE;

  895.         inIndex %= OVERSAMPLE * QUALITY;

  896.         T out = 0.f;

  897.         for (int i = 0; i < OVERSAMPLE * QUALITY; i++) {

  898.             int index = inIndex - 1 - i;

  899.             index = (index + OVERSAMPLE * QUALITY) % (OVERSAMPLE * QUALITY);

  900.             out += kernel[i] * inBuffer[index];

  901.         }

  902.         return out;

  903.     }

  904. };

  905. 

  906. struct PulseGenerator {

  907.     float remaining = 0.f;

  908.     void reset() { remaining = 0.f; }

  909.     bool process(float deltaTime) {

  910.         if (remaining > 0.f) {

  911.             remaining -= deltaTime;

  912.             return true;

  913.         }

  914.         return false;

  915.     }

  916.     void trigger(float duration = 1e-3f) {

  917.         if (duration > remaining) {

  918.             remaining = duration;

  919.         }

  920.     }

  921. };

  922. 

  923. } // namespace dsp

  924. 

  925. namespace event {

  926. // using Base = widget::BaseEvent;

  927. // using PositionBase = widget::Widget::PositionBaseEvent;

  928. // using KeyBase = widget::Widget::KeyBaseEvent;

  929. // using TextBase = widget::Widget::TextBaseEvent;

  930. // using Hover = widget::Widget::HoverEvent;

  931. // using Button = widget::Widget::ButtonEvent;

  932. // using DoubleClick = widget::Widget::DoubleClickEvent;

  933. // using HoverKey = widget::Widget::HoverKeyEvent;

  934. // using HoverText = widget::Widget::HoverTextEvent;

  935. // using HoverScroll = widget::Widget::HoverScrollEvent;

  936. // using Enter = widget::Widget::EnterEvent;

  937. // using Leave = widget::Widget::LeaveEvent;

  938. // using Select = widget::Widget::SelectEvent;

  939. // using Deselect = widget::Widget::DeselectEvent;

  940. // using SelectKey = widget::Widget::SelectKeyEvent;

  941. // using SelectText = widget::Widget::SelectTextEvent;

  942. // using DragBase = widget::Widget::DragBaseEvent;

  943. // using DragStart = widget::Widget::DragStartEvent;

  944. // using DragEnd = widget::Widget::DragEndEvent;

  945. // using DragMove = widget::Widget::DragMoveEvent;

  946. // using DragHover = widget::Widget::DragHoverEvent;

  947. // using DragEnter = widget::Widget::DragEnterEvent;

  948. // using DragLeave = widget::Widget::DragLeaveEvent;

  949. // using DragDrop = widget::Widget::DragDropEvent;

  950. // using PathDrop = widget::Widget::PathDropEvent;

  951. using Action = widget::Widget::ActionEvent;

  952. using Change = widget::Widget::ChangeEvent;

  953. // using Dirty = widget::Widget::DirtyEvent;

  954. // using Reposition = widget::Widget::RepositionEvent;

  955. // using Resize = widget::Widget::ResizeEvent;

  956. // using Add = widget::Widget::AddEvent;

  957. // using Remove = widget::Widget::RemoveEvent;

  958. // using Show = widget::Widget::ShowEvent;

  959. // using Hide = widget::Widget::HideEvent;

  960. } // namespace event

  961. 

  962. namespace plugin {

  963. 

  964. struct Model {

  965.     virtual ~Model() {}

  966.     virtual engine::Module* createModule() = 0;

  967. };

  968. 

  969. struct Plugin {

  970. };

  971. 

  972. } // namespace plugin

  973. 

  974. namespace ui {

  975. 

  976. struct Menu : widget::OpaqueWidget {

  977. //     Menu* parentMenu = NULL;

  978. //     Menu* childMenu = NULL;

  979. //     MenuEntry* activeEntry = NULL;

  980. //     BNDcornerFlags cornerFlags = BND_CORNER_NONE;

  981. //     void setChildMenu(Menu* menu) {}

  982. };

  983. 

  984. struct MenuEntry : widget::OpaqueWidget {

  985. };

  986. 

  987. struct MenuItem : MenuEntry {

  988.     std::string text;

  989.     std::string rightText;

  990.     bool disabled = false;

  991. };

  992. 

  993. struct MenuLabel : MenuEntry {

  994.     std::string text;

  995. };

  996. 

  997. } // namespace ui

  998. 

  999. namespace window {

  1000. 

  1001. static constexpr const float SVG_DPI = 75.f;

  1002. static constexpr const float MM_PER_IN = 25.4f;

  1003. 

  1004. inline float in2px(float in) { return in * SVG_DPI; }

  1005. inline math::Vec in2px(math::Vec in) { return in.mult(SVG_DPI); }

  1006. inline float mm2px(float mm) { return mm * (SVG_DPI / MM_PER_IN); }

  1007. inline math::Vec mm2px(math::Vec mm) { return mm.mult(SVG_DPI / MM_PER_IN); }

  1008. 

  1009. struct Image {

  1010.     int handle;

  1011. };

  1012. 

  1013. struct Window {

  1014.     std::shared_ptr<Image> loadImage(const std::string&) { return {}; }

  1015.     void* loadSvg(const void*) { return NULL; }

  1016. };

  1017. 

  1018. };

  1019. 

  1020. using namespace app;

  1021. using namespace componentlibrary;

  1022. using namespace engine;

  1023. using namespace math;

  1024. using namespace ui;

  1025. using namespace widget;

  1026. using namespace window;

  1027. using plugin::Plugin;

  1028. using plugin::Model;

  1029. 

  1030. template <class TModule, class TModuleWidget>

  1031. plugin::Model* createModel(std::string slug) {

  1032.     struct TModel : plugin::Model {

  1033.         engine::Module* createModule() override {

  1034.             return new TModule;

  1035.         }

  1036.     };

  1037.     return new TModel;

  1038. }

  1039. 

  1040. template <typename T>

  1041. T* construct() { return NULL; }

  1042. 

  1043. template <typename T, typename F, typename V, typename... Args>

  1044. T* construct(F f, V v, Args... args) { return NULL; }

  1045. 

  1046. template <class TWidget>

  1047. TWidget* createWidget(math::Vec pos) {

  1048.     return NULL;

  1049. }

  1050. 

  1051. template <class TParamWidget>

  1052. TParamWidget* createParam(math::Vec pos, engine::Module* module, int paramId) {

  1053.     return NULL;

  1054. }

  1055. 

  1056. template <class TParamWidget>

  1057. TParamWidget* createParamCentered(math::Vec pos, engine::Module* module, int paramId) {

  1058.     return NULL;

  1059. }

  1060. 

  1061. template <class TPortWidget>

  1062. TPortWidget* createInput(math::Vec pos, engine::Module* module, int inputId) {

  1063.     return NULL;

  1064. }

  1065. 

  1066. template <class TPortWidget>

  1067. TPortWidget* createInputCentered(math::Vec pos, engine::Module* module, int inputId) {

  1068.     return NULL;

  1069. }

  1070. 

  1071. template <class TPortWidget>

  1072. TPortWidget* createOutput(math::Vec pos, engine::Module* module, int outputId) {

  1073.     return NULL;

  1074. }

  1075. 

  1076. template <class TPortWidget>

  1077. TPortWidget* createOutputCentered(math::Vec pos, engine::Module* module, int outputId) {

  1078.     return NULL;

  1079. }

  1080. 

  1081. template <class TModuleLightWidget>

  1082. TModuleLightWidget* createLight(math::Vec pos, engine::Module* module, int firstLightId) {

  1083.     return NULL;

  1084. }

  1085. 

  1086. template <class TModuleLightWidget>

  1087. TModuleLightWidget* createLightCentered(math::Vec pos, engine::Module* module, int firstLightId) {

  1088.     return NULL;

  1089. }

  1090. 

  1091. struct Context {

  1092.     engine::Engine _engine;

  1093.     window::Window _window;

  1094.     engine::Engine* engine = &_engine;

  1095.     window::Window* window = &_window;

  1096. };

  1097. 

  1098. Context* contextGet();

  1099. void contextSet(Context* context);

  1100. 

  1101. } // namespace rack

  1102. 

  1103. #define APP rack::contextGet()