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

600 lines
22KB
Raw Blame History 

  1. #include "dsp/digital.hpp"

  2. #include "moDllz.hpp"

  3. #include "dsp/filter.hpp"

  4. /*

  5.  * XBender

  6.  */

  7. 

  8. namespace rack_plugin_moDllz {

  9. 

  10. struct XBender : Module {

  11.     enum ParamIds {

  12.         XBEND_PARAM,

  13.         XBENDCVTRIM_PARAM,

  14.         XBENDRANGE_PARAM,

  15.         BEND_PARAM,

  16.         BENDCVTRIM_PARAM,

  17.         AXISXFADE_PARAM,

  18.         AXISSLEW_PARAM,

  19.         AXISTRNSUP_PARAM,

  20.         AXISTRNSDWN_PARAM,

  21.         AXISSHIFTTRIM_PARAM,

  22.         AXISSELECT_PARAM = 10,

  23.         AXISSELECTCV_PARAM = 18,

  24.         SNAPAXIS_PARAM,

  25.         YCENTER_PARAM,

  26.         YZOOM_PARAM,

  27.         AUTOZOOM_PARAM,

  28.         NUM_PARAMS

  29.     };

  30.     enum InputIds {

  31.         IN_INPUT,

  32.         XBENDCV_INPUT = 8,

  33.         XBENDRANGE_INPUT,

  34.         BENDCV_INPUT,

  35.         AXISSELECT_INPUT,

  36.         AXISEXT_INPUT,

  37.         AXISXFADE_INPUT,

  38.         AXISSHIFT_INPUT,

  39.         AXISSLEW_INPUT,

  40.         NUM_INPUTS

  41.     };

  42.     enum OutputIds {

  43.         OUT_OUTPUT,

  44.         AXIS_OUTPUT = 8,

  45.         NUM_OUTPUTS

  46.     };

  47.     enum LightIds {

  48.         AXIS_LIGHT,

  49.         AUTOZOOM_LIGHT = 8,

  50.         SNAPAXIS_LIGHT,

  51.         NUM_LIGHTS

  52.     };

  53.     

  54.     

  55.     float inaxis = 0.f;

  56.     float slewaxis = 0.f;

  57.     int axisTransParam = 0;

  58.     float finalAxis = 0.f;

  59.     float AxisShift =  0.f;

  60.     float axisxfade;

  61.     float selectedAxisF = 0.f;

  62.     int selectedAxisI = 0;

  63.     

  64.     float dZoom = 1.f;

  65.     float dCenter = 0.5f;

  66.     int frameAutoZoom = 0;

  67.     

  68.     float slewchanged = 0.f;

  69.     

  70.     SchmittTrigger axisTransUpTrigger;

  71.     SchmittTrigger axisTransDwnTrigger;

  72.     SchmittTrigger axisSelectTrigger[8];

  73.    

  74.     struct ioXBended {

  75.         float inx = 0.0f;

  76.         float xout = 0.0f;

  77.         bool iactive = false;

  78.     };

  79.     

  80.     ioXBended ioxbended[8];

  81.     

  82.     SlewLimiter slewlimiter;

  83.     

  84.     

  85.     XBender() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {}

  86.     

  87.     void step() override;

  88.     void onReset() override {

  89.         for (int ix = 0; ix < 8 ; ix++){

  90.         outputs[OUT_OUTPUT + ix].value = inputs[IN_INPUT + ix].value;

  91.         }

  92.     }

  93.     json_t *toJson() override {

  94.         json_t *rootJ = json_object();

  95.         json_object_set_new(rootJ, "selectedAxisI", json_integer(selectedAxisI));

  96.         json_object_set_new(rootJ, "axisTransParam", json_integer(axisTransParam));

  97.         return rootJ;

  98.     }

  99.     

  100.     void fromJson(json_t *rootJ) override {

  101.         json_t *selectedAxisIJ = json_object_get(rootJ,("selectedAxisI"));

  102.         selectedAxisI = json_integer_value(selectedAxisIJ);

  103.         json_t *axisTransParamJ = json_object_get(rootJ,("axisTransParam"));

  104.         axisTransParam = json_integer_value(axisTransParamJ);

  105.     }

  106. 

  107. };

  108. 

  109. ///////////////////////////////////////////

  110. ///////////////STEP //////////////////

  111. /////////////////////////////////////////////

  112. 

  113. void XBender::step() {

  114.    

  115.     if(inputs[AXISSELECT_INPUT].active) {

  116.         if (params[SNAPAXIS_PARAM].value > 0.5f){

  117.             selectedAxisI = (clamp(static_cast<int>(inputs[AXISSELECT_INPUT].value * 0.7), 0, 7));

  118.             selectedAxisF = static_cast<float>(selectedAxisI);

  119.             inaxis = inputs[selectedAxisI].value;

  120.         } else {

  121.             selectedAxisF = clamp(inputs[AXISSELECT_INPUT].value * 0.7, 0.f, 7.f);

  122.             selectedAxisI = static_cast<int>(selectedAxisF);

  123.             float ax_float = selectedAxisF - static_cast<float>(selectedAxisI);

  124.             inaxis = (inputs[selectedAxisI].value * (1.f - ax_float) + (inputs[selectedAxisI + 1].value * ax_float));

  125.         }

  126.     }else{

  127.          inaxis = inputs[selectedAxisI].value;

  128.     }

  129.       

  130.     lights[SNAPAXIS_LIGHT].value = (params[SNAPAXIS_PARAM].value > 0.5f)? 1.f : 0.f;

  131.     

  132.     axisxfade = clamp((params[AXISXFADE_PARAM].value + inputs[AXISXFADE_INPUT].value/ 10.f), 0.f, 1.f);

  133.     

  134.     if (inputs[AXISEXT_INPUT].active){

  135.         float axisext = inputs[AXISEXT_INPUT].value;

  136.         slewaxis = crossfade(axisext, inaxis, axisxfade);

  137.     }else slewaxis = inaxis;

  138.     

  139.     float slewsum = clamp((params[AXISSLEW_PARAM].value + inputs[AXISSLEW_INPUT].value * .1f), 0.f , 1.f);

  140.     if (slewchanged != slewsum) {

  141.         float slewfloat = 1.0f/(5.0f + slewsum * engineGetSampleRate());

  142.         slewlimiter.setRiseFall(slewfloat,slewfloat);

  143.     }

  144.     finalAxis = slewlimiter.process(slewaxis) + (inputs[AXISSHIFT_INPUT].value * params[AXISSHIFTTRIM_PARAM].value);

  145.     AxisShift = (static_cast<float>(axisTransParam)/12.f);

  146.     finalAxis += clamp(AxisShift, -12.f,12.f);

  147.     

  148.     float range = clamp((params[XBENDRANGE_PARAM].value + inputs[XBENDRANGE_INPUT].value/2.f), 1.f,5.f);

  149.     float xbend = clamp((params[XBEND_PARAM].value + (inputs[XBENDCV_INPUT].value /5.f) * (params[XBENDCVTRIM_PARAM].value /24.f)),-1.f, 1.f);

  150.     float bend = clamp((params[BEND_PARAM].value + (inputs[BENDCV_INPUT].value /5.f) * (params[BENDCVTRIM_PARAM].value /60.f)),-1.f, 1.f);

  151.     

  152.     for (int i = 0; i < 8; i++){

  153.         if (inputs[IN_INPUT + i].active) {

  154.         

  155.             if (axisSelectTrigger[i].process(params[AXISSELECT_PARAM + i].value)) {

  156.                 selectedAxisI = i;

  157.                 selectedAxisF = static_cast<float>(i); // float for display

  158.             }

  159.             ioxbended[i].iactive= true;

  160.             lights[AXIS_LIGHT + i].value = (selectedAxisI == i)? 1.f : 0.01f;

  161.             ioxbended[i].inx = inputs[IN_INPUT + i].value;

  162.             float diff = (finalAxis - ioxbended[i].inx) * xbend * range;

  163.             ioxbended[i].xout = clamp((ioxbended[i].inx + diff + bend * 6.f),-12.f,12.f);

  164.             outputs[OUT_OUTPUT + i].value = ioxbended[i].xout;

  165. 

  166.         }else{

  167.             lights[AXIS_LIGHT + i].value = 0;

  168.             ioxbended[i].iactive=false;

  169.         }

  170.     } //for loop ix

  171.   

  172.     outputs[AXIS_OUTPUT].value = finalAxis;

  173.     

  174.     if (axisTransUpTrigger.process(params[AXISTRNSUP_PARAM].value))

  175.             if (axisTransParam < 48) axisTransParam ++;

  176.     if (axisTransDwnTrigger.process(params[AXISTRNSDWN_PARAM].value))

  177.             if (axisTransParam > -48) axisTransParam --;

  178.    

  179.     bool autoZoom = (params[AUTOZOOM_PARAM].value > 0.f);

  180.     if (autoZoom){

  181.         frameAutoZoom ++;

  182.         if (frameAutoZoom > 128) {

  183.             frameAutoZoom = 0;

  184.         float autoZoomMin = 12.f , autoZoomMax = -12.f;

  185.             int active = 0;

  186.         for (int i = 0; i < 8; i++){

  187.             if (inputs[IN_INPUT + i].active) {

  188.             active ++;

  189.             if (ioxbended[i].inx < autoZoomMin)

  190.                 autoZoomMin = ioxbended[i].inx;

  191.             if (ioxbended[i].xout < autoZoomMin)

  192.                 autoZoomMin = ioxbended[i].xout;

  193.             if (ioxbended[i].inx > autoZoomMax)

  194.                 autoZoomMax = ioxbended[i].inx;

  195.             if (ioxbended[i].xout > autoZoomMax)

  196.                 autoZoomMax = ioxbended[i].xout;

  197.             }

  198.         }

  199.             if (finalAxis < autoZoomMin)

  200.                 autoZoomMin = finalAxis;

  201.             if (finalAxis > autoZoomMax)

  202.                 autoZoomMax = finalAxis;

  203.             float autoZ = 22.f / clamp((autoZoomMax - autoZoomMin),1.f,24.f);

  204.             float autoCenter = 10.f * (autoZoomMin + (autoZoomMax - autoZoomMin) / 2.f);

  205.             dZoom = clamp(autoZ, 1.f, 15.f);

  206.             dCenter = clamp(autoCenter, -120.f, 120.f);

  207.         }

  208.         lights[AUTOZOOM_LIGHT].value = 10.f;

  209.     }

  210.     else {

  211.         dCenter = params[XBender::YCENTER_PARAM].value;

  212.         dZoom = params[XBender::YZOOM_PARAM].value;

  213.         lights[AUTOZOOM_LIGHT].value = 0.f;

  214.     }

  215.     

  216.     

  217. }//closing STEP

  218. 

  219. 

  220. ///Displays

  221. struct BenderDisplay : TransparentWidget {

  222.     BenderDisplay() {

  223.     }

  224.     XBender::ioXBended *ioxB;// = new XBender::ioXBended[8];

  225.     

  226.   

  227.     float *pAxis =  NULL;

  228.     float *pyCenter ;

  229.     float *pyZoom ;

  230.     float *pAxisIx;

  231.     float *pAxisXfade;

  232. 

  233.     void draw(NVGcontext* vg)

  234.     {

  235.         const float dispHeight = 228.f;

  236.         const float dispCenter = dispHeight / 2.f;

  237.         float yZoom = *pyZoom;

  238.         float yCenter =  *pyCenter * yZoom + dispCenter;

  239.         float AxisIx = *pAxisIx;

  240.         float keyw = 10.f * yZoom /12.f;

  241.         // crop drawing to display

  242.         nvgScissor(vg, 0.f, 0.f, 152.f, dispHeight);

  243. 

  244.         nvgBeginPath(vg);

  245.         nvgFillColor(vg, nvgRGB(0x2a, 0x2a, 0x2a));

  246.         nvgRect(vg, 20.f, yCenter - 120.f * yZoom, 110.f, 20.f * yZoom);

  247.         nvgRect(vg, 20.f, yCenter + 100.f * yZoom, 110.f, 20.f * yZoom);

  248.         nvgFill(vg);

  249.        

  250.         nvgBeginPath(vg);

  251.         if (yZoom > 2.5f) nvgFillColor(vg, nvgRGB(0x2d, 0x2d, 0x2d));

  252.         else nvgFillColor(vg, nvgRGB(0x1a, 0x1a, 0x1a));

  253.         nvgRect(vg, 20.f, yCenter - 50.f * yZoom, 110.f, 100.f * yZoom );

  254.         nvgFill(vg);

  255.         for (int i = 0; i < 11; i++){

  256.             if (yZoom < 2.5f){

  257.                // 1V lines

  258.                 nvgBeginPath(vg);

  259.                 nvgStrokeColor(vg, nvgRGB(0x2d,0x2d,0x2d));

  260.                 nvgMoveTo(vg, 20.f, yCenter - 10.f * yZoom * i);

  261.                 nvgLineTo(vg, 130.f,yCenter - 10.f * yZoom * i);

  262.                 nvgMoveTo(vg, 20.f, yCenter + 10.f * yZoom * i);

  263.                 nvgLineTo(vg, 130.f,yCenter + 10.f * yZoom * i);

  264.                 nvgStroke(vg);

  265.             }else if (i < 5){

  266.                 // keyboard

  267.                

  268.                 float keyPos = yCenter + 10.f * yZoom * i;

  269.                 // C's highlight

  270.                 nvgBeginPath(vg);

  271.                 nvgFillColor(vg, nvgRGB(0x44, 0x44, 0x44));

  272.                 nvgRect(vg, 20.f, yCenter - 10.f * yZoom * i - keyw * 0.5f, 110.f, keyw);

  273.                 nvgFill(vg);

  274.                 

  275.                 /// > center

  276.                 nvgBeginPath(vg);

  277.                 nvgFillColor(vg, nvgRGB(0x0, 0x0, 0x0));

  278.                 nvgRect(vg, 20.f, keyPos + keyw * 1.5f, 110.f, keyw);

  279.                 nvgFill(vg);

  280.                 nvgBeginPath(vg);

  281.                 nvgRect(vg, 20.f, keyPos + keyw * 3.5f , 110.f, keyw);

  282.                 nvgFill(vg);

  283.                 nvgBeginPath(vg);

  284.                 nvgRect(vg, 20.f, keyPos + keyw * 5.5f, 110.f, keyw);

  285.                 nvgFill(vg);

  286.                 nvgBeginPath(vg);

  287.                 nvgRect(vg, 20.f, keyPos + keyw * 8.5f, 110.f, keyw);

  288.                 nvgFill(vg);

  289.                 nvgBeginPath(vg);

  290.                 nvgRect(vg, 20.f, keyPos + keyw * 10.5f, 110.f, keyw);

  291.                 nvgFill(vg);

  292.                 /// C's highlight

  293.                 nvgBeginPath(vg);

  294.                 nvgFillColor(vg, nvgRGB(0x44, 0x44, 0x44));

  295.                 nvgRect(vg, 20.f, yCenter + 10.f * yZoom * i - keyw * 0.5f, 110.f, keyw);

  296.                 nvgFill(vg);

  297.                 /// < center

  298.                 keyPos = yCenter - 10.f * yZoom * i;

  299.                 nvgBeginPath(vg);

  300.                 nvgFillColor(vg, nvgRGB(0x0, 0x0, 0x0));

  301.                 nvgRect(vg, 20.f, keyPos - keyw * 1.5f, 110.f, keyw);

  302.                 nvgFill(vg);

  303.                 nvgBeginPath(vg);

  304.                 nvgRect(vg, 20.f, keyPos - keyw * 3.5f , 110.f, keyw);

  305.                 nvgFill(vg);

  306.                 nvgBeginPath(vg);

  307.                 nvgRect(vg, 20.f, keyPos - keyw * 6.5f, 110.f, keyw);

  308.                 nvgFill(vg);

  309.                 nvgBeginPath(vg);

  310.                 nvgRect(vg, 20.f, keyPos - keyw * 8.5f, 110.f, keyw);

  311.                 nvgFill(vg);

  312.                 nvgBeginPath(vg);

  313.                 nvgRect(vg, 20.f, keyPos - keyw * 10.5f, 110.f, keyw);

  314.                 nvgFill(vg);

  315.             }

  316.         }

  317.         // center 0v...

  318.         nvgBeginPath(vg);

  319.         if (yZoom < 2.5f){

  320.             nvgStrokeColor(vg,nvgRGBA(0x80, 0x00, 0x00 ,0x77));

  321.             nvgStrokeWidth(vg,1.f);

  322.             nvgMoveTo(vg, 20.f, yCenter);

  323.             nvgLineTo(vg, 130.f, yCenter);

  324.             nvgStroke(vg);

  325.          }//... center C

  326.          else {

  327.              nvgFillColor(vg, nvgRGBA(0x80, 0x00, 0x00 ,0x77));

  328.              nvgRect(vg, 20.f, yCenter - keyw * 0.5f, 110.f, keyw);

  329.              nvgFill(vg);

  330.         }

  331. 

  332.         float Axis = *pAxis;

  333.         ///// Bend Lines

  334.         const float yfirst = 10.5f;

  335.         const float ystep = 26.f;

  336.         for (int i = 0; i < 8 ; i++){

  337.             //nowactive =;

  338.             if (ioxB[i].iactive){

  339.                 float yport = yfirst + i * ystep;

  340.                 float yi =  yZoom * ioxB[i].inx * -10.f + yCenter ;

  341.                 float yo =  yZoom * ioxB[i].xout * -10.f + yCenter ;

  342.                 nvgBeginPath(vg);

  343.                 nvgStrokeWidth(vg,1.f);

  344.                 nvgStrokeColor(vg,nvgRGBA(0xff, 0xff, 0xff,0x80));

  345.                 nvgMoveTo(vg, 0.f, yport);

  346.                 nvgLineTo(vg, 20.f, yi);

  347.                 nvgLineTo(vg, 130.f, yo);

  348.                 nvgLineTo(vg, 150.f, yport);

  349.                 nvgStroke(vg);

  350.                 if (yZoom > 2.5f){

  351.                     nvgBeginPath(vg);

  352.                     nvgFillColor(vg, nvgRGBA(0xff, 0xff, 0xff,0x60));

  353.                     nvgRoundedRect(vg, 20.f, yi - keyw * 0.5f, 10.f, keyw, 2.f);

  354.                     nvgFill(vg);

  355.                     nvgBeginPath(vg);

  356.                     nvgRoundedRect(vg, 120.f, yo - keyw * 0.5f, 10.f, keyw, 2.f);

  357.                     nvgFill(vg);

  358.                 }

  359.             }

  360.         }

  361.             /// Axis Line

  362.             NVGcolor extColor = nvgRGBA(0xee, 0xee, 0x00, (1.f - *pAxisXfade) * 0xff);

  363.             NVGcolor intColor = nvgRGBA(0xee, 0x00, 0x00, *pAxisXfade * 0xff);

  364.             NVGcolor axisColor = nvgRGB(0xee, (1.f - *pAxisXfade) * 0xee, 0x00);

  365.         

  366.             Axis = yZoom * Axis * -10.f + yCenter;

  367.             nvgStrokeWidth(vg,1.f);

  368.         //ext

  369.             nvgBeginPath(vg);

  370.             nvgStrokeColor(vg,extColor);

  371.             nvgMoveTo(vg, 0.f, 228.f);

  372.             nvgLineTo(vg, 20.f, Axis);

  373.             nvgStroke(vg);

  374.         // int

  375.             nvgBeginPath(vg);

  376.             nvgStrokeColor(vg,intColor);

  377.             nvgMoveTo(vg, 0.f, yfirst + AxisIx * ystep);

  378.             nvgLineTo(vg, 20.f, Axis);

  379.             nvgStroke(vg);

  380.         // axis

  381.             nvgBeginPath(vg);

  382.             nvgStrokeColor(vg,axisColor);

  383.             nvgMoveTo(vg, 20.f, Axis);

  384.             nvgLineTo(vg, 130.f, Axis);

  385.             nvgLineTo(vg, 150.f, 222.f);

  386.             nvgStroke(vg);

  387.         }

  388. };

  389. 

  390. struct AxisDisplay : TransparentWidget {

  391.     AxisDisplay() {

  392.         font = Font::load(FONT_FILE);

  393.     }

  394.     float mdfontSize = 11.f;

  395.     std::string s;

  396.     std::shared_ptr<Font> font;

  397.     int *pAxisTransP = 0;

  398.     int frame = 0 ;

  399.     void draw(NVGcontext* vg)

  400.     {

  401.         if (frame ++ > 8 )

  402.         {

  403.             s = std::to_string(*pAxisTransP);

  404.            frame = 0;

  405.         }

  406.         NVGcolor backgroundColor = nvgRGB(0x22, 0x22, 0x22);

  407.         nvgBeginPath(vg);

  408.         nvgRoundedRect(vg, 0, 0, box.size.x, box.size.y, 3.0f);

  409.         nvgFillColor(vg, backgroundColor);

  410.         nvgFill(vg);

  411.         nvgFillColor(vg, nvgRGB(0xff,0xff,0xff));

  412.         nvgFontSize(vg, mdfontSize);

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

  414.         nvgTextAlign(vg, NVG_ALIGN_CENTER);

  415.         nvgTextLetterSpacing(vg, 0.0f);

  416.         nvgTextBox(vg, 0.f, 14.0f,box.size.x, s.c_str(), NULL);

  417.     }

  418. };

  419. 

  420. struct RangeSelector: moDllzSmSelector{

  421.     RangeSelector(){

  422.         minAngle = -0.4*M_PI;

  423.         maxAngle = 0.4*M_PI;

  424.     }

  425. };

  426. 

  427. 

  428. struct xbendKnob : SVGKnob {

  429.     xbendKnob() {

  430.         minAngle = -0.83*M_PI;

  431.         maxAngle = 0.83*M_PI;

  432.         setSVG(SVG::load(assetPlugin(plugin, "res/xbendKnob.svg")));

  433.         shadow->opacity = 0.f;

  434.     }

  435. };

  436. 

  437. struct zTTrim : SVGKnob {

  438.     zTTrim() {

  439.         minAngle = 0;

  440.         maxAngle = 1.75*M_PI;

  441.         setSVG(SVG::load(assetPlugin(plugin, "res/zTTrim.svg")));

  442.         shadow->opacity = 0.f;

  443.     }

  444. };

  445. struct cTTrim : SVGKnob {

  446.     cTTrim() {

  447.         minAngle = -0.83*M_PI;

  448.         maxAngle = 0.83*M_PI;

  449.         snap = true;

  450.         setSVG(SVG::load(assetPlugin(plugin, "res/cTTrim.svg")));

  451.         shadow->opacity = 0.f;

  452.     }

  453. };

  454. 

  455. struct autoZoom : SVGSwitch, ToggleSwitch {

  456.     autoZoom() {

  457.         addFrame(SVG::load(assetPlugin(plugin, "res/autoButton.svg")));

  458.         addFrame(SVG::load(assetPlugin(plugin, "res/autoButton.svg")));

  459.     }

  460. };

  461.                                   

  462. struct snapAxisButton : SVGSwitch, ToggleSwitch {

  463.   snapAxisButton() {

  464.       addFrame(SVG::load(assetPlugin(plugin, "res/snapButton.svg")));

  465.       addFrame(SVG::load(assetPlugin(plugin, "res/snapButton.svg")));

  466.   }

  467. };

  468.                                   

  469. 

  470. struct XBenderWidget : ModuleWidget {

  471.     

  472.         XBenderWidget(XBender *module): ModuleWidget(module){

  473.         setPanel(SVG::load(assetPlugin(plugin, "res/XBender.svg")));

  474.         float xPos;

  475.         float yPos;

  476.         float xyStep = 26.f ;

  477.         //Screws

  478.         addChild(Widget::create<ScrewBlack>(Vec(0, 0)));

  479.         addChild(Widget::create<ScrewBlack>(Vec(box.size.x - 15, 0)));

  480.         addChild(Widget::create<ScrewBlack>(Vec(0, 365)));

  481.         addChild(Widget::create<ScrewBlack>(Vec(box.size.x - 15, 365)));

  482.         

  483.         xPos = 73.f;

  484.         yPos = 22.f;

  485.         

  486.         {

  487.             BenderDisplay *benderDisplay = new BenderDisplay();

  488.             benderDisplay->box.pos = Vec(xPos, yPos);

  489.             benderDisplay->box.size = {152.f, 228.f};

  490.             benderDisplay->ioxB = &(module->ioxbended[0]);

  491.             benderDisplay->pAxis = &(module->finalAxis);

  492.             benderDisplay->pAxisIx = &(module->selectedAxisF);

  493.             benderDisplay->pyCenter = &(module->dCenter);

  494.             benderDisplay->pyZoom = &(module->dZoom);

  495.             benderDisplay->pAxisXfade = &(module->axisxfade);

  496.             addChild(benderDisplay);

  497.         }

  498.         

  499.         xPos = 170.f;

  500.         yPos = 252.f;

  501.         /// View Center Zoom

  502.         addParam(ParamWidget::create<cTTrim>(Vec(xPos,yPos), module, XBender::YCENTER_PARAM, -120.f, 120.f, 0.f));

  503.         xPos = 203;

  504.         addParam(ParamWidget::create<zTTrim>(Vec(xPos,yPos), module, XBender::YZOOM_PARAM, 1.f, 15.f, 1.f));

  505.         yPos += 1.5f;

  506.         xPos = 125.f;

  507.         addParam(ParamWidget::create<autoZoom>(Vec(xPos, yPos ), module, XBender::AUTOZOOM_PARAM, 0.0f, 1.0f, 1.0f));

  508.         addChild(ModuleLightWidget::create<TinyLight<RedLight>>(Vec(xPos + 17.f, yPos + 4.f), module, XBender::AUTOZOOM_LIGHT));

  509. 

  510.         /// IN  - Axis select  - OUTS

  511.         xPos = 12.f;

  512.         yPos = 22.f;

  513.         for (int i = 0; i < 8; i++){

  514.             // IN leds  OUT

  515.             addInput(Port::create<moDllzPort>(Vec(xPos, yPos), Port::INPUT, module, XBender::IN_INPUT + i));

  516.             addParam(ParamWidget::create<moDllzRoundButton>(Vec(xPos + 37.f, yPos + 5.f), module, XBender::AXISSELECT_PARAM + i, 0.0f, 1.0f, 0.0f));

  517.             addChild(ModuleLightWidget::create<TinyLight<RedLight>>(Vec(xPos + 42.5f, yPos + 10.5f), module, XBender::AXIS_LIGHT + i));

  518.             addOutput(Port::create<moDllzPort>(Vec(234.8f, yPos), Port::OUTPUT, module, XBender::OUT_OUTPUT + i));

  519.             yPos += xyStep;

  520.         }

  521.         yPos = 248.f;

  522.         //// AXIS out >>>> on the Right

  523.         addOutput(Port::create<moDllzPort>(Vec(234.8f, yPos), Port::OUTPUT, module, XBender::AXIS_OUTPUT));

  524.         

  525.         yPos = 249.f;

  526.         /// AXIS select in

  527.         addInput(Port::create<moDllzPort>(Vec(xPos, yPos), Port::INPUT, module, XBender::AXISSELECT_INPUT));

  528.         addParam(ParamWidget::create<snapAxisButton>(Vec(xPos + 22.5f, yPos + 2.f ), module, XBender::SNAPAXIS_PARAM, 0.0f, 1.0f, 0.0f));

  529.         addChild(ModuleLightWidget::create<TinyLight<RedLight>>(Vec(xPos + 40.f, yPos + 4.f), module, XBender::SNAPAXIS_LIGHT));

  530. 

  531.         /// AXIS EXT - XFADE

  532.         yPos += 25.f;

  533.         addInput(Port::create<moDllzPort>(Vec(xPos, yPos), Port::INPUT, module, XBender::AXISXFADE_INPUT));

  534.         addParam(ParamWidget::create<moDllzKnob26>(Vec(36.f,280.f), module, XBender::AXISXFADE_PARAM, 0.f, 1.f, 1.f));

  535.         yPos += 25.f;

  536.         addInput(Port::create<moDllzPort>(Vec(xPos, yPos), Port::INPUT, module, XBender::AXISEXT_INPUT));

  537.             

  538.         /// AXIS Slew

  539.         yPos += 25.f;

  540.         addInput(Port::create<moDllzPort>(Vec(xPos, yPos), Port::INPUT, module, XBender::AXISSLEW_INPUT));

  541.         addParam(ParamWidget::create<moDllzKnob26>(Vec(34.f, 324.f), module, XBender::AXISSLEW_PARAM, 0.f, 1.f, 0.f));

  542.  

  543.         //AXIS Mod Shift

  544.         addInput(Port::create<moDllzPort>(Vec(xPos + 53.f,yPos), Port::INPUT, module, XBender::AXISSHIFT_INPUT));

  545.         addParam(ParamWidget::create<moDllzKnob26>(Vec(87.f, 324.f), module, XBender::AXISSHIFTTRIM_PARAM, 0.0f, 1.0f, 0.f));

  546. 

  547.         //AXIS Transp

  548.         xPos = 73.5f;

  549.         yPos = 278.5f;

  550.         addParam(ParamWidget::create<moDllzPulseUp>(Vec(xPos + 31.f,yPos - 1.f), module, XBender::AXISTRNSUP_PARAM, 0.0f, 1.0f, 0.0f));

  551.         addParam(ParamWidget::create<moDllzPulseDwn>(Vec(xPos + 31.f ,yPos + 10.f), module, XBender::AXISTRNSDWN_PARAM, 0.0f, 1.0f, 0.0f));

  552.         {

  553.             AxisDisplay *axisDisplay = new AxisDisplay();

  554.             axisDisplay->box.pos = Vec(xPos, yPos);

  555.             axisDisplay->box.size = {30.f, 20};

  556.             axisDisplay->pAxisTransP = &(module->axisTransParam);

  557.             addChild(axisDisplay);

  558.         }

  559.         /// Knobs

  560.         //XBEND

  561.         xPos = 124.f;

  562.         yPos = 272.f;

  563.         addParam(ParamWidget::create<xbendKnob>(Vec(xPos, yPos), module, XBender::XBEND_PARAM, -1.f, 1.f, 0.f));

  564.         xPos = 127.5f;

  565.         yPos = 328.f;

  566.         addInput(Port::create<moDllzPort>(Vec(xPos,yPos), Port::INPUT, module, XBender::XBENDCV_INPUT));

  567.         addParam(ParamWidget::create<TTrimSnap>(Vec(xPos + 26.5f,yPos + 7.f), module, XBender::XBENDCVTRIM_PARAM, 0.f, 24.f, 24.f));

  568.         //XBEND RANGE

  569.         xPos = 181.f;

  570.         yPos = 288.f;

  571.         addParam(ParamWidget::create<RangeSelector>(Vec(xPos, yPos), module, XBender::XBENDRANGE_PARAM, 1.f, 5.f, 1.f));

  572.         xPos = 187.5f;

  573.         yPos = 328.f;

  574.         addInput(Port::create<moDllzPort>(Vec(xPos,yPos), Port::INPUT, module, XBender::XBENDRANGE_INPUT));

  575.         //BEND

  576.         xPos = 219.f;

  577.         yPos = 288.f;

  578.         addParam(ParamWidget::create<moDllzKnobM>(Vec(xPos, yPos), module, XBender::BEND_PARAM, -1.f, 1.f, 0.f));

  579.         xPos = 218.5f;

  580.         yPos = 328.f;

  581.         addInput(Port::create<moDllzPort>(Vec(xPos,yPos), Port::INPUT, module, XBender::BENDCV_INPUT));

  582.         addParam(ParamWidget::create<TTrimSnap>(Vec(xPos + 26.5f,yPos + 7.f), module, XBender::BENDCVTRIM_PARAM, 0.f, 60.f, 12.f));

  583. 

  584.     }

  585. };

  586. 

  587. // Specify the Module and ModuleWidget subclass, human-readable

  588. // manufacturer name for categorization, module slug (should never

  589. // change), human-readable module name, and any number of tags

  590. // (found in `include/tags.hpp`) separated by commas.

  591. 

  592. } // namespace rack_plugin_moDllz

  593. 

  594. using namespace rack_plugin_moDllz;

  595. 

  596. RACK_PLUGIN_MODEL_INIT(moDllz, XBender) {

  597.    Model *modelXBender = Model::create<XBender, XBenderWidget>("moDllz", "XBender", "Poly X Bender",MULTIPLE_TAG ,EFFECT_TAG);

  598.    return modelXBender;

  599. }