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.
1265 Commits
4 Branches
552MB
Tree: 9125cf9dfd
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '9125cf9dfd'
${ noResults }
Rack/plugins/community/repos/Valley/src/Amalgam/Amalgam.cpp

416 lines
19KB
Raw Blame History 

  1. #include "Amalgam.hpp"

  2. 

  3. Amalgam::Amalgam() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {

  4.     amalgamType = 0;

  5.     __zeros = _mm_set1_ps(0.f);

  6.     __fives = _mm_set1_ps(5.f);

  7.     __halfs = _mm_set1_ps(0.5f);

  8. 

  9.     __x = __zeros;

  10.     __y = __zeros;

  11.     __z = __zeros;

  12.     __xyAnd = __zeros;

  13.     __xyXor = __zeros;

  14. 

  15.     xGain = 0.f;

  16.     yGain = 0.f;

  17. 

  18.     float newSampleRate = engineGetSampleRate();

  19.     vecAmalgam.setSampleRate(newSampleRate);

  20.     xyAndDCFilter.setSampleRate(newSampleRate);

  21.     xyXorDCFilter.setSampleRate(newSampleRate);

  22.     zOutDCFilter.setSampleRate(newSampleRate);

  23.     zPls1DCFilter.setSampleRate(newSampleRate);

  24.     zPls2DCFilter.setSampleRate(newSampleRate);

  25.     zAndDCFilter.setSampleRate(newSampleRate);

  26.     zXorDCFilter.setSampleRate(newSampleRate);

  27.     xyAndDCFilter.setCutoffFreq(1.f);

  28.     xyXorDCFilter.setCutoffFreq(1.f);

  29.     zOutDCFilter.setCutoffFreq(1.f);

  30.     zPls1DCFilter.setCutoffFreq(1.f);

  31.     zPls2DCFilter.setCutoffFreq(1.f);

  32.     zAndDCFilter.setCutoffFreq(1.f);

  33.     zXorDCFilter.setCutoffFreq(1.f);

  34. }

  35. 

  36. void Amalgam::step() {

  37.     amalgamType = inputs[TYPE_CV1_INPUT].value * params[TYPE_CV1_PARAM].value;

  38.     amalgamType += inputs[TYPE_CV2_INPUT].value * params[TYPE_CV2_PARAM].value;

  39.     amalgamType = rescale(amalgamType, 0.f, 10.f, 0.f, (float)VecAmalgam::NUM_MODES);

  40.     amalgamType += params[TYPE_PARAM].value;

  41.     iAmalgamType = (int)clamp(amalgamType, 0.f, (float)VecAmalgam::NUM_MODES - 1);

  42.     vecAmalgam.setMode(iAmalgamType);

  43. 

  44.     paramA = params[A_PARAM].value;

  45.     paramA += inputs[PARAM_A_CV1_INPUT].value * 0.1f * params[PARAM_A_CV1_PARAM].value;

  46.     paramA += inputs[PARAM_A_CV2_INPUT].value * 0.1f * params[PARAM_A_CV2_PARAM].value;

  47.     paramA = clamp(paramA, 0.f, 1.f);

  48. 

  49.     paramB = params[B_PARAM].value;

  50.     paramB += inputs[PARAM_B_CV1_INPUT].value * 0.1f * params[PARAM_B_CV1_PARAM].value;

  51.     paramB += inputs[PARAM_B_CV2_INPUT].value * 0.1f * params[PARAM_B_CV2_PARAM].value;

  52.     paramB = clamp(paramB, 0.f, 1.f);

  53. 

  54.     dcCoupleButtonState = params[DC_COUPLE_PARAM].value > 0.5f ? true : false;

  55.     if(dcCoupleButtonState && !prevDcCoupleButtonState) {

  56.         dcCoupled = dcCoupled ? false : true;

  57.     }

  58.     prevDcCoupleButtonState = dcCoupleButtonState;

  59.     lights[DC_COUPLE_LIGHT].value = dcCoupled ? 10.f : 0.f;

  60. 

  61.     xyAndDCFilter.setBypass(dcCoupled);

  62.     xyXorDCFilter.setBypass(dcCoupled);

  63.     zOutDCFilter.setBypass(dcCoupled);

  64.     zPls1DCFilter.setBypass(dcCoupled);

  65.     zPls2DCFilter.setBypass(dcCoupled);

  66. 

  67.     xIn[0] = inputs[X_LEFT_INPUT].value;

  68.     xIn[1] = inputs[X_RIGHT_INPUT].value;

  69.     yIn[0] = inputs[Y_LEFT_INPUT].value;

  70.     yIn[1] = inputs[Y_RIGHT_INPUT].value;

  71. 

  72.     // Normal route left and right inputs if used in mono

  73.     if(inputs[X_LEFT_INPUT].active && !inputs[X_RIGHT_INPUT].active) {

  74.         xIn[1] = xIn[0];

  75.     }

  76.     else if(!inputs[X_LEFT_INPUT].active && inputs[X_RIGHT_INPUT].active) {

  77.         xIn[0] = xIn[1];

  78.     }

  79. 

  80.     if(inputs[Y_LEFT_INPUT].active && !inputs[Y_RIGHT_INPUT].active) {

  81.         yIn[1] = yIn[0];

  82.     }

  83.     else if(!inputs[Y_LEFT_INPUT].active && inputs[Y_RIGHT_INPUT].active) {

  84.         yIn[0] = yIn[1];

  85.     }

  86. 

  87.     xGain = inputs[X_GAIN_CV_INPUT].value * params[X_GAIN_CV_PARAM].value * 0.4f;

  88.     xGain += params[X_GAIN].value;

  89.     xGain = clamp(xGain, 0.f, 4.f);

  90. 

  91.     yGain = inputs[Y_GAIN_CV_INPUT].value * params[Y_GAIN_CV_PARAM].value * 0.4;

  92.     yGain += params[Y_GAIN].value;

  93.     yGain = clamp(yGain, 0.f, 4.f);

  94. 

  95.     __x = _mm_set_ps(xIn[0], xIn[0], xIn[1], xIn[1]);

  96.     __y = _mm_set_ps(yIn[0], yIn[0], yIn[1], yIn[1]);

  97.     __x = _mm_mul_ps(__x, _mm_set1_ps(0.15f));

  98.     __y = _mm_mul_ps(__y, _mm_set1_ps(0.15f));

  99.     __x = _mm_mul_ps(vecDriveSignal(__x, _mm_set1_ps(xGain)), _mm_set1_ps(1.333333f));

  100.     __y = _mm_mul_ps(vecDriveSignal(__y, _mm_set1_ps(yGain)), _mm_set1_ps(1.333333f));

  101. 

  102.     // AND and XOR

  103.     __xyAnd = _mm_switch_ps(__zeros, __fives, _mm_and_ps(_mm_cmpgt_ps(__x, __zeros), _mm_cmpgt_ps(__y, __zeros)));

  104.     __xyXor = _mm_switch_ps(__zeros, __fives, _mm_xor_ps(_mm_cmpgt_ps(__x, __zeros), _mm_cmpgt_ps(__y, __zeros)));

  105.     __xyAnd = xyAndDCFilter.process(__xyAnd);

  106.     __xyXor = xyXorDCFilter.process(__xyXor);

  107. 

  108.     __z = vecAmalgam.process(__x, __y, paramA, paramB);

  109. 

  110.     __zPls1Mask = _mm_cmpgt_ps(__z, __zeros);

  111.     __zPls1 = _mm_and_ps(__fives, _mm_and_ps(_mm_cmpgt_ps(__z, __zeros), _mm_cmple_ps(__z, __halfs)));

  112.     __zPls2 = _mm_and_ps(__fives, _mm_or_ps(_mm_and_ps(_mm_cmpgt_ps(__z, __zeros), _mm_cmple_ps(__z, _mm_set1_ps(0.25f))),

  113.                                             _mm_and_ps(_mm_cmpgt_ps(__z, __halfs), _mm_cmple_ps(__z, _mm_set1_ps(0.99f)))));

  114. 

  115.     __zPls1 = zPls1DCFilter.process(__zPls1);

  116.     __zPls2 = zPls2DCFilter.process(__zPls2);

  117. 

  118.     _mm_storeu_ps(zOut, __z);

  119.     _mm_storeu_ps(zPls1, __zPls1);

  120.     _mm_storeu_ps(zPls2, __zPls2);

  121.     _mm_storeu_ps(andOut, __xyAnd);

  122.     _mm_storeu_ps(xorOut, __xyXor);

  123. 

  124.     zAnd = (zOut[0] > 0.f) & (zOut[2] > 0.f) ? 5.f : 0.f;

  125.     zXor = (zOut[0] > 0.f) ^ (zOut[2] > 0.f) ? 5.f : 0.f;

  126.     zAndDCFilter.input = zAnd;

  127.     zXorDCFilter.input = zXor;

  128.     zAndDCFilter.process();

  129.     zXorDCFilter.process();

  130.     zAnd = dcCoupled ? zAnd : zAndDCFilter.output;

  131.     zXor = dcCoupled ? zXor : zXorDCFilter.output;

  132. 

  133.     __z = zOutDCFilter.process(__z);

  134.     _mm_storeu_ps(zOut, __z);

  135. 

  136.     outputs[X_Y_LEFT_AND_OUTPUT].value = andOut[2];

  137.     outputs[X_Y_RIGHT_AND_OUTPUT].value = andOut[0];

  138.     outputs[X_Y_LEFT_XOR_OUTPUT].value = xorOut[2];

  139.     outputs[X_Y_RIGHT_XOR_OUTPUT].value = xorOut[0];

  140.     outputs[Z_LEFT_OUTPUT].value = tanhDriveSignal(zOut[0], 0.66f) * 5.5f;

  141.     outputs[Z_RIGHT_OUTPUT].value = tanhDriveSignal(zOut[2], 0.66f) * 5.5f;

  142.     outputs[Z_AND_OUTPUT].value = zAnd;

  143.     outputs[Z_XOR_OUTPUT].value = zXor;

  144.     outputs[Z_LEFT_PULSE_1_OUTPUT].value = zPls1[2];

  145.     outputs[Z_RIGHT_PULSE_1_OUTPUT].value = zPls1[0];

  146.     outputs[Z_LEFT_PULSE_2_OUTPUT].value = zPls2[2];

  147.     outputs[Z_RIGHT_PULSE_2_OUTPUT].value = zPls2[0];

  148. }

  149. 

  150. void Amalgam::onSampleRateChange() {

  151.     float newSampleRate = engineGetSampleRate();

  152.     vecAmalgam.setSampleRate(newSampleRate);

  153.     xyAndDCFilter.setSampleRate(newSampleRate);

  154.     xyXorDCFilter.setSampleRate(newSampleRate);

  155.     zOutDCFilter.setSampleRate(newSampleRate);

  156.     zPls1DCFilter.setSampleRate(newSampleRate);

  157.     zPls2DCFilter.setSampleRate(newSampleRate);

  158. }

  159. 

  160. json_t* Amalgam::toJson()  {

  161.     json_t *rootJ = json_object();

  162.     int dcCoupledI = dcCoupled ? 1 : 0;

  163.     json_object_set_new(rootJ, "panelStyle", json_integer(panelStyle));

  164.     json_object_set_new(rootJ, "dcCoupled", json_integer(dcCoupledI));

  165.     return rootJ;

  166. }

  167. 

  168. void Amalgam::fromJson(json_t *rootJ) {

  169.     json_t *panelStyleJ = json_object_get(rootJ, "panelStyle");

  170.     json_t *dcCoupledJ = json_object_get(rootJ, "dcCoupled");

  171.     panelStyle = json_integer_value(panelStyleJ);

  172.     dcCoupled = json_integer_value(dcCoupledJ) ? true : false;

  173. }

  174. 

  175. ////////////////////////////////////////////////////////////////////////////////////////////////////

  176. 

  177. void AmalgamPanelStyleItem::onAction(EventAction &e) {

  178.     module->panelStyle = panelStyle;

  179. }

  180. 

  181. void AmalgamPanelStyleItem::step() {

  182.     rightText = (module->panelStyle == panelStyle) ? "✔" : "";

  183.     MenuItem::step();

  184. }

  185. 

  186. ////////////////////////////////////////////////////////////////////////////////////////////////////

  187. 

  188. AmalgamWidget::AmalgamWidget(Amalgam* module) : ModuleWidget(module) {

  189.     {

  190.         DynamicPanelWidget *panel = new DynamicPanelWidget();

  191.         panel->addPanel(SVG::load(assetPlugin(plugin, "res/AmalgamPanelDark.svg")));

  192.         panel->addPanel(SVG::load(assetPlugin(plugin, "res/AmalgamPanelLight.svg")));

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

  194.         panel->mode = &module->panelStyle;

  195.         addChild(panel);

  196.     }

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

  198.     addChild(Widget::create<ScrewBlack>(Vec(box.size.x - 2 * RACK_GRID_WIDTH, 0)));

  199.     addChild(Widget::create<ScrewBlack>(Vec(RACK_GRID_WIDTH, RACK_GRID_HEIGHT - RACK_GRID_WIDTH)));

  200.     addChild(Widget::create<ScrewBlack>(Vec(box.size.x - 2 * RACK_GRID_WIDTH, RACK_GRID_HEIGHT - RACK_GRID_WIDTH)));

  201. 

  202.     // Make jacks

  203.     addInput(Port::create<PJ301MDarkSmall>(xLeftInputPos, Port::INPUT, module, Amalgam::X_LEFT_INPUT));

  204.     addInput(Port::create<PJ301MDarkSmall>(xRightInputPos, Port::INPUT, module, Amalgam::X_RIGHT_INPUT));

  205.     addInput(Port::create<PJ301MDarkSmall>(yLeftInputPos, Port::INPUT, module, Amalgam::Y_LEFT_INPUT));

  206.     addInput(Port::create<PJ301MDarkSmall>(yRightInputPos, Port::INPUT, module, Amalgam::Y_RIGHT_INPUT));

  207. 

  208.     addInput(Port::create<PJ301MDarkSmall>(xDriveCVInputPos, Port::INPUT, module, Amalgam::X_GAIN_CV_INPUT));

  209.     addInput(Port::create<PJ301MDarkSmall>(yDriveCVInputPos, Port::INPUT, module, Amalgam::Y_GAIN_CV_INPUT));

  210.     //addInput(Port::create<PJ301MDarkSmall>(modeCVInputPos, Port::INPUT, module, Amalgam::MODE_CV_INPUT));

  211.     addInput(Port::create<PJ301MDarkSmall>(typeCV1InputPos, Port::INPUT, module, Amalgam::TYPE_CV1_INPUT));

  212.     addInput(Port::create<PJ301MDarkSmall>(typeCV2InputPos, Port::INPUT, module, Amalgam::TYPE_CV2_INPUT));

  213.     addInput(Port::create<PJ301MDarkSmall>(paramACV1InputPos, Port::INPUT, module, Amalgam::PARAM_A_CV1_INPUT));

  214.     addInput(Port::create<PJ301MDarkSmall>(paramACV2InputPos, Port::INPUT, module, Amalgam::PARAM_A_CV2_INPUT));

  215.     addInput(Port::create<PJ301MDarkSmall>(paramBCV1InputPos, Port::INPUT, module, Amalgam::PARAM_B_CV1_INPUT));

  216.     addInput(Port::create<PJ301MDarkSmall>(paramBCV2InputPos, Port::INPUT, module, Amalgam::PARAM_B_CV2_INPUT));

  217. 

  218. 

  219.     addOutput(Port::create<PJ301MDarkSmallOut>(leftANDOutputPos, Port::OUTPUT, module, Amalgam::X_Y_LEFT_AND_OUTPUT));

  220.     addOutput(Port::create<PJ301MDarkSmallOut>(leftXOROutputPos, Port::OUTPUT, module, Amalgam::X_Y_LEFT_XOR_OUTPUT));

  221.     addOutput(Port::create<PJ301MDarkSmallOut>(rightANDOutputPos, Port::OUTPUT, module, Amalgam::X_Y_RIGHT_AND_OUTPUT));

  222.     addOutput(Port::create<PJ301MDarkSmallOut>(rightXOROutputPos, Port::OUTPUT, module, Amalgam::X_Y_RIGHT_XOR_OUTPUT));

  223.     addOutput(Port::create<PJ301MDarkSmallOut>(zLeftOutputPos, Port::OUTPUT, module, Amalgam::Z_LEFT_OUTPUT));

  224.     addOutput(Port::create<PJ301MDarkSmallOut>(zRightOutputPos, Port::OUTPUT, module, Amalgam::Z_RIGHT_OUTPUT));

  225.     addOutput(Port::create<PJ301MDarkSmallOut>(zANDOutputPos, Port::OUTPUT, module, Amalgam::Z_AND_OUTPUT));

  226.     addOutput(Port::create<PJ301MDarkSmallOut>(zXOROutputPos, Port::OUTPUT, module, Amalgam::Z_XOR_OUTPUT));

  227.     addOutput(Port::create<PJ301MDarkSmallOut>(zLeftPulseOutputPos, Port::OUTPUT, module, Amalgam::Z_LEFT_PULSE_1_OUTPUT));

  228.     addOutput(Port::create<PJ301MDarkSmallOut>(zRightPulseOutputPos, Port::OUTPUT, module, Amalgam::Z_RIGHT_PULSE_1_OUTPUT));

  229.     addOutput(Port::create<PJ301MDarkSmallOut>(zLeftPulse2OutputPos, Port::OUTPUT, module, Amalgam::Z_LEFT_PULSE_2_OUTPUT));

  230.     addOutput(Port::create<PJ301MDarkSmallOut>(zRightPulse2OutputPos, Port::OUTPUT, module, Amalgam::Z_RIGHT_PULSE_2_OUTPUT));

  231. 

  232.     // Knobs

  233. 

  234.     addParam(ParamWidget::create<RoganSmallWhite>(xDriveKnobPos, module, Amalgam::X_GAIN, 0.f, 4.f, 1.f));

  235.     addParam(ParamWidget::create<RoganSmallWhite>(yDriveKnobPos, module, Amalgam::Y_GAIN, 0.f, 4.f, 1.f));

  236.     //addParam(ParamWidget::create<RoganMedSmallWhite>(modeKnobPos, module, Amalgam::MODE_PARAM, 0.f, 1.f, 0.f));

  237.     addParam(ParamWidget::create<DynRoganMedGreen>(paramAKnobPos, module, Amalgam::A_PARAM, 0.0f, 1.f, 0.f));

  238.     addParam(ParamWidget::create<DynRoganMedBlue>(paramBKnobPos, module, Amalgam::B_PARAM, 0.0f, 1.f, 0.f));

  239.     addParam(ParamWidget::create<RoganMedWhite>(typeKnobPos, module, Amalgam::TYPE_PARAM, 0.0f, VecAmalgam::NUM_MODES - 0.9f, 0.f));

  240.     addParam(ParamWidget::create<RoganSmallWhite>(modeCV1KnobPos, module, Amalgam::TYPE_CV1_PARAM, -1.0f, 1.f, 0.0f));

  241.     addParam(ParamWidget::create<RoganSmallWhite>(modeCV2KnobPos, module, Amalgam::TYPE_CV2_PARAM, -1.0f, 1.f, 0.0f));

  242.     addParam(ParamWidget::create<RoganSmallWhite>(xDriveCVKnobPos, module, Amalgam::X_GAIN_CV_PARAM, -1.0f, 1.f, 0.0f));

  243.     addParam(ParamWidget::create<RoganSmallWhite>(yDriveCVKnobPos, module, Amalgam::Y_GAIN_CV_PARAM, -1.0f, 1.f, 0.0f));

  244.     addParam(ParamWidget::create<RoganSmallGreen>(paramACV1KnobPos, module, Amalgam::PARAM_A_CV1_PARAM, -1.0f, 1.f, 0.0f));

  245.     addParam(ParamWidget::create<RoganSmallGreen>(paramACV2KnobPos, module, Amalgam::PARAM_A_CV2_PARAM, -1.0f, 1.f, 0.0f));

  246.     addParam(ParamWidget::create<RoganSmallBlue>(paramBCV1KnobPos, module, Amalgam::PARAM_B_CV1_PARAM, -1.0f, 1.f, 0.0f));

  247.     addParam(ParamWidget::create<RoganSmallBlue>(paramBCV2KnobPos, module, Amalgam::PARAM_B_CV2_PARAM, -1.0f, 1.f, 0.0f));

  248.     {

  249.         DynamicText* modeBackText = new DynamicText;

  250.         modeBackText->size = 13;

  251.         modeBackText->box.pos = Vec(75, 95.5);

  252.         modeBackText->box.size = Vec(82, 14);

  253.         modeBackText->visibility = nullptr;

  254.         modeBackText->viewMode = ACTIVE_LOW_VIEW;

  255.         modeBackText->horzAlignment = NVG_ALIGN_CENTER;

  256.         modeBackText->setFont(DynamicText::FontMode::FONT_MODE_7SEG);

  257.         modeBackText->text = make_shared<std::string>("~~~~~~~~");

  258.         modeBackText->customColor = nvgRGB(0x4F,0x00,0x00);

  259.         addChild(modeBackText);

  260.     }

  261. 

  262.     {

  263.         DynamicFrameText* modeText = new DynamicFrameText;

  264.         modeText->size = 13;

  265.         modeText->box.pos = Vec(75, 95.5);

  266.         modeText->box.size = Vec(82, 14);

  267.         modeText->itemHandle = &module->iAmalgamType;

  268.         modeText->visibility = nullptr;

  269.         modeText->viewMode = ACTIVE_LOW_VIEW;

  270.         modeText->horzAlignment = NVG_ALIGN_CENTER;

  271.         modeText->colorHandle = &module->textColor;

  272.         modeText->setFont(DynamicText::FontMode::FONT_MODE_7SEG);

  273.         for(auto i = 0; i < VecAmalgam::NUM_MODES; ++i) {

  274.             modeText->addItem(module->modeNames[i]);

  275.         }

  276.         addChild(modeText);

  277.     }

  278. 

  279.     {

  280.         DynamicFrameText* modeBlurText = new DynamicFrameText;

  281.         modeBlurText->size = 13;

  282.         modeBlurText->blur = 8.f;

  283.         modeBlurText->box.pos = Vec(75, 95.5);

  284.         modeBlurText->box.size = Vec(82, 14);

  285.         modeBlurText->itemHandle = &module->iAmalgamType;

  286.         modeBlurText->visibility = nullptr;

  287.         modeBlurText->viewMode = ACTIVE_LOW_VIEW;

  288.         modeBlurText->horzAlignment = NVG_ALIGN_CENTER;

  289.         modeBlurText->customColor = nvgRGB(0xFF, 0x7F, 0x7F);

  290.         modeBlurText->setFont(DynamicText::FontMode::FONT_MODE_7SEG);

  291.         for(auto i = 0; i < VecAmalgam::NUM_MODES; ++i) {

  292.             modeBlurText->addItem(module->modeNames[i]);

  293.         }

  294.         addChild(modeBlurText);

  295.     }

  296. 

  297.     {

  298.         DynamicText* paramABackText = new DynamicText;

  299.         paramABackText->size = 12;

  300.         paramABackText->box.pos = Vec(75, 177);

  301.         paramABackText->box.size = Vec(82, 14);

  302.         paramABackText->visibility = nullptr;

  303.         paramABackText->viewMode = ACTIVE_LOW_VIEW;

  304.         paramABackText->horzAlignment = NVG_ALIGN_CENTER;

  305.         paramABackText->setFont(DynamicText::FontMode::FONT_MODE_7SEG);

  306.         paramABackText->text = make_shared<std::string>("~~~~~~~~");

  307.         paramABackText->customColor = nvgRGB(0x4F,0x00,0x00);

  308.         addChild(paramABackText);

  309.     }

  310. 

  311.     {

  312.         DynamicFrameText* paramAText = new DynamicFrameText;

  313.         paramAText->size = 12;

  314.         paramAText->box.pos = Vec(75, 177);

  315.         paramAText->box.size = Vec(82, 14);

  316.         paramAText->itemHandle = &module->iAmalgamType;

  317.         paramAText->visibility = nullptr;

  318.         paramAText->viewMode = ACTIVE_LOW_VIEW;

  319.         paramAText->horzAlignment = NVG_ALIGN_CENTER;

  320.         paramAText->colorHandle = &module->textColor;

  321.         paramAText->setFont(DynamicText::FontMode::FONT_MODE_7SEG);

  322.         for(auto i = 0; i < VecAmalgam::NUM_MODES; ++i) {

  323.             paramAText->addItem(module->paramANames[i]);

  324.         }

  325.         addChild(paramAText);

  326.     }

  327. 

  328.     {

  329.         DynamicFrameText* paramABlurText = new DynamicFrameText;

  330.         paramABlurText->size = 12;

  331.         paramABlurText->blur = 8.f;

  332.         paramABlurText->box.pos = Vec(75, 177);

  333.         paramABlurText->box.size = Vec(82, 14);

  334.         paramABlurText->itemHandle = &module->iAmalgamType;

  335.         paramABlurText->visibility = nullptr;

  336.         paramABlurText->viewMode = ACTIVE_LOW_VIEW;

  337.         paramABlurText->horzAlignment = NVG_ALIGN_CENTER;

  338.         paramABlurText->customColor = nvgRGB(0xFF, 0x7F, 0x7F);

  339.         paramABlurText->setFont(DynamicText::FontMode::FONT_MODE_7SEG);

  340.         for(auto i = 0; i < VecAmalgam::NUM_MODES; ++i) {

  341.             paramABlurText->addItem(module->paramANames[i]);

  342.         }

  343.         addChild(paramABlurText);

  344.     }

  345. 

  346.     {

  347.         DynamicText* paramBBackText = new DynamicText;

  348.         paramBBackText->size = 12;

  349.         paramBBackText->box.pos = Vec(75, 249);

  350.         paramBBackText->box.size = Vec(82, 14);

  351.         paramBBackText->visibility = nullptr;

  352.         paramBBackText->viewMode = ACTIVE_LOW_VIEW;

  353.         paramBBackText->horzAlignment = NVG_ALIGN_CENTER;

  354.         paramBBackText->setFont(DynamicText::FontMode::FONT_MODE_7SEG);

  355.         paramBBackText->text = make_shared<std::string>("~~~~~~~~");

  356.         paramBBackText->customColor = nvgRGB(0x4F,0x00,0x00);

  357.         addChild(paramBBackText);

  358.     }

  359. 

  360.     {

  361.         DynamicFrameText* paramBText = new DynamicFrameText;

  362.         paramBText->size = 12;

  363.         paramBText->box.pos = Vec(75, 249);

  364.         paramBText->box.size = Vec(82, 14);

  365.         paramBText->itemHandle = &module->iAmalgamType;

  366.         paramBText->visibility = nullptr;

  367.         paramBText->viewMode = ACTIVE_LOW_VIEW;

  368.         paramBText->horzAlignment = NVG_ALIGN_CENTER;

  369.         paramBText->colorHandle = &module->textColor;

  370.         paramBText->setFont(DynamicText::FontMode::FONT_MODE_7SEG);

  371.         for(auto i = 0; i < VecAmalgam::NUM_MODES; ++i) {

  372.             paramBText->addItem(module->paramBNames[i]);

  373.         }

  374.         addChild(paramBText);

  375.     }

  376. 

  377.     {

  378.         DynamicFrameText* paramBBlurText = new DynamicFrameText;

  379.         paramBBlurText->size = 12;

  380.         paramBBlurText->blur = 8.f;

  381.         paramBBlurText->box.pos = Vec(75, 249);

  382.         paramBBlurText->box.size = Vec(82, 14);

  383.         paramBBlurText->itemHandle = &module->iAmalgamType;

  384.         paramBBlurText->visibility = nullptr;

  385.         paramBBlurText->viewMode = ACTIVE_LOW_VIEW;

  386.         paramBBlurText->horzAlignment = NVG_ALIGN_CENTER;

  387.         paramBBlurText->customColor = nvgRGB(0xFF, 0x7F, 0x7F);

  388.         paramBBlurText->setFont(DynamicText::FontMode::FONT_MODE_7SEG);

  389.         for(auto i = 0; i < VecAmalgam::NUM_MODES; ++i) {

  390.             paramBBlurText->addItem(module->paramBNames[i]);

  391.         }

  392.         addChild(paramBBlurText);

  393.     }

  394. 

  395.     addParam(ParamWidget::create<LightLEDButton>(DCCoupleLightPos, module, Amalgam::DC_COUPLE_PARAM, 0.f, 1.f, 0.f));

  396.     addChild(ModuleLightWidget::create<MediumLight<RedLight>>(DCCoupleLightPos.plus(Vec(2.5f, 2.5f)), module, Amalgam::DC_COUPLE_LIGHT));

  397. 

  398. }

  399. 

  400. void AmalgamWidget::appendContextMenu(Menu *menu) {

  401.     Amalgam *module = dynamic_cast<Amalgam*>(this->module);

  402.     assert(module);

  403. 

  404.     menu->addChild(construct<MenuLabel>());

  405.     menu->addChild(construct<MenuLabel>(&MenuLabel::text, "Panel style"));

  406.     menu->addChild(construct<AmalgamPanelStyleItem>(&MenuItem::text, "Dark", &AmalgamPanelStyleItem::module,

  407.                                                     module, &AmalgamPanelStyleItem::panelStyle, 0));

  408.     menu->addChild(construct<AmalgamPanelStyleItem>(&MenuItem::text, "Light", &AmalgamPanelStyleItem::module,

  409.                                                       module, &AmalgamPanelStyleItem::panelStyle, 1));

  410. }

  411. 

  412. RACK_PLUGIN_MODEL_INIT(Valley, Amalgam) {

  413.    Model *modelAmalgam = Model::create<Amalgam, AmalgamWidget>(TOSTRING(SLUG), "Amalgam", "Amalgam", RING_MODULATOR_TAG, EFFECT_TAG, WAVESHAPER_TAG);

  414.    return modelAmalgam;

  415. }