VCVRack
/
Rack
mirror of https://github.com/VCVRack/Rack.git
1
0
Fork 0
Code Issues 0 Releases 43 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.
1351 Commits
4 Branches
540MB
Tree: d22e99cd81
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd22e99cd81'
${ noResults }
Rack/plugins/community/repos/SynthKit/deps/rack-components/display.hpp

407 lines
8.1KB
Raw Blame History 

  1. #pragma once

  2. 

  3. #include <cstdint>

  4. 

  5. #include "asset.hpp"

  6. #include "rack.hpp"

  7. 

  8. using namespace rack;

  9. 

  10. #define plugin "SynthKit"

  11. 

  12. struct WaveSelect : TransparentWidget {

  13.   uint8_t *value;

  14.   std::shared_ptr<Font> font;

  15. 

  16. 	WaveSelect ( ) {

  17.     value = NULL;

  18.     font = Font::load(assetPlugin(plugin, "res/digit.ttf"));

  19.   }

  20. 

  21.   void draw (NVGcontext *vg) override {

  22.     nvgFontSize(vg, 8);

  23. 		nvgFontFaceId(vg, font->handle);

  24. 		nvgTextLetterSpacing(vg, 1);

  25. 

  26. 		nvgFillColor(vg, nvgRGBA(0x00, 0xff, 0x00, 0xff));

  27. 

  28.     if (value) {

  29.       switch (*value) {

  30.       case 0:

  31.         nvgText(vg, box.pos.x + 1, box.pos.y + 1, "SIN", NULL);

  32.         break;

  33.       case 1:

  34.         nvgText(vg, box.pos.x + 1, box.pos.y + 1, "TRI", NULL);

  35.         break;

  36.       case 2:

  37.         nvgText(vg, box.pos.x + 1, box.pos.y + 1, "SAW", NULL);

  38.         break;

  39.       case 3:

  40.         nvgText(vg, box.pos.x + 1, box.pos.y + 1, "SQR", NULL);

  41.         break;

  42.       default:

  43.         nvgText(vg, box.pos.x + 1, box.pos.y + 1, "ERR", NULL);

  44.         break;

  45.       }

  46.     } else {

  47.       nvgText(vg, box.pos.x + 1, box.pos.y + 1, "NUL", NULL);

  48.     }

  49.   }

  50. };

  51. 

  52. struct ValueDisplay : TransparentWidget {

  53.   float *value;

  54.   std::shared_ptr<Font> font;

  55. 

  56. 	ValueDisplay ( ) {

  57.     value = NULL;

  58.     font = Font::load(assetPlugin(plugin, "res/digit.ttf"));

  59.   }

  60. 

  61.   void draw (NVGcontext *vg) override {

  62.     char text[12];

  63.     nvgFontSize(vg, 8);

  64. 		nvgFontFaceId(vg, font->handle);

  65. 		nvgTextLetterSpacing(vg, 1);

  66. 

  67. 		nvgFillColor(vg, nvgRGBA(0x00, 0xff, 0x00, 0xff));

  68. 

  69.     if (value) {

  70.       sprintf(text, "%6.2f", *value);

  71.     } else {

  72.       sprintf(text, "ERROR");

  73.     }

  74. 

  75.     nvgText(vg, box.pos.x + 1, box.pos.y + 1, text, NULL);

  76.   }

  77. };

  78. 

  79. struct LEDDisplay : TransparentWidget {

  80.   float *value;

  81. 

  82. 	LEDDisplay ( ) {

  83.     value = NULL;

  84.   }

  85. 

  86.   void draw (NVGcontext *vg) override {

  87.     NVGcolor red = nvgRGBA(192, 0, 0, 255);

  88.     NVGcolor yellow = nvgRGBA(255, 192, 0, 255);

  89.     NVGcolor green = nvgRGBA(0, 192, 0, 255);

  90.     NVGcolor grey = nvgRGBA(64, 64, 64, 255);

  91.     float val = *value ? *value : 0.0f;

  92. 

  93.     nvgBeginPath(vg);

  94.     nvgRect(vg, 0, 0, 8, 8);

  95.     if (fabs(val) >= 4.5) {

  96.       nvgFillColor(vg, red);

  97.     } else {

  98.       nvgFillColor(vg, grey);

  99.     }

  100.     nvgFill(vg);

  101. 

  102. 

  103.     nvgBeginPath(vg);

  104.     nvgRect(vg, 0, 11, 8, 8);

  105.     if (fabs(val) >= 4.0) {

  106.       nvgFillColor(vg, yellow);

  107.     } else {

  108.       nvgFillColor(vg, grey);

  109.     }

  110.     nvgFill(vg);

  111. 

  112.     nvgBeginPath(vg);

  113.     nvgRect(vg, 0, 22, 8, 8);

  114.     if (fabs(val) >= 3.5) {

  115.       nvgFillColor(vg, yellow);

  116.     } else {

  117.       nvgFillColor(vg, grey);

  118.     }

  119.     nvgFill(vg);

  120. 

  121.     nvgBeginPath(vg);

  122.     nvgRect(vg, 0, 33, 8, 8);

  123.     if (fabs(val) >= 3.0) {

  124.       nvgFillColor(vg, green);

  125.     } else {

  126.       nvgFillColor(vg, grey);

  127.     }

  128.     nvgFill(vg);

  129. 

  130.     nvgBeginPath(vg);

  131.     nvgRect(vg, 0, 44, 8, 8);

  132.     if (fabs(val) >= 2.5) {

  133.       nvgFillColor(vg, green);

  134.     } else {

  135.       nvgFillColor(vg, grey);

  136.     }

  137.     nvgFill(vg);

  138. 

  139.     nvgBeginPath(vg);

  140.     nvgRect(vg, 0, 55, 8, 8);

  141.     if (fabs(val) >= 2.0) {

  142.       nvgFillColor(vg, green);

  143.     } else {

  144.       nvgFillColor(vg, grey);

  145.     }

  146.     nvgFill(vg);

  147. 

  148.     nvgBeginPath(vg);

  149.     nvgRect(vg, 0, 66, 8, 8);

  150.     if (fabs(val) >= 1.5) {

  151.       nvgFillColor(vg, green);

  152.     } else {

  153.       nvgFillColor(vg, grey);

  154.     }

  155.     nvgFill(vg);

  156. 

  157.     nvgBeginPath(vg);

  158.     nvgRect(vg, 0, 77, 8, 8);

  159.     if (fabs(val) >= 1.0) {

  160.       nvgFillColor(vg, green);

  161.     } else {

  162.       nvgFillColor(vg, grey);

  163.     }

  164.     nvgFill(vg);

  165. 

  166.     nvgBeginPath(vg);

  167.     nvgRect(vg, 0, 88, 8, 8);

  168.     if (fabs(val) >= 0.5) {

  169.       nvgFillColor(vg, green);

  170.     } else {

  171.       nvgFillColor(vg, grey);

  172.     }

  173.     nvgFill(vg);

  174. 

  175.     nvgBeginPath(vg);

  176.     nvgRect(vg, 0, 99, 8, 8);

  177.     if (fabs(val) > 0.0) {

  178.       nvgFillColor(vg, green);

  179.     } else {

  180.       nvgFillColor(vg, grey);

  181.     }

  182.     nvgFill(vg);

  183.   }

  184. };

  185. 

  186. struct LEDSmallDisplay : TransparentWidget {

  187.   float *value;

  188. 

  189. 	LEDSmallDisplay ( ) {

  190.     value = NULL;

  191.   }

  192. 

  193.   void draw (NVGcontext *vg) override {

  194.     NVGcolor red = nvgRGBA(192, 0, 0, 255);

  195.     NVGcolor yellow = nvgRGBA(255, 192, 0, 255);

  196.     NVGcolor green = nvgRGBA(0, 192, 0, 255);

  197.     NVGcolor grey = nvgRGBA(64, 64, 64, 255);

  198.     float val = *value ? *value : 0.0f;

  199. 

  200.     nvgBeginPath(vg);

  201.     nvgRect(vg, 0, 0, 8, 6);

  202.     if (fabs(val) >= 4.5) {

  203.       nvgFillColor(vg, red);

  204.     } else {

  205.       nvgFillColor(vg, grey);

  206.     }

  207.     nvgFill(vg);

  208. 

  209. 

  210.     nvgBeginPath(vg);

  211.     nvgRect(vg, 0, 8, 8, 6);

  212.     if (fabs(val) >= 4.0) {

  213.       nvgFillColor(vg, yellow);

  214.     } else {

  215.       nvgFillColor(vg, grey);

  216.     }

  217.     nvgFill(vg);

  218. 

  219.     nvgBeginPath(vg);

  220.     nvgRect(vg, 0, 16, 8, 6);

  221.     if (fabs(val) >= 3.5) {

  222.       nvgFillColor(vg, yellow);

  223.     } else {

  224.       nvgFillColor(vg, grey);

  225.     }

  226.     nvgFill(vg);

  227. 

  228.     nvgBeginPath(vg);

  229.     nvgRect(vg, 0, 24, 8, 6);

  230.     if (fabs(val) >= 3.0) {

  231.       nvgFillColor(vg, green);

  232.     } else {

  233.       nvgFillColor(vg, grey);

  234.     }

  235.     nvgFill(vg);

  236. 

  237.     nvgBeginPath(vg);

  238.     nvgRect(vg, 0, 32, 8, 6);

  239.     if (fabs(val) >= 2.5) {

  240.       nvgFillColor(vg, green);

  241.     } else {

  242.       nvgFillColor(vg, grey);

  243.     }

  244.     nvgFill(vg);

  245. 

  246.     nvgBeginPath(vg);

  247.     nvgRect(vg, 0, 40, 8, 6);

  248.     if (fabs(val) >= 2.0) {

  249.       nvgFillColor(vg, green);

  250.     } else {

  251.       nvgFillColor(vg, grey);

  252.     }

  253.     nvgFill(vg);

  254. 

  255.     nvgBeginPath(vg);

  256.     nvgRect(vg, 0, 48, 8, 6);

  257.     if (fabs(val) >= 1.5) {

  258.       nvgFillColor(vg, green);

  259.     } else {

  260.       nvgFillColor(vg, grey);

  261.     }

  262.     nvgFill(vg);

  263. 

  264.     nvgBeginPath(vg);

  265.     nvgRect(vg, 0, 56, 8, 6);

  266.     if (fabs(val) >= 1.0) {

  267.       nvgFillColor(vg, green);

  268.     } else {

  269.       nvgFillColor(vg, grey);

  270.     }

  271.     nvgFill(vg);

  272. 

  273.     nvgBeginPath(vg);

  274.     nvgRect(vg, 0, 64, 8, 6);

  275.     if (fabs(val) >= 0.5) {

  276.       nvgFillColor(vg, green);

  277.     } else {

  278.       nvgFillColor(vg, grey);

  279.     }

  280.     nvgFill(vg);

  281. 

  282.     nvgBeginPath(vg);

  283.     nvgRect(vg, 0, 72, 8, 6);

  284.     if (fabs(val) > 0.0) {

  285.       nvgFillColor(vg, green);

  286.     } else {

  287.       nvgFillColor(vg, grey);

  288.     }

  289.     nvgFill(vg);

  290.   }

  291. };

  292. 

  293. struct LEDWideDisplay : TransparentWidget {

  294.   float *value;

  295. 

  296. 	LEDWideDisplay ( ) {

  297.     value = NULL;

  298.   }

  299. 

  300.   void draw (NVGcontext *vg) override {

  301.     NVGcolor red = nvgRGBA(192, 0, 0, 255);

  302.     NVGcolor yellow = nvgRGBA(255, 192, 0, 255);

  303.     NVGcolor green = nvgRGBA(0, 192, 0, 255);

  304.     NVGcolor grey = nvgRGBA(64, 64, 64, 255);

  305.     float val = *value ? *value : 0.0f;

  306. 

  307.     nvgBeginPath(vg);

  308.     nvgRect(vg, 0, 0, 16, 8);

  309.     if (fabs(val) >= 4.5) {

  310.       nvgFillColor(vg, red);

  311.     } else {

  312.       nvgFillColor(vg, grey);

  313.     }

  314.     nvgFill(vg);

  315. 

  316. 

  317.     nvgBeginPath(vg);

  318.     nvgRect(vg, 0, 11, 16, 8);

  319.     if (fabs(val) >= 4.0) {

  320.       nvgFillColor(vg, yellow);

  321.     } else {

  322.       nvgFillColor(vg, grey);

  323.     }

  324.     nvgFill(vg);

  325. 

  326.     nvgBeginPath(vg);

  327.     nvgRect(vg, 0, 22, 16, 8);

  328.     if (fabs(val) >= 3.5) {

  329.       nvgFillColor(vg, yellow);

  330.     } else {

  331.       nvgFillColor(vg, grey);

  332.     }

  333.     nvgFill(vg);

  334. 

  335.     nvgBeginPath(vg);

  336.     nvgRect(vg, 0, 33, 16, 8);

  337.     if (fabs(val) >= 3.0) {

  338.       nvgFillColor(vg, green);

  339.     } else {

  340.       nvgFillColor(vg, grey);

  341.     }

  342.     nvgFill(vg);

  343. 

  344.     nvgBeginPath(vg);

  345.     nvgRect(vg, 0, 44, 16, 8);

  346.     if (fabs(val) >= 2.5) {

  347.       nvgFillColor(vg, green);

  348.     } else {

  349.       nvgFillColor(vg, grey);

  350.     }

  351.     nvgFill(vg);

  352. 

  353.     nvgBeginPath(vg);

  354.     nvgRect(vg, 0, 55, 16, 8);

  355.     if (fabs(val) >= 2.0) {

  356.       nvgFillColor(vg, green);

  357.     } else {

  358.       nvgFillColor(vg, grey);

  359.     }

  360.     nvgFill(vg);

  361. 

  362.     nvgBeginPath(vg);

  363.     nvgRect(vg, 0, 66, 16, 8);

  364.     if (fabs(val) >= 1.5) {

  365.       nvgFillColor(vg, green);

  366.     } else {

  367.       nvgFillColor(vg, grey);

  368.     }

  369.     nvgFill(vg);

  370. 

  371.     nvgBeginPath(vg);

  372.     nvgRect(vg, 0, 77, 16, 8);

  373.     if (fabs(val) >= 1.0) {

  374.       nvgFillColor(vg, green);

  375.     } else {

  376.       nvgFillColor(vg, grey);

  377.     }

  378.     nvgFill(vg);

  379. 

  380.     nvgBeginPath(vg);

  381.     nvgRect(vg, 0, 88, 16, 8);

  382.     if (fabs(val) >= 0.5) {

  383.       nvgFillColor(vg, green);

  384.     } else {

  385.       nvgFillColor(vg, grey);

  386.     }

  387.     nvgFill(vg);

  388. 

  389.     nvgBeginPath(vg);

  390.     nvgRect(vg, 0, 99, 16, 8);

  391.     if (fabs(val) > 0.0) {

  392.       nvgFillColor(vg, green);

  393.     } else {

  394.       nvgFillColor(vg, grey);

  395.     }

  396.     nvgFill(vg);

  397.   }

  398. };

  399. 

  400. template <typename BASE>

  401. struct ButtonLight : BASE {

  402. 	ButtonLight() {

  403. 	  //this->box.size = Vec(20.0, 20.0);

  404. 	  this->box.size = mm2px(Vec(6.0, 6.0));

  405. 	}

  406. };