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.
130 Commits
4 Branches
59MB
Tree: ff9fdf1800
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ff9fdf1800'
${ noResults }
AudibleInstruments/src/Stages.cpp

441 lines
17KB
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. struct GroupInfo {

  46. 	int first_segment = 0;

  47. 	int segment_count = 0;

  48. 	bool gated = false;

  49. };

  50. 

  51. struct GroupBuilder {

  52. 

  53. 	GroupInfo groups[NUM_CHANNELS];

  54. 	int groupCount = 0;

  55. 

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

  57. 		bool any_gates = false;

  58. 

  59. 		GroupInfo nextGroups[NUM_CHANNELS];

  60. 

  61. 		int currentGroup = 0;

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

  63. 			bool gated = (*gateInputs)[first + i].active;

  64. 

  65. 			if (!any_gates) {

  66. 				if (!gated) {

  67. 					// No gates at all yet, segments are all single segment groups

  68. 					nextGroups[currentGroup].first_segment = i;

  69. 					nextGroups[currentGroup].segment_count = 1;

  70. 					nextGroups[currentGroup].gated = false;

  71. 					currentGroup++;

  72. 				}

  73. 				else {

  74. 					// first gate, current group is start of a segment group

  75. 					any_gates = true;

  76. 					nextGroups[currentGroup].first_segment = i;

  77. 					nextGroups[currentGroup].segment_count = 1;

  78. 					nextGroups[currentGroup].gated = true;

  79. 					currentGroup++;

  80. 				}

  81. 			}

  82. 			else {

  83. 				if (!gated) {

  84. 					// We've had a gate, this ungated segment is part of the previous group

  85. 					nextGroups[currentGroup-1].segment_count++;

  86. 				}

  87. 				else {

  88. 					// This gated input indicates the start of the next group

  89. 					nextGroups[currentGroup].first_segment = i;

  90. 					nextGroups[currentGroup].segment_count = 1;

  91. 					nextGroups[currentGroup].gated = true;

  92. 					currentGroup++;

  93. 				}

  94. 			}

  95. 		}

  96. 

  97. 		bool changed = false;

  98. 

  99. 		if (currentGroup != groupCount) {

  100. 			changed = true;

  101. 			groupCount = currentGroup;

  102. 		}

  103. 

  104. 		for (int i = 0; i < groupCount; i++) {

  105. 			if (nextGroups[i].segment_count != groups[i].segment_count || 

  106. 					nextGroups[i].gated != groups[i].gated ||

  107. 					nextGroups[i].first_segment != groups[i].first_segment) {

  108. 				changed = true;

  109. 			}

  110. 

  111. 			groups[i].first_segment = nextGroups[i].first_segment;

  112. 			groups[i].segment_count = nextGroups[i].segment_count;

  113. 			groups[i].gated = nextGroups[i].gated;

  114. 		}

  115. 

  116. 		return changed;

  117. 	}

  118. };

  119. 

  120. struct Stages : Module {

  121. 	enum ParamIds {

  122. 		ENUMS(SHAPE_PARAMS, NUM_CHANNELS),

  123. 		ENUMS(TYPE_PARAMS, NUM_CHANNELS),

  124. 		ENUMS(LEVEL_PARAMS, NUM_CHANNELS),

  125. 		NUM_PARAMS

  126. 	};

  127. 	enum InputIds {

  128. 		ENUMS(LEVEL_INPUTS, NUM_CHANNELS),

  129. 		ENUMS(GATE_INPUTS, NUM_CHANNELS),

  130. 		NUM_INPUTS

  131. 	};

  132. 	enum OutputIds {

  133. 		ENUMS(ENVELOPE_OUTPUTS, NUM_CHANNELS),

  134. 		NUM_OUTPUTS

  135. 	};

  136. 	enum LightIds {

  137. 		ENUMS(TYPE_LIGHTS, NUM_CHANNELS * 2),

  138. 		ENUMS(ENVELOPE_LIGHTS, NUM_CHANNELS),

  139. 		NUM_LIGHTS

  140. 	};

  141. 

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

  143. 	bool configuration_changed[NUM_CHANNELS];

  144. 	stages::SegmentGenerator segment_generator[NUM_CHANNELS];

  145. 	float lightOscillatorPhase;

  146. 

  147. 	// Buttons

  148. 	LongPressButton typeButtons[NUM_CHANNELS];

  149. 

  150. 	// Buffers

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

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

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

  154. 	int blockIndex = 0;

  155. 	GroupBuilder groupBuilder;

  156. 

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

  158. 		onReset();

  159. 	}

  160. 

  161. 	void onReset() override {

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

  163. 			segment_generator[i].Init();

  164. 

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

  166. 			configurations[i].loop = false;

  167. 			configuration_changed[i] = true;

  168. 		}

  169. 

  170. 		lightOscillatorPhase = 0.f;

  171. 		onSampleRateChange();

  172. 	}

  173. 

  174. 	json_t *toJson() override {

  175. 		json_t *rootJ = json_object();

  176. 

  177. 		json_t *configurationsJ = json_array();

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

  179. 			json_t *configurationJ = json_object();

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

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

  182. 			json_array_insert_new(configurationsJ, i, configurationJ);

  183. 		}

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

  185. 

  186. 		return rootJ;

  187. 	}

  188. 

  189. 	void fromJson(json_t *rootJ) override {

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

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

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

  193. 			if (configurationJ) {

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

  195. 				if (typeJ)

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

  197. 

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

  199. 				if (loopJ)

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

  201. 			}

  202. 		}

  203. 	}

  204. 

  205. 	void onSampleRateChange() override {

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

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

  208. 		}

  209. 	}

  210. 

  211. 	void stepBlock() {

  212. 		// Get parameters

  213. 		float primaries[NUM_CHANNELS];

  214. 		float secondaries[NUM_CHANNELS];

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

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

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

  218. 		}

  219. 

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

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

  222. 

  223. 		// Process block

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

  225. 		for (int i = 0; i < groupBuilder.groupCount; i++) {

  226. 			GroupInfo &group = groupBuilder.groups[i];

  227. 

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

  229. 			bool apply_config = groups_changed;

  230. 			int numberOfLoopsInGroup = 0;

  231. 			for (int j = 0; j < group.segment_count; j++) {

  232. 				int segment = group.first_segment + j;

  233. 				numberOfLoopsInGroup += configurations[segment].loop ? 1 : 0;

  234. 				apply_config |= configuration_changed[segment];

  235. 				configuration_changed[segment] = false;

  236. 			}

  237. 

  238. 			if (numberOfLoopsInGroup > 2) {

  239. 				// Too many segments are looping, turn them all off

  240. 				apply_config = true;

  241. 				for (int j = 0; j < group.segment_count; j++) {

  242. 					configurations[group.first_segment + j].loop = false;

  243. 				}

  244. 			}

  245. 

  246. 			if (apply_config) {

  247. 				segment_generator[i].Configure(group.gated, &configurations[group.first_segment], group.segment_count);

  248. 			}

  249. 

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

  251. 			for (int j = 0; j < group.segment_count; j++) {

  252. 				segment_generator[i].set_segment_parameters(j, primaries[group.first_segment + j], secondaries[group.first_segment + j]);

  253. 			}

  254. 

  255. 			segment_generator[i].Process(gate_flags[group.first_segment], out, BLOCK_SIZE);

  256. 

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

  258. 				for (int k = 1; k < group.segment_count; k++) {

  259. 					int segment = group.first_segment + k;

  260. 					if (k == out[j].segment) {

  261. 						// Set the phase output for the active segment

  262. 						envelopeBuffer[segment][j] = 1.f - out[j].phase;

  263. 					}

  264. 					else {

  265. 						// Non active segments have 0.f output

  266. 						envelopeBuffer[segment][j] = 0.f;

  267. 					}

  268. 				}

  269. 				// First group segment gets the actual output

  270. 				envelopeBuffer[group.first_segment][j] = out[j].value;

  271. 			}

  272. 		}

  273. 	}

  274. 

  275. 	void toggleMode(int i) {

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

  277. 		configuration_changed[i] = true;

  278. 	}

  279. 

  280. 	void toggleLoop(int segment) {

  281. 		configuration_changed[segment] = true;

  282. 		configurations[segment].loop = !configurations[segment].loop;

  283. 

  284. 		// ensure that we don't have too many looping segments in the group

  285. 		if (configurations[segment].loop) {

  286. 			int segment_count = 0;

  287. 			for (int i = 0; i < groupBuilder.groupCount; i++) {

  288. 				segment_count += groupBuilder.groups[i].segment_count;

  289. 

  290. 				if (segment_count > segment) {

  291. 					GroupInfo &group = groupBuilder.groups[i];

  292. 

  293. 					// See how many loop items we have

  294. 					int numberOfLoopsInGroup = 0;

  295. 

  296. 					for (int j = 0; j < group.segment_count; j++) {

  297. 						numberOfLoopsInGroup += configurations[group.first_segment + j].loop ? 1 : 0;

  298. 					}

  299. 

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

  301. 					if (numberOfLoopsInGroup > 2) {

  302. 						for (int j = 0; j < group.segment_count; j++) {

  303. 							configurations[group.first_segment + j].loop = (group.first_segment + j) == segment;

  304. 						}

  305. 					}

  306. 

  307. 					break;

  308. 				}

  309. 			}

  310. 		}

  311. 	}

  312. 

  313. 	void step() override {

  314. 		// Oscillate flashing the type lights

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

  316. 		if (lightOscillatorPhase >= 1.0f)

  317. 			lightOscillatorPhase -= 1.0f;

  318. 

  319. 		// Buttons

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

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

  322. 				default:

  323. 				case LongPressButton::NO_PRESS: break;

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

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

  326. 			}

  327. 		}

  328. 

  329. 		// Input

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

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

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

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

  334. 		}

  335. 

  336. 		// Process block

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

  338. 			blockIndex = 0;

  339. 			stepBlock();

  340. 		}

  341. 

  342. 		// Output

  343. 		for (int i = 0; i < groupBuilder.groupCount; i++) {

  344. 			GroupInfo &group = groupBuilder.groups[i];

  345. 

  346. 			int numberOfLoopsInGroup = 0;

  347. 			for (int j = 0; j < group.segment_count; j++) {

  348. 				int segment = group.first_segment + j;

  349. 

  350. 				float envelope = envelopeBuffer[segment][blockIndex];

  351. 				outputs[ENVELOPE_OUTPUTS + segment].value = envelope * 8.f;

  352. 				lights[ENVELOPE_LIGHTS + segment].setBrightnessSmooth(envelope);

  353. 

  354. 				numberOfLoopsInGroup += configurations[segment].loop ? 1 : 0;

  355. 				float flashlevel = 1.f;

  356. 

  357. 				if (configurations[segment].loop && numberOfLoopsInGroup == 1) {

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

  359. 				}

  360. 				else if (configurations[segment].loop && numberOfLoopsInGroup > 1) {

  361. 					float advancedPhase = lightOscillatorPhase + 0.25f;

  362. 					if (advancedPhase > 1.0f)

  363. 						advancedPhase -= 1.0f;

  364. 

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

  366. 				}

  367. 

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

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

  370. 			}

  371. 		}

  372. 	}

  373. };

  374. 

  375. 

  376. struct StagesWidget : ModuleWidget {

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

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

  379. 

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

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

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

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

  384. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  403. 

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

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

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

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

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

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

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

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

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

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

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

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

  416. 

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

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

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

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

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

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

  423. 

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

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

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

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

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

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

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

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

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

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

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

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

  436. 	}

  437. };

  438. 

  439. 

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