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.
1018 Commits
4 Branches
544MB
Tree: d1398ead8f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd1398ead8f'
${ noResults }
Rack/plugins/community/repos/dBiz/src/Utility.cpp

443 lines
12KB
Raw Blame History 

  1. ///////////////////////////////////////////////////

  2. //  dBiz Utility

  3. // 

  4. ///////////////////////////////////////////////////

  5. 

  6. #include "dBiz.hpp"

  7. #include <ctime>

  8. #include <iostream>

  9. #include <vector>

  10. #include <random>

  11. #include <algorithm>

  12. 

  13. using namespace std;

  14. 

  15. namespace rack_plugin_dBiz {

  16. 

  17. /////added fine out /////////////////////////////////////////////////

  18. struct Utility : Module {

  19.   enum ParamIds

  20.   {

  21.     LINK_A_PARAM,

  22.     LINK_B_PARAM,

  23.     ROOT_NOTE_PARAM,

  24.     SCALE_PARAM,

  25.     OCTAVE_SHIFT,

  26.     SEMITONE_SHIFT = OCTAVE_SHIFT + 3,

  27.     FINE_SHIFT = SEMITONE_SHIFT + 3,

  28.     AMOUNT_PARAM = FINE_SHIFT + 3,

  29.     NUM_PARAMS = AMOUNT_PARAM + 3

  30.   };

  31.   enum InputIds {

  32.     ROOT_NOTE_INPUT,

  33.     SCALE_INPUT,

  34. 	OCTAVE_INPUT,

  35.     OCTAVE_CVINPUT=OCTAVE_INPUT+3,

  36.     SEMITONE_CVINPUT=OCTAVE_CVINPUT+3,

  37.     FINE_CVINPUT=SEMITONE_CVINPUT+3,

  38.     AMOUNT_CVINPUT=FINE_CVINPUT+3,

  39.     NUM_INPUTS=AMOUNT_CVINPUT+3

  40. 	};

  41. 	enum OutputIds {

  42. 	A_OUTPUT,

  43.     B_OUTPUT,

  44.     C_OUTPUT,

  45.     NUM_OUTPUTS

  46. };

  47. 

  48.     enum LighIds {

  49.         AMOUNT_LIGHT,

  50.         NUM_LIGHTS=AMOUNT_LIGHT+3

  51.     };

  52. 

  53. 

  54.   //copied & fixed these scales http://www.grantmuller.com/MidiReference/doc/midiReference/ScaleReference.html

  55. 	int SCALE_AEOLIAN        [7] = {0, 2, 3, 5, 7, 8, 10};

  56. 	int SCALE_BLUES          [6] = {0, 3, 5, 6, 7, 10}; //FIXED!

  57. 	int SCALE_CHROMATIC      [12]= {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};

  58. 	int SCALE_DIATONIC_MINOR [7] = {0, 2, 3, 5, 7, 8, 10};

  59. 	int SCALE_DORIAN         [7] = {0, 2, 3, 5, 7, 9, 10};

  60. 	int SCALE_HARMONIC_MINOR [7] = {0, 2, 3, 5, 7, 8, 11};

  61. 	int SCALE_INDIAN         [7] = {0, 1, 1, 4, 5, 8, 10};

  62. 	int SCALE_LOCRIAN        [7] = {0, 1, 3, 5, 6, 8, 10};

  63. 	int SCALE_LYDIAN         [7] = {0, 2, 4, 6, 7, 9, 10};

  64. 	int SCALE_MAJOR          [7] = {0, 2, 4, 5, 7, 9, 11};

  65. 	int SCALE_MELODIC_MINOR  [9] = {0, 2, 3, 5, 7, 8, 9, 10, 11};

  66. 	int SCALE_MINOR          [7] = {0, 2, 3, 5, 7, 8, 10};

  67. 	int SCALE_MIXOLYDIAN     [7] = {0, 2, 4, 5, 7, 9, 10};

  68. 	int SCALE_NATURAL_MINOR  [7] = {0, 2, 3, 5, 7, 8, 10};

  69. 	int SCALE_PENTATONIC     [5] = {0, 2, 4, 7, 9};

  70. 	int SCALE_PHRYGIAN       [7] = {0, 1, 3, 5, 7, 8, 10};

  71. 	int SCALE_TURKISH        [7] = {0, 1, 3, 5, 7, 10, 11};

  72. 

  73.   enum Notes

  74.   {

  75.     NOTE_C,

  76.     NOTE_C_SHARP,

  77.     NOTE_D,

  78.     NOTE_D_SHARP,

  79.     NOTE_E,

  80.     NOTE_F,

  81.     NOTE_F_SHARP,

  82.     NOTE_G,

  83.     NOTE_G_SHARP,

  84.     NOTE_A,

  85.     NOTE_A_SHARP,

  86.     NOTE_B,

  87.     NUM_NOTES

  88.   };

  89. 

  90.   enum Scales

  91.   {

  92.     AEOLIAN,

  93.     BLUES,

  94.     CHROMATIC,

  95.     DIATONIC_MINOR,

  96.     DORIAN,

  97.     HARMONIC_MINOR,

  98.     INDIAN,

  99.     LOCRIAN,

  100.     LYDIAN,

  101.     MAJOR,

  102.     MELODIC_MINOR,

  103.     MINOR,

  104.     MIXOLYDIAN,

  105.     NATURAL_MINOR,

  106.     PENTATONIC,

  107.     PHRYGIAN,

  108.     TURKISH,

  109.     NONE,

  110.     NUM_SCALES

  111.   };

  112. 

  113.   int rootNote = 0;

  114.   int curScaleVal = 0;

  115.   float octave_out[3] {};

  116.   float semitone_out[3] {};

  117.   float fine_out[3] {};

  118.   

  119. 

  120.   Utility() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {}

  121. 

  122. 

  123.   void step() override;

  124. 

  125.   

  126.   

  127. // Quantization based on JW quantizer module!!!

  128. 

  129.   float closestVoltageInScale(float voltsIn)

  130.   {

  131.     rootNote = params[ROOT_NOTE_PARAM].value + rescale(inputs[ROOT_NOTE_INPUT].value, 0,10,0, Utility::NUM_NOTES - 1);

  132.     curScaleVal = params[SCALE_PARAM].value + rescale(inputs[SCALE_INPUT].value, 0,10,0, Utility::NUM_SCALES - 1);

  133.     int *curScaleArr;

  134.     int notesInScale = 0;

  135.     switch (curScaleVal)

  136.     {

  137.     case AEOLIAN:

  138.       curScaleArr = SCALE_AEOLIAN;

  139.       notesInScale = LENGTHOF(SCALE_AEOLIAN);

  140.       break;

  141.     case BLUES:

  142.       curScaleArr = SCALE_BLUES;

  143.       notesInScale = LENGTHOF(SCALE_BLUES);

  144.       break;

  145.     case CHROMATIC:

  146.       curScaleArr = SCALE_CHROMATIC;

  147.       notesInScale = LENGTHOF(SCALE_CHROMATIC);

  148.       break;

  149.     case DIATONIC_MINOR:

  150.       curScaleArr = SCALE_DIATONIC_MINOR;

  151.       notesInScale = LENGTHOF(SCALE_DIATONIC_MINOR);

  152.       break;

  153.     case DORIAN:

  154.       curScaleArr = SCALE_DORIAN;

  155.       notesInScale = LENGTHOF(SCALE_DORIAN);

  156.       break;

  157.     case HARMONIC_MINOR:

  158.       curScaleArr = SCALE_HARMONIC_MINOR;

  159.       notesInScale = LENGTHOF(SCALE_HARMONIC_MINOR);

  160.       break;

  161.     case INDIAN:

  162.       curScaleArr = SCALE_INDIAN;

  163.       notesInScale = LENGTHOF(SCALE_INDIAN);

  164.       break;

  165.     case LOCRIAN:

  166.       curScaleArr = SCALE_LOCRIAN;

  167.       notesInScale = LENGTHOF(SCALE_LOCRIAN);

  168.       break;

  169.     case LYDIAN:

  170.       curScaleArr = SCALE_LYDIAN;

  171.       notesInScale = LENGTHOF(SCALE_LYDIAN);

  172.       break;

  173.     case MAJOR:

  174.       curScaleArr = SCALE_MAJOR;

  175.       notesInScale = LENGTHOF(SCALE_MAJOR);

  176.       break;

  177.     case MELODIC_MINOR:

  178.       curScaleArr = SCALE_MELODIC_MINOR;

  179.       notesInScale = LENGTHOF(SCALE_MELODIC_MINOR);

  180.       break;

  181.     case MINOR:

  182.       curScaleArr = SCALE_MINOR;

  183.       notesInScale = LENGTHOF(SCALE_MINOR);

  184.       break;

  185.     case MIXOLYDIAN:

  186.       curScaleArr = SCALE_MIXOLYDIAN;

  187.       notesInScale = LENGTHOF(SCALE_MIXOLYDIAN);

  188.       break;

  189.     case NATURAL_MINOR:

  190.       curScaleArr = SCALE_NATURAL_MINOR;

  191.       notesInScale = LENGTHOF(SCALE_NATURAL_MINOR);

  192.       break;

  193.     case PENTATONIC:

  194.       curScaleArr = SCALE_PENTATONIC;

  195.       notesInScale = LENGTHOF(SCALE_PENTATONIC);

  196.       break;

  197.     case PHRYGIAN:

  198.       curScaleArr = SCALE_PHRYGIAN;

  199.       notesInScale = LENGTHOF(SCALE_PHRYGIAN);

  200.       break;

  201.     case TURKISH:

  202.       curScaleArr = SCALE_TURKISH;

  203.       notesInScale = LENGTHOF(SCALE_TURKISH);

  204.       break;

  205.     case NONE:

  206.       return voltsIn;

  207.     }

  208. 

  209.     float closestVal = 10.0;

  210.     float closestDist = 10.0;

  211.     float scaleNoteInVolts = 0;

  212.     float distAway = 0;

  213.     int octaveInVolts = int(floorf(voltsIn));

  214.     float voltMinusOct = voltsIn - octaveInVolts;

  215.     		for (int i=0; i < notesInScale; i++) {

  216. 			scaleNoteInVolts = curScaleArr[i] / 12.0;

  217. 			distAway = fabs(voltMinusOct - scaleNoteInVolts);

  218. 			if(distAway < closestDist){

  219. 				closestVal = scaleNoteInVolts;

  220. 				closestDist = distAway;

  221. 			}

  222.     }

  223.     return octaveInVolts + rootNote/12.0 + closestVal;

  224.   }

  225.   

  226. };

  227. 

  228. 

  229. 

  230. 

  231. /////////////////////////////////////////////////////

  232. void Utility::step() {

  233. 

  234. if(params[LINK_A_PARAM].value ==1.0 )

  235.   inputs[OCTAVE_INPUT + 1].value = inputs[OCTAVE_INPUT + 0].value;

  236. 

  237. if (params[LINK_B_PARAM].value == 1.0)

  238.   inputs[OCTAVE_INPUT + 2].value = inputs[OCTAVE_INPUT + 1].value;

  239. 

  240. for (int i = 0; i < 3; i++)

  241. {

  242.   octave_out[i] = inputs[OCTAVE_INPUT + i].value + round(params[OCTAVE_SHIFT + i].value) + round(inputs[OCTAVE_CVINPUT + i].value / 2);

  243.   semitone_out[i] = octave_out[i] + round(params[SEMITONE_SHIFT + i].value) * (1.0 / 12.0) + round(inputs[SEMITONE_CVINPUT + i].value / 2) * (1.0 / 12.0);

  244.   fine_out[i] = semitone_out[i] + (params[FINE_SHIFT + i].value) * (1.0 / 12.0) + (inputs[FINE_CVINPUT + i].value / 2) * (1.0 / 2.0);

  245.     }

  246. 

  247.     float out_a = closestVoltageInScale(fine_out[0]);

  248.     float out_b = closestVoltageInScale(fine_out[1]);

  249.     float out_c = closestVoltageInScale(fine_out[2]);

  250. 

  251.     outputs[A_OUTPUT].value = out_a;

  252.     outputs[B_OUTPUT].value = out_b;

  253.     outputs[C_OUTPUT].value = out_c;

  254. 

  255. }

  256. 

  257. 

  258. struct UtilityDisplay : TransparentWidget

  259. {

  260.   Utility *module;

  261.   int frame = 0;

  262.   shared_ptr<Font> font;

  263. 

  264.   string note, scale;

  265. 

  266.   UtilityDisplay()

  267.   {

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

  269.   }

  270. 

  271.   void drawMessage(NVGcontext *vg, Vec pos, string note,string scale)

  272.   {

  273.     nvgFontSize(vg, 18);

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

  275.     nvgTextLetterSpacing(vg, -2);

  276.     nvgFillColor(vg, nvgRGBA(75, 199, 75, 0xff));

  277.     nvgFontSize(vg, 14);

  278.     nvgFillColor(vg, nvgRGBA(0xff, 0xff, 0xff, 0xff));

  279.     nvgText(vg, pos.x + 8, pos.y + 23, note.c_str(), NULL);

  280.     nvgText(vg, pos.x + 30, pos.y + 23, scale.c_str(), NULL);

  281.   

  282.   }

  283. 

  284.   string displayRootNote(int value)

  285.   {

  286.     switch (value)

  287.     {

  288.     case Utility::NOTE_C:

  289.       return "C";

  290.     case Utility::NOTE_C_SHARP:

  291.       return "C#";

  292.     case Utility::NOTE_D:

  293.       return "D";

  294.     case Utility::NOTE_D_SHARP:

  295.       return "D#";

  296.     case Utility::NOTE_E:

  297.       return "E";

  298.     case Utility::NOTE_F:

  299.       return "F";

  300.     case Utility::NOTE_F_SHARP:

  301.       return "F#";

  302.     case Utility::NOTE_G:

  303.       return "G";

  304.     case Utility::NOTE_G_SHARP:

  305.       return "G#";

  306.     case Utility::NOTE_A:

  307.       return "A";

  308.     case Utility::NOTE_A_SHARP:

  309.       return "A#";

  310.     case Utility::NOTE_B:

  311.       return "B";

  312.     default:

  313.       return "";

  314.     }

  315.   }

  316. 

  317.   string displayScale(int value)

  318.   {

  319.     switch (value)

  320.     {

  321.     case Utility::AEOLIAN:

  322.       return "Aeolian";

  323.     case Utility::BLUES:

  324.       return "Blues";

  325.     case Utility::CHROMATIC:

  326.       return "Chromatic";

  327.     case Utility::DIATONIC_MINOR:

  328.       return "Diat. Min.";

  329.     case Utility::DORIAN:

  330.       return "Dorian";

  331.     case Utility::HARMONIC_MINOR:

  332.       return "Harm. Min.";

  333.     case Utility::INDIAN:

  334.       return "Indian";

  335.     case Utility::LOCRIAN:

  336.       return "Locrian";

  337.     case Utility::LYDIAN:

  338.       return "Lydian";

  339.     case Utility::MAJOR:

  340.       return "Major";

  341.     case Utility::MELODIC_MINOR:

  342.       return "Melo. Min.";

  343.     case Utility::MINOR:

  344.       return "Minor";

  345.     case Utility::MIXOLYDIAN:

  346.       return "Mixolydian";

  347.     case Utility::NATURAL_MINOR:

  348.       return "Nat. Min.";

  349.     case Utility::PENTATONIC:

  350.       return "Pentatonic";

  351.     case Utility::PHRYGIAN:

  352.       return "Phrygian";

  353.     case Utility::TURKISH:

  354.       return "Turkish";

  355.     case Utility::NONE:

  356.       return "None";

  357.     default:

  358.       return "";

  359.     }

  360.   }

  361. 

  362.   void draw(NVGcontext *vg) override

  363.   {

  364.     if (++frame >= 4)

  365.     {

  366.       frame = 0;

  367.       note = displayRootNote(module->rootNote);

  368.       scale = displayScale(module->curScaleVal);

  369.     }

  370.     drawMessage(vg, Vec(0, 20), note, scale);

  371.   }

  372. };

  373. 

  374. 

  375. //////////////////////////////////////////////////////////////////

  376. struct UtilityWidget : ModuleWidget 

  377. {

  378. UtilityWidget(Utility *module) : ModuleWidget(module)

  379. {

  380. 	box.size = Vec(15*8, 380);

  381. 

  382. 	{

  383. 		SVGPanel *panel = new SVGPanel();

  384. 		panel->box.size = box.size;

  385.     panel->setBackground(SVG::load(assetPlugin(plugin,"res/Utility.svg")));

  386. 		addChild(panel);

  387.     }

  388.     

  389.   {

  390.     UtilityDisplay *display = new UtilityDisplay();

  391.     display->module = module;

  392.     display->box.pos = Vec(10, + 240);

  393.     display->box.size = Vec(250, 60);

  394.     addChild(display);

  395.   }

  396. 

  397. //Screw

  398.   addChild(Widget::create<ScrewSilver>(Vec(15, 0)));

  399.   addChild(Widget::create<ScrewSilver>(Vec(box.size.x-30, 0)));

  400.   addChild(Widget::create<ScrewSilver>(Vec(15, 365)));

  401.   addChild(Widget::create<ScrewSilver>(Vec(box.size.x-30, 365)));

  402.     

  403.    int knob=35;  

  404.   

  405. 

  406. 

  407. //

  408. for (int i=0;i<3;i++)

  409. { 

  410.     addParam(ParamWidget::create<FlatASnap>(Vec(10+knob*i, 20), module, Utility::OCTAVE_SHIFT+i, -4.5, 4.5, 0.0));

  411.     addParam(ParamWidget::create<FlatASnap>(Vec(10+knob*i, 60), module, Utility::SEMITONE_SHIFT+i, -5.0 ,5.0, 0.0));

  412.     addParam(ParamWidget::create<FlatA>(Vec(10+knob*i, 100), module, Utility::FINE_SHIFT+i, -1, 1, 0.0));

  413. 

  414.     addInput(Port::create<PJ301MIPort>(Vec(12.5+knob*i, 100+knob*1.3), Port::INPUT, module, Utility::OCTAVE_INPUT+i));

  415.     addInput(Port::create<PJ301MCPort>(Vec(12.5+knob*i, 130+knob*1.3), Port::INPUT, module, Utility::OCTAVE_CVINPUT+i));

  416.     addInput(Port::create<PJ301MCPort>(Vec(12.5+knob*i, 160+knob*1.3), Port::INPUT, module, Utility::SEMITONE_CVINPUT+i));

  417.     addInput(Port::create<PJ301MCPort>(Vec(12.5+knob*i, 190+knob*1.3), Port::INPUT, module, Utility::FINE_CVINPUT+i));   

  418. }

  419. 

  420.   addParam(ParamWidget::create<Trimpot>(Vec(65,304), module, Utility::ROOT_NOTE_PARAM, 0.0, Utility::NUM_NOTES - 1 + 0.1, 0));

  421.   addParam(ParamWidget::create<Trimpot>(Vec(90,304), module, Utility::SCALE_PARAM, 0.0, Utility::NUM_SCALES - 1 + 0.1, 0));

  422. 

  423.   addInput(Port::create<PJ301MPort>(Vec(10,300), Port::INPUT, module, Utility::ROOT_NOTE_INPUT));

  424.   addInput(Port::create<PJ301MPort>(Vec(37,300), Port::INPUT, module, Utility::SCALE_INPUT));

  425. 

  426.   addOutput(Port::create<PJ301MOPort>(Vec(12.5,340), Port::OUTPUT, module, Utility::A_OUTPUT));

  427.   addOutput(Port::create<PJ301MOPort>(Vec(12.5+knob*1,340), Port::OUTPUT, module, Utility::B_OUTPUT));

  428.   addOutput(Port::create<PJ301MOPort>(Vec(12.5+knob*2,340), Port::OUTPUT, module, Utility::C_OUTPUT));

  429. 

  430.   addParam(ParamWidget::create<CKSSS>(Vec(39,150), module, Utility::LINK_A_PARAM, 0.0, 1.0, 0.0));

  431.   addParam(ParamWidget::create<CKSSS>(Vec(74.5, 150), module, Utility::LINK_B_PARAM, 0.0, 1.0, 0.0));

  432. }

  433. };

  434. 

  435. } // namespace rack_plugin_dBiz

  436. 

  437. using namespace rack_plugin_dBiz;

  438. 

  439. RACK_PLUGIN_MODEL_INIT(dBiz, Utility) {

  440.    Model *modelUtility = Model::create<Utility, UtilityWidget>("dBiz", "Utility", "Utility", QUANTIZER_TAG);

  441.    return modelUtility;

  442. }