VCVRack
/
Rack
mirror of https://github.com/VCVRack/Rack.git
1
0
Fork 0
Code Issues 0 Releases 43 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.
2936 Commits
4 Branches
723MB
Tree: f93a6dd82a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f93a6dd82a'
${ noResults }
Rack/src/core/MIDI_CV.cpp

579 lines
16KB
Raw Blame History 

  1. #include <algorithm>

  2. 

  3. #include "plugin.hpp"

  4. 

  5. 

  6. namespace rack {

  7. namespace core {

  8. 

  9. 

  10. struct MIDI_CV : Module {

  11. 	enum ParamIds {

  12. 		NUM_PARAMS

  13. 	};

  14. 	enum InputIds {

  15. 		NUM_INPUTS

  16. 	};

  17. 	enum OutputIds {

  18. 		PITCH_OUTPUT,

  19. 		GATE_OUTPUT,

  20. 		VELOCITY_OUTPUT,

  21. 		AFTERTOUCH_OUTPUT,

  22. 		PW_OUTPUT,

  23. 		MOD_OUTPUT,

  24. 		RETRIGGER_OUTPUT,

  25. 		CLOCK_OUTPUT,

  26. 		CLOCK_DIV_OUTPUT,

  27. 		START_OUTPUT,

  28. 		STOP_OUTPUT,

  29. 		CONTINUE_OUTPUT,

  30. 		NUM_OUTPUTS

  31. 	};

  32. 	enum LightIds {

  33. 		NUM_LIGHTS

  34. 	};

  35. 

  36. 	midi::InputQueue midiInput;

  37. 

  38. 	bool smooth;

  39. 	int channels;

  40. 	enum PolyMode {

  41. 		ROTATE_MODE,

  42. 		REUSE_MODE,

  43. 		RESET_MODE,

  44. 		MPE_MODE,

  45. 		NUM_POLY_MODES

  46. 	};

  47. 	PolyMode polyMode;

  48. 

  49. 	uint32_t clock = 0;

  50. 	int clockDivision;

  51. 

  52. 	bool pedal;

  53. 	// Indexed by channel

  54. 	uint8_t notes[16];

  55. 	bool gates[16];

  56. 	uint8_t velocities[16];

  57. 	uint8_t aftertouches[16];

  58. 	std::vector<uint8_t> heldNotes;

  59. 

  60. 	int rotateIndex;

  61. 

  62. 	/** Pitch wheel.

  63. 	When MPE is disabled, only the first channel is used.

  64. 	[channel]

  65. 	*/

  66. 	uint16_t pws[16];

  67. 	/** [channel] */

  68. 	uint8_t mods[16];

  69. 	dsp::ExponentialFilter pwFilters[16];

  70. 	dsp::ExponentialFilter modFilters[16];

  71. 

  72. 	dsp::PulseGenerator clockPulse;

  73. 	dsp::PulseGenerator clockDividerPulse;

  74. 	dsp::PulseGenerator retriggerPulses[16];

  75. 	dsp::PulseGenerator startPulse;

  76. 	dsp::PulseGenerator stopPulse;

  77. 	dsp::PulseGenerator continuePulse;

  78. 

  79. 	MIDI_CV() {

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

  81. 		configOutput(PITCH_OUTPUT, "1V/octave pitch");

  82. 		configOutput(GATE_OUTPUT, "Gate");

  83. 		configOutput(VELOCITY_OUTPUT, "Velocity");

  84. 		configOutput(AFTERTOUCH_OUTPUT, "Aftertouch");

  85. 		configOutput(PW_OUTPUT, "Pitch wheel");

  86. 		configOutput(MOD_OUTPUT, "Mod wheel");

  87. 		configOutput(RETRIGGER_OUTPUT, "Retrigger");

  88. 		configOutput(CLOCK_OUTPUT, "Clock");

  89. 		configOutput(CLOCK_DIV_OUTPUT, "Clock divider");

  90. 		configOutput(START_OUTPUT, "Start trigger");

  91. 		configOutput(STOP_OUTPUT, "Stop trigger");

  92. 		configOutput(CONTINUE_OUTPUT, "Continue trigger");

  93. 		heldNotes.reserve(128);

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

  95. 			pwFilters[c].setTau(1 / 30.f);

  96. 			modFilters[c].setTau(1 / 30.f);

  97. 		}

  98. 		onReset();

  99. 	}

  100. 

  101. 	void onReset() override {

  102. 		smooth = true;

  103. 		channels = 1;

  104. 		polyMode = ROTATE_MODE;

  105. 		clockDivision = 24;

  106. 		panic();

  107. 		midiInput.reset();

  108. 	}

  109. 

  110. 	/** Resets performance state */

  111. 	void panic() {

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

  113. 			notes[c] = 60;

  114. 			gates[c] = false;

  115. 			velocities[c] = 0;

  116. 			aftertouches[c] = 0;

  117. 			pws[c] = 8192;

  118. 			mods[c] = 0;

  119. 			pwFilters[c].reset();

  120. 			modFilters[c].reset();

  121. 		}

  122. 		pedal = false;

  123. 		rotateIndex = -1;

  124. 		heldNotes.clear();

  125. 	}

  126. 

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

  128. 		midi::Message msg;

  129. 		while (midiInput.tryPop(&msg, args.frame)) {

  130. 			processMessage(msg);

  131. 		}

  132. 

  133. 		outputs[PITCH_OUTPUT].setChannels(channels);

  134. 		outputs[GATE_OUTPUT].setChannels(channels);

  135. 		outputs[VELOCITY_OUTPUT].setChannels(channels);

  136. 		outputs[AFTERTOUCH_OUTPUT].setChannels(channels);

  137. 		outputs[RETRIGGER_OUTPUT].setChannels(channels);

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

  139. 			outputs[PITCH_OUTPUT].setVoltage((notes[c] - 60.f) / 12.f, c);

  140. 			outputs[GATE_OUTPUT].setVoltage(gates[c] ? 10.f : 0.f, c);

  141. 			outputs[VELOCITY_OUTPUT].setVoltage(rescale(velocities[c], 0, 127, 0.f, 10.f), c);

  142. 			outputs[AFTERTOUCH_OUTPUT].setVoltage(rescale(aftertouches[c], 0, 127, 0.f, 10.f), c);

  143. 			outputs[RETRIGGER_OUTPUT].setVoltage(retriggerPulses[c].process(args.sampleTime) ? 10.f : 0.f, c);

  144. 		}

  145. 

  146. 		// Set pitch and mod wheel

  147. 		int wheelChannels = (polyMode == MPE_MODE) ? 16 : 1;

  148. 		outputs[PW_OUTPUT].setChannels(wheelChannels);

  149. 		outputs[MOD_OUTPUT].setChannels(wheelChannels);

  150. 		for (int c = 0; c < wheelChannels; c++) {

  151. 			float pw = ((int) pws[c] - 8192) / 8191.f;

  152. 			pw = clamp(pw, -1.f, 1.f);

  153. 			if (smooth)

  154. 				pw = pwFilters[c].process(args.sampleTime, pw);

  155. 			else

  156. 				pwFilters[c].out = pw;

  157. 			outputs[PW_OUTPUT].setVoltage(pw * 5.f);

  158. 

  159. 			float mod = mods[c] / 127.f;

  160. 			mod = clamp(mod, 0.f, 1.f);

  161. 			if (smooth)

  162. 				mod = modFilters[c].process(args.sampleTime, mod);

  163. 			else

  164. 				modFilters[c].out = mod;

  165. 			outputs[MOD_OUTPUT].setVoltage(mod * 10.f);

  166. 		}

  167. 

  168. 		outputs[CLOCK_OUTPUT].setVoltage(clockPulse.process(args.sampleTime) ? 10.f : 0.f);

  169. 		outputs[CLOCK_DIV_OUTPUT].setVoltage(clockDividerPulse.process(args.sampleTime) ? 10.f : 0.f);

  170. 		outputs[START_OUTPUT].setVoltage(startPulse.process(args.sampleTime) ? 10.f : 0.f);

  171. 		outputs[STOP_OUTPUT].setVoltage(stopPulse.process(args.sampleTime) ? 10.f : 0.f);

  172. 		outputs[CONTINUE_OUTPUT].setVoltage(continuePulse.process(args.sampleTime) ? 10.f : 0.f);

  173. 	}

  174. 

  175. 	void processMessage(const midi::Message& msg) {

  176. 		// DEBUG("MIDI: %ld %s", msg.getFrame(), msg.toString().c_str());

  177. 

  178. 		switch (msg.getStatus()) {

  179. 			// note off

  180. 			case 0x8: {

  181. 				releaseNote(msg.getNote());

  182. 			} break;

  183. 			// note on

  184. 			case 0x9: {

  185. 				if (msg.getValue() > 0) {

  186. 					int c = msg.getChannel();

  187. 					pressNote(msg.getNote(), &c);

  188. 					velocities[c] = msg.getValue();

  189. 				}

  190. 				else {

  191. 					// For some reason, some keyboards send a "note on" event with a velocity of 0 to signal that the key has been released.

  192. 					releaseNote(msg.getNote());

  193. 				}

  194. 			} break;

  195. 			// key pressure

  196. 			case 0xa: {

  197. 				// Set the aftertouches with the same note

  198. 				// TODO Should we handle the MPE case differently?

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

  200. 					if (notes[c] == msg.getNote())

  201. 						aftertouches[c] = msg.getValue();

  202. 				}

  203. 			} break;

  204. 			// cc

  205. 			case 0xb: {

  206. 				processCC(msg);

  207. 			} break;

  208. 			// channel pressure

  209. 			case 0xd: {

  210. 				if (polyMode == MPE_MODE) {

  211. 					// Set the channel aftertouch

  212. 					aftertouches[msg.getChannel()] = msg.getNote();

  213. 				}

  214. 				else {

  215. 					// Set all aftertouches

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

  217. 						aftertouches[c] = msg.getNote();

  218. 					}

  219. 				}

  220. 			} break;

  221. 			// pitch wheel

  222. 			case 0xe: {

  223. 				int c = (polyMode == MPE_MODE) ? msg.getChannel() : 0;

  224. 				pws[c] = ((uint16_t) msg.getValue() << 7) | msg.getNote();

  225. 			} break;

  226. 			case 0xf: {

  227. 				processSystem(msg);

  228. 			} break;

  229. 			default: break;

  230. 		}

  231. 	}

  232. 

  233. 	void processCC(const midi::Message &msg) {

  234. 		switch (msg.getNote()) {

  235. 			// mod

  236. 			case 0x01: {

  237. 				int c = (polyMode == MPE_MODE) ? msg.getChannel() : 0;

  238. 				mods[c] = msg.getValue();

  239. 			} break;

  240. 			// sustain

  241. 			case 0x40: {

  242. 				if (msg.getValue() >= 64)

  243. 					pressPedal();

  244. 				else

  245. 					releasePedal();

  246. 			} break;

  247. 			// all notes off (panic)

  248. 			case 0x7b: {

  249. 				if (msg.getValue() == 0) {

  250. 					panic();

  251. 				}

  252. 			} break;

  253. 			default: break;

  254. 		}

  255. 	}

  256. 

  257. 	void processSystem(const midi::Message &msg) {

  258. 		switch (msg.getChannel()) {

  259. 			// Song Position Pointer

  260. 			case 0x2: {

  261. 				int32_t pos = int32_t(msg.getNote()) | (int32_t(msg.getValue()) << 7);

  262. 				clock = pos * 6;

  263. 			} break;

  264. 			// Timing

  265. 			case 0x8: {

  266. 				clockPulse.trigger(1e-3);

  267. 				if (clock % clockDivision == 0) {

  268. 					clockDividerPulse.trigger(1e-3);

  269. 				}

  270. 				clock++;

  271. 			} break;

  272. 			// Start

  273. 			case 0xa: {

  274. 				startPulse.trigger(1e-3);

  275. 				clock = 0;

  276. 			} break;

  277. 			// Continue

  278. 			case 0xb: {

  279. 				continuePulse.trigger(1e-3);

  280. 			} break;

  281. 			// Stop

  282. 			case 0xc: {

  283. 				stopPulse.trigger(1e-3);

  284. 			} break;

  285. 			default: break;

  286. 		}

  287. 	}

  288. 

  289. 	int assignChannel(uint8_t note) {

  290. 		if (channels == 1)

  291. 			return 0;

  292. 

  293. 		switch (polyMode) {

  294. 			case REUSE_MODE: {

  295. 				// Find channel with the same note

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

  297. 					if (notes[c] == note)

  298. 						return c;

  299. 				}

  300. 			} // fallthrough

  301. 

  302. 			case ROTATE_MODE: {

  303. 				// Find next available channel

  304. 				for (int i = 0; i < channels; i++) {

  305. 					rotateIndex++;

  306. 					if (rotateIndex >= channels)

  307. 						rotateIndex = 0;

  308. 					if (!gates[rotateIndex])

  309. 						return rotateIndex;

  310. 				}

  311. 				// No notes are available. Advance rotateIndex once more.

  312. 				rotateIndex++;

  313. 				if (rotateIndex >= channels)

  314. 					rotateIndex = 0;

  315. 				return rotateIndex;

  316. 			} break;

  317. 

  318. 			case RESET_MODE: {

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

  320. 					if (!gates[c])

  321. 						return c;

  322. 				}

  323. 				return channels - 1;

  324. 			} break;

  325. 

  326. 			case MPE_MODE: {

  327. 				// This case is handled by querying the MIDI message channel.

  328. 				return 0;

  329. 			} break;

  330. 

  331. 			default: return 0;

  332. 		}

  333. 	}

  334. 

  335. 	void pressNote(uint8_t note, int* channel) {

  336. 		// Remove existing similar note

  337. 		auto it = std::find(heldNotes.begin(), heldNotes.end(), note);

  338. 		if (it != heldNotes.end())

  339. 			heldNotes.erase(it);

  340. 		// Push note

  341. 		heldNotes.push_back(note);

  342. 		// Determine actual channel

  343. 		if (polyMode == MPE_MODE) {

  344. 			// Channel is already decided for us

  345. 		}

  346. 		else {

  347. 			*channel = assignChannel(note);

  348. 		}

  349. 		// Set note

  350. 		notes[*channel] = note;

  351. 		gates[*channel] = true;

  352. 		retriggerPulses[*channel].trigger(1e-3);

  353. 	}

  354. 

  355. 	void releaseNote(uint8_t note) {

  356. 		// Remove the note

  357. 		auto it = std::find(heldNotes.begin(), heldNotes.end(), note);

  358. 		if (it != heldNotes.end())

  359. 			heldNotes.erase(it);

  360. 		// Hold note if pedal is pressed

  361. 		if (pedal)

  362. 			return;

  363. 		// Turn off gate of all channels with note

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

  365. 			if (notes[c] == note) {

  366. 				gates[c] = false;

  367. 			}

  368. 		}

  369. 		// Set last note if monophonic

  370. 		if (channels == 1) {

  371. 			if (note == notes[0] && !heldNotes.empty()) {

  372. 				uint8_t lastNote = heldNotes.back();

  373. 				notes[0] = lastNote;

  374. 				gates[0] = true;

  375. 				return;

  376. 			}

  377. 		}

  378. 	}

  379. 

  380. 	void pressPedal() {

  381. 		if (pedal)

  382. 			return;

  383. 		pedal = true;

  384. 	}

  385. 

  386. 	void releasePedal() {

  387. 		if (!pedal)

  388. 			return;

  389. 		pedal = false;

  390. 		// Set last note if monophonic

  391. 		if (channels == 1) {

  392. 			if (!heldNotes.empty()) {

  393. 				uint8_t lastNote = heldNotes.back();

  394. 				notes[0] = lastNote;

  395. 			}

  396. 		}

  397. 		// Clear notes that are not held if polyphonic

  398. 		else {

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

  400. 				if (!gates[c])

  401. 					continue;

  402. 				gates[c] = false;

  403. 				for (uint8_t note : heldNotes) {

  404. 					if (notes[c] == note) {

  405. 						gates[c] = true;

  406. 						break;

  407. 					}

  408. 				}

  409. 			}

  410. 		}

  411. 	}

  412. 

  413. 	void setChannels(int channels) {

  414. 		if (channels == this->channels)

  415. 			return;

  416. 		this->channels = channels;

  417. 		panic();

  418. 	}

  419. 

  420. 	void setPolyMode(PolyMode polyMode) {

  421. 		if (polyMode == this->polyMode)

  422. 			return;

  423. 		this->polyMode = polyMode;

  424. 		panic();

  425. 	}

  426. 

  427. 	json_t* dataToJson() override {

  428. 		json_t* rootJ = json_object();

  429. 		json_object_set_new(rootJ, "smooth", json_boolean(smooth));

  430. 		json_object_set_new(rootJ, "channels", json_integer(channels));

  431. 		json_object_set_new(rootJ, "polyMode", json_integer(polyMode));

  432. 		json_object_set_new(rootJ, "clockDivision", json_integer(clockDivision));

  433. 		// Saving/restoring pitch and mod doesn't make much sense for MPE.

  434. 		if (polyMode != MPE_MODE) {

  435. 			json_object_set_new(rootJ, "lastPitch", json_integer(pws[0]));

  436. 			json_object_set_new(rootJ, "lastMod", json_integer(mods[0]));

  437. 		}

  438. 		json_object_set_new(rootJ, "midi", midiInput.toJson());

  439. 		return rootJ;

  440. 	}

  441. 

  442. 	void dataFromJson(json_t* rootJ) override {

  443. 		json_t* smoothJ = json_object_get(rootJ, "smooth");

  444. 		if (smoothJ)

  445. 			smooth = json_boolean_value(smoothJ);

  446. 

  447. 		json_t* channelsJ = json_object_get(rootJ, "channels");

  448. 		if (channelsJ)

  449. 			setChannels(json_integer_value(channelsJ));

  450. 

  451. 		json_t* polyModeJ = json_object_get(rootJ, "polyMode");

  452. 		if (polyModeJ)

  453. 			polyMode = (PolyMode) json_integer_value(polyModeJ);

  454. 

  455. 		json_t* clockDivisionJ = json_object_get(rootJ, "clockDivision");

  456. 		if (clockDivisionJ)

  457. 			clockDivision = json_integer_value(clockDivisionJ);

  458. 

  459. 		json_t* lastPitchJ = json_object_get(rootJ, "lastPitch");

  460. 		if (lastPitchJ)

  461. 			pws[0] = json_integer_value(lastPitchJ);

  462. 

  463. 		json_t* lastModJ = json_object_get(rootJ, "lastMod");

  464. 		if (lastModJ)

  465. 			mods[0] = json_integer_value(lastModJ);

  466. 

  467. 		json_t* midiJ = json_object_get(rootJ, "midi");

  468. 		if (midiJ)

  469. 			midiInput.fromJson(midiJ);

  470. 	}

  471. };

  472. 

  473. 

  474. struct MIDI_CVWidget : ModuleWidget {

  475. 	MIDI_CVWidget(MIDI_CV* module) {

  476. 		setModule(module);

  477. 		setPanel(Svg::load(asset::system("res/Core/MIDI_CV.svg")));

  478. 

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

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

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

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

  483. 

  484. 		addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(7.905, 64.347)), module, MIDI_CV::PITCH_OUTPUT));

  485. 		addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(20.248, 64.347)), module, MIDI_CV::GATE_OUTPUT));

  486. 		addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(32.591, 64.347)), module, MIDI_CV::VELOCITY_OUTPUT));

  487. 		addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(7.905, 80.603)), module, MIDI_CV::AFTERTOUCH_OUTPUT));

  488. 		addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(20.248, 80.603)), module, MIDI_CV::PW_OUTPUT));

  489. 		addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(32.591, 80.603)), module, MIDI_CV::MOD_OUTPUT));

  490. 		addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(7.905, 96.859)), module, MIDI_CV::CLOCK_OUTPUT));

  491. 		addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(20.248, 96.707)), module, MIDI_CV::CLOCK_DIV_OUTPUT));

  492. 		addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(32.591, 96.859)), module, MIDI_CV::RETRIGGER_OUTPUT));

  493. 		addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(7.905, 113.115)), module, MIDI_CV::START_OUTPUT));

  494. 		addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(20.248, 113.115)), module, MIDI_CV::STOP_OUTPUT));

  495. 		addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(32.591, 112.975)), module, MIDI_CV::CONTINUE_OUTPUT));

  496. 

  497. 		MidiDisplay* display = createWidget<MidiDisplay>(mm2px(Vec(0.0, 13.048)));

  498. 		display->box.size = mm2px(Vec(40.64, 29.012));

  499. 		display->setMidiPort(module ? &module->midiInput : NULL);

  500. 		addChild(display);

  501. 

  502. 		// MidiButton example

  503. 		// MidiButton* midiButton = createWidget<MidiButton_MIDI_DIN>(Vec(0, 0));

  504. 		// midiButton->setMidiPort(module ? &module->midiInput : NULL);

  505. 		// addChild(midiButton);

  506. 	}

  507. 

  508. 	void appendContextMenu(Menu* menu) override {

  509. 		MIDI_CV* module = dynamic_cast<MIDI_CV*>(this->module);

  510. 

  511. 		menu->addChild(new MenuSeparator);

  512. 

  513. 		menu->addChild(createBoolPtrMenuItem("Smooth pitch/mod wheel", "", &module->smooth));

  514. 

  515. 		static const std::vector<int> clockDivisions = {24 * 4, 24 * 2, 24, 24 / 2, 24 / 4, 24 / 8, 2, 1};

  516. 		static const std::vector<std::string> clockDivisionLabels = {"Whole", "Half", "Quarter", "8th", "16th", "32nd", "12 PPQN", "24 PPQN"};

  517. 		struct ClockDivisionItem : MenuItem {

  518. 			MIDI_CV* module;

  519. 			Menu* createChildMenu() override {

  520. 				Menu* menu = new Menu;

  521. 				for (size_t i = 0; i < clockDivisions.size(); i++) {

  522. 					menu->addChild(createCheckMenuItem(clockDivisionLabels[i], "",

  523. 						[=]() {return module->clockDivision == clockDivisions[i];},

  524. 						[=]() {module->clockDivision = clockDivisions[i];}

  525. 					));

  526. 				}

  527. 				return menu;

  528. 			}

  529. 		};

  530. 		ClockDivisionItem* clockDivisionItem = new ClockDivisionItem;

  531. 		clockDivisionItem->text = "CLK/N divider";

  532. 		clockDivisionItem->rightText = RIGHT_ARROW;

  533. 		clockDivisionItem->module = module;

  534. 		menu->addChild(clockDivisionItem);

  535. 

  536. 		struct ChannelItem : MenuItem {

  537. 			MIDI_CV* module;

  538. 			Menu* createChildMenu() override {

  539. 				Menu* menu = new Menu;

  540. 				for (int c = 1; c <= 16; c++) {

  541. 					menu->addChild(createCheckMenuItem((c == 1) ? "Monophonic" : string::f("%d", c), "",

  542. 						[=]() {return module->channels == c;},

  543. 						[=]() {module->setChannels(c);}

  544. 					));

  545. 				}

  546. 				return menu;

  547. 			}

  548. 		};

  549. 		ChannelItem* channelItem = new ChannelItem;

  550. 		channelItem->text = "Polyphony channels";

  551. 		channelItem->rightText = string::f("%d", module->channels) + "  " + RIGHT_ARROW;

  552. 		channelItem->module = module;

  553. 		menu->addChild(channelItem);

  554. 

  555. 		menu->addChild(createIndexPtrSubmenuItem("Polyphony mode", {

  556. 			"Rotate",

  557. 			"Reuse",

  558. 			"Reset",

  559. 			"MPE",

  560. 		}, &module->polyMode));

  561. 

  562. 		menu->addChild(createMenuItem("Panic", "",

  563. 			[=]() {module->panic();}

  564. 		));

  565. 

  566. 		// Example of using appendMidiMenu()

  567. 		// menu->addChild(new MenuSeparator);

  568. 		// appendMidiMenu(menu, &module->midiInput);

  569. 	}

  570. };

  571. 

  572. 

  573. // Use legacy slug for compatibility

  574. Model* modelMIDI_CV = createModel<MIDI_CV, MIDI_CVWidget>("MIDIToCVInterface");

  575. 

  576. 

  577. } // namespace core

  578. } // namespace rack