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.
1157 Commits
4 Branches
540MB
Tree: 33a014f5e8
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '33a014f5e8'
${ noResults }
Rack/plugins/community/repos/Valley/src/Plateau/Plateau.cpp

344 lines
16KB
Raw Blame History 

  1. #include "Plateau.hpp"

  2. 

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

  4.     reverb.setSampleRate(engineGetSampleRate());

  5.     size = 1.f;

  6.     diffusion;

  7.     decay = 0.f;

  8.     inputDampLow = 0.f;

  9.     inputDampHigh = 10.f;

  10.     reverbDampLow = 0.f;

  11.     reverbDampHigh = 10.f;

  12.     modSpeed = 0.1f;

  13.     modShape = 0.5f;

  14.     modDepth = 0.0f;

  15. 

  16.     freezeButtonState = false;

  17.     freezeToggle = false;

  18.     freezeToggleButtonState = false;

  19.     freeze = false;

  20.     frozen = false;

  21.     tunedButtonState = false;

  22.     diffuseButtonState = false;

  23. 

  24.     clear = 0;

  25.     cleared = false;

  26.     tuned = 0;

  27.     diffuseInput = 1;

  28. }

  29. 

  30. void Plateau::step() {

  31.     //Freeze

  32.     if(params[FREEZE_TOGGLE_PARAM].value > 0.5f && !freezeToggleButtonState) {

  33.         freezeToggleButtonState = true;

  34.         freezeToggle = !freezeToggle;

  35.     }

  36.     else if(params[FREEZE_TOGGLE_PARAM].value < 0.5f && freezeToggleButtonState) {

  37.         freezeToggleButtonState = false;

  38.     }

  39.     lights[FREEZE_TOGGLE_LIGHT].value = freezeToggle ? 10.f : 0.f;

  40. 

  41.     if((params[FREEZE_PARAM].value > 0.5f || inputs[FREEZE_CV_INPUT].value > 0.5f)

  42.     && !freezeButtonState) {

  43.         freeze = freezeToggle ? !freeze : true;

  44.         freezeButtonState = true;

  45.     }

  46.     if(params[FREEZE_PARAM].value <= 0.5f && inputs[FREEZE_CV_INPUT].value <= 0.5f

  47.     && freezeButtonState) {

  48.         freeze = freezeToggle ? freeze : false;

  49.         freezeButtonState = false;

  50.     }

  51. 

  52.     if(freeze && !frozen) {

  53.         frozen = true;

  54.         reverb.freeze();

  55.     }

  56.     else if(!freeze && frozen){

  57.         frozen = false;

  58.         reverb.unFreeze();

  59.     }

  60.     lights[FREEZE_LIGHT].value = freeze ? 10.f : 0.f;

  61. 

  62.     // Clear

  63.     if(params[CLEAR_PARAM].value > 0.5f || inputs[CLEAR_CV_INPUT].value > 0.5f) {

  64.         clear = 1;

  65.     }

  66.     else if(params[CLEAR_PARAM].value < 0.5f && inputs[CLEAR_CV_INPUT].value < 0.5f) {

  67.         clear = 0;

  68.     }

  69. 

  70.     if(params[TUNED_MODE_PARAM].value > 0.5f && tunedButtonState == false) {

  71.         tuned = 1 - tuned;

  72.         tunedButtonState = true;

  73.     }

  74.     else if(params[TUNED_MODE_PARAM].value < 0.5f && tunedButtonState) {

  75.         tunedButtonState = false;

  76.     }

  77.     lights[TUNED_MODE_LIGHT].value = tuned ? 10.f : 0.f;

  78. 

  79.     if(params[DIFFUSE_INPUT_PARAM].value > 0.5f && diffuseButtonState == false) {

  80.         diffuseInput = 1 - diffuseInput;

  81.         diffuseButtonState = true;

  82.     }

  83.     else if(params[DIFFUSE_INPUT_PARAM].value < 0.5f && diffuseButtonState) {

  84.         diffuseButtonState = false;

  85.     }

  86.     lights[DIFFUSE_INPUT_LIGHT].value = diffuseInput ? 10.f : 0.f;

  87. 

  88.     if(clear && !cleared) {

  89.         cleared = true;

  90.         reverb.clear();

  91.         lights[CLEAR_LIGHT].value = 10.f;

  92.     }

  93.     else if(!clear && cleared){

  94.         cleared = false;

  95.         lights[CLEAR_LIGHT].value = 0.f;

  96.     }

  97. 

  98.     // CV

  99.     reverb.setPreDelay(params[PRE_DELAY_PARAM].value);

  100. 

  101.     size = inputs[SIZE_CV_INPUT].value * params[SIZE_CV_PARAM].value * 0.1f;

  102.     size += params[SIZE_PARAM].value;

  103.     if(tuned) {

  104.         size = sizeMin * powf(2.f, size * 5.f);

  105.         size = clamp(size, sizeMin, 2.5f);

  106.     }

  107.     else {

  108.         size *= size;

  109.         size = rescale(size, 0.f, 1.f, 0.01f, sizeMax);

  110.         size = clamp(size, 0.01f, sizeMax);

  111.     }

  112.     reverb.setTimeScale(size);

  113. 

  114.     diffusion = inputs[DIFFUSION_CV_INPUT].value * params[DIFFUSION_CV_PARAM].value;

  115.     diffusion += params[DIFFUSION_PARAM].value;

  116.     diffusion = clamp(diffusion, 0.f, 10.f);

  117.     reverb.plateDiffusion1 = rescale(diffusion, 0.f, 10.f, 0.f, 0.7f);

  118.     reverb.plateDiffusion2 = rescale(diffusion, 0.f, 10.f, 0.f, 0.5f);

  119. 

  120.     decay = rescale(inputs[DECAY_CV_INPUT].value * params[DECAY_CV_PARAM].value, 0.f, 10.f, 0.1f, 0.999f);

  121.     decay += params[DECAY_PARAM].value;

  122.     decay = clamp(decay, 0.1f, decayMax);

  123.     decay = 1.f - decay;

  124.     decay = 1.f - decay * decay;

  125. 

  126.     inputDampLow = inputs[INPUT_LOW_DAMP_CV_INPUT].value * params[INPUT_LOW_DAMP_CV_PARAM].value;

  127.     inputDampLow += params[INPUT_LOW_DAMP_PARAM].value;

  128.     inputDampLow = clamp(inputDampLow, 0.f, 10.f);

  129.     inputDampLow = 10.f - inputDampLow;

  130. 

  131.     inputDampHigh = inputs[INPUT_HIGH_DAMP_CV_INPUT].value * params[INPUT_HIGH_DAMP_CV_PARAM].value;

  132.     inputDampHigh += params[INPUT_HIGH_DAMP_PARAM].value;

  133.     inputDampHigh = clamp(inputDampHigh, 0.f, 10.f);

  134. 

  135.     reverbDampLow = inputs[REVERB_LOW_DAMP_CV_INPUT].value * params[REVERB_LOW_DAMP_CV_PARAM].value;

  136.     reverbDampLow += params[REVERB_LOW_DAMP_PARAM].value;

  137.     reverbDampLow = clamp(reverbDampLow, 0.f, 10.f);

  138.     reverbDampLow = 10.f - reverbDampLow;

  139. 

  140.     reverbDampHigh = inputs[REVERB_HIGH_DAMP_CV_INPUT].value * params[REVERB_HIGH_DAMP_CV_PARAM].value;

  141.     reverbDampHigh += params[REVERB_HIGH_DAMP_PARAM].value;

  142.     reverbDampHigh = clamp(reverbDampHigh, 0.f, 10.f);

  143. 

  144.     reverb.diffuseInput = (double)diffuseInput;

  145. 

  146.     reverb.decay = decay;

  147.     reverb.inputLowCut = 440.f * powf(2.f, inputDampLow - 5.f);

  148.     reverb.inputHighCut = 440.f * powf(2.f, inputDampHigh - 5.f);

  149.     reverb.reverbLowCut = 440.f * powf(2.f, reverbDampLow - 5.f);

  150.     reverb.reverbHighCut = 440.f * powf(2.f, reverbDampHigh - 5.f);

  151. 

  152.     modSpeed = inputs[MOD_SPEED_CV_INPUT].value * params[MOD_SPEED_CV_PARAM].value * 0.1f;

  153.     modSpeed += params[MOD_SPEED_PARAM].value;

  154.     modSpeed = clamp(modSpeed, modSpeedMin, modSpeedMax);

  155.     modSpeed *= modSpeed;

  156.     modSpeed = modSpeed * 99.f + 1.f;

  157. 

  158.     modShape = inputs[MOD_SHAPE_CV_INPUT].value * params[MOD_DEPTH_CV_PARAM].value * 0.1f;

  159.     modShape += params[MOD_SHAPE_PARAM].value;

  160.     modShape = rescale(modShape, 0.f, 1.f, modShapeMin, modShapeMax);

  161.     modShape = clamp(modShape, modShapeMin, modShapeMax);

  162. 

  163.     modDepth = inputs[MOD_DEPTH_CV_INPUT].value * params[MOD_DEPTH_CV_PARAM].value;

  164.     modDepth = rescale(modDepth, 0.f, 10.f, modDepthMin, modDepthMax);

  165.     modDepth += params[MOD_DEPTH_PARAM].value;

  166.     modDepth = clamp(modDepth, modDepthMin, modDepthMax);

  167. 

  168.     reverb.modSpeed = modSpeed;

  169.     reverb.modDepth = modDepth;

  170.     reverb.setModShape(modShape);

  171. 

  172.     reverb.process(inputs[LEFT_INPUT].value / 10.f, inputs[RIGHT_INPUT].value / 10.f);

  173. 

  174.     dry = inputs[DRY_CV_INPUT].value * params[DRY_CV_PARAM].value;

  175.     dry += params[DRY_PARAM].value;

  176.     dry = clamp(dry, 0.f, 1.f);

  177. 

  178.     wet = inputs[WET_CV_INPUT].value * params[WET_CV_PARAM].value;

  179.     wet += params[WET_PARAM].value;

  180.     wet = clamp(wet, 0.f, 1.f) * 10.f;

  181. 

  182.     outputs[LEFT_OUTPUT].value = inputs[LEFT_INPUT].value * dry;

  183.     outputs[RIGHT_OUTPUT].value = inputs[LEFT_INPUT].value * dry;

  184.     outputs[LEFT_OUTPUT].value += reverb.leftOut * wet;

  185.     outputs[RIGHT_OUTPUT].value += reverb.rightOut * wet;

  186. }

  187. 

  188. void Plateau::onSampleRateChange() {

  189.     reverb.setSampleRate(engineGetSampleRate());

  190. }

  191. 

  192. void Plateau::reset() {

  193.     diffuseInput = 1;

  194. }

  195. 

  196. json_t* Plateau::toJson()  {

  197.     json_t *rootJ = json_object();

  198.     json_object_set_new(rootJ, "frozen", json_boolean(freeze));

  199.     json_object_set_new(rootJ, "freezeToggle", json_boolean(freezeToggle));

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

  201.     json_object_set_new(rootJ, "tuned", json_integer((int)tuned));

  202.     json_object_set_new(rootJ, "diffuseInput", json_integer((int)diffuseInput));

  203.     return rootJ;

  204. }

  205. 

  206. void Plateau::fromJson(json_t *rootJ) {

  207.     json_t *frozenJ = json_object_get(rootJ, "frozen");

  208.     freeze = json_boolean_value(frozenJ);

  209. 

  210.     json_t *freezeToggleJ = json_object_get(rootJ, "freezeToggle");

  211.     freezeToggle = json_boolean_value(freezeToggleJ);

  212. 

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

  214.     panelStyle = json_integer_value(panelStyleJ);

  215. 

  216.     json_t *tunedJ = json_object_get(rootJ, "tuned");

  217.     tuned = json_integer_value(tunedJ);

  218. 

  219.     json_t *diffuseInputJ = json_object_get(rootJ, "diffuseInput");

  220.     diffuseInput = json_integer_value(diffuseInputJ);

  221. }

  222. 

  223. ////////////////////////////////////////////////////////////////////////////////////////////////////

  224. 

  225. void PlateauPanelStyleItem::onAction(EventAction &e) {

  226.     module->panelStyle = panelStyle;

  227. }

  228. 

  229. void PlateauPanelStyleItem::step() {

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

  231.     MenuItem::step();

  232. }

  233. 

  234. ////////////////////////////////////////////////////////////////////////////////////////////////////

  235. 

  236. PlateauWidget::PlateauWidget(Plateau* module) : ModuleWidget(module) {

  237.     {

  238.         DynamicPanelWidget *panel = new DynamicPanelWidget();

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

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

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

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

  243.         addChild(panel);

  244.     }

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

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

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

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

  249. 

  250.     // Make jacks

  251.     addInput(Port::create<PJ301MDarkSmall>(module->leftInputPos, Port::INPUT, module, Plateau::LEFT_INPUT));

  252.     addInput(Port::create<PJ301MDarkSmall>(module->rightInputPos, Port::INPUT, module, Plateau::RIGHT_INPUT));

  253.     addInput(Port::create<PJ301MDarkSmall>(module->dryCVPos, Port::INPUT, module, Plateau::DRY_CV_INPUT));

  254.     addInput(Port::create<PJ301MDarkSmall>(module->wetCVPos, Port::INPUT, module, Plateau::WET_CV_INPUT));

  255.     addInput(Port::create<PJ301MDarkSmall>(module->inputLowDampCVPos, Port::INPUT, module, Plateau::INPUT_LOW_DAMP_CV_INPUT));

  256.     addInput(Port::create<PJ301MDarkSmall>(module->inputHighDampCVPos, Port::INPUT, module, Plateau::INPUT_HIGH_DAMP_CV_INPUT));

  257. 

  258.     addInput(Port::create<PJ301MDarkSmall>(module->sizeCVPos, Port::INPUT, module, Plateau::SIZE_CV_INPUT));

  259.     addInput(Port::create<PJ301MDarkSmall>(module->diffCVPos, Port::INPUT, module, Plateau::DIFFUSION_CV_INPUT));

  260.     addInput(Port::create<PJ301MDarkSmall>(module->decayCVPos, Port::INPUT, module, Plateau::DECAY_CV_INPUT));

  261.     addInput(Port::create<PJ301MDarkSmall>(module->reverbLowDampCVPos, Port::INPUT, module, Plateau::REVERB_LOW_DAMP_CV_INPUT));

  262.     addInput(Port::create<PJ301MDarkSmall>(module->reverbHighDampCVPos, Port::INPUT, module, Plateau::REVERB_HIGH_DAMP_CV_INPUT));

  263. 

  264.     addInput(Port::create<PJ301MDarkSmall>(module->modRateCVPos, Port::INPUT, module, Plateau::MOD_SPEED_CV_INPUT));

  265.     addInput(Port::create<PJ301MDarkSmall>(module->modShapeCVPos, Port::INPUT, module, Plateau::MOD_SHAPE_CV_INPUT));

  266.     addInput(Port::create<PJ301MDarkSmall>(module->modDepthCVPos, Port::INPUT, module, Plateau::MOD_DEPTH_CV_INPUT));

  267. 

  268.     addInput(Port::create<PJ301MDarkSmall>(module->holdCVPos, Port::INPUT, module, Plateau::FREEZE_CV_INPUT));

  269.     addInput(Port::create<PJ301MDarkSmall>(module->clearCVPos, Port::INPUT, module, Plateau::CLEAR_CV_INPUT));

  270. 

  271.     addOutput(Port::create<PJ301MDarkSmallOut>(module->leftOutputPos, Port::OUTPUT, module, Plateau::LEFT_OUTPUT));

  272.     addOutput(Port::create<PJ301MDarkSmallOut>(module->rightOutputPos, Port::OUTPUT, module, Plateau::RIGHT_OUTPUT));

  273. 

  274.     // Make knobs

  275. 

  276.     float minAngle = -0.77f * M_PI;

  277.     float maxAngle = 0.77f * M_PI;

  278.     addParam(createValleyKnob<RoganMedWhite>(module->dryPos, module, Plateau::DRY_PARAM, 0.0f, 1.f, 1.f, minAngle, maxAngle));

  279.     addParam(createValleyKnob<RoganMedWhite>(module->wetPos, module, Plateau::WET_PARAM, 0.0f, 1.f, 0.5f, minAngle, maxAngle));

  280.     addParam(createValleyKnob<RoganSmallWhite>(module->preDelayPos, module, Plateau::PRE_DELAY_PARAM, 0.f, 0.500f, 0.f, minAngle, maxAngle));

  281.     addParam(createValleyKnob<RoganMedGreen>(module->inputLowDampPos, module, Plateau::INPUT_LOW_DAMP_PARAM, 0.f, 10.f, 10.f, minAngle, maxAngle));

  282.     addParam(createValleyKnob<RoganMedGreen>(module->inputHighDampPos, module, Plateau::INPUT_HIGH_DAMP_PARAM, 0.f, 10.f, 10.f, minAngle, maxAngle));

  283. 

  284.     addParam(createValleyKnob<RoganMedBlue>(module->sizePos, module, Plateau::SIZE_PARAM, 0.f, 1.f, 0.5f, minAngle, maxAngle));

  285.     addParam(createValleyKnob<RoganMedBlue>(module->diffPos, module, Plateau::DIFFUSION_PARAM, 0.f, 10.f, 10.f, minAngle, maxAngle));

  286.     addParam(createValleyKnob<RoganMedBlue>(module->decayPos, module, Plateau::DECAY_PARAM, 0.1f, 0.9999f, 0.54995f, minAngle, maxAngle));

  287.     addParam(createValleyKnob<RoganMedGreen>(module->reverbLowDampPos, module, Plateau::REVERB_LOW_DAMP_PARAM, 0.0f, 10.f, 10.f, minAngle, maxAngle));

  288.     addParam(createValleyKnob<RoganMedGreen>(module->reverbHighDampPos, module, Plateau::REVERB_HIGH_DAMP_PARAM, 0.0f, 10.f, 10.f, minAngle, maxAngle));

  289. 

  290.     addParam(createValleyKnob<RoganMedRed>(module->modRatePos, module, Plateau::MOD_SPEED_PARAM, 0.f, 1.f, 0.f, minAngle, maxAngle));

  291.     addParam(createValleyKnob<RoganMedRed>(module->modDepthPos, module, Plateau::MOD_DEPTH_PARAM, 0.f, 16.f, 0.5f, minAngle, maxAngle));

  292.     addParam(createValleyKnob<RoganMedRed>(module->modShapePos, module, Plateau::MOD_SHAPE_PARAM, 0.f, 1.f, 0.5f, minAngle, maxAngle));

  293. 

  294.     // Make Attenuverters

  295.     addParam(ParamWidget::create<RoganSmallWhite>(module->dryAttenPos, module, Plateau::DRY_CV_PARAM, -1.f, 1.f, 1.f));

  296.     addParam(ParamWidget::create<RoganSmallWhite>(module->wetAttenPos, module, Plateau::WET_CV_PARAM, -1.f, 1.f, 1.f));

  297.     addParam(ParamWidget::create<RoganSmallGreen>(module->inputLowDampAttenPos, module, Plateau::INPUT_LOW_DAMP_CV_PARAM, -1.f, 1.f, 1.f));

  298.     addParam(ParamWidget::create<RoganSmallGreen>(module->inputHighDampAttenPos, module, Plateau::INPUT_HIGH_DAMP_CV_PARAM, -1.f, 1.f, 1.f));

  299. 

  300.     addParam(ParamWidget::create<RoganSmallBlue>(module->sizeAttenPos, module, Plateau::SIZE_CV_PARAM, -1.f, 1.f, 1.f));

  301.     addParam(ParamWidget::create<RoganSmallBlue>(module->diffAttenPos, module, Plateau::DIFFUSION_CV_PARAM, -1.f, 1.f, 1.f));

  302.     addParam(ParamWidget::create<RoganSmallBlue>(module->decayAttenPos, module, Plateau::DECAY_CV_PARAM, -1.f, 1.f, 1.f));

  303.     addParam(ParamWidget::create<RoganSmallGreen>(module->reverbLowDampAttenPos, module, Plateau::REVERB_LOW_DAMP_CV_PARAM, -1.f, 1.f, 1.f));

  304.     addParam(ParamWidget::create<RoganSmallGreen>(module->reverbHighDampAttenPos, module, Plateau::REVERB_HIGH_DAMP_CV_PARAM, -1.f, 1.f, 1.f));

  305. 

  306.     addParam(ParamWidget::create<RoganSmallRed>(module->modRateAttenPos, module, Plateau::MOD_SPEED_CV_PARAM, -1.f, 1.f, 1.f));

  307.     addParam(ParamWidget::create<RoganSmallRed>(module->modShapeAttenPos, module, Plateau::MOD_DEPTH_CV_PARAM, -1.f, 1.f, 1.f));

  308.     addParam(ParamWidget::create<RoganSmallRed>(module->modDepthAttenPos, module, Plateau::MOD_SHAPE_CV_PARAM, -1.f, 1.f, 1.f));

  309. 

  310.     // Make buttons

  311.     addParam(ParamWidget::create<LightLEDButton>(Vec(7.875, 244.85), module, Plateau::FREEZE_PARAM, 0.f, 10.f, 0.f));

  312.     addChild(ModuleLightWidget::create<MediumLight<RedLight>>(Vec(10.375, 247.35), module, Plateau::FREEZE_LIGHT));

  313. 

  314.     addParam(ParamWidget::create<LightLEDButton>(Vec(31.375, 256.35), module, Plateau::FREEZE_TOGGLE_PARAM, 0.f, 10.f, 0.f));

  315.     addChild(ModuleLightWidget::create<MediumLight<RedLight>>(Vec(33.875, 258.85), module, Plateau::FREEZE_TOGGLE_LIGHT));

  316. 

  317.     addParam(ParamWidget::create<LightLEDButton>(Vec(157.875, 244.85), module, Plateau::CLEAR_PARAM, 0.f, 10.f, 0.f));

  318.     addChild(ModuleLightWidget::create<MediumLight<RedLight>>(Vec(160.375, 247.35), module, Plateau::CLEAR_LIGHT));

  319. 

  320.     addParam(ParamWidget::create<LightLEDButton>(Vec(13.875, 123.35), module, Plateau::TUNED_MODE_PARAM, 0.f, 10.f, 0.f));

  321.     addChild(ModuleLightWidget::create<MediumLight<RedLight>>(Vec(16.375, 125.85), module, Plateau::TUNED_MODE_LIGHT));

  322. 

  323.     addParam(ParamWidget::create<LightLEDButton>(Vec(151.875, 123.35), module, Plateau::DIFFUSE_INPUT_PARAM, 0.f, 10.f, 0.f));

  324.     addChild(ModuleLightWidget::create<MediumLight<RedLight>>(Vec(154.375, 125.85), module, Plateau::DIFFUSE_INPUT_LIGHT));

  325. }

  326. 

  327. void PlateauWidget::appendContextMenu(Menu *menu) {

  328.     Plateau *module = dynamic_cast<Plateau*>(this->module);

  329.     assert(module);

  330. 

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

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

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

  334.                                                     module, &PlateauPanelStyleItem::panelStyle, 0));

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

  336.                                                       module, &PlateauPanelStyleItem::panelStyle, 1));

  337. }

  338. 

  339. RACK_PLUGIN_MODEL_INIT(Valley, Plateau) {

  340.    Model *modelPlateau = Model::create<Plateau, PlateauWidget>(TOSTRING(SLUG), "Plateau", "Plateau",

  341.                                                                REVERB_TAG);

  342.    return modelPlateau;

  343. }