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.
2661 Commits
4 Branches
723MB
Tree: 681b76708e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '681b76708e'
${ noResults }
Rack/src/core/MIDI_CV.cpp

575 lines
15KB
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, "Pitch (1V/oct)");

  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. 			// Timing

  260. 			case 0x8: {

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

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

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

  264. 				}

  265. 				clock++;

  266. 			} break;

  267. 			// Start

  268. 			case 0xa: {

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

  270. 				clock = 0;

  271. 			} break;

  272. 			// Continue

  273. 			case 0xb: {

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

  275. 			} break;

  276. 			// Stop

  277. 			case 0xc: {

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

  279. 				clock = 0;

  280. 			} break;

  281. 			default: break;

  282. 		}

  283. 	}

  284. 

  285. 	int assignChannel(uint8_t note) {

  286. 		if (channels == 1)

  287. 			return 0;

  288. 

  289. 		switch (polyMode) {

  290. 			case REUSE_MODE: {

  291. 				// Find channel with the same note

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

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

  294. 						return c;

  295. 				}

  296. 			} // fallthrough

  297. 

  298. 			case ROTATE_MODE: {

  299. 				// Find next available channel

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

  301. 					rotateIndex++;

  302. 					if (rotateIndex >= channels)

  303. 						rotateIndex = 0;

  304. 					if (!gates[rotateIndex])

  305. 						return rotateIndex;

  306. 				}

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

  308. 				rotateIndex++;

  309. 				if (rotateIndex >= channels)

  310. 					rotateIndex = 0;

  311. 				return rotateIndex;

  312. 			} break;

  313. 

  314. 			case RESET_MODE: {

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

  316. 					if (!gates[c])

  317. 						return c;

  318. 				}

  319. 				return channels - 1;

  320. 			} break;

  321. 

  322. 			case MPE_MODE: {

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

  324. 				return 0;

  325. 			} break;

  326. 

  327. 			default: return 0;

  328. 		}

  329. 	}

  330. 

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

  332. 		// Remove existing similar note

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

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

  335. 			heldNotes.erase(it);

  336. 		// Push note

  337. 		heldNotes.push_back(note);

  338. 		// Determine actual channel

  339. 		if (polyMode == MPE_MODE) {

  340. 			// Channel is already decided for us

  341. 		}

  342. 		else {

  343. 			*channel = assignChannel(note);

  344. 		}

  345. 		// Set note

  346. 		notes[*channel] = note;

  347. 		gates[*channel] = true;

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

  349. 	}

  350. 

  351. 	void releaseNote(uint8_t note) {

  352. 		// Remove the note

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

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

  355. 			heldNotes.erase(it);

  356. 		// Hold note if pedal is pressed

  357. 		if (pedal)

  358. 			return;

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

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

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

  362. 				gates[c] = false;

  363. 			}

  364. 		}

  365. 		// Set last note if monophonic

  366. 		if (channels == 1) {

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

  368. 				uint8_t lastNote = heldNotes.back();

  369. 				notes[0] = lastNote;

  370. 				gates[0] = true;

  371. 				return;

  372. 			}

  373. 		}

  374. 	}

  375. 

  376. 	void pressPedal() {

  377. 		if (pedal)

  378. 			return;

  379. 		pedal = true;

  380. 	}

  381. 

  382. 	void releasePedal() {

  383. 		if (!pedal)

  384. 			return;

  385. 		pedal = false;

  386. 		// Set last note if monophonic

  387. 		if (channels == 1) {

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

  389. 				uint8_t lastNote = heldNotes.back();

  390. 				notes[0] = lastNote;

  391. 			}

  392. 		}

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

  394. 		else {

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

  396. 				if (!gates[c])

  397. 					continue;

  398. 				gates[c] = false;

  399. 				for (uint8_t note : heldNotes) {

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

  401. 						gates[c] = true;

  402. 						break;

  403. 					}

  404. 				}

  405. 			}

  406. 		}

  407. 	}

  408. 

  409. 	void setChannels(int channels) {

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

  411. 			return;

  412. 		this->channels = channels;

  413. 		panic();

  414. 	}

  415. 

  416. 	void setPolyMode(PolyMode polyMode) {

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

  418. 			return;

  419. 		this->polyMode = polyMode;

  420. 		panic();

  421. 	}

  422. 

  423. 	json_t* dataToJson() override {

  424. 		json_t* rootJ = json_object();

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

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

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

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

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

  430. 		if (polyMode != MPE_MODE) {

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

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

  433. 		}

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

  435. 		return rootJ;

  436. 	}

  437. 

  438. 	void dataFromJson(json_t* rootJ) override {

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

  440. 		if (smoothJ)

  441. 			smooth = json_boolean_value(smoothJ);

  442. 

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

  444. 		if (channelsJ)

  445. 			setChannels(json_integer_value(channelsJ));

  446. 

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

  448. 		if (polyModeJ)

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

  450. 

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

  452. 		if (clockDivisionJ)

  453. 			clockDivision = json_integer_value(clockDivisionJ);

  454. 

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

  456. 		if (lastPitchJ)

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

  458. 

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

  460. 		if (lastModJ)

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

  462. 

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

  464. 		if (midiJ)

  465. 			midiInput.fromJson(midiJ);

  466. 	}

  467. };

  468. 

  469. 

  470. struct MIDI_CVWidget : ModuleWidget {

  471. 	MIDI_CVWidget(MIDI_CV* module) {

  472. 		setModule(module);

  473. 		setPanel(Svg::load(asset::system("res/Core/MIDI-CV.svg")));

  474. 

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

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

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

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

  479. 

  480. 		addOutput(createOutput<PJ301MPort>(mm2px(Vec(4.61505, 60.1445)), module, MIDI_CV::PITCH_OUTPUT));

  481. 		addOutput(createOutput<PJ301MPort>(mm2px(Vec(16.214, 60.1445)), module, MIDI_CV::GATE_OUTPUT));

  482. 		addOutput(createOutput<PJ301MPort>(mm2px(Vec(27.8143, 60.1445)), module, MIDI_CV::VELOCITY_OUTPUT));

  483. 		addOutput(createOutput<PJ301MPort>(mm2px(Vec(4.61505, 76.1449)), module, MIDI_CV::AFTERTOUCH_OUTPUT));

  484. 		addOutput(createOutput<PJ301MPort>(mm2px(Vec(16.214, 76.1449)), module, MIDI_CV::PW_OUTPUT));

  485. 		addOutput(createOutput<PJ301MPort>(mm2px(Vec(27.8143, 76.1449)), module, MIDI_CV::MOD_OUTPUT));

  486. 		addOutput(createOutput<PJ301MPort>(mm2px(Vec(4.61505, 92.1439)), module, MIDI_CV::CLOCK_OUTPUT));

  487. 		addOutput(createOutput<PJ301MPort>(mm2px(Vec(16.214, 92.1439)), module, MIDI_CV::CLOCK_DIV_OUTPUT));

  488. 		addOutput(createOutput<PJ301MPort>(mm2px(Vec(27.8143, 92.1439)), module, MIDI_CV::RETRIGGER_OUTPUT));

  489. 		addOutput(createOutput<PJ301MPort>(mm2px(Vec(4.61505, 108.144)), module, MIDI_CV::START_OUTPUT));

  490. 		addOutput(createOutput<PJ301MPort>(mm2px(Vec(16.214, 108.144)), module, MIDI_CV::STOP_OUTPUT));

  491. 		addOutput(createOutput<PJ301MPort>(mm2px(Vec(27.8143, 108.144)), module, MIDI_CV::CONTINUE_OUTPUT));

  492. 

  493. 		MidiWidget* midiWidget = createWidget<MidiWidget>(mm2px(Vec(3.41891, 14.8373)));

  494. 		midiWidget->box.size = mm2px(Vec(33.840, 28));

  495. 		midiWidget->setMidiPort(module ? &module->midiInput : NULL);

  496. 		addChild(midiWidget);

  497. 

  498. 		// MidiButton example

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

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

  501. 		// addChild(midiButton);

  502. 	}

  503. 

  504. 	void appendContextMenu(Menu* menu) override {

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

  506. 

  507. 		menu->addChild(new MenuSeparator);

  508. 

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

  510. 

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

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

  513. 		struct ClockDivisionItem : MenuItem {

  514. 			MIDI_CV* module;

  515. 			Menu* createChildMenu() override {

  516. 				Menu* menu = new Menu;

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

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

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

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

  521. 					));

  522. 				}

  523. 				return menu;

  524. 			}

  525. 		};

  526. 		ClockDivisionItem* clockDivisionItem = new ClockDivisionItem;

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

  528. 		clockDivisionItem->rightText = RIGHT_ARROW;

  529. 		clockDivisionItem->module = module;

  530. 		menu->addChild(clockDivisionItem);

  531. 

  532. 		struct ChannelItem : MenuItem {

  533. 			MIDI_CV* module;

  534. 			Menu* createChildMenu() override {

  535. 				Menu* menu = new Menu;

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

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

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

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

  540. 					));

  541. 				}

  542. 				return menu;

  543. 			}

  544. 		};

  545. 		ChannelItem* channelItem = new ChannelItem;

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

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

  548. 		channelItem->module = module;

  549. 		menu->addChild(channelItem);

  550. 

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

  552. 			"Rotate",

  553. 			"Reuse",

  554. 			"Reset",

  555. 			"MPE",

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

  557. 

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

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

  560. 		));

  561. 

  562. 		// Example of using appendMidiMenu()

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

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

  565. 	}

  566. };

  567. 

  568. 

  569. // Use legacy slug for compatibility

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

  571. 

  572. 

  573. } // namespace core

  574. } // namespace rack