VCVRack
/
AudibleInstruments
mirror of https://github.com/VCVRack/AudibleInstruments.git
1
0
Fork 0
Code Issues 0 Releases 8 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.
125 Commits
4 Branches
59MB
Tree: d1525bd8c7
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd1525bd8c7'
${ noResults }
AudibleInstruments/src/Stages.cpp

404 lines
15KB
Raw Blame History 

  1. #include "AudibleInstruments.hpp"

  2. #include "dsp/digital.hpp"

  3. #include "stages/segment_generator.h"

  4. #include "stages/oscillator.h"

  5. 

  6. 

  7. // Must match io_buffer.h

  8. static const int NUM_CHANNELS = 6;

  9. static const int BLOCK_SIZE = 8;

  10. 

  11. struct LongPressButton {

  12. 	enum Events {

  13. 		NO_PRESS,

  14. 		SHORT_PRESS,

  15. 		LONG_PRESS

  16. 	};

  17. 

  18. 	float pressedTime = 0.f;

  19. 	BooleanTrigger trigger;

  20. 

  21. 	Events step(Param &param) {

  22. 		Events result = NO_PRESS;

  23. 

  24. 		bool pressed = param.value > 0.f;

  25. 		if (pressed && pressedTime >= 0.f) {

  26. 			pressedTime += engineGetSampleTime();

  27. 			if (pressedTime >= 1.f) {

  28. 				pressedTime = -1.f;

  29. 				result = LONG_PRESS;

  30. 			}

  31. 		}

  32. 

  33. 		// Check if released

  34. 		if (trigger.process(!pressed)) {

  35. 			if (pressedTime >= 0.f) {

  36. 				result = SHORT_PRESS;

  37. 			}

  38. 			pressedTime = 0.f;

  39. 		}

  40. 

  41. 		return result;

  42. 	}

  43. };

  44. 

  45. 

  46. struct GroupBuilder {

  47. 	GroupBuilder() {

  48. 		for (size_t i = 0; i < NUM_CHANNELS; i++) {

  49. 			groupSize[i] = 0;

  50. 		}

  51. 	}

  52. 

  53. 	size_t groupSize[NUM_CHANNELS];

  54. 	bool isPatched = false;

  55. 

  56. 	bool buildGroups(std::vector<Input> *inputs, size_t first, size_t count) {

  57. 		bool changed = false;

  58. 		isPatched = false;

  59. 		size_t activeGroup = 0;

  60. 

  61. 		for (int i = count - 1; i >= 0; i -= 1) {

  62. 			bool patched = (*inputs)[first + i].active;

  63. 

  64. 			activeGroup++;

  65. 			if (!patched) {

  66. 				changed = changed || (groupSize[i] != 0);

  67. 				groupSize[i] = 0;

  68. 			}

  69. 			else if (patched) {

  70. 				isPatched = true;

  71. 				changed = changed || (groupSize[i] != activeGroup);

  72. 				groupSize[i] = activeGroup;

  73. 				activeGroup = 0;

  74. 			}

  75. 		}

  76. 

  77. 		return changed;

  78. 	}

  79. 

  80. 	int groupForSegment(int segment) {

  81. 		int group = 0;

  82. 		int currentGroupSize = 0;

  83. 

  84. 		for (int i = 0; i < NUM_CHANNELS; i++) {

  85. 			if (currentGroupSize <= 0) {

  86. 				currentGroupSize = max(1, groupSize[i]);

  87. 				group = i;

  88. 			}

  89. 

  90. 			if (segment == i) {

  91. 				return group;

  92. 			}

  93. 

  94. 			currentGroupSize -= 1;

  95. 		}

  96. 

  97. 		return segment;

  98. 	}

  99. };

  100. 

  101. struct Stages : Module {

  102. 	enum ParamIds {

  103. 		ENUMS(SHAPE_PARAMS, NUM_CHANNELS),

  104. 		ENUMS(TYPE_PARAMS, NUM_CHANNELS),

  105. 		ENUMS(LEVEL_PARAMS, NUM_CHANNELS),

  106. 		NUM_PARAMS

  107. 	};

  108. 	enum InputIds {

  109. 		ENUMS(LEVEL_INPUTS, NUM_CHANNELS),

  110. 		ENUMS(GATE_INPUTS, NUM_CHANNELS),

  111. 		NUM_INPUTS

  112. 	};

  113. 	enum OutputIds {

  114. 		ENUMS(ENVELOPE_OUTPUTS, NUM_CHANNELS),

  115. 		NUM_OUTPUTS

  116. 	};

  117. 	enum LightIds {

  118. 		ENUMS(TYPE_LIGHTS, NUM_CHANNELS * 2),

  119. 		ENUMS(ENVELOPE_LIGHTS, NUM_CHANNELS),

  120. 		NUM_LIGHTS

  121. 	};

  122. 

  123. 	stages::segment::Configuration configurations[NUM_CHANNELS];

  124. 	bool configuration_changed[NUM_CHANNELS];

  125. 	stages::SegmentGenerator segment_generator[NUM_CHANNELS];

  126. 	float lightOscillatorPhase;

  127. 

  128. 	// Buttons

  129. 	LongPressButton typeButtons[NUM_CHANNELS];

  130. 

  131. 	// Buffers

  132. 	float envelopeBuffer[NUM_CHANNELS][BLOCK_SIZE] = {};

  133. 	stmlib::GateFlags last_gate_flags[NUM_CHANNELS] = {};

  134. 	stmlib::GateFlags gate_flags[NUM_CHANNELS][BLOCK_SIZE] = {};

  135. 	int blockIndex = 0;

  136. 	GroupBuilder groupBuilder;

  137. 

  138. 	Stages() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {

  139. 		onReset();

  140. 	}

  141. 

  142. 	void onReset() override {

  143. 		for (size_t i = 0; i < NUM_CHANNELS; ++i) {

  144. 			segment_generator[i].Init();

  145. 

  146. 			configurations[i].type = stages::segment::TYPE_RAMP;

  147. 			configurations[i].loop = false;

  148. 			configuration_changed[i] = true;

  149. 		}

  150. 

  151. 		lightOscillatorPhase = 0.f;

  152. 		onSampleRateChange();

  153. 	}

  154. 

  155. 	json_t *toJson() override {

  156. 		json_t *rootJ = json_object();

  157. 

  158. 		json_t *configurationsJ = json_array();

  159. 		for (int i = 0; i < NUM_CHANNELS; i++) {

  160. 			json_t *configurationJ = json_object();

  161. 			json_object_set_new(configurationJ, "type", json_integer(configurations[i].type));

  162. 			json_object_set_new(configurationJ, "loop", json_boolean(configurations[i].loop));

  163. 			json_array_insert_new(configurationsJ, i, configurationJ);

  164. 		}

  165. 		json_object_set_new(rootJ, "configurations", configurationsJ);

  166. 

  167. 		return rootJ;

  168. 	}

  169. 

  170. 	void fromJson(json_t *rootJ) override {

  171. 		json_t *configurationsJ = json_object_get(rootJ, "configurations");

  172. 		for (int i = 0; i < NUM_CHANNELS; i++) {

  173. 			json_t *configurationJ = json_array_get(configurationsJ, i);

  174. 			if (configurationJ) {

  175. 				json_t *typeJ = json_object_get(configurationJ, "type");

  176. 				if (typeJ)

  177. 					configurations[i].type = (stages::segment::Type) json_integer_value(typeJ);

  178. 

  179. 				json_t *loopJ = json_object_get(configurationJ, "loop");

  180. 				if (loopJ)

  181. 					configurations[i].loop = json_boolean_value(loopJ);

  182. 			}

  183. 		}

  184. 	}

  185. 

  186. 	void onSampleRateChange() override {

  187. 		for (int i = 0; i < NUM_CHANNELS; i++) {

  188. 			segment_generator[i].SetSampleRate(engineGetSampleRate());

  189. 		}

  190. 	}

  191. 

  192. 	void stepBlock() {

  193. 		// Get parameters

  194. 		float primaries[NUM_CHANNELS];

  195. 		float secondaries[NUM_CHANNELS];

  196. 		for (int i = 0; i < NUM_CHANNELS; i++) {

  197. 			primaries[i] = clamp(params[LEVEL_PARAMS + i].value + inputs[LEVEL_INPUTS + i].value / 8.f, 0.f, 1.f);

  198. 			secondaries[i] = params[SHAPE_PARAMS + i].value;

  199. 		}

  200. 

  201. 		// See if the group associations have changed since the last group

  202. 		bool groups_changed = groupBuilder.buildGroups(&inputs, GATE_INPUTS, NUM_CHANNELS);

  203. 

  204. 		// Process block

  205. 		stages::SegmentGenerator::Output out[BLOCK_SIZE] = {};

  206. 		for (int i = 0; i < NUM_CHANNELS;) {

  207. 			// Check if the config needs applying to the segment generator for this group

  208. 			bool segment_changed = groups_changed;

  209. 			int numberOfLoops = 0;

  210. 			for (int j = 0; j < max(1, groupBuilder.groupSize[i]); j++) {

  211. 				numberOfLoops += configurations[i + j].loop ? 1 : 0;

  212. 				segment_changed |= configuration_changed[i + j];

  213. 				configuration_changed[i + j] = false;

  214. 			}

  215. 

  216. 			if (segment_changed) {

  217. 				if (numberOfLoops > 2) {

  218. 					for (int j = 0; j < max(1, groupBuilder.groupSize[i]); j++) {

  219. 						configurations[i + j].loop = false;

  220. 					}

  221. 				}

  222. 				segment_generator[i].Configure(groupBuilder.groupSize[i] > 0, &configurations[i], max(1, groupBuilder.groupSize[i]));

  223. 			}

  224. 

  225. 			// Set the segment parameters on the generator we're about to process

  226. 			for (int j = 0; j < segment_generator[i].num_segments(); j++) {

  227. 				segment_generator[i].set_segment_parameters(j, primaries[i + j], secondaries[i + j]);

  228. 			}

  229. 

  230. 			segment_generator[i].Process(gate_flags[i], out, BLOCK_SIZE);

  231. 

  232. 			// Set the outputs for the active segment in each output sample

  233. 			// All outputs also go to the first segment

  234. 			for (int j = 0; j < BLOCK_SIZE; j++) {

  235. 				for (int k = 1; k < segment_generator[i].num_segments(); k++) {

  236. 					envelopeBuffer[i + k][j] = k == out[j].segment ? 1 - out[j].phase : 0.f;

  237. 				}

  238. 				envelopeBuffer[i][j] = out[j].value;

  239. 			}

  240. 

  241. 			i += segment_generator[i].num_segments();

  242. 		}

  243. 	}

  244. 

  245. 	void toggleMode(int i) {

  246. 		configurations[i].type = (stages::segment::Type) ((configurations[i].type + 1) % 3);

  247. 		configuration_changed[i] = true;

  248. 	}

  249. 

  250. 	void toggleLoop(int i) {

  251. 		configuration_changed[i] = true;

  252. 		configurations[i].loop = !configurations[i].loop;

  253. 

  254. 		// ensure that we're the only loop item in the group

  255. 		if (configurations[i].loop) {

  256. 			int group = groupBuilder.groupForSegment(i);

  257. 

  258. 			// See how many loop items we have

  259. 			int loopitems = 0;

  260. 

  261. 			for (size_t j = 0; j < groupBuilder.groupSize[group]; j++) {

  262. 				loopitems += configurations[group + j].loop ? 1 : 0;

  263. 			}

  264. 

  265. 			// If we've got too many loop items, clear down to the one looping segment

  266. 			if (loopitems > 2) {

  267. 				for (size_t j = 0; j < groupBuilder.groupSize[group]; j++) {

  268. 					configurations[group + j].loop = (group + (int)j) == i;

  269. 				}

  270. 				loopitems = 1;

  271. 			}

  272. 		}

  273. 	}

  274. 

  275. 	void step() override {

  276. 		// Oscillate flashing the type lights

  277. 		lightOscillatorPhase += 0.5f * engineGetSampleTime();

  278. 		if (lightOscillatorPhase >= 1.0f)

  279. 			lightOscillatorPhase -= 1.0f;

  280. 

  281. 		// Buttons

  282. 		for (int i = 0; i < NUM_CHANNELS; i++) {

  283. 			switch (typeButtons[i].step(params[TYPE_PARAMS + i])) {

  284. 				default:

  285. 				case LongPressButton::NO_PRESS: break;

  286. 				case LongPressButton::SHORT_PRESS: toggleMode(i); break;

  287. 				case LongPressButton::LONG_PRESS: toggleLoop(i); break;

  288. 			}

  289. 		}

  290. 

  291. 		// Input

  292. 		for (int i = 0; i < NUM_CHANNELS; i++) {

  293. 			bool gate = (inputs[GATE_INPUTS + i].value >= 1.7f);

  294. 			last_gate_flags[i] = stmlib::ExtractGateFlags(last_gate_flags[i], gate);

  295. 			gate_flags[i][blockIndex] = last_gate_flags[i];

  296. 		}

  297. 

  298. 		// Process block

  299. 		if (++blockIndex >= BLOCK_SIZE) {

  300. 			blockIndex = 0;

  301. 			stepBlock();

  302. 		}

  303. 

  304. 		// Output

  305. 		int currentGroupSize = 0;

  306. 		int loopcount = 0;

  307. 		for (int i = 0; i < NUM_CHANNELS; i++) {

  308. 			float envelope = envelopeBuffer[i][blockIndex];

  309. 			outputs[ENVELOPE_OUTPUTS + i].value = envelope * 8.f;

  310. 			lights[ENVELOPE_LIGHTS + i].setBrightnessSmooth(envelope);

  311. 

  312. 			if (currentGroupSize <= 0) {

  313. 				currentGroupSize = max(1, groupBuilder.groupSize[i]);

  314. 				loopcount = 0;

  315. 			}

  316. 			currentGroupSize -= 1;

  317. 

  318. 			loopcount += configurations[i].loop ? 1 : 0;

  319. 			float flashlevel = 1.f;

  320. 

  321. 			if (configurations[i].loop && loopcount == 1) {

  322. 				flashlevel = abs(sinf(2.0f * M_PI * lightOscillatorPhase));

  323. 			}

  324. 			else if (configurations[i].loop && loopcount > 1) {

  325. 				float advancedPhase = lightOscillatorPhase + 0.25f;

  326. 				if (advancedPhase > 1.0f)

  327. 					advancedPhase -= 1.0f;

  328. 

  329. 				flashlevel = abs(sinf(2.0f * M_PI * advancedPhase));

  330. 			}

  331. 

  332. 			lights[TYPE_LIGHTS + i * 2 + 0].setBrightness((configurations[i].type == 0 || configurations[i].type == 1) * flashlevel);

  333. 			lights[TYPE_LIGHTS + i * 2 + 1].setBrightness((configurations[i].type == 1 || configurations[i].type == 2) * flashlevel);

  334. 		}

  335. 	}

  336. };

  337. 

  338. 

  339. struct StagesWidget : ModuleWidget {

  340. 	StagesWidget(Stages *module) : ModuleWidget(module) {

  341. 		setPanel(SVG::load(assetPlugin(plugin, "res/Stages.svg")));

  342. 

  343. 		addChild(Widget::create<ScrewSilver>(Vec(RACK_GRID_WIDTH, 0)));

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

  345. 		addChild(Widget::create<ScrewSilver>(Vec(RACK_GRID_WIDTH, RACK_GRID_HEIGHT - RACK_GRID_WIDTH)));

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

  347. 

  348. 		addParam(ParamWidget::create<Trimpot>(mm2px(Vec(3.72965, 13.98158)), module, Stages::SHAPE_PARAMS + 0, 0.0, 1.0, 0.5));

  349. 		addParam(ParamWidget::create<Trimpot>(mm2px(Vec(15.17012, 13.98158)), module, Stages::SHAPE_PARAMS + 1, 0.0, 1.0, 0.5));

  350. 		addParam(ParamWidget::create<Trimpot>(mm2px(Vec(26.6099, 13.98158)), module, Stages::SHAPE_PARAMS + 2, 0.0, 1.0, 0.5));

  351. 		addParam(ParamWidget::create<Trimpot>(mm2px(Vec(38.07174, 13.98158)), module, Stages::SHAPE_PARAMS + 3, 0.0, 1.0, 0.5));

  352. 		addParam(ParamWidget::create<Trimpot>(mm2px(Vec(49.51152, 13.98158)), module, Stages::SHAPE_PARAMS + 4, 0.0, 1.0, 0.5));

  353. 		addParam(ParamWidget::create<Trimpot>(mm2px(Vec(60.95199, 13.98158)), module, Stages::SHAPE_PARAMS + 5, 0.0, 1.0, 0.5));

  354. 		addParam(ParamWidget::create<TL1105>(mm2px(Vec(4.17259, 32.37248)), module, Stages::TYPE_PARAMS + 0, 0.0, 1.0, 0.0));

  355. 		addParam(ParamWidget::create<TL1105>(mm2px(Vec(15.61237, 32.37248)), module, Stages::TYPE_PARAMS + 1, 0.0, 1.0, 0.0));

  356. 		addParam(ParamWidget::create<TL1105>(mm2px(Vec(27.05284, 32.37248)), module, Stages::TYPE_PARAMS + 2, 0.0, 1.0, 0.0));

  357. 		addParam(ParamWidget::create<TL1105>(mm2px(Vec(38.51399, 32.37248)), module, Stages::TYPE_PARAMS + 3, 0.0, 1.0, 0.0));

  358. 		addParam(ParamWidget::create<TL1105>(mm2px(Vec(49.95446, 32.37248)), module, Stages::TYPE_PARAMS + 4, 0.0, 1.0, 0.0));

  359. 		addParam(ParamWidget::create<TL1105>(mm2px(Vec(61.39424, 32.37248)), module, Stages::TYPE_PARAMS + 5, 0.0, 1.0, 0.0));

  360. 		addParam(ParamWidget::create<LEDSliderGreen>(mm2px(Vec(3.36193, 43.06508)), module, Stages::LEVEL_PARAMS + 0, 0.0, 1.0, 1.0));

  361. 		addParam(ParamWidget::create<LEDSliderGreen>(mm2px(Vec(14.81619, 43.06508)), module, Stages::LEVEL_PARAMS + 1, 0.0, 1.0, 1.0));

  362. 		addParam(ParamWidget::create<LEDSliderGreen>(mm2px(Vec(26.26975, 43.06508)), module, Stages::LEVEL_PARAMS + 2, 0.0, 1.0, 1.0));

  363. 		addParam(ParamWidget::create<LEDSliderGreen>(mm2px(Vec(37.70265, 43.06508)), module, Stages::LEVEL_PARAMS + 3, 0.0, 1.0, 1.0));

  364. 		addParam(ParamWidget::create<LEDSliderGreen>(mm2px(Vec(49.15759, 43.06508)), module, Stages::LEVEL_PARAMS + 4, 0.0, 1.0, 1.0));

  365. 		addParam(ParamWidget::create<LEDSliderGreen>(mm2px(Vec(60.61184, 43.06508)), module, Stages::LEVEL_PARAMS + 5, 0.0, 1.0, 1.0));

  366. 

  367. 		addInput(Port::create<PJ301MPort>(mm2px(Vec(2.70756, 77.75277)), Port::INPUT, module, Stages::LEVEL_INPUTS + 0));

  368. 		addInput(Port::create<PJ301MPort>(mm2px(Vec(14.14734, 77.75277)), Port::INPUT, module, Stages::LEVEL_INPUTS + 1));

  369. 		addInput(Port::create<PJ301MPort>(mm2px(Vec(25.58781, 77.75277)), Port::INPUT, module, Stages::LEVEL_INPUTS + 2));

  370. 		addInput(Port::create<PJ301MPort>(mm2px(Vec(37.04896, 77.75277)), Port::INPUT, module, Stages::LEVEL_INPUTS + 3));

  371. 		addInput(Port::create<PJ301MPort>(mm2px(Vec(48.48943, 77.75277)), Port::INPUT, module, Stages::LEVEL_INPUTS + 4));

  372. 		addInput(Port::create<PJ301MPort>(mm2px(Vec(59.92921, 77.75277)), Port::INPUT, module, Stages::LEVEL_INPUTS + 5));

  373. 		addInput(Port::create<PJ301MPort>(mm2px(Vec(2.70756, 92.35239)), Port::INPUT, module, Stages::GATE_INPUTS + 0));

  374. 		addInput(Port::create<PJ301MPort>(mm2px(Vec(14.14734, 92.35239)), Port::INPUT, module, Stages::GATE_INPUTS + 1));

  375. 		addInput(Port::create<PJ301MPort>(mm2px(Vec(25.58781, 92.35239)), Port::INPUT, module, Stages::GATE_INPUTS + 2));

  376. 		addInput(Port::create<PJ301MPort>(mm2px(Vec(37.04896, 92.35239)), Port::INPUT, module, Stages::GATE_INPUTS + 3));

  377. 		addInput(Port::create<PJ301MPort>(mm2px(Vec(48.48943, 92.35239)), Port::INPUT, module, Stages::GATE_INPUTS + 4));

  378. 		addInput(Port::create<PJ301MPort>(mm2px(Vec(59.92921, 92.35239)), Port::INPUT, module, Stages::GATE_INPUTS + 5));

  379. 

  380. 		addOutput(Port::create<PJ301MPort>(mm2px(Vec(2.70756, 106.95203)), Port::OUTPUT, module, Stages::ENVELOPE_OUTPUTS + 0));

  381. 		addOutput(Port::create<PJ301MPort>(mm2px(Vec(14.14734, 106.95203)), Port::OUTPUT, module, Stages::ENVELOPE_OUTPUTS + 1));

  382. 		addOutput(Port::create<PJ301MPort>(mm2px(Vec(25.58781, 106.95203)), Port::OUTPUT, module, Stages::ENVELOPE_OUTPUTS + 2));

  383. 		addOutput(Port::create<PJ301MPort>(mm2px(Vec(37.04896, 106.95203)), Port::OUTPUT, module, Stages::ENVELOPE_OUTPUTS + 3));

  384. 		addOutput(Port::create<PJ301MPort>(mm2px(Vec(48.48943, 106.95203)), Port::OUTPUT, module, Stages::ENVELOPE_OUTPUTS + 4));

  385. 		addOutput(Port::create<PJ301MPort>(mm2px(Vec(59.92921, 106.95203)), Port::OUTPUT, module, Stages::ENVELOPE_OUTPUTS + 5));

  386. 

  387. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(mm2px(Vec(5.27737, 26.74447)), module, Stages::TYPE_LIGHTS + 0 * 2));

  388. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(mm2px(Vec(16.73784, 26.74447)), module, Stages::TYPE_LIGHTS + 1 * 2));

  389. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(mm2px(Vec(28.1783, 26.74447)), module, Stages::TYPE_LIGHTS + 2 * 2));

  390. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(mm2px(Vec(39.61877, 26.74447)), module, Stages::TYPE_LIGHTS + 3 * 2));

  391. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(mm2px(Vec(51.07923, 26.74447)), module, Stages::TYPE_LIGHTS + 4 * 2));

  392. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(mm2px(Vec(62.51971, 26.74447)), module, Stages::TYPE_LIGHTS + 5 * 2));

  393. 		addChild(ModuleLightWidget::create<MediumLight<GreenLight>>(mm2px(Vec(2.29462, 103.19253)), module, Stages::ENVELOPE_LIGHTS + 0));

  394. 		addChild(ModuleLightWidget::create<MediumLight<GreenLight>>(mm2px(Vec(13.73509, 103.19253)), module, Stages::ENVELOPE_LIGHTS + 1));

  395. 		addChild(ModuleLightWidget::create<MediumLight<GreenLight>>(mm2px(Vec(25.17556, 103.19253)), module, Stages::ENVELOPE_LIGHTS + 2));

  396. 		addChild(ModuleLightWidget::create<MediumLight<GreenLight>>(mm2px(Vec(36.63671, 103.19253)), module, Stages::ENVELOPE_LIGHTS + 3));

  397. 		addChild(ModuleLightWidget::create<MediumLight<GreenLight>>(mm2px(Vec(48.07649, 103.19253)), module, Stages::ENVELOPE_LIGHTS + 4));

  398. 		addChild(ModuleLightWidget::create<MediumLight<GreenLight>>(mm2px(Vec(59.51696, 103.19253)), module, Stages::ENVELOPE_LIGHTS + 5));

  399. 	}

  400. };

  401. 

  402. 

  403. Model *modelStages = Model::create<Stages, StagesWidget>("Audible Instruments", "Stages", "Segment Generator", FUNCTION_GENERATOR_TAG, ENVELOPE_GENERATOR_TAG);