VCVRack
/
Fundamental
mirror of https://github.com/VCVRack/Fundamental.git
1
0
Fork 0
Code Issues 0 Releases 28 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.
446 Commits
6 Branches
3.1MB
Tree: b73fb1aed8
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b73fb1aed8'
${ noResults }
Fundamental/src/SEQ3.cpp

406 lines
17KB
Raw Blame History 

  1. #include "plugin.hpp"

  2. 

  3. 

  4. struct SEQ3 : Module {

  5. 	enum ParamIds {

  6. 		TEMPO_PARAM,

  7. 		RUN_PARAM,

  8. 		RESET_PARAM,

  9. 		TRIG_PARAM,

  10. 		ENUMS(CV_PARAMS, 3 * 8),

  11. 		ENUMS(GATE_PARAMS, 8),

  12. 		// added in 2.0

  13. 		TEMPO_CV_PARAM,

  14. 		STEPS_CV_PARAM,

  15. 		NUM_PARAMS

  16. 	};

  17. 	enum InputIds {

  18. 		TEMPO_INPUT,

  19. 		CLOCK_INPUT,

  20. 		RESET_INPUT,

  21. 		STEPS_INPUT,

  22. 		// added in 2.0

  23. 		RUN_INPUT,

  24. 		NUM_INPUTS

  25. 	};

  26. 	enum OutputIds {

  27. 		TRIG_OUTPUT,

  28. 		ENUMS(CV_OUTPUTS, 3),

  29. 		ENUMS(STEP_OUTPUTS, 8),

  30. 		// added in 2.0

  31. 		STEPS_OUTPUT,

  32. 		CLOCK_OUTPUT,

  33. 		RUN_OUTPUT,

  34. 		RESET_OUTPUT,

  35. 		NUM_OUTPUTS

  36. 	};

  37. 	enum LightIds {

  38. 		CLOCK_LIGHT,

  39. 		RUN_LIGHT,

  40. 		RESET_LIGHT,

  41. 		ENUMS(GATE_LIGHTS, 8),

  42. 		ENUMS(STEP_LIGHTS, 8 * 2),

  43. 		NUM_LIGHTS

  44. 	};

  45. 

  46. 	bool running = true;

  47. 	bool clockPassthrough = false;

  48. 

  49. 	dsp::BooleanTrigger runButtonTrigger;

  50. 	dsp::BooleanTrigger resetButtonTrigger;

  51. 	dsp::BooleanTrigger gateTriggers[8];

  52. 

  53. 	dsp::SchmittTrigger runTrigger;

  54. 	dsp::SchmittTrigger clockTrigger;

  55. 	dsp::SchmittTrigger resetTrigger;

  56. 

  57. 	dsp::PulseGenerator runPulse;

  58. 	dsp::PulseGenerator clockPulse;

  59. 	dsp::PulseGenerator resetPulse;

  60. 

  61. 	/** Phase of internal LFO */

  62. 	float phase = 0.f;

  63. 	int index = 0;

  64. 	bool gates[8] = {};

  65. 

  66. 	SEQ3() {

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

  68. 

  69. 		configParam(TEMPO_PARAM, -2.f, 4.f, 1.f, "Tempo", " bpm", 2.f, 60.f);

  70. 		getParamQuantity(TEMPO_PARAM)->randomizeEnabled = false;

  71. 		configParam(TEMPO_CV_PARAM, 0.f, 1.f, 1.f, "Tempo CV", "%", 0, 100);

  72. 		getParamQuantity(TEMPO_CV_PARAM)->randomizeEnabled = false;

  73. 		configButton(RUN_PARAM, "Run");

  74. 		configButton(RESET_PARAM, "Reset");

  75. 		configParam(TRIG_PARAM, 1.f, 8.f, 8.f, "Steps");

  76. 		getParamQuantity(TRIG_PARAM)->randomizeEnabled = false;

  77. 		configParam(STEPS_CV_PARAM, 0.f, 1.f, 1.f, "Steps CV", "%", 0, 100);

  78. 		getParamQuantity(STEPS_CV_PARAM)->randomizeEnabled = false;

  79. 		paramQuantities[TRIG_PARAM]->snapEnabled = true;

  80. 		for (int j = 0; j < 3; j++) {

  81. 			for (int i = 0; i < 8; i++) {

  82. 				configParam(CV_PARAMS + 8 * j + i, -10.f, 10.f, 0.f, string::f("CV %d step %d", j + 1, i + 1), " V");

  83. 			}

  84. 		}

  85. 		for (int i = 0; i < 8; i++) {

  86. 			configButton(GATE_PARAMS + i, string::f("Step %d trigger", i + 1));

  87. 		}

  88. 

  89. 		configInput(TEMPO_INPUT, "Tempo");

  90. 		configInput(CLOCK_INPUT, "Clock");

  91. 		configInput(RUN_INPUT, "Run");

  92. 		configInput(RESET_INPUT, "Reset");

  93. 		configInput(STEPS_INPUT, "Steps");

  94. 

  95. 		for (int i = 0; i < 8; i++) {

  96. 			configOutput(STEP_OUTPUTS + i, string::f("Step %d", i + 1));

  97. 		}

  98. 		for (int j = 0; j < 3; j++) {

  99. 			configOutput(CV_OUTPUTS + j, string::f("CV %d", j + 1));

  100. 		}

  101. 		configOutput(TRIG_OUTPUT, "Trigger");

  102. 		configOutput(STEPS_OUTPUT, "Steps");

  103. 		configOutput(CLOCK_OUTPUT, "Clock");

  104. 		configOutput(RUN_OUTPUT, "Run");

  105. 		configOutput(RESET_OUTPUT, "Reset");

  106. 

  107. 		configLight(CLOCK_LIGHT, "Clock trigger");

  108. 

  109. 		onReset();

  110. 	}

  111. 

  112. 	void onReset() override {

  113. 		clockPassthrough = false;

  114. 		for (int i = 0; i < 8; i++) {

  115. 			gates[i] = true;

  116. 		}

  117. 		index = 0;

  118. 	}

  119. 

  120. 	void onRandomize() override {

  121. 		for (int i = 0; i < 8; i++) {

  122. 			gates[i] = random::get<bool>();

  123. 		}

  124. 	}

  125. 

  126. 	void rotateStates(int delta) {

  127. 		// Rotate CV params

  128. 		for (int j = 0; j < 3; j++) {

  129. 			float cvs[8];

  130. 			for (int i = 0; i < 8; i++) {

  131. 				cvs[i] = params[CV_PARAMS + 8 * j + i].getValue();

  132. 			}

  133. 			for (int i = 0; i < 8; i++) {

  134. 				int index = eucMod(i + delta, 8);

  135. 				params[CV_PARAMS + 8 * j + index].setValue(cvs[i]);

  136. 			}

  137. 		}

  138. 		// Rotate gates

  139. 		bool gates[8];

  140. 		for (int i = 0; i < 8; i++) {

  141. 			gates[i] = this->gates[i];

  142. 		}

  143. 		for (int i = 0; i < 8; i++) {

  144. 			int index = eucMod(i + delta, 8);

  145. 			this->gates[index] = gates[i];

  146. 		}

  147. 	}

  148. 

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

  150. 		// Toggle run

  151. 		bool runButtonTriggered = runButtonTrigger.process(params[RUN_PARAM].getValue());

  152. 		bool runTriggered = runTrigger.process(inputs[RUN_INPUT].getVoltage(), 0.1f, 2.f);

  153. 		if (runButtonTriggered || runTriggered) {

  154. 			running ^= true;

  155. 			runPulse.trigger(1e-3f);

  156. 		}

  157. 		bool runGate = runPulse.process(args.sampleTime);

  158. 

  159. 		int oldIndex = index;

  160. 

  161. 		// Reset to step 1

  162. 		bool resetButtonTriggered = resetButtonTrigger.process(params[RESET_PARAM].getValue());

  163. 		bool resetTriggered = resetTrigger.process(inputs[RESET_INPUT].getVoltage(), 0.1f, 2.f);

  164. 		if (resetButtonTriggered || resetTriggered) {

  165. 			resetPulse.trigger(1e-3f);

  166. 			// Reset step index

  167. 			index = 0;

  168. 			// Reset phase

  169. 			phase = 0.f;

  170. 		}

  171. 		bool resetGate = resetPulse.process(args.sampleTime);

  172. 

  173. 		// Clock

  174. 		bool clock = false;

  175. 		bool clockGate = false;

  176. 		if (running) {

  177. 			if (inputs[CLOCK_INPUT].isConnected()) {

  178. 				// External clock

  179. 				bool clockTriggered = clockTrigger.process(inputs[CLOCK_INPUT].getVoltage(), 0.1f, 2.f);

  180. 				// Ignore clock while reset pulse is high

  181. 				if (clockTriggered && !resetGate) {

  182. 					clock = true;

  183. 				}

  184. 				clockGate = clockTrigger.isHigh();

  185. 			}

  186. 			else {

  187. 				// Internal clock

  188. 				float clockPitch = params[TEMPO_PARAM].getValue() + inputs[TEMPO_INPUT].getVoltage() * params[TEMPO_CV_PARAM].getValue();

  189. 				float clockFreq = dsp::exp2_taylor5(clockPitch);

  190. 				phase += clockFreq * args.sampleTime;

  191. 				if (phase >= 1.f && !resetGate) {

  192. 					clock = true;

  193. 				}

  194. 				phase -= std::trunc(phase);

  195. 				clockGate = (phase < 0.5f);

  196. 			}

  197. 		}

  198. 

  199. 		// Get number of steps

  200. 		float steps = params[TRIG_PARAM].getValue() + inputs[STEPS_INPUT].getVoltage() * params[STEPS_CV_PARAM].getValue();

  201. 		int numSteps = (int) clamp(std::round(steps), 1.f, 8.f);

  202. 

  203. 		// Advance step when clocked

  204. 		if (clock) {

  205. 			index++;

  206. 			if (index >= numSteps)

  207. 				index = 0;

  208. 		}

  209. 		// Trigger pulse if step was changed

  210. 		if (index != oldIndex) {

  211. 			clockPulse.trigger(1e-3f);

  212. 		}

  213. 

  214. 		// Unless we're passing the clock gate, generate a pulse

  215. 		if (!clockPassthrough) {

  216. 			clockGate = clockPulse.process(args.sampleTime);

  217. 		}

  218. 

  219. 		// Gate buttons

  220. 		for (int i = 0; i < 8; i++) {

  221. 			if (gateTriggers[i].process(params[GATE_PARAMS + i].getValue())) {

  222. 				gates[i] ^= true;

  223. 			}

  224. 			lights[GATE_LIGHTS + i].setBrightness(gates[i]);

  225. 		}

  226. 

  227. 		// Step outputs

  228. 		for (int i = 0; i < 8; i++) {

  229. 			outputs[STEP_OUTPUTS + i].setVoltage((index == i) ? 10.f : 0.f);

  230. 			lights[STEP_LIGHTS + 2 * i + 0].setSmoothBrightness(index == i, args.sampleTime);

  231. 			lights[STEP_LIGHTS + 2 * i + 1].setBrightness(i >= numSteps);

  232. 		}

  233. 

  234. 		// Outputs

  235. 		outputs[CV_OUTPUTS + 0].setVoltage(params[CV_PARAMS + 8 * 0 + index].getValue());

  236. 		outputs[CV_OUTPUTS + 1].setVoltage(params[CV_PARAMS + 8 * 1 + index].getValue());

  237. 		outputs[CV_OUTPUTS + 2].setVoltage(params[CV_PARAMS + 8 * 2 + index].getValue());

  238. 		outputs[TRIG_OUTPUT].setVoltage((clockGate && gates[index]) ? 10.f : 0.f);

  239. 

  240. 		outputs[STEPS_OUTPUT].setVoltage((numSteps - 1) * 1.f);

  241. 		outputs[CLOCK_OUTPUT].setVoltage(clockGate ? 10.f : 0.f);

  242. 		outputs[RUN_OUTPUT].setVoltage(runGate ? 10.f : 0.f);

  243. 		outputs[RESET_OUTPUT].setVoltage(resetGate ? 10.f : 0.f);

  244. 

  245. 		lights[CLOCK_LIGHT].setSmoothBrightness(clockGate, args.sampleTime);

  246. 		lights[RUN_LIGHT].setBrightness(running);

  247. 		lights[RESET_LIGHT].setSmoothBrightness(resetGate, args.sampleTime);

  248. 	}

  249. 

  250. 	json_t* dataToJson() override {

  251. 		json_t* rootJ = json_object();

  252. 

  253. 		// running

  254. 		json_object_set_new(rootJ, "running", json_boolean(running));

  255. 

  256. 		// gates

  257. 		json_t* gatesJ = json_array();

  258. 		for (int i = 0; i < 8; i++) {

  259. 			json_array_insert_new(gatesJ, i, json_integer((int) gates[i]));

  260. 		}

  261. 		json_object_set_new(rootJ, "gates", gatesJ);

  262. 

  263. 		// clockPassthrough

  264. 		json_object_set_new(rootJ, "clockPassthrough", json_boolean(clockPassthrough));

  265. 

  266. 		return rootJ;

  267. 	}

  268. 

  269. 	void dataFromJson(json_t* rootJ) override {

  270. 		// running

  271. 		json_t* runningJ = json_object_get(rootJ, "running");

  272. 		if (runningJ)

  273. 			running = json_is_true(runningJ);

  274. 

  275. 		// gates

  276. 		json_t* gatesJ = json_object_get(rootJ, "gates");

  277. 		if (gatesJ) {

  278. 			for (int i = 0; i < 8; i++) {

  279. 				json_t* gateJ = json_array_get(gatesJ, i);

  280. 				if (gateJ)

  281. 					gates[i] = !!json_integer_value(gateJ);

  282. 			}

  283. 		}

  284. 

  285. 		// clockPassthrough

  286. 		json_t* clockPassthroughJ = json_object_get(rootJ, "clockPassthrough");

  287. 		if (clockPassthroughJ)

  288. 			clockPassthrough = json_is_true(clockPassthroughJ);

  289. 		else

  290. 			clockPassthrough = true;

  291. 	}

  292. };

  293. 

  294. 

  295. struct SEQ3Widget : ModuleWidget {

  296. 	SEQ3Widget(SEQ3* module) {

  297. 		setModule(module);

  298. 		setPanel(createPanel(asset::plugin(pluginInstance, "res/SEQ3.svg"), asset::plugin(pluginInstance, "res/SEQ3-dark.svg")));

  299. 

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

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

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

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

  304. 

  305. 		addParam(createParamCentered<RoundLargeBlackKnob>(mm2px(Vec(11.753, 26.755)), module, SEQ3::TEMPO_PARAM));

  306. 		addParam(createParamCentered<RoundLargeBlackKnob>(mm2px(Vec(32.077, 26.782)), module, SEQ3::TRIG_PARAM));

  307. 		addParam(createParamCentered<Trimpot>(mm2px(Vec(49.372, 34.066)), module, SEQ3::TEMPO_CV_PARAM));

  308. 		addParam(createLightParamCentered<VCVLightButton<MediumSimpleLight<WhiteLight>>>(mm2px(Vec(88.424, 33.679)), module, SEQ3::RUN_PARAM, SEQ3::RUN_LIGHT));

  309. 		addParam(createParamCentered<Trimpot>(mm2px(Vec(62.39, 34.066)), module, SEQ3::STEPS_CV_PARAM));

  310. 		addParam(createLightParamCentered<VCVLightButton<MediumSimpleLight<WhiteLight>>>(mm2px(Vec(101.441, 33.679)), module, SEQ3::RESET_PARAM, SEQ3::RESET_LIGHT));

  311. 

  312. 		addParam(createParamCentered<RoundBlackKnob>(mm2px(Vec(10.319, 46.563)), module, SEQ3::CV_PARAMS + 8 * 0 + 0));

  313. 		addParam(createParamCentered<RoundBlackKnob>(mm2px(Vec(23.336, 46.563)), module, SEQ3::CV_PARAMS + 8 * 0 + 1));

  314. 		addParam(createParamCentered<RoundBlackKnob>(mm2px(Vec(36.354, 46.563)), module, SEQ3::CV_PARAMS + 8 * 0 + 2));

  315. 		addParam(createParamCentered<RoundBlackKnob>(mm2px(Vec(49.371, 46.563)), module, SEQ3::CV_PARAMS + 8 * 0 + 3));

  316. 		addParam(createParamCentered<RoundBlackKnob>(mm2px(Vec(62.389, 46.563)), module, SEQ3::CV_PARAMS + 8 * 0 + 4));

  317. 		addParam(createParamCentered<RoundBlackKnob>(mm2px(Vec(75.406, 46.563)), module, SEQ3::CV_PARAMS + 8 * 0 + 5));

  318. 		addParam(createParamCentered<RoundBlackKnob>(mm2px(Vec(88.424, 46.563)), module, SEQ3::CV_PARAMS + 8 * 0 + 6));

  319. 		addParam(createParamCentered<RoundBlackKnob>(mm2px(Vec(101.441, 46.563)), module, SEQ3::CV_PARAMS + 8 * 0 + 7));

  320. 

  321. 		addParam(createParamCentered<RoundBlackKnob>(mm2px(Vec(10.319, 60.607)), module, SEQ3::CV_PARAMS + 8 * 1 + 0));

  322. 		addParam(createParamCentered<RoundBlackKnob>(mm2px(Vec(23.336, 60.607)), module, SEQ3::CV_PARAMS + 8 * 1 + 1));

  323. 		addParam(createParamCentered<RoundBlackKnob>(mm2px(Vec(36.354, 60.607)), module, SEQ3::CV_PARAMS + 8 * 1 + 2));

  324. 		addParam(createParamCentered<RoundBlackKnob>(mm2px(Vec(49.371, 60.607)), module, SEQ3::CV_PARAMS + 8 * 1 + 3));

  325. 		addParam(createParamCentered<RoundBlackKnob>(mm2px(Vec(62.389, 60.607)), module, SEQ3::CV_PARAMS + 8 * 1 + 4));

  326. 		addParam(createParamCentered<RoundBlackKnob>(mm2px(Vec(75.406, 60.607)), module, SEQ3::CV_PARAMS + 8 * 1 + 5));

  327. 		addParam(createParamCentered<RoundBlackKnob>(mm2px(Vec(88.424, 60.607)), module, SEQ3::CV_PARAMS + 8 * 1 + 6));

  328. 		addParam(createParamCentered<RoundBlackKnob>(mm2px(Vec(101.441, 60.607)), module, SEQ3::CV_PARAMS + 8 * 1 + 7));

  329. 

  330. 		addParam(createParamCentered<RoundBlackKnob>(mm2px(Vec(10.319, 74.605)), module, SEQ3::CV_PARAMS + 8 * 2 + 0));

  331. 		addParam(createParamCentered<RoundBlackKnob>(mm2px(Vec(23.336, 74.605)), module, SEQ3::CV_PARAMS + 8 * 2 + 1));

  332. 		addParam(createParamCentered<RoundBlackKnob>(mm2px(Vec(36.354, 74.605)), module, SEQ3::CV_PARAMS + 8 * 2 + 2));

  333. 		addParam(createParamCentered<RoundBlackKnob>(mm2px(Vec(49.371, 74.605)), module, SEQ3::CV_PARAMS + 8 * 2 + 3));

  334. 		addParam(createParamCentered<RoundBlackKnob>(mm2px(Vec(62.389, 74.605)), module, SEQ3::CV_PARAMS + 8 * 2 + 4));

  335. 		addParam(createParamCentered<RoundBlackKnob>(mm2px(Vec(75.406, 74.605)), module, SEQ3::CV_PARAMS + 8 * 2 + 5));

  336. 		addParam(createParamCentered<RoundBlackKnob>(mm2px(Vec(88.424, 74.605)), module, SEQ3::CV_PARAMS + 8 * 2 + 6));

  337. 		addParam(createParamCentered<RoundBlackKnob>(mm2px(Vec(101.441, 74.605)), module, SEQ3::CV_PARAMS + 8 * 2 + 7));

  338. 

  339. 		addParam(createLightParamCentered<VCVLightBezel<WhiteLight>>(mm2px(Vec(10.319, 85.801)), module, SEQ3::GATE_PARAMS + 0, SEQ3::GATE_LIGHTS + 0));

  340. 		addParam(createLightParamCentered<VCVLightBezel<WhiteLight>>(mm2px(Vec(23.336, 85.801)), module, SEQ3::GATE_PARAMS + 1, SEQ3::GATE_LIGHTS + 1));

  341. 		addParam(createLightParamCentered<VCVLightBezel<WhiteLight>>(mm2px(Vec(36.354, 85.801)), module, SEQ3::GATE_PARAMS + 2, SEQ3::GATE_LIGHTS + 2));

  342. 		addParam(createLightParamCentered<VCVLightBezel<WhiteLight>>(mm2px(Vec(49.371, 85.801)), module, SEQ3::GATE_PARAMS + 3, SEQ3::GATE_LIGHTS + 3));

  343. 		addParam(createLightParamCentered<VCVLightBezel<WhiteLight>>(mm2px(Vec(62.389, 85.801)), module, SEQ3::GATE_PARAMS + 4, SEQ3::GATE_LIGHTS + 4));

  344. 		addParam(createLightParamCentered<VCVLightBezel<WhiteLight>>(mm2px(Vec(75.406, 85.801)), module, SEQ3::GATE_PARAMS + 5, SEQ3::GATE_LIGHTS + 5));

  345. 		addParam(createLightParamCentered<VCVLightBezel<WhiteLight>>(mm2px(Vec(88.424, 85.801)), module, SEQ3::GATE_PARAMS + 6, SEQ3::GATE_LIGHTS + 6));

  346. 		addParam(createLightParamCentered<VCVLightBezel<WhiteLight>>(mm2px(Vec(101.441, 85.801)), module, SEQ3::GATE_PARAMS + 7, SEQ3::GATE_LIGHTS + 7));

  347. 

  348. 		addInput(createInputCentered<ThemedPJ301MPort>(mm2px(Vec(49.371, 17.307)), module, SEQ3::TEMPO_INPUT));

  349. 		addInput(createInputCentered<ThemedPJ301MPort>(mm2px(Vec(62.389, 17.307)), module, SEQ3::STEPS_INPUT));

  350. 		addInput(createInputCentered<ThemedPJ301MPort>(mm2px(Vec(75.406, 17.42)), module, SEQ3::CLOCK_INPUT));

  351. 		addInput(createInputCentered<ThemedPJ301MPort>(mm2px(Vec(88.424, 17.42)), module, SEQ3::RUN_INPUT));

  352. 		addInput(createInputCentered<ThemedPJ301MPort>(mm2px(Vec(101.441, 17.42)), module, SEQ3::RESET_INPUT));

  353. 

  354. 		addOutput(createOutputCentered<ThemedPJ301MPort>(mm2px(Vec(10.319, 96.859)), module, SEQ3::STEP_OUTPUTS + 0));

  355. 		addOutput(createOutputCentered<ThemedPJ301MPort>(mm2px(Vec(23.336, 96.859)), module, SEQ3::STEP_OUTPUTS + 1));

  356. 		addOutput(createOutputCentered<ThemedPJ301MPort>(mm2px(Vec(36.354, 96.859)), module, SEQ3::STEP_OUTPUTS + 2));

  357. 		addOutput(createOutputCentered<ThemedPJ301MPort>(mm2px(Vec(49.371, 96.859)), module, SEQ3::STEP_OUTPUTS + 3));

  358. 		addOutput(createOutputCentered<ThemedPJ301MPort>(mm2px(Vec(62.389, 96.859)), module, SEQ3::STEP_OUTPUTS + 4));

  359. 		addOutput(createOutputCentered<ThemedPJ301MPort>(mm2px(Vec(75.406, 96.859)), module, SEQ3::STEP_OUTPUTS + 5));

  360. 		addOutput(createOutputCentered<ThemedPJ301MPort>(mm2px(Vec(88.424, 96.859)), module, SEQ3::STEP_OUTPUTS + 6));

  361. 		addOutput(createOutputCentered<ThemedPJ301MPort>(mm2px(Vec(101.441, 96.859)), module, SEQ3::STEP_OUTPUTS + 7));

  362. 

  363. 		addOutput(createOutputCentered<ThemedPJ301MPort>(mm2px(Vec(10.319, 113.115)), module, SEQ3::CV_OUTPUTS + 0));

  364. 		addOutput(createOutputCentered<ThemedPJ301MPort>(mm2px(Vec(23.336, 113.115)), module, SEQ3::CV_OUTPUTS + 1));

  365. 		addOutput(createOutputCentered<ThemedPJ301MPort>(mm2px(Vec(36.354, 113.115)), module, SEQ3::CV_OUTPUTS + 2));

  366. 		addOutput(createOutputCentered<ThemedPJ301MPort>(mm2px(Vec(49.371, 113.115)), module, SEQ3::TRIG_OUTPUT));

  367. 		addOutput(createOutputCentered<ThemedPJ301MPort>(mm2px(Vec(62.389, 113.115)), module, SEQ3::STEPS_OUTPUT));

  368. 		addOutput(createOutputCentered<ThemedPJ301MPort>(mm2px(Vec(75.406, 113.115)), module, SEQ3::CLOCK_OUTPUT));

  369. 		addOutput(createOutputCentered<ThemedPJ301MPort>(mm2px(Vec(88.424, 113.115)), module, SEQ3::RUN_OUTPUT));

  370. 		addOutput(createOutputCentered<ThemedPJ301MPort>(mm2px(Vec(101.441, 113.115)), module, SEQ3::RESET_OUTPUT));

  371. 

  372. 		addChild(createLightCentered<SmallLight<YellowLight>>(mm2px(Vec(75.406, 33.497)), module, SEQ3::CLOCK_LIGHT));

  373. 

  374. 		addChild(createLightCentered<TinyLight<YellowRedLight<>>>(mm2px(Vec(14.064, 93.103)), module, SEQ3::STEP_LIGHTS + 2 * 0));

  375. 		addChild(createLightCentered<TinyLight<YellowRedLight<>>>(mm2px(Vec(27.084, 93.103)), module, SEQ3::STEP_LIGHTS + 2 * 1));

  376. 		addChild(createLightCentered<TinyLight<YellowRedLight<>>>(mm2px(Vec(40.103, 93.103)), module, SEQ3::STEP_LIGHTS + 2 * 2));

  377. 		addChild(createLightCentered<TinyLight<YellowRedLight<>>>(mm2px(Vec(53.122, 93.103)), module, SEQ3::STEP_LIGHTS + 2 * 3));

  378. 		addChild(createLightCentered<TinyLight<YellowRedLight<>>>(mm2px(Vec(66.142, 93.103)), module, SEQ3::STEP_LIGHTS + 2 * 4));

  379. 		addChild(createLightCentered<TinyLight<YellowRedLight<>>>(mm2px(Vec(79.161, 93.103)), module, SEQ3::STEP_LIGHTS + 2 * 5));

  380. 		addChild(createLightCentered<TinyLight<YellowRedLight<>>>(mm2px(Vec(92.181, 93.103)), module, SEQ3::STEP_LIGHTS + 2 * 6));

  381. 		addChild(createLightCentered<TinyLight<YellowRedLight<>>>(mm2px(Vec(105.2, 93.103)), module, SEQ3::STEP_LIGHTS + 2 * 7));

  382. 	}

  383. 

  384. 	void appendContextMenu(Menu* menu) override {

  385. 		SEQ3* module = dynamic_cast<SEQ3*>(this->module);

  386. 		assert(module);

  387. 

  388. 		menu->addChild(new MenuSeparator);

  389. 

  390. 		menu->addChild(createBoolPtrMenuItem("Clock passthrough", "", &module->clockPassthrough));

  391. 

  392. 		menu->addChild(new MenuSeparator);

  393. 

  394. 		menu->addChild(createMenuItem("Rotate left", "",

  395. 			[=]() {module->rotateStates(-1);}

  396. 		));

  397. 

  398. 		menu->addChild(createMenuItem("Rotate right", "",

  399. 			[=]() {module->rotateStates(1);}

  400. 		));

  401. 	}

  402. };

  403. 

  404. 

  405. Model* modelSEQ3 = createModel<SEQ3, SEQ3Widget>("SEQ3");