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

417 lines
16KB
Raw Blame History 

  1. #include "plugin.hpp"

  2. #include "elements/dsp/part.h"

  3. 

  4. 

  5. struct Elements : Module {

  6. 	enum ParamIds {

  7. 		CONTOUR_PARAM,

  8. 		BOW_PARAM,

  9. 		BLOW_PARAM,

  10. 		STRIKE_PARAM,

  11. 		COARSE_PARAM,

  12. 		FINE_PARAM,

  13. 		FM_PARAM,

  14. 

  15. 		FLOW_PARAM,

  16. 		MALLET_PARAM,

  17. 		GEOMETRY_PARAM,

  18. 		BRIGHTNESS_PARAM,

  19. 

  20. 		BOW_TIMBRE_PARAM,

  21. 		BLOW_TIMBRE_PARAM,

  22. 		STRIKE_TIMBRE_PARAM,

  23. 		DAMPING_PARAM,

  24. 		POSITION_PARAM,

  25. 		SPACE_PARAM,

  26. 

  27. 		BOW_TIMBRE_MOD_PARAM,

  28. 		FLOW_MOD_PARAM,

  29. 		BLOW_TIMBRE_MOD_PARAM,

  30. 		MALLET_MOD_PARAM,

  31. 		STRIKE_TIMBRE_MOD_PARAM,

  32. 		DAMPING_MOD_PARAM,

  33. 		GEOMETRY_MOD_PARAM,

  34. 		POSITION_MOD_PARAM,

  35. 		BRIGHTNESS_MOD_PARAM,

  36. 		SPACE_MOD_PARAM,

  37. 

  38. 		PLAY_PARAM,

  39. 		NUM_PARAMS

  40. 	};

  41. 	enum InputIds {

  42. 		NOTE_INPUT,

  43. 		FM_INPUT,

  44. 		GATE_INPUT,

  45. 		STRENGTH_INPUT,

  46. 		BLOW_INPUT,

  47. 		STRIKE_INPUT,

  48. 

  49. 		BOW_TIMBRE_MOD_INPUT,

  50. 		FLOW_MOD_INPUT,

  51. 		BLOW_TIMBRE_MOD_INPUT,

  52. 		MALLET_MOD_INPUT,

  53. 		STRIKE_TIMBRE_MOD_INPUT,

  54. 		DAMPING_MOD_INPUT,

  55. 		GEOMETRY_MOD_INPUT,

  56. 		POSITION_MOD_INPUT,

  57. 		BRIGHTNESS_MOD_INPUT,

  58. 		SPACE_MOD_INPUT,

  59. 		NUM_INPUTS

  60. 	};

  61. 	enum OutputIds {

  62. 		AUX_OUTPUT,

  63. 		MAIN_OUTPUT,

  64. 		NUM_OUTPUTS

  65. 	};

  66. 	enum LightIds {

  67. 		GATE_LIGHT,

  68. 		EXCITER_LIGHT,

  69. 		RESONATOR_LIGHT,

  70. 		NUM_LIGHTS

  71. 	};

  72. 

  73. 	dsp::SampleRateConverter<16 * 2> inputSrc;

  74. 	dsp::SampleRateConverter<16 * 2> outputSrc;

  75. 	dsp::DoubleRingBuffer<dsp::Frame<16 * 2>, 256> inputBuffer;

  76. 	dsp::DoubleRingBuffer<dsp::Frame<16 * 2>, 256> outputBuffer;

  77. 

  78. 	uint16_t reverb_buffers[16][32768] = {};

  79. 	elements::Part* parts[16];

  80. 

  81. 	Elements() {

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

  83. 		configParam(CONTOUR_PARAM, 0.0, 1.0, 1.0, "Envelope contour");

  84. 		configParam(BOW_PARAM, 0.0, 1.0, 0.0, "Bow exciter");

  85. 		configParam(BLOW_PARAM, 0.0, 1.0, 0.0, "Blow exciter");

  86. 		configParam(STRIKE_PARAM, 0.0, 1.0, 0.5, "Percussive noise amount");

  87. 		configParam(COARSE_PARAM, -30.0, 30.0, 0.0, "Coarse frequency adjustment");

  88. 		configParam(FINE_PARAM, -2.0, 2.0, 0.0, "Fine frequency adjustment");

  89. 		configParam(FM_PARAM, -1.0, 1.0, 0.0, "FM input attenuverter");

  90. 		configParam(FLOW_PARAM, 0.0, 1.0, 0.5, "Air flow noise color");

  91. 		configParam(MALLET_PARAM, 0.0, 1.0, 0.5, "Percussive noise type");

  92. 		configParam(GEOMETRY_PARAM, 0.0, 1.0, 0.5, "Resonator geometry");

  93. 		configParam(BRIGHTNESS_PARAM, 0.0, 1.0, 0.5, "Brightness");

  94. 		configParam(BOW_TIMBRE_PARAM, 0.0, 1.0, 0.5, "Bow timbre");

  95. 		configParam(BLOW_TIMBRE_PARAM, 0.0, 1.0, 0.5, "Blow timbre");

  96. 		configParam(STRIKE_TIMBRE_PARAM, 0.0, 1.0, 0.5, "Strike timbre");

  97. 		configParam(DAMPING_PARAM, 0.0, 1.0, 0.5, "Energy dissipation speed");

  98. 		configParam(POSITION_PARAM, 0.0, 1.0, 0.5, "Excitation position");

  99. 		configParam(SPACE_PARAM, 0.0, 2.0, 0.0, "Reverb space");

  100. 		configParam(BOW_TIMBRE_MOD_PARAM, -1.0, 1.0, 0.0, "Bow timbre CV");

  101. 		configParam(FLOW_MOD_PARAM, -1.0, 1.0, 0.0, "Air flow noise CV");

  102. 		configParam(BLOW_TIMBRE_MOD_PARAM, -1.0, 1.0, 0.0, "Blow timbre CV");

  103. 		configParam(MALLET_MOD_PARAM, -1.0, 1.0, 0.0, "Percussive noise CV");

  104. 		configParam(STRIKE_TIMBRE_MOD_PARAM, -1.0, 1.0, 0.0, "Strike timbre CV");

  105. 		configParam(DAMPING_MOD_PARAM, -1.0, 1.0, 0.0, "Energy dissipation speed CV");

  106. 		configParam(GEOMETRY_MOD_PARAM, -1.0, 1.0, 0.0, "Resonator geometry CV");

  107. 		configParam(POSITION_MOD_PARAM, -1.0, 1.0, 0.0, "Excitation position CV");

  108. 		configParam(BRIGHTNESS_MOD_PARAM, -1.0, 1.0, 0.0, "Brightness CV");

  109. 		configParam(SPACE_MOD_PARAM, -2.0, 2.0, 0.0, "Reverb space CV");

  110. 		configButton(PLAY_PARAM, "Play");

  111. 

  112. 		configInput(NOTE_INPUT, "Pitch (1V/oct)");

  113. 		configInput(FM_INPUT, "FM");

  114. 		configInput(GATE_INPUT, "Gate");

  115. 		configInput(STRENGTH_INPUT, "Strength");

  116. 		configInput(BLOW_INPUT, "External blow");

  117. 		configInput(STRIKE_INPUT, "External strike");

  118. 		configInput(BOW_TIMBRE_MOD_INPUT, "Bow timbre");

  119. 		configInput(FLOW_MOD_INPUT, "Air flow noise");

  120. 		configInput(BLOW_TIMBRE_MOD_INPUT, "Blow timbre");

  121. 		configInput(MALLET_MOD_INPUT, "Percussive noise");

  122. 		configInput(STRIKE_TIMBRE_MOD_INPUT, "Strike timbre");

  123. 		configInput(DAMPING_MOD_INPUT, "Energy dissipation speed");

  124. 		configInput(GEOMETRY_MOD_INPUT, "Resonator geometry");

  125. 		configInput(POSITION_MOD_INPUT, "Excitation position");

  126. 		configInput(BRIGHTNESS_MOD_INPUT, "Brightness");

  127. 		configInput(SPACE_MOD_INPUT, "Reverb space");

  128. 

  129. 		configOutput(AUX_OUTPUT, "Left");

  130. 		configOutput(MAIN_OUTPUT, "Right");

  131. 

  132. 		configBypass(BLOW_INPUT, AUX_OUTPUT);

  133. 		configBypass(STRIKE_INPUT, MAIN_OUTPUT);

  134. 

  135. 		for (int c = 0; c < 16; c++) {

  136. 			parts[c] = new elements::Part();

  137. 			// In the Mutable Instruments code, Part doesn't initialize itself, so zero it here.

  138. 			std::memset(parts[c], 0, sizeof(*parts[c]));

  139. 			parts[c]->Init(reverb_buffers[c]);

  140. 			// Just some random numbers

  141. 			uint32_t seed[3] = {1, 2, 3};

  142. 			parts[c]->Seed(seed, 3);

  143. 		}

  144. 	}

  145. 

  146. 	~Elements() {

  147. 		for (int c = 0; c < 16; c++) {

  148. 			delete parts[c];

  149. 		}

  150. 	}

  151. 

  152. 	void onReset() override {

  153. 		setModel(0);

  154. 	}

  155. 

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

  157. 		int channels = std::max(inputs[NOTE_INPUT].getChannels(), 1);

  158. 

  159. 		// Get input

  160. 		if (!inputBuffer.full()) {

  161. 			dsp::Frame<16 * 2> inputFrame = {};

  162. 			for (int c = 0; c < channels; c++) {

  163. 				inputFrame.samples[c * 2 + 0] = inputs[BLOW_INPUT].getPolyVoltage(c) / 5.0;

  164. 				inputFrame.samples[c * 2 + 1] = inputs[STRIKE_INPUT].getPolyVoltage(c) / 5.0;

  165. 			}

  166. 			inputBuffer.push(inputFrame);

  167. 		}

  168. 

  169. 		// Generate output if output buffer is empty

  170. 		if (outputBuffer.empty()) {

  171. 			// blow[channel][bufferIndex]

  172. 			float blow[16][16] = {};

  173. 			float strike[16][16] = {};

  174. 

  175. 			// Convert input buffer

  176. 			{

  177. 				inputSrc.setRates(args.sampleRate, 32000);

  178. 				inputSrc.setChannels(channels * 2);

  179. 				int inLen = inputBuffer.size();

  180. 				int outLen = 16;

  181. 				dsp::Frame<16 * 2> inputFrames[outLen];

  182. 				inputSrc.process(inputBuffer.startData(), &inLen, inputFrames, &outLen);

  183. 				inputBuffer.startIncr(inLen);

  184. 

  185. 				for (int c = 0; c < channels; c++) {

  186. 					for (int i = 0; i < outLen; i++) {

  187. 						blow[c][i] = inputFrames[i].samples[c * 2 + 0];

  188. 						strike[c][i] = inputFrames[i].samples[c * 2 + 1];

  189. 					}

  190. 				}

  191. 			}

  192. 

  193. 			// Process channels

  194. 			// main[channel][bufferIndex]

  195. 			float main[16][16];

  196. 			float aux[16][16];

  197. 			float gateLight = 0.f;

  198. 			float exciterLight = 0.f;

  199. 			float resonatorLight = 0.f;

  200. 

  201. 			for (int c = 0; c < channels; c++) {

  202. 				// Set patch from parameters

  203. 				elements::Patch* p = parts[c]->mutable_patch();

  204. 				p->exciter_envelope_shape = params[CONTOUR_PARAM].getValue();

  205. 				p->exciter_bow_level = params[BOW_PARAM].getValue();

  206. 				p->exciter_blow_level = params[BLOW_PARAM].getValue();

  207. 				p->exciter_strike_level = params[STRIKE_PARAM].getValue();

  208. 

  209. #define BIND(_p, _m, _i) clamp(params[_p].getValue() + 3.3f * dsp::quadraticBipolar(params[_m].getValue()) * inputs[_i].getPolyVoltage(c) / 5.f, 0.f, 0.9995f)

  210. 

  211. 				p->exciter_bow_timbre = BIND(BOW_TIMBRE_PARAM, BOW_TIMBRE_MOD_PARAM, BOW_TIMBRE_MOD_INPUT);

  212. 				p->exciter_blow_meta = BIND(FLOW_PARAM, FLOW_MOD_PARAM, FLOW_MOD_INPUT);

  213. 				p->exciter_blow_timbre = BIND(BLOW_TIMBRE_PARAM, BLOW_TIMBRE_MOD_PARAM, BLOW_TIMBRE_MOD_INPUT);

  214. 				p->exciter_strike_meta = BIND(MALLET_PARAM, MALLET_MOD_PARAM, MALLET_MOD_INPUT);

  215. 				p->exciter_strike_timbre = BIND(STRIKE_TIMBRE_PARAM, STRIKE_TIMBRE_MOD_PARAM, STRIKE_TIMBRE_MOD_INPUT);

  216. 				p->resonator_geometry = BIND(GEOMETRY_PARAM, GEOMETRY_MOD_PARAM, GEOMETRY_MOD_INPUT);

  217. 				p->resonator_brightness = BIND(BRIGHTNESS_PARAM, BRIGHTNESS_MOD_PARAM, BRIGHTNESS_MOD_INPUT);

  218. 				p->resonator_damping = BIND(DAMPING_PARAM, DAMPING_MOD_PARAM, DAMPING_MOD_INPUT);

  219. 				p->resonator_position = BIND(POSITION_PARAM, POSITION_MOD_PARAM, POSITION_MOD_INPUT);

  220. 				p->space = clamp(params[SPACE_PARAM].getValue() + params[SPACE_MOD_PARAM].getValue() * inputs[SPACE_MOD_INPUT].getPolyVoltage(c) / 5.f, 0.f, 2.f);

  221. 

  222. 				// Get performance inputs

  223. 				elements::PerformanceState performance;

  224. 				performance.note = 12.f * inputs[NOTE_INPUT].getVoltage(c) + std::round(params[COARSE_PARAM].getValue()) + params[FINE_PARAM].getValue() + 69.f;

  225. 				performance.modulation = 3.3f * dsp::quarticBipolar(params[FM_PARAM].getValue()) * 49.5f * inputs[FM_INPUT].getPolyVoltage(c) / 5.f;

  226. 				performance.gate = params[PLAY_PARAM].getValue() >= 1.f || inputs[GATE_INPUT].getPolyVoltage(c) >= 1.f;

  227. 				performance.strength = clamp(1.f - inputs[STRENGTH_INPUT].getPolyVoltage(c) / 5.f, 0.f, 1.f);

  228. 

  229. 				// Generate audio

  230. 				parts[c]->Process(performance, blow[c], strike[c], main[c], aux[c], 16);

  231. 

  232. 				// Set lights based on first poly channel

  233. 				gateLight = std::max(gateLight, performance.gate ? 0.75f : 0.f);

  234. 				exciterLight = std::max(exciterLight, parts[c]->exciter_level());

  235. 				resonatorLight = std::max(resonatorLight, parts[c]->resonator_level());

  236. 			}

  237. 

  238. 			// Set lights

  239. 			lights[GATE_LIGHT].setBrightness(gateLight);

  240. 			lights[EXCITER_LIGHT].setBrightness(exciterLight);

  241. 			lights[RESONATOR_LIGHT].setBrightness(resonatorLight);

  242. 

  243. 			// Convert output buffer

  244. 			{

  245. 				dsp::Frame<16 * 2> outputFrames[16];

  246. 				for (int c = 0; c < channels; c++) {

  247. 					for (int i = 0; i < 16; i++) {

  248. 						outputFrames[i].samples[c * 2 + 0] = main[c][i];

  249. 						outputFrames[i].samples[c * 2 + 1] = aux[c][i];

  250. 					}

  251. 				}

  252. 

  253. 				outputSrc.setRates(32000, args.sampleRate);

  254. 				outputSrc.setChannels(channels * 2);

  255. 				int inLen = 16;

  256. 				int outLen = outputBuffer.capacity();

  257. 				outputSrc.process(outputFrames, &inLen, outputBuffer.endData(), &outLen);

  258. 				outputBuffer.endIncr(outLen);

  259. 			}

  260. 		}

  261. 

  262. 		// Set output

  263. 		if (!outputBuffer.empty()) {

  264. 			dsp::Frame<16 * 2> outputFrame = outputBuffer.shift();

  265. 			for (int c = 0; c < channels; c++) {

  266. 				outputs[AUX_OUTPUT].setVoltage(5.f * outputFrame.samples[c * 2 + 0], c);

  267. 				outputs[MAIN_OUTPUT].setVoltage(5.f * outputFrame.samples[c * 2 + 1], c);

  268. 			}

  269. 		}

  270. 

  271. 		outputs[AUX_OUTPUT].setChannels(channels);

  272. 		outputs[MAIN_OUTPUT].setChannels(channels);

  273. 	}

  274. 

  275. 	json_t* dataToJson() override {

  276. 		json_t* rootJ = json_object();

  277. 		json_object_set_new(rootJ, "model", json_integer(getModel()));

  278. 		return rootJ;

  279. 	}

  280. 

  281. 	void dataFromJson(json_t* rootJ) override {

  282. 		json_t* modelJ = json_object_get(rootJ, "model");

  283. 		if (modelJ) {

  284. 			setModel(json_integer_value(modelJ));

  285. 		}

  286. 	}

  287. 

  288. 	int getModel() {

  289. 		// Use the first channel's Part as the reference model

  290. 		if (parts[0]->easter_egg())

  291. 			return -1;

  292. 		return (int) parts[0]->resonator_model();

  293. 	}

  294. 

  295. 	/** Sets the resonator model.

  296. 	-1 means easter egg (Ominous voice)

  297. 	*/

  298. 	void setModel(int model) {

  299. 		if (model < 0) {

  300. 			for (int c = 0; c < 16; c++) {

  301. 				parts[c]->set_easter_egg(true);

  302. 			}

  303. 		}

  304. 		else {

  305. 			for (int c = 0; c < 16; c++) {

  306. 				parts[c]->set_easter_egg(false);

  307. 				parts[c]->set_resonator_model((elements::ResonatorModel) model);

  308. 			}

  309. 		}

  310. 	}

  311. };

  312. 

  313. 

  314. struct ElementsWidget : ModuleWidget {

  315. 	ElementsWidget(Elements* module) {

  316. 		setModule(module);

  317. 		setPanel(Svg::load(asset::plugin(pluginInstance, "res/Elements.svg")));

  318. 

  319. 		addChild(createWidget<ScrewSilver>(Vec(15, 0)));

  320. 		addChild(createWidget<ScrewSilver>(Vec(480, 0)));

  321. 		addChild(createWidget<ScrewSilver>(Vec(15, 365)));

  322. 		addChild(createWidget<ScrewSilver>(Vec(480, 365)));

  323. 

  324. 		addParam(createParam<Rogan1PSWhite>(Vec(28, 42), module, Elements::CONTOUR_PARAM));

  325. 		addParam(createParam<Rogan1PSWhite>(Vec(99, 42), module, Elements::BOW_PARAM));

  326. 		addParam(createParam<Rogan1PSRed>(Vec(169, 42), module, Elements::BLOW_PARAM));

  327. 		addParam(createParam<Rogan1PSGreen>(Vec(239, 42), module, Elements::STRIKE_PARAM));

  328. 		addParam(createParam<Rogan1PSWhite>(Vec(310, 42), module, Elements::COARSE_PARAM));

  329. 		addParam(createParam<Rogan1PSWhite>(Vec(381, 42), module, Elements::FINE_PARAM));

  330. 		addParam(createParam<Rogan1PSWhite>(Vec(451, 42), module, Elements::FM_PARAM));

  331. 

  332. 		addParam(createParam<Rogan3PSRed>(Vec(115, 116), module, Elements::FLOW_PARAM));

  333. 		addParam(createParam<Rogan3PSGreen>(Vec(212, 116), module, Elements::MALLET_PARAM));

  334. 		addParam(createParam<Rogan3PSWhite>(Vec(326, 116), module, Elements::GEOMETRY_PARAM));

  335. 		addParam(createParam<Rogan3PSWhite>(Vec(423, 116), module, Elements::BRIGHTNESS_PARAM));

  336. 

  337. 		addParam(createParam<Rogan1PSWhite>(Vec(99, 202), module, Elements::BOW_TIMBRE_PARAM));

  338. 		addParam(createParam<Rogan1PSRed>(Vec(170, 202), module, Elements::BLOW_TIMBRE_PARAM));

  339. 		addParam(createParam<Rogan1PSGreen>(Vec(239, 202), module, Elements::STRIKE_TIMBRE_PARAM));

  340. 		addParam(createParam<Rogan1PSWhite>(Vec(310, 202), module, Elements::DAMPING_PARAM));

  341. 		addParam(createParam<Rogan1PSWhite>(Vec(380, 202), module, Elements::POSITION_PARAM));

  342. 		addParam(createParam<Rogan1PSWhite>(Vec(451, 202), module, Elements::SPACE_PARAM));

  343. 

  344. 		addParam(createParam<Trimpot>(Vec(104.5, 273), module, Elements::BOW_TIMBRE_MOD_PARAM));

  345. 		addParam(createParam<Trimpot>(Vec(142.5, 273), module, Elements::FLOW_MOD_PARAM));

  346. 		addParam(createParam<Trimpot>(Vec(181.5, 273), module, Elements::BLOW_TIMBRE_MOD_PARAM));

  347. 		addParam(createParam<Trimpot>(Vec(219.5, 273), module, Elements::MALLET_MOD_PARAM));

  348. 		addParam(createParam<Trimpot>(Vec(257.5, 273), module, Elements::STRIKE_TIMBRE_MOD_PARAM));

  349. 		addParam(createParam<Trimpot>(Vec(315.5, 273), module, Elements::DAMPING_MOD_PARAM));

  350. 		addParam(createParam<Trimpot>(Vec(354.5, 273), module, Elements::GEOMETRY_MOD_PARAM));

  351. 		addParam(createParam<Trimpot>(Vec(392.5, 273), module, Elements::POSITION_MOD_PARAM));

  352. 		addParam(createParam<Trimpot>(Vec(430.5, 273), module, Elements::BRIGHTNESS_MOD_PARAM));

  353. 		addParam(createParam<Trimpot>(Vec(469.5, 273), module, Elements::SPACE_MOD_PARAM));

  354. 

  355. 		addInput(createInput<PJ301MPort>(Vec(20, 178), module, Elements::NOTE_INPUT));

  356. 		addInput(createInput<PJ301MPort>(Vec(55, 178), module, Elements::FM_INPUT));

  357. 

  358. 		addInput(createInput<PJ301MPort>(Vec(20, 224), module, Elements::GATE_INPUT));

  359. 		addInput(createInput<PJ301MPort>(Vec(55, 224), module, Elements::STRENGTH_INPUT));

  360. 

  361. 		addInput(createInput<PJ301MPort>(Vec(20, 270), module, Elements::BLOW_INPUT));

  362. 		addInput(createInput<PJ301MPort>(Vec(55, 270), module, Elements::STRIKE_INPUT));

  363. 

  364. 		addOutput(createOutput<PJ301MPort>(Vec(20, 316), module, Elements::AUX_OUTPUT));

  365. 		addOutput(createOutput<PJ301MPort>(Vec(55, 316), module, Elements::MAIN_OUTPUT));

  366. 

  367. 		addInput(createInput<PJ301MPort>(Vec(101, 316), module, Elements::BOW_TIMBRE_MOD_INPUT));

  368. 		addInput(createInput<PJ301MPort>(Vec(139, 316), module, Elements::FLOW_MOD_INPUT));

  369. 		addInput(createInput<PJ301MPort>(Vec(178, 316), module, Elements::BLOW_TIMBRE_MOD_INPUT));

  370. 		addInput(createInput<PJ301MPort>(Vec(216, 316), module, Elements::MALLET_MOD_INPUT));

  371. 		addInput(createInput<PJ301MPort>(Vec(254, 316), module, Elements::STRIKE_TIMBRE_MOD_INPUT));

  372. 		addInput(createInput<PJ301MPort>(Vec(312, 316), module, Elements::DAMPING_MOD_INPUT));

  373. 		addInput(createInput<PJ301MPort>(Vec(350, 316), module, Elements::GEOMETRY_MOD_INPUT));

  374. 		addInput(createInput<PJ301MPort>(Vec(389, 316), module, Elements::POSITION_MOD_INPUT));

  375. 		addInput(createInput<PJ301MPort>(Vec(427, 316), module, Elements::BRIGHTNESS_MOD_INPUT));

  376. 		addInput(createInput<PJ301MPort>(Vec(466, 316), module, Elements::SPACE_MOD_INPUT));

  377. 

  378. 		addParam(createParam<CKD6>(Vec(36, 116), module, Elements::PLAY_PARAM));

  379. 

  380. 		struct GateLight : YellowLight {

  381. 			GateLight() {

  382. 				box.size = Vec(28 - 6, 28 - 6);

  383. 				bgColor = color::BLACK_TRANSPARENT;

  384. 			}

  385. 		};

  386. 

  387. 		addChild(createLight<GateLight>(Vec(36 + 3, 116 + 3), module, Elements::GATE_LIGHT));

  388. 		addChild(createLight<MediumLight<GreenLight>>(Vec(184, 165), module, Elements::EXCITER_LIGHT));

  389. 		addChild(createLight<MediumLight<RedLight>>(Vec(395, 165), module, Elements::RESONATOR_LIGHT));

  390. 	}

  391. 

  392. 	void appendContextMenu(Menu* menu) override {

  393. 		Elements* module = dynamic_cast<Elements*>(this->module);

  394. 		assert(module);

  395. 

  396. 		menu->addChild(new MenuSeparator);

  397. 

  398. 		menu->addChild(createMenuLabel("Models"));

  399. 

  400. 		static const std::vector<std::string> modelLabels = {

  401. 			"Original",

  402. 			"Non-linear string",

  403. 			"Chords",

  404. 			"Ominous voice",

  405. 		};

  406. 		for (int i = 0; i < 4; i++) {

  407. 			menu->addChild(createCheckMenuItem(modelLabels[i], "",

  408. 				[=]() {return module->getModel() == i;},

  409. 				[=]() {module->setModel(i);}

  410. 			));

  411. 		}

  412. 	}

  413. };

  414. 

  415. 

  416. Model* modelElements = createModel<Elements, ElementsWidget>("Elements");