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

399 lines
18KB
Raw Blame History 

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

  2. //

  3. //   Mixer VCV Module

  4. //   Strum 2017

  5. //

  6. ///////////////////////////////////////////////////

  7.  

  8. #include "dBiz.hpp"

  9. #include "dsp/digital.hpp"

  10. #include "dsp/vumeter.hpp"

  11. 

  12. namespace rack_plugin_dBiz {

  13. 

  14. ///////////////////////////////////////////////////

  15. struct PerfMixer : Module {

  16.   enum ParamIds

  17.   {

  18.     MIX_PARAM,

  19.     AUX_R1_PARAM,

  20.     AUX_R2_PARAM,

  21.     AUX_S1_PARAM = AUX_R2_PARAM + 8,

  22.     AUX_S2_PARAM = AUX_S1_PARAM + 8,

  23.     VOL_PARAM = AUX_S2_PARAM + 8,

  24.     PAN_PARAM = VOL_PARAM + 8,

  25.     AUX_1_PARAM = PAN_PARAM + 8,

  26.     AUX_2_PARAM = AUX_1_PARAM + 8,

  27.     MUTE_PARAM = AUX_2_PARAM + 8,

  28.     NUM_PARAMS = MUTE_PARAM + 8

  29.   };

  30.   enum InputIds

  31.   {

  32.     MIX_IN_L_INPUT,

  33.     MIX_IN_R_INPUT,

  34.     CH_L_INPUT = 8,

  35.     CH_R_INPUT = CH_L_INPUT + 8,

  36.     CH_VOL_INPUT = CH_R_INPUT + 8,

  37.     CH_PAN_INPUT = CH_VOL_INPUT + 8,

  38.     CH_MUTE_INPUT = CH_PAN_INPUT + 8,

  39.     AUX_1_INPUT = CH_MUTE_INPUT + 8,

  40.     AUX_2_INPUT = CH_MUTE_INPUT + 8,

  41.     RETURN_1_L_INPUT = CH_MUTE_INPUT + 16,

  42.     RETURN_1_R_INPUT = RETURN_1_L_INPUT + 16,

  43.     RETURN_2_L_INPUT = RETURN_1_R_INPUT + 16,

  44.     RETURN_2_R_INPUT = RETURN_2_L_INPUT + 16,

  45.     NUM_INPUTS

  46.   };

  47. 

  48.   enum OutputIds {

  49. 		MIX_OUTPUT_L,

  50.     MIX_OUTPUT_R,

  51.     SEND_1_L_OUTPUT,

  52.     SEND_1_R_OUTPUT,

  53.     SEND_2_L_OUTPUT,

  54.     SEND_2_R_OUTPUT,    

  55. 		NUM_OUTPUTS

  56.   };

  57. 

  58.   enum LightIds

  59.   {

  60.     PAN_L_LIGHT,

  61.     PAN_R_LIGHT = PAN_L_LIGHT + 8,

  62.     MUTE_LIGHT = PAN_R_LIGHT + 8,

  63.     METERL_LIGHT=MUTE_LIGHT+8,

  64.     METERR_LIGHT=METERL_LIGHT+(12*8),

  65.     NUM_LIGHTS=METERR_LIGHT+(12*8)

  66.   };

  67. 

  68.   SchmittTrigger mute_triggers[8];

  69.   bool mute_states[8] = {1, 1, 1, 1, 1, 1, 1, 1};

  70. 

  71.   float ch_l_ins[8];

  72.   float ch_r_ins[8];

  73.   float channel_outs_l[8];

  74.   float channel_outs_r[8];

  75.   float channel_s1_L[8];

  76.   float channel_s1_R[8];

  77.   float channel_s2_L[8];

  78.   float channel_s2_R[8];

  79.   float left_sum = 0.0;

  80.   float right_sum = 0.0;

  81. 

  82.   float mix_in_l =0.0f;

  83.   float mix_in_r = 0.0f;

  84. 

  85.   float send_1_L_sum = 0.0;

  86.   float send_1_R_sum = 0.0;

  87.   float send_2_R_sum = 0.0;

  88.   float send_2_L_sum = 0.0;

  89. 

  90.   PerfMixer() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS,NUM_LIGHTS) {}

  91.   void step() override;

  92. 

  93.   json_t *toJson() override

  94.   {

  95.     json_t *rootJ = json_object();

  96. 

  97.     // mute states

  98.     json_t *mute_statesJ = json_array();

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

  100.     {

  101.       json_t *mute_stateJ = json_integer((int)mute_states[i]);

  102.       json_array_append_new(mute_statesJ, mute_stateJ);

  103.     }

  104.     json_object_set_new(rootJ, "mutes", mute_statesJ);

  105.     return rootJ;

  106.   }

  107. 

  108.   void fromJson(json_t *rootJ) override

  109.   {

  110.     // mute states

  111.     json_t *mute_statesJ = json_object_get(rootJ, "mutes");

  112.     if (mute_statesJ)

  113.     {

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

  115.       {

  116.         json_t *mute_stateJ = json_array_get(mute_statesJ, i);

  117.         if (mute_stateJ)

  118.           mute_states[i] = !!json_integer_value(mute_stateJ);

  119.       }

  120.     }

  121.   }

  122. 

  123. };

  124. 

  125. ///////////////////////////////////////////////////////////////////

  126. void PerfMixer::step() 

  127. {

  128.   send_1_L_sum = 0.0;

  129.   send_1_R_sum = 0.0;

  130.   send_2_L_sum = 0.0;

  131.   send_2_R_sum = 0.0;

  132.   left_sum = 0.0;

  133.   right_sum = 0.0;

  134.   VUMeter vuBarsL[8]={};

  135.   VUMeter vuBarsR[8] = {};

  136. 

  137.   mix_in_l=inputs[MIX_IN_L_INPUT].value;

  138.   mix_in_r=inputs[MIX_IN_R_INPUT].value;

  139. 

  140.   float pan_cv[8]={};

  141.   float pan_pos[8]={};

  142. 

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

  144.   {

  145.     

  146. 

  147.   }

  148. 

  149.     // mute triggers

  150. 

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

  152.       {

  153. 

  154.         if (mute_triggers[i].process(params[MUTE_PARAM + i].value))

  155.         {

  156.     		  mute_states[i] = !mute_states[i];

  157.     	  }

  158.         lights[MUTE_LIGHT + i].value = mute_states[i] ? 1.0 : 0.0;

  159.       }

  160. 

  161. 

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

  163.     {

  164.       pan_cv[i] = inputs[CH_PAN_INPUT + i].value / 5;

  165.       pan_pos[i] = pan_cv[i] + params[PAN_PARAM + i].value;

  166.       if (pan_pos[i] < 0)

  167.         pan_pos[i] = 0;

  168.       if (pan_pos[i] > 1)

  169.         pan_pos[i] = 1;

  170. 

  171.       lights[PAN_L_LIGHT+i].value=1-pan_pos[i];

  172.       lights[PAN_R_LIGHT+i].value=pan_pos[i];

  173. 

  174.       ch_l_ins[i] = inputs[CH_L_INPUT + i].value * params[VOL_PARAM + i].value * clamp(inputs[CH_VOL_INPUT + i].normalize(10.0f) / 10.0f, 0.0f, 1.0f);

  175.       ch_r_ins[i] = inputs[CH_R_INPUT + i].value * params[VOL_PARAM + i].value * clamp(inputs[CH_VOL_INPUT + i].normalize(10.0f) / 10.0f, 0.0f, 1.0f);

  176. 

  177.       if (!mute_states[i] || inputs[CH_MUTE_INPUT + i].value > 0.0)

  178.       {

  179.         ch_l_ins[i] = 0.0;

  180.         ch_r_ins[i] = 0.0;

  181.         lights[MUTE_LIGHT + i].value = 0.0;      

  182.       }

  183. 

  184.           if(!inputs[CH_R_INPUT+i].value)

  185.           {

  186.             channel_outs_l[i] = ch_l_ins[i] * (1 - pan_pos[i]) * 3;

  187.             channel_outs_r[i] = ch_l_ins[i] * pan_pos[i] * 3;

  188.           }

  189.           else

  190.           {

  191.             channel_outs_l[i] = ch_l_ins[i] * 2;

  192.             channel_outs_r[i] = ch_r_ins[i] * 2;

  193.           }

  194.           

  195. 

  196.           channel_s1_L[i] = channel_outs_l[i] * params[AUX_1_PARAM + i].value * clamp(inputs[AUX_1_INPUT + i].normalize(5.0f) / 5.0f, 0.0f, 1.0f) * clamp(inputs[CH_VOL_INPUT + i].normalize(10.0f) / 10.0f, 0.0f, 1.0f);

  197.           channel_s2_L[i] = channel_outs_l[i] * params[AUX_2_PARAM + i].value * clamp(inputs[AUX_2_INPUT + i].normalize(5.0f)/5.0f,0.0f,1.0f) * clamp(inputs[CH_VOL_INPUT + i].normalize(10.0f) / 10.0f, 0.0f, 1.0f);

  198. 

  199.           channel_s1_R[i] = channel_outs_r[i] * params[AUX_1_PARAM + i].value * clamp(inputs[AUX_1_INPUT + i].normalize(5.0f)/5.0f,0.0f,1.0f) * clamp(inputs[CH_VOL_INPUT + i].normalize(10.0f) / 10.0f, 0.0f, 1.0f);

  200.           channel_s2_R[i] = channel_outs_r[i] * params[AUX_2_PARAM + i].value * clamp(inputs[AUX_2_INPUT + i].normalize(5.0f)/5.0f,0.0f,1.0f) * clamp(inputs[CH_VOL_INPUT + i].normalize(10.0f) / 10.0f, 0.0f, 1.0f);

  201. 

  202.           vuBarsL[i].dBInterval = 3;

  203.           vuBarsR[i].dBInterval = 3;

  204. 

  205.           vuBarsL[i].setValue(channel_outs_l[i] / 10.0);

  206.           vuBarsR[i].setValue(channel_outs_r[i] / 10.0);

  207. 

  208.           for (int l = 0; l < 12; l++)

  209.           {

  210.             lights[METERL_LIGHT + l + (i * 11)].setBrightnessSmooth(vuBarsL[i].getBrightness(l));

  211.             lights[METERR_LIGHT + l + (i * 11)].setBrightnessSmooth(vuBarsR[i].getBrightness(l));

  212.             }

  213. 

  214.             send_1_L_sum += channel_s1_L[i];

  215.             send_1_R_sum += channel_s1_R[i];

  216.             send_2_L_sum += channel_s2_L[i];

  217.             send_2_R_sum += channel_s2_R[i];

  218.             left_sum += channel_outs_l[i];

  219.             right_sum += channel_outs_r[i];

  220.         

  221.     }

  222. 	

  223. 

  224.     // get returns

  225.  

  226.     float return_1_l = inputs[RETURN_1_L_INPUT].value * params[AUX_R1_PARAM].value;

  227.     float return_1_r = inputs[RETURN_1_R_INPUT].value * params[AUX_R1_PARAM].value;

  228.     float return_2_l = inputs[RETURN_2_L_INPUT].value * params[AUX_R2_PARAM].value;

  229.     float return_2_r = inputs[RETURN_2_R_INPUT].value * params[AUX_R2_PARAM].value;

  230. 

  231. 

  232.   	float mix_l = (left_sum + return_1_l + return_2_l) * params[MIX_PARAM].value*0.5;

  233.     float mix_r = (right_sum + return_1_r + return_2_r) * params[MIX_PARAM].value*0.5;

  234.       

  235.     

  236.     float send_1_L_mix = (send_1_L_sum) * params[AUX_S1_PARAM].value;

  237.     float send_1_R_mix = (send_1_R_sum) * params[AUX_S1_PARAM].value;

  238.     float send_2_L_mix = (send_2_L_sum) * params[AUX_S2_PARAM].value;

  239.     float send_2_R_mix = (send_2_R_sum) * params[AUX_S2_PARAM].value;

  240. 

  241.     outputs[MIX_OUTPUT_L].value = mix_l+mix_in_l;

  242.     outputs[MIX_OUTPUT_R].value = mix_r+mix_in_r;

  243. 

  244. 

  245.     outputs[SEND_1_L_OUTPUT].value = 3 * send_1_L_mix;

  246.     outputs[SEND_1_R_OUTPUT].value = 3 * send_1_R_mix;

  247.     outputs[SEND_2_L_OUTPUT].value = 3 * send_2_L_mix;

  248.     outputs[SEND_2_R_OUTPUT].value = 3 * send_2_R_mix;

  249. 

  250.     	

  251.   }

  252.   

  253. template <typename BASE>

  254. struct MuteLight : BASE

  255. {

  256.   MuteLight()

  257.   {

  258.     this->box.size = Vec(15.0, 15.0);

  259.   }

  260. };

  261. 

  262. template <typename BASE>

  263. struct MeterLight : BASE

  264. {

  265.   MeterLight()

  266.   {

  267.     this->box.size = Vec(4, 4);

  268.     this->bgColor = nvgRGBAf(0.0, 0.0, 0.0, 0.1);

  269.   }

  270. };

  271. 

  272. 

  273. struct PerfMixerWidget : ModuleWidget 

  274. {

  275. PerfMixerWidget(PerfMixer *module) : ModuleWidget(module)

  276. {

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

  278. 

  279. 	{

  280. 		SVGPanel *panel = new SVGPanel();

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

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

  283. 		addChild(panel);

  284. 	}

  285.   int column_1 = 70;

  286.   int lb=5;

  287.   int right_column = 310;

  288.   int top=50;

  289.   int top_row = 60;

  290.   int row_spacing = 28;

  291.   int row_in = 40;

  292.   int column_spacing = 30;

  293. 

  294.   addParam(ParamWidget::create<LRoundWhy>(Vec(right_column + 5, 10), module, PerfMixer::MIX_PARAM, 0.0, 1.0, 0.5)); // master volume

  295. 

  296.   addParam(ParamWidget::create<MicroBlu>(Vec(right_column+7.5, 225 ), module, PerfMixer::AUX_R1_PARAM, 0.0, 1.0, 0.0));

  297.   addParam(ParamWidget::create<MicroBlu>(Vec(right_column+7.5, 285 ), module, PerfMixer::AUX_R2_PARAM, 0.0, 1.0, 0.0));

  298. 

  299.   addParam(ParamWidget::create<MicroBlu>(Vec(right_column+7.5, 102.5 ), module, PerfMixer::AUX_S1_PARAM, 0.0, 1.0, 0.0));

  300.   addParam(ParamWidget::create<MicroBlu>(Vec(right_column+7.5, 160 ), module, PerfMixer::AUX_S2_PARAM, 0.0, 1.0, 0.0));

  301. 

  302.   // channel strips

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

  304.   {

  305. 

  306.     addInput(Port::create<PJ301MLPort>(Vec(5,7), Port::INPUT, module, PerfMixer::MIX_IN_L_INPUT));

  307.     addInput(Port::create<PJ301MRPort>(Vec(30,7), Port::INPUT, module, PerfMixer::MIX_IN_R_INPUT));

  308. 

  309.     addParam(ParamWidget::create<MicroBlu>(Vec(column_1 + column_spacing * i, 75), module, PerfMixer::AUX_1_PARAM + i, 0.0, 1.0, 0.0));

  310.     addParam(ParamWidget::create<MicroBlu>(Vec(column_1 + column_spacing * i, 105), module, PerfMixer::AUX_2_PARAM + i, 0.0, 1.0, 0.0));

  311. 

  312.     addInput(Port::create<PJ301MCPort>(Vec(column_1 + column_spacing * i, 15), Port::INPUT, module, PerfMixer::AUX_1_INPUT + i));

  313.     addInput(Port::create<PJ301MCPort>(Vec(column_1 + column_spacing * i, 40), Port::INPUT, module, PerfMixer::AUX_2_INPUT + i));

  314. 

  315.     addInput(Port::create<PJ301MIPort>(Vec(lb, top + row_in * i), Port::INPUT, module, PerfMixer::CH_L_INPUT + i));

  316.     addInput(Port::create<PJ301MIPort>(Vec(lb + 25, top + row_in * i), Port::INPUT, module, PerfMixer::CH_R_INPUT + i));

  317. 

  318.     addParam(ParamWidget::create<LEDSliderBlue>(Vec(column_1 + column_spacing * i-5, top_row + row_spacing * 2 - 20 + top), module, PerfMixer::VOL_PARAM + i, 0.0, 1.0, 0.0));

  319. 

  320.     addInput(Port::create<PJ301MCPort>(Vec(column_1 + column_spacing * i - 1, top_row + row_spacing * 6 - 45 + top), Port::INPUT, module, PerfMixer::CH_VOL_INPUT + i));

  321. 

  322. /////////////////////////////////////////////////////

  323. 

  324.     addChild(ModuleLightWidget::create<MeterLight<OrangeLight>>(Vec(column_1 + column_spacing * i + 1 , top_row + row_spacing * 6 + top-15),module,PerfMixer::PAN_L_LIGHT+i));

  325.     addChild(ModuleLightWidget::create<MeterLight<OrangeLight>>(Vec(column_1 + column_spacing * i + 20 , top_row + row_spacing * 6 + top-15),module,PerfMixer::PAN_R_LIGHT+i));

  326. 

  327. 

  328.     addParam(ParamWidget::create<Trimpot>(Vec(column_1 + column_spacing * i +3, top_row + row_spacing * 6 + top-10), module, PerfMixer::PAN_PARAM + i, 0.0, 1.0, 0.5));

  329.     addInput(Port::create<PJ301MOrPort>(Vec(column_1 + column_spacing * i - 1, top_row + row_spacing * 6 + top+10), Port::INPUT, module, PerfMixer::CH_PAN_INPUT + i));

  330. 

  331.     ////////////////////////////////////////////////////////

  332. 

  333.     addParam(ParamWidget::create<LEDButton>(Vec(column_1 + column_spacing * i + 3 , top_row + row_spacing * 7+ 10.5 + top+3), module, PerfMixer::MUTE_PARAM + i, 0.0, 1.0, 0.0));

  334.     addChild(GrayModuleLightWidget::create<MuteLight<BlueLight>>(Vec(column_1 + column_spacing * i + 4.5 , top_row + row_spacing * 7 +12 + top+3), module, PerfMixer::MUTE_LIGHT + i));

  335.     

  336.     addInput(Port::create<PJ301MCPort>(Vec(column_1 + column_spacing * i-1, top_row + row_spacing * 8 + top+5), Port::INPUT, module, PerfMixer::CH_MUTE_INPUT + i));

  337. 

  338.     //addChild(GrayModuleLightWidget::create<MeterLight<RedLight>>(Vec(column_1   +19 + column_spacing * i, top_row + row_spacing * 2 - 30 + top), module, PerfMixer::METER_LIGHT + 0+(11*i)));

  339.     addChild(ModuleLightWidget::create<MeterLight<RedLight>>(Vec(column_1 + 19 + column_spacing * i-5, top_row + row_spacing * 2 - 27 + top + 7.5), module, PerfMixer::METERL_LIGHT + 1 + (11 * i)));

  340.     addChild(ModuleLightWidget::create<MeterLight<RedLight>>(Vec(column_1 + 19 + column_spacing * i-5, top_row + row_spacing * 2 - 27 + top + 7.5 * 2), module, PerfMixer::METERL_LIGHT + 2 + (11 * i)));

  341.     addChild(ModuleLightWidget::create<MeterLight<BlueLight>>(Vec(column_1 + 19 + column_spacing * i-5, top_row + row_spacing * 2 - 27 + top + 7.5 * 3), module, PerfMixer::METERL_LIGHT + 3 + (11 * i)));

  342.     addChild(ModuleLightWidget::create<MeterLight<BlueLight>>(Vec(column_1 + 19 + column_spacing * i-5, top_row + row_spacing * 2 - 27 + top + 7.5 * 4), module, PerfMixer::METERL_LIGHT + 4 + (11 * i)));

  343.     addChild(ModuleLightWidget::create<MeterLight<BlueLight>>(Vec(column_1 + 19 + column_spacing * i-5, top_row + row_spacing * 2 - 27 + top + 7.5 * 5), module, PerfMixer::METERL_LIGHT + 5 + (11 * i)));

  344.     addChild(ModuleLightWidget::create<MeterLight<BlueLight>>(Vec(column_1 + 19 + column_spacing * i-5, top_row + row_spacing * 2 - 27 + top + 7.5 * 6), module, PerfMixer::METERL_LIGHT + 6 + (11 * i)));

  345.     addChild(ModuleLightWidget::create<MeterLight<BlueLight>>(Vec(column_1 + 19 + column_spacing * i-5, top_row + row_spacing * 2 - 27 + top + 7.5 * 7), module, PerfMixer::METERL_LIGHT + 7 + (11 * i)));

  346.     addChild(ModuleLightWidget::create<MeterLight<GreenLight>>(Vec(column_1 + 19 + column_spacing * i-5, top_row + row_spacing * 2 - 27 + top + 7.5 * 8), module, PerfMixer::METERL_LIGHT + 8 + (11 * i)));

  347.     addChild(ModuleLightWidget::create<MeterLight<GreenLight>>(Vec(column_1 + 19 + column_spacing * i-5, top_row + row_spacing * 2 - 27 + top + 7.5 * 9), module, PerfMixer::METERL_LIGHT + 9 + (11 * i)));

  348.     addChild(ModuleLightWidget::create<MeterLight<GreenLight>>(Vec(column_1 + 19 + column_spacing * i-5, top_row + row_spacing * 2 - 27 + top + 7.5 * 10), module, PerfMixer::METERL_LIGHT + 10 + (11 * i)));

  349.     addChild(ModuleLightWidget::create<MeterLight<GreenLight>>(Vec(column_1 + 19 + column_spacing * i-5, top_row + row_spacing * 2 - 27 + top + 7.5 * 11), module, PerfMixer::METERL_LIGHT + 11 + (11 * i)));

  350. 

  351.     addChild(ModuleLightWidget::create<MeterLight<RedLight>>(Vec(column_1 + 24 + column_spacing * i-5, top_row + row_spacing * 2 - 27 + top + 7.5), module, PerfMixer::METERR_LIGHT + 1 + (11 * i)));

  352.     addChild(ModuleLightWidget::create<MeterLight<RedLight>>(Vec(column_1 + 24 + column_spacing * i-5, top_row + row_spacing * 2 - 27 + top + 7.5 * 2), module, PerfMixer::METERR_LIGHT + 2 + (11 * i)));

  353.     addChild(ModuleLightWidget::create<MeterLight<BlueLight>>(Vec(column_1 + 24 + column_spacing * i-5, top_row + row_spacing * 2 - 27 + top + 7.5 * 3), module, PerfMixer::METERR_LIGHT + 3 + (11 * i)));

  354.     addChild(ModuleLightWidget::create<MeterLight<BlueLight>>(Vec(column_1 + 24 + column_spacing * i-5, top_row + row_spacing * 2 - 27 + top + 7.5 * 4), module, PerfMixer::METERR_LIGHT + 4 + (11 * i)));

  355.     addChild(ModuleLightWidget::create<MeterLight<BlueLight>>(Vec(column_1 + 24 + column_spacing * i-5, top_row + row_spacing * 2 - 27 + top + 7.5 * 5), module, PerfMixer::METERR_LIGHT + 5 + (11 * i)));

  356.     addChild(ModuleLightWidget::create<MeterLight<BlueLight>>(Vec(column_1 + 24 + column_spacing * i-5, top_row + row_spacing * 2 - 27 + top + 7.5 * 6), module, PerfMixer::METERR_LIGHT + 6 + (11 * i)));

  357.     addChild(ModuleLightWidget::create<MeterLight<BlueLight>>(Vec(column_1 + 24 + column_spacing * i-5, top_row + row_spacing * 2 - 27 + top + 7.5 * 7), module, PerfMixer::METERR_LIGHT + 7 + (11 * i)));

  358.     addChild(ModuleLightWidget::create<MeterLight<GreenLight>>(Vec(column_1 + 24 + column_spacing * i-5, top_row + row_spacing * 2 - 27 + top + 7.5 * 8), module, PerfMixer::METERR_LIGHT + 8 + (11 * i)));

  359.     addChild(ModuleLightWidget::create<MeterLight<GreenLight>>(Vec(column_1 + 24 + column_spacing * i-5, top_row + row_spacing * 2 - 27 + top + 7.5 * 9), module, PerfMixer::METERR_LIGHT + 9 + (11 * i)));

  360.     addChild(ModuleLightWidget::create<MeterLight<GreenLight>>(Vec(column_1 + 24 + column_spacing * i-5, top_row + row_spacing * 2 - 27 + top + 7.5 * 10), module, PerfMixer::METERR_LIGHT + 10 + (11 * i)));

  361.     addChild(ModuleLightWidget::create<MeterLight<GreenLight>>(Vec(column_1 + 24 + column_spacing * i-5, top_row + row_spacing * 2 - 27 + top + 7.5 * 11), module, PerfMixer::METERR_LIGHT + 11 + (11 * i)));

  362.   } 

  363.  

  364. 

  365. //Screw

  366. 

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

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

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

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

  371. 

  372.   // outputs

  373.   addOutput(Port::create<PJ301MLPort>(Vec(right_column +5 , 60), Port::OUTPUT, module, PerfMixer::MIX_OUTPUT_L));

  374. 	addOutput(Port::create<PJ301MRPort>(Vec(right_column +30 , 60 ), Port::OUTPUT, module, PerfMixer::MIX_OUTPUT_R));

  375. 

  376.   addOutput(Port::create<PJ301MLPort>(Vec(right_column + 35, 100 ), Port::OUTPUT, module, PerfMixer::SEND_1_L_OUTPUT));

  377.   addOutput(Port::create<PJ301MRPort>(Vec(right_column + 35, 125 ), Port::OUTPUT, module, PerfMixer::SEND_1_R_OUTPUT));

  378.   

  379.   addOutput(Port::create<PJ301MLPort>(Vec(right_column + 35, 160 ), Port::OUTPUT, module, PerfMixer::SEND_2_L_OUTPUT));

  380.   addOutput(Port::create<PJ301MRPort>(Vec(right_column + 35, 185 ), Port::OUTPUT, module, PerfMixer::SEND_2_R_OUTPUT));

  381. 

  382.   addInput(Port::create<PJ301MLPort>(Vec(right_column + 35, 225 ), Port::INPUT, module, PerfMixer::RETURN_1_L_INPUT));

  383.   addInput(Port::create<PJ301MRPort>(Vec(right_column + 35, 250 ), Port::INPUT, module, PerfMixer::RETURN_1_R_INPUT));

  384. 

  385.   addInput(Port::create<PJ301MLPort>(Vec(right_column + 35, 285 ), Port::INPUT, module, PerfMixer::RETURN_2_L_INPUT));

  386.   addInput(Port::create<PJ301MRPort>(Vec(right_column + 35, 310 ), Port::INPUT, module, PerfMixer::RETURN_2_R_INPUT));

  387. }

  388. };

  389. 

  390. } // namespace rack_plugin_dBiz

  391. 

  392. using namespace rack_plugin_dBiz;

  393. 

  394. RACK_PLUGIN_MODEL_INIT(dBiz, PerfMixer) {

  395.    Model *modelPerfMixer = Model::create<PerfMixer, PerfMixerWidget>("dBiz", "PerfMixer", "PerfMixer", MIXER_TAG);

  396.    return modelPerfMixer;

  397. }