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

656 lines
17KB
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. 		CV_OUTPUT,

  19. 		GATE_OUTPUT,

  20. 		VELOCITY_OUTPUT,

  21. 		AFTERTOUCH_OUTPUT,

  22. 		PITCH_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. 	// 16 channels for MPE. When MPE is disabled, only the first channel is used.

  63. 	uint16_t pitches[16];

  64. 	uint8_t mods[16];

  65. 	dsp::ExponentialFilter pitchFilters[16];

  66. 	dsp::ExponentialFilter modFilters[16];

  67. 

  68. 	dsp::PulseGenerator clockPulse;

  69. 	dsp::PulseGenerator clockDividerPulse;

  70. 	dsp::PulseGenerator retriggerPulses[16];

  71. 	dsp::PulseGenerator startPulse;

  72. 	dsp::PulseGenerator stopPulse;

  73. 	dsp::PulseGenerator continuePulse;

  74. 

  75. 	MIDI_CV() {

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

  77. 		configOutput(CV_OUTPUT, "V/oct");

  78. 		configOutput(GATE_OUTPUT, "Gate");

  79. 		configOutput(VELOCITY_OUTPUT, "Velocity");

  80. 		configOutput(AFTERTOUCH_OUTPUT, "Aftertouch");

  81. 		configOutput(PITCH_OUTPUT, "Pitch wheel");

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

  83. 		configOutput(RETRIGGER_OUTPUT, "Retrigger");

  84. 		configOutput(CLOCK_OUTPUT, "Clock");

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

  86. 		configOutput(START_OUTPUT, "Start");

  87. 		configOutput(STOP_OUTPUT, "Stop");

  88. 		configOutput(CONTINUE_OUTPUT, "Continue");

  89. 		heldNotes.reserve(128);

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

  91. 			pitchFilters[c].setTau(1 / 30.f);

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

  93. 		}

  94. 		onReset();

  95. 	}

  96. 

  97. 	void onReset() override {

  98. 		smooth = true;

  99. 		channels = 1;

  100. 		polyMode = ROTATE_MODE;

  101. 		clockDivision = 24;

  102. 		panic();

  103. 		midiInput.reset();

  104. 	}

  105. 

  106. 	/** Resets performance state */

  107. 	void panic() {

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

  109. 			notes[c] = 60;

  110. 			gates[c] = false;

  111. 			velocities[c] = 0;

  112. 			aftertouches[c] = 0;

  113. 			pitches[c] = 8192;

  114. 			mods[c] = 0;

  115. 			pitchFilters[c].reset();

  116. 			modFilters[c].reset();

  117. 		}

  118. 		pedal = false;

  119. 		rotateIndex = -1;

  120. 		heldNotes.clear();

  121. 	}

  122. 

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

  124. 		while (!midiInput.queue.empty()) {

  125. 			const midi::Message& msg = midiInput.queue.front();

  126. 			// Don't process MIDI message until we've reached its frame.

  127. 			if (msg.frame > args.frame)

  128. 				break;

  129. 			processMessage(msg);

  130. 			midiInput.queue.pop();

  131. 		}

  132. 

  133. 		outputs[CV_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[CV_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. 		auto updatePitch = [&](int c) {

  148. 			float pitch = ((int) pitches[c] - 8192) / 8191.f;

  149. 			pitch = clamp(pitch, -1.f, 1.f);

  150. 			if (smooth)

  151. 				pitch = pitchFilters[c].process(args.sampleTime, pitch);

  152. 			else

  153. 				pitchFilters[c].out = pitch;

  154. 			outputs[PITCH_OUTPUT].setVoltage(pitchFilters[c].out * 5.f);

  155. 		};

  156. 		auto updateMod = [&](int c) {

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

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

  159. 			if (smooth)

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

  161. 			else

  162. 				modFilters[c].out = mod;

  163. 			outputs[MOD_OUTPUT].setVoltage(modFilters[c].out * 10.f);

  164. 		};

  165. 		if (polyMode == MPE_MODE) {

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

  167. 				updatePitch(c);

  168. 				outputs[PITCH_OUTPUT].setChannels(1);

  169. 				updateMod(c);

  170. 				outputs[MOD_OUTPUT].setChannels(1);

  171. 			}

  172. 		}

  173. 		else {

  174. 			updatePitch(0);

  175. 			outputs[PITCH_OUTPUT].setChannels(1);

  176. 			updateMod(0);

  177. 			outputs[MOD_OUTPUT].setChannels(1);

  178. 		}

  179. 

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

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

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

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

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

  185. 	}

  186. 

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

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

  189. 

  190. 		switch (msg.getStatus()) {

  191. 			// note off

  192. 			case 0x8: {

  193. 				releaseNote(msg.getNote());

  194. 			} break;

  195. 			// note on

  196. 			case 0x9: {

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

  198. 					int c = msg.getChannel();

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

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

  201. 				}

  202. 				else {

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

  204. 					releaseNote(msg.getNote());

  205. 				}

  206. 			} break;

  207. 			// key pressure

  208. 			case 0xa: {

  209. 				// Set the aftertouches with the same note

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

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

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

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

  214. 				}

  215. 			} break;

  216. 			// cc

  217. 			case 0xb: {

  218. 				processCC(msg);

  219. 			} break;

  220. 			// channel pressure

  221. 			case 0xd: {

  222. 				if (polyMode == MPE_MODE) {

  223. 					// Set the channel aftertouch

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

  225. 				}

  226. 				else {

  227. 					// Set all aftertouches

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

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

  230. 					}

  231. 				}

  232. 			} break;

  233. 			// pitch wheel

  234. 			case 0xe: {

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

  236. 				pitches[c] = ((uint16_t) msg.getValue() << 7) | msg.getNote();

  237. 			} break;

  238. 			case 0xf: {

  239. 				processSystem(msg);

  240. 			} break;

  241. 			default: break;

  242. 		}

  243. 	}

  244. 

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

  246. 		switch (msg.getNote()) {

  247. 			// mod

  248. 			case 0x01: {

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

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

  251. 			} break;

  252. 			// sustain

  253. 			case 0x40: {

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

  255. 					pressPedal();

  256. 				else

  257. 					releasePedal();

  258. 			} break;

  259. 			// all notes off (panic)

  260. 			case 0x7b: {

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

  262. 					panic();

  263. 				}

  264. 			} break;

  265. 			default: break;

  266. 		}

  267. 	}

  268. 

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

  270. 		switch (msg.getChannel()) {

  271. 			// Timing

  272. 			case 0x8: {

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

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

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

  276. 				}

  277. 				clock++;

  278. 			} break;

  279. 			// Start

  280. 			case 0xa: {

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

  282. 				clock = 0;

  283. 			} break;

  284. 			// Continue

  285. 			case 0xb: {

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

  287. 			} break;

  288. 			// Stop

  289. 			case 0xc: {

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

  291. 				clock = 0;

  292. 			} break;

  293. 			default: break;

  294. 		}

  295. 	}

  296. 

  297. 	int assignChannel(uint8_t note) {

  298. 		if (channels == 1)

  299. 			return 0;

  300. 

  301. 		switch (polyMode) {

  302. 			case REUSE_MODE: {

  303. 				// Find channel with the same note

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

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

  306. 						return c;

  307. 				}

  308. 			} // fallthrough

  309. 

  310. 			case ROTATE_MODE: {

  311. 				// Find next available channel

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

  313. 					rotateIndex++;

  314. 					if (rotateIndex >= channels)

  315. 						rotateIndex = 0;

  316. 					if (!gates[rotateIndex])

  317. 						return rotateIndex;

  318. 				}

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

  320. 				rotateIndex++;

  321. 				if (rotateIndex >= channels)

  322. 					rotateIndex = 0;

  323. 				return rotateIndex;

  324. 			} break;

  325. 

  326. 			case RESET_MODE: {

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

  328. 					if (!gates[c])

  329. 						return c;

  330. 				}

  331. 				return channels - 1;

  332. 			} break;

  333. 

  334. 			case MPE_MODE: {

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

  336. 				return 0;

  337. 			} break;

  338. 

  339. 			default: return 0;

  340. 		}

  341. 	}

  342. 

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

  344. 		// Remove existing similar note

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

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

  347. 			heldNotes.erase(it);

  348. 		// Push note

  349. 		heldNotes.push_back(note);

  350. 		// Determine actual channel

  351. 		if (polyMode == MPE_MODE) {

  352. 			// Channel is already decided for us

  353. 		}

  354. 		else {

  355. 			*channel = assignChannel(note);

  356. 		}

  357. 		// Set note

  358. 		notes[*channel] = note;

  359. 		gates[*channel] = true;

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

  361. 	}

  362. 

  363. 	void releaseNote(uint8_t note) {

  364. 		// Remove the note

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

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

  367. 			heldNotes.erase(it);

  368. 		// Hold note if pedal is pressed

  369. 		if (pedal)

  370. 			return;

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

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

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

  374. 				gates[c] = false;

  375. 			}

  376. 		}

  377. 		// Set last note if monophonic

  378. 		if (channels == 1) {

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

  380. 				uint8_t lastNote = heldNotes.back();

  381. 				notes[0] = lastNote;

  382. 				gates[0] = true;

  383. 				return;

  384. 			}

  385. 		}

  386. 	}

  387. 

  388. 	void pressPedal() {

  389. 		if (pedal)

  390. 			return;

  391. 		pedal = true;

  392. 	}

  393. 

  394. 	void releasePedal() {

  395. 		if (!pedal)

  396. 			return;

  397. 		pedal = false;

  398. 		// Set last note if monophonic

  399. 		if (channels == 1) {

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

  401. 				uint8_t lastNote = heldNotes.back();

  402. 				notes[0] = lastNote;

  403. 			}

  404. 		}

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

  406. 		else {

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

  408. 				if (!gates[c])

  409. 					continue;

  410. 				gates[c] = false;

  411. 				for (uint8_t note : heldNotes) {

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

  413. 						gates[c] = true;

  414. 						break;

  415. 					}

  416. 				}

  417. 			}

  418. 		}

  419. 	}

  420. 

  421. 	void setChannels(int channels) {

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

  423. 			return;

  424. 		this->channels = channels;

  425. 		panic();

  426. 	}

  427. 

  428. 	void setPolyMode(PolyMode polyMode) {

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

  430. 			return;

  431. 		this->polyMode = polyMode;

  432. 		panic();

  433. 	}

  434. 

  435. 	json_t* dataToJson() override {

  436. 		json_t* rootJ = json_object();

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

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

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

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

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

  442. 		if (polyMode != MPE_MODE) {

  443. 			json_object_set_new(rootJ, "lastPitch", json_integer(pitches[0]));

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

  445. 		}

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

  447. 		return rootJ;

  448. 	}

  449. 

  450. 	void dataFromJson(json_t* rootJ) override {

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

  452. 		if (smoothJ)

  453. 			smooth = json_boolean_value(smoothJ);

  454. 

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

  456. 		if (channelsJ)

  457. 			setChannels(json_integer_value(channelsJ));

  458. 

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

  460. 		if (polyModeJ)

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

  462. 

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

  464. 		if (clockDivisionJ)

  465. 			clockDivision = json_integer_value(clockDivisionJ);

  466. 

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

  468. 		if (lastPitchJ)

  469. 			pitches[0] = json_integer_value(lastPitchJ);

  470. 

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

  472. 		if (lastModJ)

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

  474. 

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

  476. 		if (midiJ)

  477. 			midiInput.fromJson(midiJ);

  478. 	}

  479. };

  480. 

  481. 

  482. struct MIDI_CVWidget : ModuleWidget {

  483. 	MIDI_CVWidget(MIDI_CV* module) {

  484. 		setModule(module);

  485. 		setPanel(APP->window->loadSvg(asset::system("res/Core/MIDI-CV.svg")));

  486. 

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

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

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

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

  491. 

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

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

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

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

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

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

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

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

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

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

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

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

  504. 

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

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

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

  508. 		addChild(midiWidget);

  509. 	}

  510. 

  511. 	void appendContextMenu(Menu* menu) override {

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

  513. 

  514. 		menu->addChild(new MenuSeparator);

  515. 

  516. 		struct SmoothItem : MenuItem {

  517. 			MIDI_CV* module;

  518. 			void onAction(const ActionEvent& e) override {

  519. 				module->smooth ^= true;

  520. 			}

  521. 		};

  522. 

  523. 		SmoothItem* smoothItem = new SmoothItem;

  524. 		smoothItem->text = "Smooth pitch/mod wheel";

  525. 		smoothItem->rightText = CHECKMARK(module->smooth);

  526. 		smoothItem->module = module;

  527. 		menu->addChild(smoothItem);

  528. 

  529. 		struct ClockDivisionValueItem : MenuItem {

  530. 			MIDI_CV* module;

  531. 			int clockDivision;

  532. 			void onAction(const ActionEvent& e) override {

  533. 				module->clockDivision = clockDivision;

  534. 			}

  535. 		};

  536. 

  537. 		struct ClockDivisionItem : MenuItem {

  538. 			MIDI_CV* module;

  539. 			Menu* createChildMenu() override {

  540. 				Menu* menu = new Menu;

  541. 				std::vector<int> divisions = {24 * 4, 24 * 2, 24, 24 / 2, 24 / 4, 24 / 8, 2, 1};

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

  543. 				for (size_t i = 0; i < divisions.size(); i++) {

  544. 					ClockDivisionValueItem* item = new ClockDivisionValueItem;

  545. 					item->text = divisionNames[i];

  546. 					item->rightText = CHECKMARK(module->clockDivision == divisions[i]);

  547. 					item->module = module;

  548. 					item->clockDivision = divisions[i];

  549. 					menu->addChild(item);

  550. 				}

  551. 				return menu;

  552. 			}

  553. 		};

  554. 

  555. 		ClockDivisionItem* clockDivisionItem = new ClockDivisionItem;

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

  557. 		clockDivisionItem->rightText = RIGHT_ARROW;

  558. 		clockDivisionItem->module = module;

  559. 		menu->addChild(clockDivisionItem);

  560. 

  561. 		struct ChannelValueItem : MenuItem {

  562. 			MIDI_CV* module;

  563. 			int channels;

  564. 			void onAction(const ActionEvent& e) override {

  565. 				module->setChannels(channels);

  566. 			}

  567. 		};

  568. 

  569. 		struct ChannelItem : MenuItem {

  570. 			MIDI_CV* module;

  571. 			Menu* createChildMenu() override {

  572. 				Menu* menu = new Menu;

  573. 				for (int channels = 1; channels <= 16; channels++) {

  574. 					ChannelValueItem* item = new ChannelValueItem;

  575. 					if (channels == 1)

  576. 						item->text = "Monophonic";

  577. 					else

  578. 						item->text = string::f("%d", channels);

  579. 					item->rightText = CHECKMARK(module->channels == channels);

  580. 					item->module = module;

  581. 					item->channels = channels;

  582. 					menu->addChild(item);

  583. 				}

  584. 				return menu;

  585. 			}

  586. 		};

  587. 

  588. 		ChannelItem* channelItem = new ChannelItem;

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

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

  591. 		channelItem->module = module;

  592. 		menu->addChild(channelItem);

  593. 

  594. 		struct PolyModeValueItem : MenuItem {

  595. 			MIDI_CV* module;

  596. 			MIDI_CV::PolyMode polyMode;

  597. 			void onAction(const ActionEvent& e) override {

  598. 				module->setPolyMode(polyMode);

  599. 			}

  600. 		};

  601. 

  602. 		struct PolyModeItem : MenuItem {

  603. 			MIDI_CV* module;

  604. 			Menu* createChildMenu() override {

  605. 				Menu* menu = new Menu;

  606. 				std::vector<std::string> polyModeNames = {

  607. 					"Rotate",

  608. 					"Reuse",

  609. 					"Reset",

  610. 					"MPE",

  611. 				};

  612. 				for (int i = 0; i < MIDI_CV::NUM_POLY_MODES; i++) {

  613. 					MIDI_CV::PolyMode polyMode = (MIDI_CV::PolyMode) i;

  614. 					PolyModeValueItem* item = new PolyModeValueItem;

  615. 					item->text = polyModeNames[i];

  616. 					item->rightText = CHECKMARK(module->polyMode == polyMode);

  617. 					item->module = module;

  618. 					item->polyMode = polyMode;

  619. 					menu->addChild(item);

  620. 				}

  621. 				return menu;

  622. 			}

  623. 		};

  624. 

  625. 		PolyModeItem* polyModeItem = new PolyModeItem;

  626. 		polyModeItem->text = "Polyphony mode";

  627. 		polyModeItem->rightText = RIGHT_ARROW;

  628. 		polyModeItem->module = module;

  629. 		menu->addChild(polyModeItem);

  630. 

  631. 		struct PanicItem : MenuItem {

  632. 			MIDI_CV* module;

  633. 			void onAction(const ActionEvent& e) override {

  634. 				module->panic();

  635. 			}

  636. 		};

  637. 

  638. 		PanicItem* panicItem = new PanicItem;

  639. 		panicItem->text = "Panic";

  640. 		panicItem->module = module;

  641. 		menu->addChild(panicItem);

  642. 

  643. 		// Example of using appendMidiMenu()

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

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

  646. 	}

  647. };

  648. 

  649. 

  650. // Use legacy slug for compatibility

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

  652. 

  653. 

  654. } // namespace core

  655. } // namespace rack