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.
1093 Commits
4 Branches
573MB
Tree: 3534b6ce48
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '3534b6ce48'
${ noResults }
Rack/plugins/community/repos/dBiz/src/Bene.cpp

606 lines
16KB
Raw Blame History 

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

  2. //

  3. //  dBiz revisited version of 

  4. //

  5. //  Cartesian Sequencer Module for VCV

  6. // many thx to 

  7. //  Strum 2017

  8. //  strum@softhome.net

  9. //

  10. ///////////////////////////////////////////////////////////////////

  11. 

  12. #include "dBiz.hpp"

  13. #include "dsp/digital.hpp"

  14. 

  15. 

  16. using namespace std;

  17. 

  18. namespace rack_plugin_dBiz {

  19. 

  20. struct Bene : Module {

  21.   enum ParamIds

  22.   {

  23.     ROOT_NOTE_PARAM,

  24.     SCALE_PARAM,

  25.   //  QUANT_PARAM,

  26.     KNOB_PARAM,

  27.     NUM_PARAMS = KNOB_PARAM + 16

  28.   };

  29.   enum InputIds

  30.   {

  31.     ROOT_NOTE_INPUT,

  32.     SCALE_INPUT,

  33.     UP,

  34.     DOWN,

  35.     LEFT,

  36.     RIGHT,

  37.     X_PAD,

  38.     Y_PAD,

  39.     G_PAD,

  40.     RESET,

  41.     X_RESET,

  42.     Y_RESET,

  43.     NUM_INPUTS

  44.   };

  45.   enum OutputIds {

  46. 		UNQUANT_OUT,

  47.     QUANT_OUT,

  48.     ROW_OUT,

  49.     COLUMN_OUT = ROW_OUT + 4,    

  50. 		NUM_OUTPUTS = COLUMN_OUT + 4

  51.   };

  52. 

  53.   enum LightIds

  54.   {

  55.     GRID_LIGHTS,

  56.     NUM_LIGHTS = GRID_LIGHTS + 16

  57.   };

  58. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  77. 

  78.   enum Notes

  79.   {

  80.     NOTE_C,

  81.     NOTE_C_SHARP,

  82.     NOTE_D,

  83.     NOTE_D_SHARP,

  84.     NOTE_E,

  85.     NOTE_F,

  86.     NOTE_F_SHARP,

  87.     NOTE_G,

  88.     NOTE_G_SHARP,

  89.     NOTE_A,

  90.     NOTE_A_SHARP,

  91.     NOTE_B,

  92.     NUM_NOTES

  93.   };

  94. 

  95.   enum Scales

  96.   {

  97.     AEOLIAN,

  98.     BLUES,

  99.     CHROMATIC,

  100.     DIATONIC_MINOR,

  101.     DORIAN,

  102.     HARMONIC_MINOR,

  103.     INDIAN,

  104.     LOCRIAN,

  105.     LYDIAN,

  106.     MAJOR,

  107.     MELODIC_MINOR,

  108.     MINOR,

  109.     MIXOLYDIAN,

  110.     NATURAL_MINOR,

  111.     PENTATONIC,

  112.     PHRYGIAN,

  113.     TURKISH,

  114.     NONE,

  115.     NUM_SCALES

  116.   };

  117. 

  118.   SchmittTrigger leftTrigger;

  119.   SchmittTrigger rightTrigger;

  120.   SchmittTrigger upTrigger;

  121.   SchmittTrigger downTrigger;

  122.   SchmittTrigger resetTrigger;

  123.   SchmittTrigger x_resetTrigger;

  124.   SchmittTrigger y_resetTrigger;

  125.     

  126.   SchmittTrigger button_triggers[4][4];                

  127.     

  128.   float row_outs[4] = {0.0,0.0,0.0,0.0};

  129.   float column_outs[4] = {0.0,0.0,0.0,0.0};

  130.   

  131.   int x_position = 0;

  132.   int y_position = 0;

  133. 

  134.   int rootNote = 0;

  135.   int curScaleVal = 0;

  136.   float pitch = 0;

  137.   float previousPitch = 0;

  138. 

  139.   Bene() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {}

  140.   

  141.   void step() override;

  142. 

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

  144. 

  145.   float closestVoltageInScale(float voltsIn)

  146.   {

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

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

  149.     int *curScaleArr;

  150.     int notesInScale = 0;

  151.     switch (curScaleVal)

  152.     {

  153.     case AEOLIAN:

  154.       curScaleArr = SCALE_AEOLIAN;

  155.       notesInScale = LENGTHOF(SCALE_AEOLIAN);

  156.       break;

  157.     case BLUES:

  158.       curScaleArr = SCALE_BLUES;

  159.       notesInScale = LENGTHOF(SCALE_BLUES);

  160.       break;

  161.     case CHROMATIC:

  162.       curScaleArr = SCALE_CHROMATIC;

  163.       notesInScale = LENGTHOF(SCALE_CHROMATIC);

  164.       break;

  165.     case DIATONIC_MINOR:

  166.       curScaleArr = SCALE_DIATONIC_MINOR;

  167.       notesInScale = LENGTHOF(SCALE_DIATONIC_MINOR);

  168.       break;

  169.     case DORIAN:

  170.       curScaleArr = SCALE_DORIAN;

  171.       notesInScale = LENGTHOF(SCALE_DORIAN);

  172.       break;

  173.     case HARMONIC_MINOR:

  174.       curScaleArr = SCALE_HARMONIC_MINOR;

  175.       notesInScale = LENGTHOF(SCALE_HARMONIC_MINOR);

  176.       break;

  177.     case INDIAN:

  178.       curScaleArr = SCALE_INDIAN;

  179.       notesInScale = LENGTHOF(SCALE_INDIAN);

  180.       break;

  181.     case LOCRIAN:

  182.       curScaleArr = SCALE_LOCRIAN;

  183.       notesInScale = LENGTHOF(SCALE_LOCRIAN);

  184.       break;

  185.     case LYDIAN:

  186.       curScaleArr = SCALE_LYDIAN;

  187.       notesInScale = LENGTHOF(SCALE_LYDIAN);

  188.       break;

  189.     case MAJOR:

  190.       curScaleArr = SCALE_MAJOR;

  191.       notesInScale = LENGTHOF(SCALE_MAJOR);

  192.       break;

  193.     case MELODIC_MINOR:

  194.       curScaleArr = SCALE_MELODIC_MINOR;

  195.       notesInScale = LENGTHOF(SCALE_MELODIC_MINOR);

  196.       break;

  197.     case MINOR:

  198.       curScaleArr = SCALE_MINOR;

  199.       notesInScale = LENGTHOF(SCALE_MINOR);

  200.       break;

  201.     case MIXOLYDIAN:

  202.       curScaleArr = SCALE_MIXOLYDIAN;

  203.       notesInScale = LENGTHOF(SCALE_MIXOLYDIAN);

  204.       break;

  205.     case NATURAL_MINOR:

  206.       curScaleArr = SCALE_NATURAL_MINOR;

  207.       notesInScale = LENGTHOF(SCALE_NATURAL_MINOR);

  208.       break;

  209.     case PENTATONIC:

  210.       curScaleArr = SCALE_PENTATONIC;

  211.       notesInScale = LENGTHOF(SCALE_PENTATONIC);

  212.       break;

  213.     case PHRYGIAN:

  214.       curScaleArr = SCALE_PHRYGIAN;

  215.       notesInScale = LENGTHOF(SCALE_PHRYGIAN);

  216.       break;

  217.     case TURKISH:

  218.       curScaleArr = SCALE_TURKISH;

  219.       notesInScale = LENGTHOF(SCALE_TURKISH);

  220.       break;

  221.     case NONE:

  222.       return voltsIn;

  223.     }

  224. 

  225.     float closestVal = 10.0;

  226.     float closestDist = 10.0;

  227.     float scaleNoteInVolts = 0;

  228.     float distAway = 0;

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

  230.     float voltMinusOct = voltsIn - octaveInVolts;

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

  232. 			scaleNoteInVolts = curScaleArr[i] / 12.0;

  233. 			distAway = fabs(voltMinusOct - scaleNoteInVolts);

  234. 			if(distAway < closestDist){

  235. 				closestVal = scaleNoteInVolts;

  236. 				closestDist = distAway;

  237. 			}

  238.     }

  239.     return octaveInVolts + rootNote/12.0 + closestVal;

  240.   }

  241.   

  242. };

  243. 

  244. 

  245. 

  246. void Bene::step() {

  247. 

  248.   	bool step_right = false;

  249.     bool step_left = false;

  250.     bool step_up = false;

  251.     bool step_down = false;

  252.     lights[GRID_LIGHTS+x_position+y_position*4].value =1.0;

  253.     

  254. 

  255.     // handle clock inputs

  256.     if (inputs[RIGHT].active)

  257.     {

  258. 			if (rightTrigger.process(inputs[RIGHT].value))

  259.       {

  260. 				step_right = true;

  261. 			}

  262. 		}

  263.     if (inputs[LEFT].active)

  264.     {

  265. 			if (leftTrigger.process(inputs[LEFT].value))

  266.       {

  267. 				step_left = true;

  268. 			}

  269. 		}

  270.     if (inputs[DOWN].active)

  271.     {

  272. 			if (downTrigger.process(inputs[DOWN].value))

  273.       {

  274. 				step_down = true;

  275. 			}

  276. 		}

  277.     if (inputs[UP].active)

  278.     {

  279. 			if (upTrigger.process(inputs[UP].value))

  280.       {

  281. 				step_up = true;

  282. 			}

  283. 		}

  284.     // resets

  285. 

  286.     if (resetTrigger.process(inputs[RESET].value))

  287.     {

  288.       lights[GRID_LIGHTS + x_position + y_position*4].value = 0.0;

  289.       x_position = 0;

  290.       y_position = 0;

  291.       lights[GRID_LIGHTS + x_position + y_position*4].value = 1.0;

  292.       step_right = false;

  293.       step_left = false;

  294.       step_up = false;	

  295.       step_down = false;	

  296. 	  }

  297.     if (x_resetTrigger.process(inputs[X_RESET].value))

  298.     {

  299.       lights[GRID_LIGHTS + x_position + y_position*4].value  = 0.0;

  300. 		  x_position = 0;

  301.       lights[GRID_LIGHTS + x_position + y_position*4].value  = 1.0;

  302.       step_right = false;

  303.       step_left = false;

  304.       step_up = false;	

  305.       step_down = false;	

  306. 	  }

  307.     if (y_resetTrigger.process(inputs[Y_RESET].value))

  308.     {

  309.       lights[GRID_LIGHTS + x_position + y_position*4].value  = 0.0;

  310. 		  y_position = 0;

  311.       lights[GRID_LIGHTS + x_position + y_position*4].value  = 1.0;

  312.       step_right = false;

  313.       step_left = false;

  314.       step_up = false;	

  315.       step_down = false;	

  316. 	  }

  317.    

  318.    

  319.     // handle button triggers

  320. 

  321.     int xpad = round(inputs[X_PAD].value);

  322.     int ypad = round(inputs[Y_PAD].value);

  323. 

  324.     bool gated = inputs[G_PAD].value > 0.0;

  325. 

  326.     if (gated)

  327.     {

  328.       for (int i = 0; i < 4; i++)

  329.       {

  330.         for (int j = 0; j < 4; j++)

  331.         {

  332.           lights[GRID_LIGHTS + x_position + y_position*4].value = 0.0;

  333.           x_position = xpad-1;

  334.           y_position = ypad-1;

  335.           lights[GRID_LIGHTS + x_position + y_position*4].value = 1.0;

  336.       }

  337.     }

  338.     }

  339. 

  340.     // change x and y    

  341.     if (step_right)

  342.     {

  343.        lights[GRID_LIGHTS + x_position + y_position*4].value  = 0.0;

  344.       x_position += 1;

  345.       if (x_position > 3) x_position = 0;

  346.        lights[GRID_LIGHTS + x_position + y_position*4].value  = 1.0;

  347.     }

  348.     if (step_left)

  349.     {

  350.        lights[GRID_LIGHTS + x_position + y_position*4].value  = 0.0;

  351.       x_position -= 1;

  352.       if (x_position < 0) x_position = 3;      

  353.        lights[GRID_LIGHTS + x_position + y_position*4].value  = 1.0;

  354.     }

  355.     if (step_down)

  356.     {

  357.        lights[GRID_LIGHTS + x_position + y_position*4].value  = 0.0;

  358.       y_position += 1;

  359.       if (y_position > 3) y_position = 0;

  360.        lights[GRID_LIGHTS + x_position + y_position*4].value  = 1.0;

  361.     }

  362.     if (step_up)

  363.     {

  364.        lights[GRID_LIGHTS + x_position + y_position*4].value  = 0.0;

  365.       y_position -= 1;

  366.       if (y_position < 0) y_position = 3;      

  367.        lights[GRID_LIGHTS + x_position + y_position*4].value  = 1.0;

  368.     }

  369.     

  370.     /// set outputs

  371.     int which_knob = y_position * 4 + x_position;

  372.     //float main_out = params[KNOB_PARAM + which_knob].value;

  373. 

  374.    // int oct = round(main_out);

  375.    // float left = main_out - oct;

  376.    // int semi = round(left * 12);

  377.    // float quant_out = oct + semi/12.0;

  378. //

  379. 

  380.     for (int i = 0 ; i < 4 ; i++)

  381.     {

  382.     float main_out = params[KNOB_PARAM + which_knob].value;

  383.     float quant_out = closestVoltageInScale(params[KNOB_PARAM + which_knob].value);

  384.     row_outs[i] = closestVoltageInScale(params[KNOB_PARAM + y_position * 4 + i].value);

  385.     column_outs[i] = closestVoltageInScale(params[KNOB_PARAM + x_position + i * 4].value);

  386. 

  387.    /* roct[i] = round(row_outs[i]);

  388.     rleft[i] = row_outs[i] - roct[i];

  389.     rsemi[i] = round(rleft[i] * 12);

  390.     rquant_out[i] = roct[i] + rsemi[i] / 12.0;

  391. 

  392.     coct[i] = round(column_outs[i]);

  393.     cleft[i] = column_outs[i] - roct[i];

  394.     csemi[i] = round(cleft[i] * 12);

  395.     cquant_out[i] = coct[i] + csemi[i] / 12.0;

  396.   */

  397. 

  398.     outputs[ROW_OUT + i].value = row_outs[i];

  399.     outputs[COLUMN_OUT + i].value = column_outs[i];

  400. 

  401.     outputs[UNQUANT_OUT].value = main_out;

  402.     outputs[QUANT_OUT].value = quant_out;

  403.    }

  404. }

  405. 

  406. //////////////////////////////////// Display --- Based on DTROY by Bidoo  

  407. 

  408. struct BeneDisplay : TransparentWidget

  409. {

  410.   Bene *module;

  411.   int frame = 0;

  412.   shared_ptr<Font> font;

  413. 

  414.   string note, scale;

  415. 

  416.   BeneDisplay()

  417.   {

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

  419.   }

  420. 

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

  422.   {

  423.     nvgFontSize(vg, 18);

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

  425.     nvgTextLetterSpacing(vg, -2);

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

  427.     nvgFontSize(vg, 14);

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

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

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

  431.   

  432.   }

  433. 

  434.   string displayRootNote(int value)

  435.   {

  436.     switch (value)

  437.     {

  438.     case Bene::NOTE_C:

  439.       return "C";

  440.     case Bene::NOTE_C_SHARP:

  441.       return "C#";

  442.     case Bene::NOTE_D:

  443.       return "D";

  444.     case Bene::NOTE_D_SHARP:

  445.       return "D#";

  446.     case Bene::NOTE_E:

  447.       return "E";

  448.     case Bene::NOTE_F:

  449.       return "F";

  450.     case Bene::NOTE_F_SHARP:

  451.       return "F#";

  452.     case Bene::NOTE_G:

  453.       return "G";

  454.     case Bene::NOTE_G_SHARP:

  455.       return "G#";

  456.     case Bene::NOTE_A:

  457.       return "A";

  458.     case Bene::NOTE_A_SHARP:

  459.       return "A#";

  460.     case Bene::NOTE_B:

  461.       return "B";

  462.     default:

  463.       return "";

  464.     }

  465.   }

  466. 

  467.   string displayScale(int value)

  468.   {

  469.     switch (value)

  470.     {

  471.     case Bene::AEOLIAN:

  472.       return "Aeolian";

  473.     case Bene::BLUES:

  474.       return "Blues";

  475.     case Bene::CHROMATIC:

  476.       return "Chromatic";

  477.     case Bene::DIATONIC_MINOR:

  478.       return "Diat. Min.";

  479.     case Bene::DORIAN:

  480.       return "Dorian";

  481.     case Bene::HARMONIC_MINOR:

  482.       return "Harm. Min.";

  483.     case Bene::INDIAN:

  484.       return "Indian";

  485.     case Bene::LOCRIAN:

  486.       return "Locrian";

  487.     case Bene::LYDIAN:

  488.       return "Lydian";

  489.     case Bene::MAJOR:

  490.       return "Major";

  491.     case Bene::MELODIC_MINOR:

  492.       return "Melo. Min.";

  493.     case Bene::MINOR:

  494.       return "Minor";

  495.     case Bene::MIXOLYDIAN:

  496.       return "Mixolydian";

  497.     case Bene::NATURAL_MINOR:

  498.       return "Nat. Min.";

  499.     case Bene::PENTATONIC:

  500.       return "Pentatonic";

  501.     case Bene::PHRYGIAN:

  502.       return "Phrygian";

  503.     case Bene::TURKISH:

  504.       return "Turkish";

  505.     case Bene::NONE:

  506.       return "None";

  507.     default:

  508.       return "";

  509.     }

  510.   }

  511. 

  512.   void draw(NVGcontext *vg) override

  513.   {

  514.     if (++frame >= 4)

  515.     {

  516.       frame = 0;

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

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

  519.     }

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

  521.   }

  522. };

  523. 

  524. ////////////////////////////////

  525. 

  526. struct BeneWidget : ModuleWidget 

  527. {

  528. BeneWidget(Bene *module) : ModuleWidget(module)

  529. {

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

  531. 

  532.   int top = 20;

  533.   int top2 = 35;

  534.   int left = 8;

  535.   int column_spacing = 35;

  536.   int row_spacing = 35;

  537. 

  538.   {

  539.     SVGPanel *panel = new SVGPanel();

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

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

  542.     addChild(panel);

  543.   }

  544. 

  545.   {

  546.     BeneDisplay *display = new BeneDisplay();

  547.     display->module = module;

  548.     display->box.pos = Vec(left, top + 105);

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

  550.     addChild(display);

  551.   }

  552. 

  553.  

  554. 

  555. 

  556.   addInput(Port::create<PJ301MIPort>(Vec(left, top), Port::INPUT, module, Bene::LEFT));

  557.   addInput(Port::create<PJ301MIPort>(Vec(left+column_spacing, top), Port::INPUT, module, Bene::RIGHT));

  558. 

  559.   addInput(Port::create<PJ301MIPort>(Vec(left, top + 40), Port::INPUT, module, Bene::UP));

  560.   addInput(Port::create<PJ301MIPort>(Vec(left + column_spacing, top + 40), Port::INPUT, module, Bene::DOWN));

  561.   

  562.   addInput(Port::create<PJ301MIPort>(Vec(left+column_spacing * 2, top), Port::INPUT, module, Bene::X_RESET));

  563.   addInput(Port::create<PJ301MIPort>(Vec(left + column_spacing * 2, top + 40), Port::INPUT, module, Bene::Y_RESET));

  564. 

  565.   addInput(Port::create<PJ301MOrPort>(Vec(left , top+85), Port::INPUT, module, Bene::X_PAD));

  566.   addInput(Port::create<PJ301MOrPort>(Vec(left + column_spacing , top + 85), Port::INPUT, module, Bene::Y_PAD));

  567.   addInput(Port::create<PJ301MOrPort>(Vec(left + column_spacing * 2, top + 85), Port::INPUT, module, Bene::G_PAD));

  568. 

  569.   addInput(Port::create<PJ301MIPort>(Vec(left + column_spacing * 3, top ), Port::INPUT, module, Bene::RESET));

  570. 

  571.   addOutput(Port::create<PJ301MOPort>(Vec(left + column_spacing * 5-20, top), Port::OUTPUT, module, Bene::UNQUANT_OUT));

  572.   addOutput(Port::create<PJ301MOPort>(Vec(left + column_spacing * 5-20, top+30), Port::OUTPUT, module, Bene::QUANT_OUT));

  573.  

  574.   for ( int i = 0 ; i < 4 ; i++)

  575.   {

  576.     for ( int j = 0 ; j < 4 ; j++)

  577.     {

  578.       addParam(ParamWidget::create<Rogan2PWhite>(Vec(left+column_spacing * i, top2 + row_spacing * j + 150 ), module, Bene::KNOB_PARAM + i + j * 4, 0.0, 2.0, 1.0));

  579.       addChild(GrayModuleLightWidget::create<BigLight<OrangeLight>>(Vec(left + column_spacing * i + 8, top2 + row_spacing * j + 150 + 8), module, Bene::GRID_LIGHTS + i + j * 4));

  580.     }

  581.     addOutput(Port::create<PJ301MOPort>(Vec(left+column_spacing * i+5, top2 + row_spacing * 4 + 155 ), Port::OUTPUT, module, Bene::ROW_OUT + i));

  582.     addOutput(Port::create<PJ301MOPort>(Vec(left+column_spacing * 4+5, top2 + row_spacing * i + 155 ), Port::OUTPUT, module, Bene::COLUMN_OUT + i));

  583. 	}

  584. 

  585.   addParam(ParamWidget::create<Rogan2PWhite>(Vec(left + column_spacing*3-5, top + 85 + row_spacing), module, Bene::ROOT_NOTE_PARAM, 0.0, Bene::NUM_NOTES - 1 + 0.1, 0));

  586.   addParam(ParamWidget::create<Rogan2PWhite>(Vec(left + column_spacing*4 , top + 85 + row_spacing), module, Bene::SCALE_PARAM, 0.0, Bene::NUM_SCALES - 1 + 0.1, 0));

  587. 

  588.   addInput(Port::create<PJ301MPort>(Vec(column_spacing * 4-25, top + 85), Port::INPUT, module, Bene::ROOT_NOTE_INPUT));

  589.   addInput(Port::create<PJ301MPort>(Vec(column_spacing * 4 +15, top + 85), Port::INPUT, module, Bene::SCALE_INPUT));

  590. 

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

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

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

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

  595. }

  596. };

  597. 

  598. } // namespace rack_plugin_dBiz

  599. 

  600. using namespace rack_plugin_dBiz;

  601. 

  602. RACK_PLUGIN_MODEL_INIT(dBiz, Bene) {

  603.    Model *modelBene = Model::create<Bene, BeneWidget>("dBiz", "Bene", "Bene", SEQUENCER_TAG);

  604.    return modelBene;

  605. }