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

461 lines
17KB
Raw Blame History 

  1. #include "plugin.hpp"

  2. #include "stages/segment_generator.h"

  3. #include "stages/oscillator.h"

  4. 

  5. 

  6. // Must match io_buffer.h

  7. static const int NUM_CHANNELS = 6;

  8. static const int BLOCK_SIZE = 8;

  9. 

  10. struct LongPressButton {

  11. 	enum Events {

  12. 		NO_PRESS,

  13. 		SHORT_PRESS,

  14. 		LONG_PRESS

  15. 	};

  16. 

  17. 	float pressedTime = 0.f;

  18. 	dsp::BooleanTrigger trigger;

  19. 

  20. 	Events step(Param& param) {

  21. 		Events result = NO_PRESS;

  22. 

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

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

  25. 			pressedTime += APP->engine->getSampleTime();

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

  27. 				pressedTime = -1.f;

  28. 				result = LONG_PRESS;

  29. 			}

  30. 		}

  31. 

  32. 		// Check if released

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

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

  35. 				result = SHORT_PRESS;

  36. 			}

  37. 			pressedTime = 0.f;

  38. 		}

  39. 

  40. 		return result;

  41. 	}

  42. };

  43. 

  44. struct GroupInfo {

  45. 	int first_segment = 0;

  46. 	int segment_count = 0;

  47. 	bool gated = false;

  48. };

  49. 

  50. struct GroupBuilder {

  51. 

  52. 	GroupInfo groups[NUM_CHANNELS];

  53. 	int groupCount = 0;

  54. 

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

  56. 		bool any_gates = false;

  57. 

  58. 		GroupInfo nextGroups[NUM_CHANNELS];

  59. 

  60. 		int currentGroup = 0;

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

  62. 			bool gated = (*gateInputs)[first + i].isConnected();

  63. 

  64. 			if (!any_gates) {

  65. 				if (!gated) {

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

  67. 					nextGroups[currentGroup].first_segment = i;

  68. 					nextGroups[currentGroup].segment_count = 1;

  69. 					nextGroups[currentGroup].gated = false;

  70. 					currentGroup++;

  71. 				}

  72. 				else {

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

  74. 					any_gates = true;

  75. 					nextGroups[currentGroup].first_segment = i;

  76. 					nextGroups[currentGroup].segment_count = 1;

  77. 					nextGroups[currentGroup].gated = true;

  78. 					currentGroup++;

  79. 				}

  80. 			}

  81. 			else {

  82. 				if (!gated) {

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

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

  85. 				}

  86. 				else {

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

  88. 					nextGroups[currentGroup].first_segment = i;

  89. 					nextGroups[currentGroup].segment_count = 1;

  90. 					nextGroups[currentGroup].gated = true;

  91. 					currentGroup++;

  92. 				}

  93. 			}

  94. 		}

  95. 

  96. 		bool changed = false;

  97. 

  98. 		if (currentGroup != groupCount) {

  99. 			changed = true;

  100. 			groupCount = currentGroup;

  101. 		}

  102. 

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

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

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

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

  107. 				changed = true;

  108. 			}

  109. 

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

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

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

  113. 		}

  114. 

  115. 		return changed;

  116. 	}

  117. };

  118. 

  119. struct Stages : Module {

  120. 	enum ParamIds {

  121. 		ENUMS(SHAPE_PARAMS, NUM_CHANNELS),

  122. 		ENUMS(TYPE_PARAMS, NUM_CHANNELS),

  123. 		ENUMS(LEVEL_PARAMS, NUM_CHANNELS),

  124. 		NUM_PARAMS

  125. 	};

  126. 	enum InputIds {

  127. 		ENUMS(LEVEL_INPUTS, NUM_CHANNELS),

  128. 		ENUMS(GATE_INPUTS, NUM_CHANNELS),

  129. 		NUM_INPUTS

  130. 	};

  131. 	enum OutputIds {

  132. 		ENUMS(ENVELOPE_OUTPUTS, NUM_CHANNELS),

  133. 		NUM_OUTPUTS

  134. 	};

  135. 	enum LightIds {

  136. 		ENUMS(TYPE_LIGHTS, NUM_CHANNELS * 2),

  137. 		ENUMS(ENVELOPE_LIGHTS, NUM_CHANNELS),

  138. 		NUM_LIGHTS

  139. 	};

  140. 

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

  142. 	bool configuration_changed[NUM_CHANNELS];

  143. 	stages::SegmentGenerator segment_generator[NUM_CHANNELS];

  144. 	float lightOscillatorPhase;

  145. 

  146. 	// Buttons

  147. 	LongPressButton typeButtons[NUM_CHANNELS];

  148. 

  149. 	// Buffers

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

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

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

  153. 	int blockIndex = 0;

  154. 	GroupBuilder groupBuilder;

  155. 

  156. 	Stages() {

  157. 		config(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS);

  158. 		configParam(SHAPE_PARAMS + 0, 0.0, 1.0, 0.5, "Shape 1");

  159. 		configParam(SHAPE_PARAMS + 1, 0.0, 1.0, 0.5, "Shape 2");

  160. 		configParam(SHAPE_PARAMS + 2, 0.0, 1.0, 0.5, "Shape 3");

  161. 		configParam(SHAPE_PARAMS + 3, 0.0, 1.0, 0.5, "Shape 4");

  162. 		configParam(SHAPE_PARAMS + 4, 0.0, 1.0, 0.5, "Shape 5");

  163. 		configParam(SHAPE_PARAMS + 5, 0.0, 1.0, 0.5, "Shape 6");

  164. 		configParam(TYPE_PARAMS + 0, 0.0, 1.0, 0.0, "Type 1");

  165. 		configParam(TYPE_PARAMS + 1, 0.0, 1.0, 0.0, "Type 2");

  166. 		configParam(TYPE_PARAMS + 2, 0.0, 1.0, 0.0, "Type 3");

  167. 		configParam(TYPE_PARAMS + 3, 0.0, 1.0, 0.0, "Type 4");

  168. 		configParam(TYPE_PARAMS + 4, 0.0, 1.0, 0.0, "Type 5");

  169. 		configParam(TYPE_PARAMS + 5, 0.0, 1.0, 0.0, "Type 6");

  170. 		configParam(LEVEL_PARAMS + 0, 0.0, 1.0, 0.5, "Level 1");

  171. 		configParam(LEVEL_PARAMS + 1, 0.0, 1.0, 0.5, "Level 2");

  172. 		configParam(LEVEL_PARAMS + 2, 0.0, 1.0, 0.5, "Level 3");

  173. 		configParam(LEVEL_PARAMS + 3, 0.0, 1.0, 0.5, "Level 4");

  174. 		configParam(LEVEL_PARAMS + 4, 0.0, 1.0, 0.5, "Level 5");

  175. 		configParam(LEVEL_PARAMS + 5, 0.0, 1.0, 0.5, "Level 6");

  176. 

  177. 		onReset();

  178. 	}

  179. 

  180. 	void onReset() override {

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

  182. 			segment_generator[i].Init();

  183. 

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

  185. 			configurations[i].loop = false;

  186. 			configuration_changed[i] = true;

  187. 		}

  188. 

  189. 		lightOscillatorPhase = 0.f;

  190. 		onSampleRateChange();

  191. 	}

  192. 

  193. 	json_t* dataToJson() override {

  194. 		json_t* rootJ = json_object();

  195. 

  196. 		json_t* configurationsJ = json_array();

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

  198. 			json_t* configurationJ = json_object();

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

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

  201. 			json_array_insert_new(configurationsJ, i, configurationJ);

  202. 		}

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

  204. 

  205. 		return rootJ;

  206. 	}

  207. 

  208. 	void dataFromJson(json_t* rootJ) override {

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

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

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

  212. 			if (configurationJ) {

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

  214. 				if (typeJ)

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

  216. 

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

  218. 				if (loopJ)

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

  220. 			}

  221. 		}

  222. 	}

  223. 

  224. 	void onSampleRateChange() override {

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

  226. 			segment_generator[i].SetSampleRate(APP->engine->getSampleRate());

  227. 		}

  228. 	}

  229. 

  230. 	void stepBlock() {

  231. 		// Get parameters

  232. 		float primaries[NUM_CHANNELS];

  233. 		float secondaries[NUM_CHANNELS];

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

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

  236. 			secondaries[i] = params[SHAPE_PARAMS + i].getValue();

  237. 		}

  238. 

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

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

  241. 

  242. 		// Process block

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

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

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

  246. 

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

  248. 			bool apply_config = groups_changed;

  249. 			int numberOfLoopsInGroup = 0;

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

  251. 				int segment = group.first_segment + j;

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

  253. 				apply_config |= configuration_changed[segment];

  254. 				configuration_changed[segment] = false;

  255. 			}

  256. 

  257. 			if (numberOfLoopsInGroup > 2) {

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

  259. 				apply_config = true;

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

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

  262. 				}

  263. 			}

  264. 

  265. 			if (apply_config) {

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

  267. 			}

  268. 

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

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

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

  272. 			}

  273. 

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

  275. 

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

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

  278. 					int segment = group.first_segment + k;

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

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

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

  282. 					}

  283. 					else {

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

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

  286. 					}

  287. 				}

  288. 				// First group segment gets the actual output

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

  290. 			}

  291. 		}

  292. 	}

  293. 

  294. 	void toggleMode(int i) {

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

  296. 		configuration_changed[i] = true;

  297. 	}

  298. 

  299. 	void toggleLoop(int segment) {

  300. 		configuration_changed[segment] = true;

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

  302. 

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

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

  305. 			int segment_count = 0;

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

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

  308. 

  309. 				if (segment_count > segment) {

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

  311. 

  312. 					// See how many loop items we have

  313. 					int numberOfLoopsInGroup = 0;

  314. 

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

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

  317. 					}

  318. 

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

  320. 					if (numberOfLoopsInGroup > 2) {

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

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

  323. 						}

  324. 					}

  325. 

  326. 					break;

  327. 				}

  328. 			}

  329. 		}

  330. 	}

  331. 

  332. 	void process(const ProcessArgs& args) override {

  333. 		// Oscillate flashing the type lights

  334. 		lightOscillatorPhase += 0.5f * args.sampleTime;

  335. 		if (lightOscillatorPhase >= 1.0f)

  336. 			lightOscillatorPhase -= 1.0f;

  337. 

  338. 		// Buttons

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

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

  341. 				default:

  342. 				case LongPressButton::NO_PRESS: break;

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

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

  345. 			}

  346. 		}

  347. 

  348. 		// Input

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

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

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

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

  353. 		}

  354. 

  355. 		// Process block

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

  357. 			blockIndex = 0;

  358. 			stepBlock();

  359. 		}

  360. 

  361. 		// Output

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

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

  364. 

  365. 			int numberOfLoopsInGroup = 0;

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

  367. 				int segment = group.first_segment + j;

  368. 

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

  370. 				outputs[ENVELOPE_OUTPUTS + segment].setVoltage(envelope * 8.f);

  371. 				lights[ENVELOPE_LIGHTS + segment].setSmoothBrightness(envelope, args.sampleTime);

  372. 

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

  374. 				float flashlevel = 1.f;

  375. 

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

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

  378. 				}

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

  380. 					float advancedPhase = lightOscillatorPhase + 0.25f;

  381. 					if (advancedPhase > 1.0f)

  382. 						advancedPhase -= 1.0f;

  383. 

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

  385. 				}

  386. 

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

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

  389. 			}

  390. 		}

  391. 	}

  392. };

  393. 

  394. 

  395. struct StagesWidget : ModuleWidget {

  396. 	StagesWidget(Stages* module) {

  397. 		setModule(module);

  398. 		setPanel(APP->window->loadSvg(asset::plugin(pluginInstance, "res/Stages.svg")));

  399. 

  400. 		addChild(createWidget<ScrewSilver>(Vec(RACK_GRID_WIDTH, 0)));

  401. 		addChild(createWidget<ScrewSilver>(Vec(box.size.x - 2 * RACK_GRID_WIDTH, 0)));

  402. 		addChild(createWidget<ScrewSilver>(Vec(RACK_GRID_WIDTH, RACK_GRID_HEIGHT - RACK_GRID_WIDTH)));

  403. 		addChild(createWidget<ScrewSilver>(Vec(box.size.x - 2 * RACK_GRID_WIDTH, RACK_GRID_HEIGHT - RACK_GRID_WIDTH)));

  404. 

  405. 		addParam(createParam<Trimpot>(mm2px(Vec(3.72965, 13.98158)), module, Stages::SHAPE_PARAMS + 0));

  406. 		addParam(createParam<Trimpot>(mm2px(Vec(15.17012, 13.98158)), module, Stages::SHAPE_PARAMS + 1));

  407. 		addParam(createParam<Trimpot>(mm2px(Vec(26.6099, 13.98158)), module, Stages::SHAPE_PARAMS + 2));

  408. 		addParam(createParam<Trimpot>(mm2px(Vec(38.07174, 13.98158)), module, Stages::SHAPE_PARAMS + 3));

  409. 		addParam(createParam<Trimpot>(mm2px(Vec(49.51152, 13.98158)), module, Stages::SHAPE_PARAMS + 4));

  410. 		addParam(createParam<Trimpot>(mm2px(Vec(60.95199, 13.98158)), module, Stages::SHAPE_PARAMS + 5));

  411. 		addParam(createParam<TL1105>(mm2px(Vec(4.17259, 32.37248)), module, Stages::TYPE_PARAMS + 0));

  412. 		addParam(createParam<TL1105>(mm2px(Vec(15.61237, 32.37248)), module, Stages::TYPE_PARAMS + 1));

  413. 		addParam(createParam<TL1105>(mm2px(Vec(27.05284, 32.37248)), module, Stages::TYPE_PARAMS + 2));

  414. 		addParam(createParam<TL1105>(mm2px(Vec(38.51399, 32.37248)), module, Stages::TYPE_PARAMS + 3));

  415. 		addParam(createParam<TL1105>(mm2px(Vec(49.95446, 32.37248)), module, Stages::TYPE_PARAMS + 4));

  416. 		addParam(createParam<TL1105>(mm2px(Vec(61.39424, 32.37248)), module, Stages::TYPE_PARAMS + 5));

  417. 		addParam(createParam<LEDSliderGreen>(mm2px(Vec(3.36193, 43.06508)), module, Stages::LEVEL_PARAMS + 0));

  418. 		addParam(createParam<LEDSliderGreen>(mm2px(Vec(14.81619, 43.06508)), module, Stages::LEVEL_PARAMS + 1));

  419. 		addParam(createParam<LEDSliderGreen>(mm2px(Vec(26.26975, 43.06508)), module, Stages::LEVEL_PARAMS + 2));

  420. 		addParam(createParam<LEDSliderGreen>(mm2px(Vec(37.70265, 43.06508)), module, Stages::LEVEL_PARAMS + 3));

  421. 		addParam(createParam<LEDSliderGreen>(mm2px(Vec(49.15759, 43.06508)), module, Stages::LEVEL_PARAMS + 4));

  422. 		addParam(createParam<LEDSliderGreen>(mm2px(Vec(60.61184, 43.06508)), module, Stages::LEVEL_PARAMS + 5));

  423. 

  424. 		addInput(createInput<PJ301MPort>(mm2px(Vec(2.70756, 77.75277)), module, Stages::LEVEL_INPUTS + 0));

  425. 		addInput(createInput<PJ301MPort>(mm2px(Vec(14.14734, 77.75277)), module, Stages::LEVEL_INPUTS + 1));

  426. 		addInput(createInput<PJ301MPort>(mm2px(Vec(25.58781, 77.75277)), module, Stages::LEVEL_INPUTS + 2));

  427. 		addInput(createInput<PJ301MPort>(mm2px(Vec(37.04896, 77.75277)), module, Stages::LEVEL_INPUTS + 3));

  428. 		addInput(createInput<PJ301MPort>(mm2px(Vec(48.48943, 77.75277)), module, Stages::LEVEL_INPUTS + 4));

  429. 		addInput(createInput<PJ301MPort>(mm2px(Vec(59.92921, 77.75277)), module, Stages::LEVEL_INPUTS + 5));

  430. 		addInput(createInput<PJ301MPort>(mm2px(Vec(2.70756, 92.35239)), module, Stages::GATE_INPUTS + 0));

  431. 		addInput(createInput<PJ301MPort>(mm2px(Vec(14.14734, 92.35239)), module, Stages::GATE_INPUTS + 1));

  432. 		addInput(createInput<PJ301MPort>(mm2px(Vec(25.58781, 92.35239)), module, Stages::GATE_INPUTS + 2));

  433. 		addInput(createInput<PJ301MPort>(mm2px(Vec(37.04896, 92.35239)), module, Stages::GATE_INPUTS + 3));

  434. 		addInput(createInput<PJ301MPort>(mm2px(Vec(48.48943, 92.35239)), module, Stages::GATE_INPUTS + 4));

  435. 		addInput(createInput<PJ301MPort>(mm2px(Vec(59.92921, 92.35239)), module, Stages::GATE_INPUTS + 5));

  436. 

  437. 		addOutput(createOutput<PJ301MPort>(mm2px(Vec(2.70756, 106.95203)), module, Stages::ENVELOPE_OUTPUTS + 0));

  438. 		addOutput(createOutput<PJ301MPort>(mm2px(Vec(14.14734, 106.95203)), module, Stages::ENVELOPE_OUTPUTS + 1));

  439. 		addOutput(createOutput<PJ301MPort>(mm2px(Vec(25.58781, 106.95203)), module, Stages::ENVELOPE_OUTPUTS + 2));

  440. 		addOutput(createOutput<PJ301MPort>(mm2px(Vec(37.04896, 106.95203)), module, Stages::ENVELOPE_OUTPUTS + 3));

  441. 		addOutput(createOutput<PJ301MPort>(mm2px(Vec(48.48943, 106.95203)), module, Stages::ENVELOPE_OUTPUTS + 4));

  442. 		addOutput(createOutput<PJ301MPort>(mm2px(Vec(59.92921, 106.95203)), module, Stages::ENVELOPE_OUTPUTS + 5));

  443. 

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

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

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

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

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

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

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

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

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

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

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

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

  456. 	}

  457. };

  458. 

  459. 

  460. Model* modelStages = createModel<Stages, StagesWidget>("Stages");