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.
1307 Commits
4 Branches
541MB
Tree: 426fa771a1
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '426fa771a1'
${ noResults }
Rack/plugins/community/repos/moDllz/src/MIDI8MPE.cpp

1489 lines
41KB
Raw Blame History 

  1. #include "midi.hpp"

  2. #include "dsp/filter.hpp"

  3. #include "dsp/digital.hpp"

  4. #include "moDllz.hpp"

  5. #include <algorithm>    // std::find

  6. #include <vector>       // std::vector

  7. 

  8. namespace rack_plugin_moDllz {

  9. 

  10. struct MIDI8MPE : Module {

  11. 	enum ParamIds {

  12. 		RESETMIDI_PARAM,

  13. 		LCURSOR_PARAM,

  14. 		RCURSOR_PARAM,

  15. 		PLUSONE_PARAM,

  16. 		MINUSONE_PARAM,

  17. 		LEARNCCA_PARAM,

  18. 		LEARNCCB_PARAM,

  19. 		LEARNCCC_PARAM,

  20. 		LEARNCCD_PARAM,

  21. 		LEARNCCE_PARAM,

  22. 		LEARNCCF_PARAM,

  23. 		SUSTHOLD_PARAM,

  24. 		NUM_PARAMS

  25. 	};

  26. 	enum InputIds {

  27. 		NUM_INPUTS

  28. 	};

  29. 	enum OutputIds {

  30. 		ENUMS(X_OUTPUT, 8),

  31. 		ENUMS(Y_OUTPUT, 8),

  32. 		ENUMS(Z_OUTPUT, 8),

  33. 		ENUMS(VEL_OUTPUT, 8),

  34. 		ENUMS(GATE_OUTPUT, 8),

  35. 

  36. 		MMA_OUTPUT,

  37. 		MMB_OUTPUT,

  38. 		MMC_OUTPUT,

  39. 		MMD_OUTPUT,

  40. 		MME_OUTPUT,

  41. 		MMF_OUTPUT,

  42. 		NUM_OUTPUTS

  43. 	};

  44. 	enum LightIds {

  45. 		RESETMIDI_LIGHT,

  46. 		ENUMS(CH_LIGHT, 8),

  47. 		SUSTHOLD_LIGHT,

  48. 		NUM_LIGHTS

  49. 	};

  50. 

  51. 	MidiInputQueue midiInput;

  52. 

  53. 	enum PolyMode {

  54. 		MPE_MODE,

  55. 		ROTATE_MODE,

  56. 		REUSE_MODE,

  57. 		RESET_MODE,

  58. 		REASSIGN_MODE,

  59. 		UNISON_MODE,

  60. 		NUM_MODES

  61. 	};

  62. 	PolyMode polyMode = ROTATE_MODE;

  63. 

  64. 	bool holdGates = true;

  65. 	struct NoteData {

  66. 		uint8_t velocity = 0;

  67. 		uint8_t aftertouch = 0;

  68. 	};

  69. 

  70. 	NoteData noteData[128];

  71. 	

  72. 	// cachedNotes : UNISON_MODE and REASSIGN_MODE cache all played notes. The other polyModes cache stolen notes (after the 4th one).

  73. 	std::vector<uint8_t> cachedNotes;

  74. 	

  75. 	std::vector<uint8_t> cachedMPE[8];

  76. 	

  77. 	

  78. 	uint8_t notes[8] = {0};

  79. 	uint8_t vels[8] = {0};

  80. 	int16_t mpex[8] = {0};

  81. 	uint16_t mpey[8] = {0};

  82. 	uint16_t mpez[8] = {0};

  83. 	uint8_t mpeyLB[8] = {0};

  84. 	uint8_t mpezLB[8] = {0};

  85. 	

  86. 	uint8_t mpePlusLB[8] = {0};

  87. 

  88. 	bool gates[8] = {false};

  89. 	uint8_t Maft = 0;

  90. 	int midiCCs[6] = {128,1,129,11,7,64};

  91. 	uint8_t midiCCsVal[6] = {0};

  92. 	uint16_t Mpit = 8192;

  93. 	float xpitch[8] = {0.f};

  94. 	

  95. 	// gates set to TRUE by pedal and current gate. FALSE by pedal.

  96. 	bool pedalgates[8] = {false};

  97. 	bool pedal = false;

  98. 	int rotateIndex = 0;

  99. 	int stealIndex = 0;

  100. 	int numVo = 8;

  101. 	int polyModeIx = 1;

  102. 	int pbMain = 12;

  103. 	int pbMPE = 96;

  104. 	int mpeYcc = 74; //cc74 (default MPE Y)

  105. 	int mpeZcc = 128; //128 = ChannelAfterTouch (default MPE Z)

  106. 	int MPEmode = 0; // Index of different MPE modes...(User and HakenPlus for now)

  107. 	int savedMidiCh = -1;//to reset channel from MPE all channels

  108. 	int MPEmasterCh = 0;// 0 ~ 15

  109. 	int MPEfirstCh = 1;// 0 ~ 15

  110. 

  111. 	int displayYcc = 74;

  112. 	int displayZcc = 128;

  113. 

  114. 	int learnIx = 0;

  115. 

  116. 	int cursorIx = 0;

  117. 	int cursorI = 0;

  118. 	int selectedmidich = 0;

  119. 	int cursorPoly[9] = {0,1,3,7,8,9,10,11,12};

  120. 	int cursorMPE[12] = {0,2,3,4,5,6,7,8,9,10,11,12};

  121. 	int cursorMPEsub[10] = {0,2,3,4,7,8,9,10,11,12};

  122. 	float dummy = 0.f;

  123. 	float *dataKnob = &dummy;

  124. 	int frameData = 100000;

  125. 

  126. 	ExponentialFilter MPExFilter[8];

  127. 	ExponentialFilter MPEyFilter[8];

  128. 	ExponentialFilter MPEzFilter[8];

  129. 	ExponentialFilter MCCsFilter[6];

  130. 	ExponentialFilter MpitFilter;

  131. 	

  132. 	// retrigger for stolen notes (when gates already open)

  133. 	PulseGenerator reTrigger[8];

  134. 	SchmittTrigger resetMidiTrigger;

  135. 

  136. 	SchmittTrigger PlusOneTrigger;

  137. 	SchmittTrigger MinusOneTrigger;

  138. 	SchmittTrigger LcursorTrigger;

  139. 	SchmittTrigger RcursorTrigger;

  140. 

  141. 	SchmittTrigger learnCCsTrigger[6];

  142. 

  143. 	

  144. 	MIDI8MPE() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {

  145. 		onReset();

  146. 	}

  147. 

  148. 	json_t *toJson() override {

  149. 		json_t *rootJ = json_object();

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

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

  152. 		json_object_set_new(rootJ, "pbMain", json_integer(pbMain));

  153. 		json_object_set_new(rootJ, "pbMPE", json_integer(pbMPE));

  154. 		json_object_set_new(rootJ, "numVo", json_integer(numVo));

  155. 		json_object_set_new(rootJ, "MPEmasterCh", json_integer(MPEmasterCh));

  156. 		json_object_set_new(rootJ, "MPEfirstCh", json_integer(MPEfirstCh));

  157. 		json_object_set_new(rootJ, "midiAcc", json_integer(midiCCs[0]));

  158. 		json_object_set_new(rootJ, "midiBcc", json_integer(midiCCs[1]));

  159. 		json_object_set_new(rootJ, "midiCcc", json_integer(midiCCs[2]));

  160. 		json_object_set_new(rootJ, "midiDcc", json_integer(midiCCs[3]));

  161. 		json_object_set_new(rootJ, "midiEcc", json_integer(midiCCs[4]));

  162. 		json_object_set_new(rootJ, "midiFcc", json_integer(midiCCs[5]));

  163. 		json_object_set_new(rootJ, "mpeYcc", json_integer(mpeYcc));

  164. 		json_object_set_new(rootJ, "mpeZcc", json_integer(mpeZcc));

  165. 		json_object_set_new(rootJ, "MPEmode", json_integer(MPEmode));

  166. 		return rootJ;

  167. 	}

  168. 

  169. 	void fromJson(json_t *rootJ) override {

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

  171. 		if (midiJ)

  172. 			midiInput.fromJson(midiJ);

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

  174. 		if (polyModeJ)

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

  176. 		polyModeIx = polyMode;

  177. 		json_t *pbMainJ = json_object_get(rootJ, "pbMain");

  178. 		if (pbMainJ)

  179. 			pbMain = json_integer_value(pbMainJ);

  180. 		json_t *pbMPEJ = json_object_get(rootJ, "pbMPE");

  181. 		if (pbMPEJ)

  182. 			pbMPE = json_integer_value(pbMPEJ);

  183. 		json_t *numVoJ = json_object_get(rootJ, "numVo");

  184. 		if (numVoJ)

  185. 			numVo = json_integer_value(numVoJ);

  186. 		json_t *MPEmasterChJ = json_object_get(rootJ, "MPEmasterCh");

  187. 		if (MPEmasterChJ)

  188. 			MPEmasterCh = json_integer_value(MPEmasterChJ);

  189. 		json_t *MPEfirstChJ = json_object_get(rootJ, "MPEfirstCh");

  190. 		if (MPEfirstChJ)

  191. 			MPEfirstCh = json_integer_value(MPEfirstChJ);

  192. 		json_t *midiAccJ = json_object_get(rootJ, "midiAcc");

  193. 		if (midiAccJ)

  194. 			midiCCs[0] = json_integer_value(midiAccJ);

  195. 		json_t *midiBccJ = json_object_get(rootJ, "midiBcc");

  196. 		if (midiBccJ)

  197. 			midiCCs[1] = json_integer_value(midiBccJ);

  198. 		json_t *midiCccJ = json_object_get(rootJ, "midiCcc");

  199. 		if (midiCccJ)

  200. 			midiCCs[2] = json_integer_value(midiCccJ);

  201. 		json_t *midiDccJ = json_object_get(rootJ, "midiDcc");

  202. 		if (midiDccJ)

  203. 			midiCCs[3] = json_integer_value(midiDccJ);

  204. 		json_t *midiEccJ = json_object_get(rootJ, "midiEcc");

  205. 		if (midiEccJ)

  206. 			midiCCs[4] = json_integer_value(midiEccJ);

  207. 		json_t *midiFccJ = json_object_get(rootJ, "midiFcc");

  208. 		if (midiFccJ)

  209. 			midiCCs[5] = json_integer_value(midiFccJ);

  210. 		json_t *mpeYccJ = json_object_get(rootJ, "mpeYcc");

  211. 		if (mpeYccJ)

  212. 			mpeYcc = json_integer_value(mpeYccJ);

  213. 		json_t *mpeZccJ = json_object_get(rootJ, "mpeZcc");

  214. 		if (mpeZccJ)

  215. 			mpeZcc = json_integer_value(mpeZccJ);

  216. 		json_t *MPEmodeJ = json_object_get(rootJ, "MPEmode");

  217. 		if (MPEmodeJ)

  218. 			MPEmode = json_integer_value(MPEmodeJ);

  219. 		

  220. 		if (polyModeIx > 0){

  221. 			displayYcc = 129;

  222. 			displayZcc = 130;

  223. 		}else if (MPEmode > 0){

  224. 			displayYcc = 131;

  225. 			displayZcc = 132;

  226. 		}else {

  227. 			displayYcc = mpeYcc;

  228. 			displayZcc = mpeZcc;

  229. 		}

  230. 	}

  231. ///////////////////////////ON RESET

  232. 	void onReset() override {

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

  234. 			notes[i] = 60;

  235. 			gates[i] = false;

  236. 			pedalgates[i] = false;

  237. 			mpey[i] = 0.f;

  238. 		}

  239. 		rotateIndex = -1;

  240. 		cachedNotes.clear();

  241. 		float lambdaf = 100.f * engineGetSampleTime();

  242. 		

  243. 		if (polyMode == MPE_MODE) {

  244. 			midiInput.channel = -1;

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

  246. 				mpex[i] = 0.f;

  247. 				mpez[i] = 0.f;

  248. 				cachedMPE[i].clear();

  249. 				MPExFilter[i].lambda = lambdaf;

  250. 				MPEyFilter[i].lambda = lambdaf;

  251. 				MPEzFilter[i].lambda = lambdaf;

  252. 			}

  253. 			if (MPEmode > 0){// Haken MPE Plus

  254. 				displayYcc = 131;

  255. 				displayZcc = 132;

  256. 			}else{

  257. 				displayYcc = mpeYcc;

  258. 				displayZcc = mpeZcc;

  259. 			}

  260. 		} else {

  261. 			displayYcc = 129;

  262. 			displayZcc = 130;

  263. 		}

  264. 		learnIx = 0;

  265. 		

  266. 		MpitFilter.lambda = lambdaf;

  267. 		for (int i=0; i < 6; i++){

  268. 			MCCsFilter[i].lambda = lambdaf;

  269. 		}

  270. 		MpitFilter.lambda = lambdaf;

  271. 	}

  272. 

  273. ////////////////////////////////////////////////////

  274. 	int getPolyIndex(int nowIndex) {

  275. 		for (int i = 0; i < numVo; i++) {

  276. 			nowIndex++;

  277. 			if (nowIndex > (numVo - 1))

  278. 				nowIndex = 0;

  279. 			if (!(gates[nowIndex] || pedalgates[nowIndex])) {

  280. 				stealIndex = nowIndex;

  281. 				return nowIndex;

  282. 			}

  283. 		}

  284. 		// All taken = steal (stealIndex always rotates)

  285. 		stealIndex++;

  286. 		if (stealIndex > (numVo - 1))

  287. 			stealIndex = 0;

  288. 		///if ((polyMode > MPE_MODE) && (polyMode < REASSIGN_MODE) && (gates[stealIndex]))

  289. 		/// cannot reach here if polyMode == MPE mode ...no need to check

  290. 		if ((polyMode < REASSIGN_MODE) && (gates[stealIndex]))

  291. 			cachedNotes.push_back(notes[stealIndex]);

  292. 		return stealIndex;

  293. 	}

  294. 

  295. 	void pressNote(uint8_t channel, uint8_t note, uint8_t vel) {

  296. 		

  297. 		// Set notes and gates

  298. 		switch (polyMode) {

  299. 			case MPE_MODE: {

  300. 				//////if gate push note to mpe_buffer for legato/////

  301. 				rotateIndex = channel - MPEfirstCh;

  302. 				if ((rotateIndex < 0) || (rotateIndex > 7)) return;

  303. 				if (gates[rotateIndex]) cachedMPE[rotateIndex].push_back(notes[rotateIndex]);

  304. 				

  305. 			} break;

  306. 

  307. 			case ROTATE_MODE: {

  308. 				rotateIndex = getPolyIndex(rotateIndex);

  309. 			} break;

  310. 

  311. 			case REUSE_MODE: {

  312. 				bool reuse = false;

  313. 				for (int i = 0; i < numVo; i++) {

  314. 					if (notes[i] == note) {

  315. 						rotateIndex = i;

  316. 						reuse = true;

  317. 						break;

  318. 					}

  319. 				}

  320. 				if (!reuse)

  321. 					rotateIndex = getPolyIndex(rotateIndex);

  322. 			} break;

  323. 

  324. 			case RESET_MODE: {

  325. 				rotateIndex = getPolyIndex(-1);

  326. 			} break;

  327. 

  328. 			case REASSIGN_MODE: {

  329. 				cachedNotes.push_back(note);

  330. 				rotateIndex = getPolyIndex(-1);

  331. 			} break;

  332. 

  333. 			case UNISON_MODE: {

  334. 				cachedNotes.push_back(note);

  335. 				for (int i = 0; i < numVo; i++) {

  336. 					notes[i] = note;

  337. 					vels[i] = vel;

  338. 					gates[i] = true;

  339. 					pedalgates[i] = pedal;

  340. 					reTrigger[i].trigger(1e-3);

  341. 				}

  342. 				return;

  343. 			} break;

  344. 

  345. 			default: break;

  346. 		}

  347. 		// Set notes and gates

  348. 		if (gates[rotateIndex] || pedalgates[rotateIndex])

  349. 			reTrigger[rotateIndex].trigger(1e-3);

  350. 		notes[rotateIndex] = note;

  351. 		vels[rotateIndex] = vel;

  352. 		gates[rotateIndex] = true;

  353. 		pedalgates[rotateIndex] = pedal;

  354. 	}

  355. 

  356. 	void releaseNote(uint8_t channel, uint8_t note, uint8_t vel) {

  357. 		

  358. 		if (polyMode > MPE_MODE) {

  359. 		// Remove the note

  360. 		auto it = std::find(cachedNotes.begin(), cachedNotes.end(), note);

  361. 		if (it != cachedNotes.end())

  362. 			cachedNotes.erase(it);

  363. 		}else{

  364. 			int i = channel - MPEfirstCh;

  365. 			if ((i < 0) || (i > 7)) return;

  366. 			auto it = std::find(cachedMPE[i].begin(), cachedMPE[i].end(), note);

  367. 			if (it != cachedMPE[i].end())

  368. 				cachedMPE[i].erase(it);

  369. 		}

  370. 

  371. 		switch (polyMode) {

  372. 			case MPE_MODE: {

  373. 				int i = channel - MPEfirstCh;

  374. 				if (note == notes[i]) {

  375. 					if (pedalgates[i]) {

  376. 						gates[i] = false;

  377. 					}

  378. 					/// check for cachednotes on MPE buffers [8]...

  379. 					else if (!cachedMPE[i].empty()) {

  380. 						notes[i] = cachedMPE[i].back();

  381. 						cachedMPE[i].pop_back();

  382. 					}

  383. 					else {

  384. 						gates[i] = false;

  385. 					}

  386. 					if (vel < 128) // 128 = from NoteOn ZeroVel

  387. 						vels[i] = vel;///Rel Vel

  388. 				}

  389. 			} break;

  390. 

  391. 			case REASSIGN_MODE: {

  392. 				if (vel > 128) vel = 64;

  393. 				for (int i = 0; i < numVo; i++) {

  394. 					if (i < (int) cachedNotes.size()) {

  395. 						if (!pedalgates[i])

  396. 							notes[i] = cachedNotes[i];

  397. 						pedalgates[i] = pedal;

  398. 					}

  399. 					else {

  400. 						gates[i] = false;

  401. 						mpey[i] = vel * 128;

  402. 					}

  403. 				}

  404. 			} break;

  405. 

  406. 			case UNISON_MODE: {

  407. 				if (vel > 128) vel = 64;

  408. 				if (!cachedNotes.empty()) {

  409. 					uint8_t backnote = cachedNotes.back();

  410. 					for (int i = 0; i < numVo; i++) {

  411. 						notes[i] = backnote;

  412. 						gates[i] = true;

  413. 						mpey[i] = vel * 128;

  414. 					}

  415. 				}

  416. 				else {

  417. 					for (int i = 0; i < numVo; i++) {

  418. 						gates[i] = false;

  419. 						mpey[i] = vel * 128;

  420. 					}

  421. 				}

  422. 				

  423. 			} break;

  424. 

  425. 			// default ROTATE_MODE REUSE_MODE RESET_MODE

  426. 			default: {

  427. 				for (int i = 0; i < numVo; i++) {

  428. 					if (notes[i] == note) {

  429. 						if (pedalgates[i]) {

  430. 							gates[i] = false;

  431. 						}

  432. 						else if (!cachedNotes.empty()) {

  433. 							notes[i] = cachedNotes.back();

  434. 							cachedNotes.pop_back();

  435. 						}

  436. 						else {

  437. 							gates[i] = false;

  438. 						}

  439. 						if (vel < 128) // 128 = from NoteOn ZeroVel

  440. 							mpey[i] = vel * 128;

  441. 						else//Fixed RelVel

  442. 							mpey[i] = 8192;

  443. 					}

  444. 				}

  445. 			} break;

  446. 		}

  447. 	}

  448. 

  449. 	void pressPedal() {

  450. 		pedal = true;

  451. 		lights[SUSTHOLD_LIGHT].value = params[SUSTHOLD_PARAM].value;

  452. 		if (polyMode == MPE_MODE) {

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

  454. 				pedalgates[i] = gates[i];

  455. 			}

  456. 		}else {

  457. 			for (int i = 0; i < numVo; i++) {

  458. 				pedalgates[i] = gates[i];

  459. 			}

  460. 		}

  461. 	}

  462. 

  463. 	void releasePedal() {

  464. 		pedal = false;

  465. 		lights[SUSTHOLD_LIGHT].value = 0.f;

  466. 		// When pedal is off, recover notes for pressed keys (if any) after they were already being "cycled" out by pedal-sustained notes.

  467. 		if (polyMode == MPE_MODE) {

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

  469. 				pedalgates[i] = false;

  470. 				if (!cachedMPE[i].empty()) {

  471. 						notes[i] = cachedMPE[i].back();

  472. 						cachedMPE[i].pop_back();

  473. 						gates[i] = true;

  474. 				}

  475. 			}

  476. 		}else{

  477. 			for (int i = 0; i < numVo; i++) {

  478. 				pedalgates[i] = false;

  479. 				if (!cachedNotes.empty()) {

  480. 					if  (polyMode < REASSIGN_MODE){

  481. 						notes[i] = cachedNotes.back();

  482. 						cachedNotes.pop_back();

  483. 						gates[i] = true;

  484. 					}

  485. 				}

  486. 			}

  487. 			if (polyMode == REASSIGN_MODE) {

  488. 				for (int i = 0; i < numVo; i++) {

  489. 					if (i < (int) cachedNotes.size()) {

  490. 						notes[i] = cachedNotes[i];

  491. 						gates[i] = true;

  492. 					}

  493. 					else {

  494. 						gates[i] = false;

  495. 					}

  496. 				}

  497. 			}

  498. 		}

  499. 	}

  500. 	

  501. 	void onSampleRateChange() override {

  502. 		onReset();

  503. 	}

  504. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  505. ///////////////////////

  506. //////   STEP START

  507. ///////////////////////

  508. 	

  509. 	

  510. 	void step() override {

  511. 

  512. 		MidiMessage msg;

  513. 		while (midiInput.shift(&msg)) {

  514. 			processMessage(msg);

  515. 		}

  516. 

  517. 		float pbVo = 0.f;

  518. 		if (Mpit < 8192){

  519. 			pbVo = MpitFilter.process(rescale(Mpit, 0, 8192, -5.f, 0.f));

  520. 		} else {

  521. 			pbVo = MpitFilter.process(rescale(Mpit, 8192, 16383, 0.f, 5.f));

  522. 		}

  523. //		outputs[MMA_OUTPUT].value = pbVo;

  524. 		bool sustainHold = (params[SUSTHOLD_PARAM].value > .5 );

  525. 

  526. 		if (polyMode > PolyMode::MPE_MODE){

  527. 			for (int i = 0; i < numVo; i++) {

  528. 				float lastGate = ((gates[i] || (sustainHold && pedalgates[i])) && (!(reTrigger[i].process(engineGetSampleTime()))))? 10.f : 0.f;

  529. 				outputs[GATE_OUTPUT + i].value = lastGate;

  530. 				outputs[X_OUTPUT + i].value = ((notes[i] - 60) / 12.f) + (pbVo * static_cast<float>(pbMain) / 60.f);

  531. 				outputs[VEL_OUTPUT + i].value = rescale(vels[i], 0, 127, 0.f, 10.f);

  532. 				outputs[Y_OUTPUT + i].value = rescale(mpey[i], 0, 16383, 0.f, 10.f);

  533. 				outputs[Z_OUTPUT + i].value = rescale(noteData[notes[i]].aftertouch, 0, 127, 0.f, 10.f);

  534. 				lights[CH_LIGHT + i].value = ((i == rotateIndex)? 0.2f : 0.f) + (lastGate * .08f);

  535. 			}

  536. 		} else {/// MPE MODE!!!

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

  538. 				float lastGate = ((gates[i] || (sustainHold && pedalgates[i])) && (!(reTrigger[i].process(engineGetSampleTime())))) ? 10.f : 0.f;

  539. 				outputs[GATE_OUTPUT + i].value = lastGate ;

  540. 				if ( mpex[i] < 0){

  541. 					xpitch[i] = (MPExFilter[i].process(rescale(mpex[i], -8192 , 0, -5.f, 0.f))) * pbMPE / 60.f;

  542. 				} else {

  543. 					xpitch[i] = (MPExFilter[i].process(rescale(mpex[i], 0, 8191, 0.f, 5.f))) * pbMPE / 60.f;

  544. 				}

  545. 				outputs[X_OUTPUT + i].value = xpitch[i] + ((notes[i] - 60) / 12.f) + (pbVo * static_cast<float>(pbMain) / 60.f);

  546. 				outputs[VEL_OUTPUT + i].value = rescale(vels[i], 0, 127, 0.f, 10.f);

  547. 				outputs[Y_OUTPUT + i].value = MPEyFilter[i].process(rescale(mpey[i], 0, 16383, 0.f, 10.f));

  548. 				outputs[Z_OUTPUT + i].value = MPEzFilter[i].process(rescale(mpez[i], 0, 16383, 0.f, 10.f));

  549. 				lights[CH_LIGHT + i].value = ((i == rotateIndex)? 0.2f : 0.f) + (lastGate * .08f);

  550. 			}

  551. 		}

  552. 		for (int i = 0; i < 6; i++){

  553. 			if (midiCCs[i] == 128)

  554. 				outputs[MMA_OUTPUT + i].value = pbVo;

  555. 			else if (midiCCs[i] == 129)

  556. 				outputs[MMA_OUTPUT + i].value = MCCsFilter[i].process(rescale(Maft, 0, 127, 0.f, 10.f));

  557. 			else

  558. 				outputs[MMA_OUTPUT + i].value = MCCsFilter[i].process(rescale(midiCCsVal[i], 0, 127, 0.f, 10.f));

  559. 		}

  560. 

  561. 		//// PANEL KNOB AND BUTTONS

  562. 		float f_dataKnob = *dataKnob;

  563. 		if ( f_dataKnob > 0.07f){

  564. 			int knobInterval = static_cast<int>(0.05 * static_cast<float>(engineGetSampleRate()) / f_dataKnob);

  565. 			if (frameData ++ > knobInterval){

  566. 				frameData = 0;

  567. 				dataPlus();

  568. 			}

  569. 		}else if(f_dataKnob < -0.07f){

  570. 			int knobInterval = static_cast<int>(0.05 * static_cast<float>(engineGetSampleRate()) / -f_dataKnob);

  571. 			if (frameData ++ > knobInterval){

  572. 				frameData = 0;

  573. 				dataMinus();

  574. 			}

  575. 		}

  576. 		

  577. 		if (PlusOneTrigger.process(params[PLUSONE_PARAM].value)) {

  578. 			dataPlus();

  579. 			return;

  580. 		}

  581. 		if (MinusOneTrigger.process(params[MINUSONE_PARAM].value)) {

  582. 			dataMinus();

  583. 			return;

  584. 		}

  585. 		if (LcursorTrigger.process(params[LCURSOR_PARAM].value)) {

  586. 			if (polyMode == MPE_MODE){

  587. 				if (MPEmode > 0){

  588. 					if (cursorI > 0) cursorI --;

  589. 					else cursorI = 9;

  590. 					cursorIx = cursorMPEsub[cursorI];

  591. 				}else{

  592. 					if (cursorI > 0) cursorI --;

  593. 					else cursorI = 11;

  594. 					cursorIx = cursorMPE[cursorI];

  595. 				}

  596. 			}else{

  597. 				if (cursorI > 0) cursorI --;

  598. 				else cursorI = 8;

  599. 				cursorIx = cursorPoly[cursorI];

  600. 			}

  601. 			learnIx = 0;

  602. 			return;

  603. 		}

  604. 		if (RcursorTrigger.process(params[RCURSOR_PARAM].value)) {

  605. 			if (polyMode == MPE_MODE){

  606. 				if (MPEmode > 0){

  607. 					if (cursorI < 9) cursorI ++;

  608. 					else cursorI = 0;

  609. 					cursorIx = cursorMPEsub[cursorI];

  610. 				}else{

  611. 					if (cursorI < 11) cursorI ++;

  612. 					else cursorI = 0;

  613. 					cursorIx = cursorMPE[cursorI];

  614. 				}

  615. 			}else{

  616. 				if (cursorI < 8) cursorI ++;

  617. 				else cursorI = 0;

  618. 				cursorIx = cursorPoly[cursorI];

  619. 			}

  620. 			learnIx = 0;

  621. 			return;

  622. 		}

  623. 		for (int i = 0; i < 6; i++){

  624. 			if (learnCCsTrigger[i].process(params[LEARNCCA_PARAM + i].value)) {

  625. 				if (learnIx == i + 1)

  626. 					learnIx = 0;

  627. 				else{

  628. 					learnIx = i + 1;

  629. 					//cursorIx = i + 7;

  630. 				}

  631. 				return;

  632. 			}

  633. 		}

  634. 		

  635. 		///// RESET MIDI

  636. 		if (resetMidiTrigger.process(params[RESETMIDI_PARAM].value)) {

  637. 			lights[RESETMIDI_LIGHT].value= 1.0f;

  638. 			onReset();

  639. 			return;

  640. 		}

  641. 		if (lights[RESETMIDI_LIGHT].value > 0.0001f){

  642. 			lights[RESETMIDI_LIGHT].value -= 0.0001f ; // fade out light

  643. 		}

  644. 	}

  645. ///////////////////////

  646. //////   STEP END

  647. ///////////////////////

  648. 

  649. 	void dataPlus(){

  650. 		switch (cursorIx){

  651. 			case 0: {

  652. 				if (polyMode == MPE_MODE){

  653. 					if (MPEmode < 1){

  654. 						MPEmode ++;

  655. 						onReset();

  656. 					}else{//last MPE submode... go to Poly

  657. 						polyMode = (PolyMode) (1);

  658. 						onReset();

  659. 						midiInput.channel = savedMidiCh;//restore channel

  660. 					}

  661. 				}else if (polyMode < UNISON_MODE) {

  662. 					polyMode = (PolyMode) (polyMode + 1);

  663. 					onReset();

  664. 				}else {

  665. 					polyMode = MPE_MODE;

  666. 					MPEmode = 0; // no MPE submode...

  667. 					savedMidiCh = midiInput.channel;// save Poly MIDI channel

  668. 					onReset();

  669. 				}

  670. 				polyModeIx = polyMode;

  671. 					

  672. 			}break;

  673. 			case 1: {

  674. 				if (numVo < 8) numVo ++;

  675. 				//else numVo = 2;

  676. 				onReset();

  677. 			}break;

  678. 			case 2: {

  679. 				if (MPEfirstCh < 8){

  680. 					MPEfirstCh ++;

  681. 					MPEmasterCh = MPEfirstCh - 1;

  682. 				}else{

  683. 					MPEfirstCh = 0;

  684. 					MPEmasterCh = 15;

  685. 				}

  686. 				onReset();

  687. 			}break;

  688. 			case 3: {

  689. 				if (pbMain < 96) pbMain ++;

  690. 			}break;

  691. 			case 4: {

  692. 				if (pbMPE < 96) pbMPE ++;

  693. 			}break;

  694. 			case 5: {

  695. 				if (mpeYcc <128)

  696. 					mpeYcc ++;

  697. 				else

  698. 					mpeYcc = 0;

  699. 				displayYcc = mpeYcc;

  700. 			}break;

  701. 			case 6: {

  702. 				if (mpeZcc <128)

  703. 					mpeZcc ++;

  704. 				else

  705. 					mpeZcc = 0;

  706. 				displayZcc = mpeZcc;

  707. 			}break;

  708. 			default: {

  709. 				if (midiCCs[cursorIx - 7] < 129)

  710. 					midiCCs[cursorIx - 7]  ++;

  711. 				else

  712. 					midiCCs[cursorIx - 7] = 0;

  713. 			}break;

  714. 		}

  715. 		learnIx = 0;;

  716. 		return;

  717. 	}

  718. 	void dataMinus(){

  719. 		switch (cursorIx){

  720. 			case 0: {

  721. 				if (polyMode > MPE_MODE) {

  722. 					polyMode = (PolyMode) (polyMode - 1);

  723. 					MPEmode = 1;

  724. 					savedMidiCh = midiInput.channel;

  725. 					onReset();

  726. 				}else if (MPEmode > 0){

  727. 					MPEmode --;

  728. 					onReset();

  729. 				}else {//last MPE submode... go to Poly

  730. 					polyMode = UNISON_MODE;

  731. 					onReset();

  732. 					midiInput.channel = savedMidiCh;//restore channel

  733. 				}

  734. 				polyModeIx = polyMode;

  735. 			}break;

  736. 			case 1: {

  737. 				if (numVo > 2) numVo --;

  738. 				//else numVo = 8;

  739. 				onReset();

  740. 			}break;

  741. 			case 2:{

  742. 				if (MPEfirstCh > 1){

  743. 					MPEfirstCh -- ;

  744. 					MPEmasterCh = MPEfirstCh - 1;

  745. 				}else if (MPEfirstCh == 1){

  746. 					MPEfirstCh = 0;

  747. 					MPEmasterCh = 15;

  748. 				}else {

  749. 					MPEfirstCh = 8;

  750. 					MPEmasterCh = 7;

  751. 				}

  752. 				onReset();

  753. 			}break;

  754. 			case 3: {

  755. 				if (pbMain > 0) pbMain --;

  756. 			}break;

  757. 			case 4: {

  758. 				if (pbMPE > 0) pbMPE --;

  759. 			}break;

  760. 			case 5: {

  761. 				if (mpeYcc > 0)

  762. 					mpeYcc --;

  763. 				else

  764. 					mpeYcc = 128;

  765. 				displayYcc = mpeYcc;

  766. 			}break;

  767. 			case 6: {

  768. 				if (mpeZcc > 0)

  769. 					mpeZcc --;

  770. 				else

  771. 					mpeZcc = 128;

  772. 				displayZcc = mpeZcc;

  773. 			}break;

  774. 			default: {

  775. 				if (midiCCs[cursorIx - 7] > 0)

  776. 					midiCCs[cursorIx - 7] --;

  777. 				else

  778. 					midiCCs[cursorIx - 7] = 129;

  779. 			}break;

  780. 		}

  781. 		learnIx = 0;

  782. 		return;

  783. 	}

  784. 	void processMessage(MidiMessage msg) {

  785. 

  786. 

  787. 		switch (msg.status()) {

  788. 			// note off

  789. 			case 0x8: {

  790. 				if ((polyMode == MPE_MODE) && (msg.channel() == MPEmasterCh)) return;

  791. 				releaseNote(msg.channel(), msg.note(), msg.value());

  792. 			} break;

  793. 			// note on

  794. 			case 0x9: {

  795. 				if ((polyMode == MPE_MODE) && (msg.channel() == MPEmasterCh)) return;

  796. 				if (msg.value() > 0) {

  797. 					//noteData[msg.note()].velocity = msg.value();

  798. 					pressNote(msg.channel(), msg.note(), msg.value());

  799. 				}

  800. 				else {

  801. 					releaseNote(msg.channel(), msg.note(), 128);//128 to bypass Release vel on Vel Outputs

  802. 				}

  803. 			} break;

  804. 			// note (poly) aftertouch

  805. 			case 0xa: {

  806. 				if (polyMode == MPE_MODE) return;

  807. 				noteData[msg.note()].aftertouch = msg.value();

  808. 			} break;

  809. 				

  810. 			// channel aftertouch

  811. 			case 0xd: {

  812. 				if (learnIx > 0) {// learn enabled ???

  813. 					midiCCs[learnIx - 1] = 129;

  814. 					learnIx = 0;

  815. 					return;

  816. 				}////////////////////////////////////////

  817. 				else if (polyMode == MPE_MODE){

  818. 					if (msg.channel() == MPEmasterCh){

  819. 						Maft = msg.data1;

  820. 					}else if (MPEmode == 1){

  821. 						mpez[msg.channel() - MPEfirstCh] =  msg.data1 * 128 + mpePlusLB[msg.channel() - MPEfirstCh];

  822. 						mpePlusLB[msg.channel() - MPEfirstCh] = 0;

  823. 					}else {

  824. 						if (mpeZcc == 128)

  825. 							mpez[msg.channel() - MPEfirstCh] = msg.data1 * 128;

  826. 						if (mpeYcc == 128)

  827. 							mpey[msg.channel() - MPEfirstCh] = msg.data1 * 128;

  828. 						}

  829. 				}else{

  830. 					Maft = msg.data1;

  831. 				}

  832. 			} break;

  833. 				// pitch Bend

  834. 			case 0xe:{

  835. 				if (learnIx > 0) {// learn enabled ???

  836. 					midiCCs[learnIx - 1] = 128;

  837. 					learnIx = 0;

  838. 					return;

  839. 				}////////////////////////////////////////

  840. 				else if (polyMode == MPE_MODE){

  841. 					if (msg.channel() == MPEmasterCh){

  842. 						Mpit = msg.data2 * 128 + msg.data1;

  843. 					}else{

  844. 						mpex[msg.channel() - MPEfirstCh] = msg.data2 * 128 + msg.data1 - 8192;

  845. 					}

  846. 				}else{

  847. 					Mpit = msg.data2 * 128 + msg.data1; //14bit Pitch Bend

  848. 				}

  849. 			} break;

  850. 			// cc

  851. 			case 0xb: {

  852. 				///////// LEARN CC   ???

  853. 				if (learnIx > 0) {

  854. 					midiCCs[learnIx - 1] = msg.note();

  855. 					learnIx = 0;

  856. 					return;

  857. 				}else if (polyMode == MPE_MODE){

  858. 					if (msg.channel() == MPEmasterCh){

  859. 						processCC(msg);

  860. 					}else if (MPEmode == 1){ //Continuum

  861. 						if (msg.note() == 87){

  862. 							mpePlusLB[msg.channel() - MPEfirstCh] = msg.data2;

  863. 						}else if (msg.note() == 74){

  864. 							mpey[msg.channel() - MPEfirstCh] =  msg.data2 * 128 + mpePlusLB[msg.channel() - MPEfirstCh];

  865. 							mpePlusLB[msg.channel() - MPEfirstCh] = 0;

  866. 						}

  867. 

  868. 					}else if (msg.note() == mpeYcc){

  869. 					//cc74 0x4a default

  870. 						mpey[msg.channel() - MPEfirstCh] = msg.data2 * 128;

  871. 					}else if (msg.note() == mpeZcc){

  872. 						mpez[msg.channel() - MPEfirstCh] = msg.data2 * 128;

  873. 					}

  874. 				}else{

  875. 					processCC(msg);

  876. 				}

  877. 			} break;

  878. 			default: break;

  879. 		}

  880. 	}

  881. 

  882. 	void processCC(MidiMessage msg) {

  883. 		if (msg.note() ==  0x40) { //internal sust pedal

  884. 			if (msg.value() >= 64)

  885. 				pressPedal();

  886. 			else

  887. 				releasePedal();

  888. 		}

  889. 		for (int i = 0; i < 6; i++){

  890. 			if (midiCCs[i] == msg.note()){

  891. 				midiCCsVal[i] = msg.value();

  892. 				return;

  893. 			}

  894. 		}

  895. 	}

  896. 	void MidiPanic() {

  897. 		onReset();

  898. 		pedal = false;

  899. 		lights[SUSTHOLD_LIGHT].value = 0.f;

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

  901. 			notes[i] = 0;

  902. 			vels[i] = 0;

  903. 			mpex[i] = 0;

  904. 			mpey[i] = 0;

  905. 			mpez[i] = 0;

  906. 			gates[i] = false;

  907. 			xpitch[i] = {0.f};

  908. 		}

  909. 		for (int i = 0; i < NUM_OUTPUTS; i++) {

  910. 			outputs[i].value = 0.f;

  911. 		}

  912. 	}

  913. };

  914. // Main Display

  915. struct PolyModeDisplay : TransparentWidget {

  916. 	PolyModeDisplay(){

  917. 		font = Font::load(mFONT_FILE);

  918. 	}

  919. 	int pointerinit = 0;

  920. 	float mdfontSize = 12.f;

  921. 	std::string sMode ="";

  922. 	std::string sVo ="";

  923. 	std::string sPBM ="";

  924. 	std::string sPBMPE ="";

  925. 	std::string sMPEmidiCh = "";

  926. 	std::string yyDisplay = "";

  927. 	std::string zzDisplay = "";

  928. 	std::shared_ptr<Font> font;

  929. 	std::string polyModeStr[6] = {

  930. 		"M. P. E.",

  931. 		"C Y C L E",

  932. 		"R E U S E",

  933. 		"R E S E T",

  934. 		"R E A S S I G N",

  935. 		"U N I S O N",

  936. 	};

  937. 	int drawFrame = 0;

  938. 	int *p_polyMode = &pointerinit;

  939. 	int polyModeI = -1;

  940. 	int *p_numVo = &pointerinit;

  941. 	int numVoI = -1;

  942. 	int *p_pbMain = &pointerinit;

  943. 	int pbMainI = -1;

  944. 	int *p_pbMPE = &pointerinit;

  945. 	int pbMPEI = -1;

  946. 	int *p_MPEmasterCh = &pointerinit;

  947. 	int MPEmasterChI = -1;

  948. 	int *p_MPEfirstCh = &pointerinit;

  949. 	int MPEfirstChI = -1;

  950. 	int *p_MPEmode = &pointerinit;

  951. 	int MPEmodeI;

  952. 	int *p_YccNumber = &pointerinit;

  953. 	int YccNumber = -1;

  954. 	int *p_ZccNumber = &pointerinit;

  955. 	int ZccNumber = -1;

  956. 	int *p_cursorIx = &pointerinit;

  957. 	int cursorIxI = 0;

  958. 	int flashFocus = 0;

  959. 	void draw(NVGcontext* vg) {

  960. 		if (drawFrame ++ > 5){

  961. 			drawFrame = 0;

  962. 			

  963. 			if (MPEmodeI != *p_MPEmode){

  964. 				MPEmodeI = *p_MPEmode;

  965. 				//if (MPEmodeI > 1) sMode = "M. P. E. w RelVel";///

  966. 				if (MPEmodeI == 1) sMode = "M. P. E. Plus";/// Continuum Hi Res YZ

  967. 				else sMode = polyModeStr[polyModeI];

  968. 			}

  969. 			if (polyModeI !=  *p_polyMode) {

  970. 				polyModeI = *p_polyMode;

  971. 				if (polyModeI < 1) {

  972. 					if (MPEmodeI == 1) sMode = "M. P. E. Plus";/// Continuum Hi Res YZ

  973. 					else sMode = polyModeStr[polyModeI];

  974. 				}else{

  975. 					sMode = polyModeStr[polyModeI];

  976. 				}

  977. 			}

  978. 

  979. 			if (numVoI != *p_numVo){

  980. 				numVoI = *p_numVo;

  981. 				sVo = "Poly "+ std::to_string(numVoI) +" Vo outs";

  982. 			}

  983. 			if (pbMainI != *p_pbMain){

  984. 				pbMainI = *p_pbMain;

  985. 				sPBM = "PBend:" + std::to_string(pbMainI);

  986. 				

  987. 			}

  988. 			if (pbMPEI != *p_pbMPE){

  989. 				pbMPEI = *p_pbMPE;

  990. 				sPBMPE = " CH PBend:" + std::to_string(pbMPEI);

  991. 			}

  992. 

  993. 			if  ((MPEmasterChI != *p_MPEmasterCh) || (MPEfirstChI != *p_MPEfirstCh)){

  994. 				MPEmasterChI = *p_MPEmasterCh;

  995. 				MPEfirstChI = *p_MPEfirstCh;

  996. 				sMPEmidiCh = "channels M:" + std::to_string(MPEmasterChI + 1) + " Vo:" + std::to_string(MPEfirstChI + 1) + "++";

  997. 			}

  998. 			if  (YccNumber != *p_YccNumber){

  999. 				YccNumber = *p_YccNumber;

  1000. 				switch (YccNumber) {

  1001. 					case 129 :{//(locked)  Rel Vel

  1002. 						yyDisplay = "rVel";

  1003. 					}break;

  1004. 					case 131 :{//HiRes MPE Y

  1005. 						yyDisplay = "cc74+";

  1006. 					}break;

  1007. 					default :{

  1008. 						yyDisplay = "cc" + std::to_string(YccNumber);

  1009. 					}

  1010. 				}

  1011. 			}

  1012. 			if  (ZccNumber != *p_ZccNumber){

  1013. 				ZccNumber = *p_ZccNumber;

  1014. 				switch (ZccNumber) {

  1015. 					case 128 :{

  1016. 						zzDisplay = "chnAT";

  1017. 					}break;

  1018. 					case 130 :{//(locked)  note AfterT

  1019. 						zzDisplay = "nteAT";

  1020. 					}break;

  1021. 					case 132 :{//HiRes MPE Z

  1022. 						zzDisplay = "chAT+";

  1023. 					}break;

  1024. 					default :{

  1025. 						zzDisplay = "cc" + std::to_string(ZccNumber);

  1026. 					}

  1027. 				}

  1028. 			}

  1029. 			if (cursorIxI != *p_cursorIx){

  1030. 				cursorIxI = *p_cursorIx;

  1031. 				flashFocus = 64;

  1032. 			}

  1033. 		}

  1034. 		nvgFontSize(vg, mdfontSize);

  1035. 		nvgFontFaceId(vg, font->handle);

  1036. 		nvgFillColor(vg, nvgRGB(0xcc, 0xcc, 0xcc));//Text

  1037. 

  1038. 		//nvgGlobalCompositeOperation(vg, NVG_SOURCE_OUT);

  1039. 		nvgTextAlign(vg, NVG_ALIGN_CENTER);

  1040. 		nvgTextBox(vg, 4.f, 11.0f,124.f, sMode.c_str(), NULL);

  1041. 	

  1042. 		nvgTextBox(vg, 50.f, 52.f, 31.f, yyDisplay.c_str(), NULL);// YY

  1043. 		nvgTextBox(vg, 82.f, 52.f, 31.f, zzDisplay.c_str(), NULL);// ZZ

  1044. 		

  1045. 		if (polyModeI < 1){

  1046. 			nvgTextBox(vg, 4.f, 24.f,124.f, sMPEmidiCh.c_str(), NULL);// MPE Channels

  1047. 			nvgTextAlign(vg, NVG_ALIGN_LEFT);

  1048. 			nvgTextBox(vg, 58.f, 37.f,66.f, sPBMPE.c_str(), NULL);//MPE PitchBend

  1049. 		} else {

  1050. 			nvgTextBox(vg, 4.f, 24.f,124.f, sVo.c_str(), NULL);

  1051. 		}

  1052. 		

  1053. 		nvgTextAlign(vg, NVG_ALIGN_LEFT);

  1054. 		nvgTextBox(vg, 4.f, 37.0f, 50.f, sPBM.c_str(), NULL);

  1055. 		

  1056. 		nvgGlobalCompositeBlendFunc(vg,  NVG_ONE , NVG_ONE);

  1057. 		

  1058. 		nvgBeginPath(vg);

  1059. 		switch (cursorIxI){

  1060. 			case 0:{ // PolyMode

  1061. 				nvgRoundedRect(vg, 1.f, 1.f, 130.f, 12.f, 3.f);

  1062. 			}break;

  1063. 			case 1:{ //numVoices Poly

  1064. 				nvgRoundedRect(vg, 1.f, 14.f, 130.f, 12.f, 3.f);

  1065. 			}break;

  1066. 			case 2:{ //MPE channels

  1067. 				nvgRoundedRect(vg, 1.f, 14.f, 130.f, 12.f, 3.f);

  1068. 			}break;

  1069. 			case 3:{//mainPB

  1070. 				nvgRoundedRect(vg, 1.f, 27.f, 52.f, 12.f, 3.f);

  1071. 			}break;

  1072. 			case 4:{//mpePB

  1073. 				nvgRoundedRect(vg, 54.f, 27.f, 77.f, 12.f, 3.f);

  1074. 			}break;

  1075. 			case 5:{//YY

  1076. 				nvgRoundedRect(vg, 50.f, 42.f, 31, 13.f, 3.f);

  1077. 			}break;

  1078. 			case 6:{//ZZ

  1079. 				nvgRoundedRect(vg, 82.f, 42.f, 31, 13.f, 3.f);

  1080. 			}break;

  1081. 		}

  1082. 

  1083. 		if (flashFocus > 0)

  1084. 			flashFocus -= 2;

  1085. 		int rgbint = 0x55 + flashFocus;

  1086. 		nvgFillColor(vg, nvgRGB(rgbint,rgbint,rgbint)); //SELECTED

  1087. 		nvgFill(vg);

  1088. 		

  1089. 	}

  1090. };

  1091. 

  1092. struct MidiccDisplay : TransparentWidget {

  1093. 	MidiccDisplay(){

  1094. 		font = Font::load(mFONT_FILE);

  1095. 	}

  1096. 	float mdfontSize = 12.f;

  1097. 	std::string sDisplay = "";

  1098. 	int pointerinit = 0;

  1099. 	int *p_cursor = &pointerinit;

  1100. 	int cursorI = -1;

  1101. 	int displayID = 0;//set on each instance

  1102. 	int *p_ccNumber = &pointerinit;

  1103. 	int ccNumber = -1;

  1104. 	bool learnOn = false;

  1105. 	bool learnChanged = false;

  1106. 	int *p_learnIx = &pointerinit;

  1107. 	int flashFocus = 0;

  1108. 	int displayFrames = 0;

  1109. 	std::shared_ptr<Font> font;

  1110. 	void draw(NVGcontext* vg) {

  1111. 		if(displayFrames ++ > 5){

  1112. 			displayFrames = 0;

  1113. 			learnOn = (displayID - 6 == *p_learnIx);

  1114. 			if (learnOn){

  1115. 				learnChanged = true;

  1116. 				sDisplay = "LRN";

  1117. 			}else if ((ccNumber != *p_ccNumber) || (learnChanged)){

  1118. 				learnChanged = false;

  1119. 				ccNumber = *p_ccNumber;

  1120. 				switch (ccNumber) {

  1121. 					case 128 :{

  1122. 						sDisplay = "PBnd";

  1123. 					}break;

  1124. 					case 129 :{

  1125. 						sDisplay = "chAT";

  1126. 					}break;

  1127. 					case 1 :{

  1128. 						sDisplay = "Mod";

  1129. 					}break;

  1130. 					case 2 :{

  1131. 						sDisplay = "BrC";

  1132. 					}break;

  1133. 					case 7 :{

  1134. 						sDisplay = "Vol";

  1135. 					}break;

  1136. 					case 10 :{

  1137. 						sDisplay = "Pan";

  1138. 					}break;

  1139. 					case 11 :{

  1140. 						sDisplay = "Expr";

  1141. 					}break;

  1142. 					case 64 :{

  1143. 						sDisplay = "Sust";

  1144. 					}break;

  1145. 					default :{

  1146. 						sDisplay = "c" + std::to_string(ccNumber);

  1147. 					}

  1148. 				}

  1149. 			}

  1150. 		}

  1151. 		if (learnOn) {

  1152. 			nvgBeginPath(vg);

  1153. 			nvgRoundedRect(vg, 0.f, 0.f, box.size.x, box.size.y,3.f);

  1154. 			nvgStrokeColor(vg, nvgRGB(0xdd, 0x0, 0x0));

  1155. 			nvgStroke(vg);

  1156. 			nvgRoundedRect(vg, 0.f, 0.f, box.size.x, box.size.y,3.f);

  1157. 

  1158. 			nvgFillColor(vg, nvgRGBA(0xcc, 0x0, 0x0,0x64));

  1159. 			nvgFill(vg);

  1160. 			///text color

  1161. 			nvgFillColor(vg, nvgRGB(0xff, 0x00, 0x00));//LEARN

  1162. 		}else{

  1163. 			///text color

  1164. 			nvgFillColor(vg, nvgRGB(0xcc, 0xcc, 0xcc));

  1165. 		}

  1166. 		nvgFontSize(vg, mdfontSize);

  1167. 		nvgFontFaceId(vg, font->handle);

  1168. 		nvgTextAlign(vg, NVG_ALIGN_CENTER);

  1169. 		nvgTextBox(vg, 0.f, 10.f,box.size.x, sDisplay.c_str(), NULL);

  1170. 

  1171. 		if (cursorI != *p_cursor){

  1172. 			cursorI = *p_cursor;

  1173. 			if (*p_cursor == displayID)

  1174. 				flashFocus = 64;

  1175. 		}

  1176. 		if ((displayID == cursorI) && (!learnOn)){

  1177. 			nvgGlobalCompositeBlendFunc(vg,  NVG_ONE , NVG_ONE);

  1178. 			nvgBeginPath(vg);

  1179. 			nvgRoundedRect(vg, 0.f, 0.f, box.size.x, box.size.y,3.f);

  1180. //			nvgStrokeColor(vg, nvgRGB(0x66, 0x66, 0x66));

  1181. //			nvgStroke(vg);

  1182. 			if (flashFocus > 0)

  1183. 				flashFocus -= 2;

  1184. 			int rgbint = 0x55 + flashFocus;

  1185. 			nvgFillColor(vg, nvgRGB(rgbint,rgbint,rgbint)); //SELECTED

  1186. 			nvgFill(vg);

  1187. 		}

  1188. 	}

  1189. };

  1190. 

  1191. 

  1192. struct BlockChannel : OpaqueWidget {

  1193. 	int *p_polyMode;

  1194. 	void draw(NVGcontext* vg) {

  1195. 		if ( *p_polyMode > 0) {

  1196. 				box.size = Vec(0.f,0.f);

  1197. 			}else{

  1198. 				box.size = Vec(94.f,13.f);

  1199. 				NVGcolor ledColor = nvgRGBA(0x00, 0x00, 0x00,0xaa);

  1200. 				nvgBeginPath(vg);

  1201. 				nvgRoundedRect(vg, 0.f, 0.f, 94.f, 13.f,3.f);

  1202. 				nvgFillColor(vg, ledColor);

  1203. 				nvgFill(vg);

  1204. 			}

  1205. 	}

  1206. };

  1207. 

  1208. ///MIDIlearnMCC

  1209. struct learnMccButton : SVGSwitch, MomentarySwitch {

  1210. 	learnMccButton() {

  1211. 		box.size = Vec(26, 13);

  1212. 		addFrame(SVG::load(assetPlugin(plugin, "res/learnMcc_0.svg")));

  1213. 		addFrame(SVG::load(assetPlugin(plugin, "res/learnMcc_1.svg")));

  1214. 	}

  1215. };

  1216. 

  1217. 

  1218. struct springDataKnob : SVGKnob {

  1219. 		int *p_frameData;

  1220. 

  1221. 	springDataKnob() {

  1222. 		minAngle = -0.75*M_PI;

  1223. 		maxAngle = 0.75*M_PI;

  1224. 		setSVG(SVG::load(assetPlugin(plugin, "res/dataKnob.svg")));

  1225. 		shadow->opacity = 0.f;

  1226. 	}

  1227. 		void onMouseUp(EventMouseUp &e){

  1228. 			this->value = 0.f;

  1229. 			*p_frameData = 100000; //reset frame Counter to start (over sampleRate counter)

  1230. 		}

  1231. };

  1232. 

  1233. struct TranspOffRedLight : TranspOffLight {

  1234. 	TranspOffRedLight() {

  1235. 		addBaseColor(nvgRGBA(0xff, 0x00, 0x00, 0x88));//borderColor = nvgRGBA(0, 0, 0, 0x60);

  1236. 	}

  1237. };

  1238. 

  1239. 

  1240. struct MIDI8MPEWidget : ModuleWidget {

  1241. 	MIDI8MPEWidget(MIDI8MPE *module) : ModuleWidget(module) {

  1242. 		setPanel(SVG::load(assetPlugin(plugin,"res/MIDI8MPE.svg")));

  1243. 		//Screws

  1244. 		addChild(Widget::create<ScrewBlack>(Vec(0, 0)));

  1245. 		addChild(Widget::create<ScrewBlack>(Vec(180, 0)));

  1246. 		addChild(Widget::create<ScrewBlack>(Vec(0, 365)));

  1247. 		addChild(Widget::create<ScrewBlack>(Vec(180, 365)));

  1248. 		

  1249. 		float xPos = 8.f;//61;

  1250. 		float yPos = 18.f;

  1251. 		{

  1252. 			MidiWidget *midiWidget = Widget::create<MidiWidget>(Vec(xPos,yPos));

  1253. 			midiWidget->box.size = Vec(132.f,41.f);

  1254. 			midiWidget->midiIO = &module->midiInput;

  1255. 			

  1256. 			midiWidget->driverChoice->box.size.y = 12.f;

  1257. 			midiWidget->deviceChoice->box.size.y = 12.f;

  1258. 			midiWidget->channelChoice->box.size.y = 12.f;

  1259. 

  1260. 			midiWidget->driverChoice->box.pos = Vec(0.f, 2.f);

  1261. 			midiWidget->deviceChoice->box.pos = Vec(0.f, 15.f);

  1262. 			midiWidget->channelChoice->box.pos = Vec(0.f, 28.f);

  1263. 

  1264. 			midiWidget->driverSeparator->box.pos = Vec(0.f, 15.f);

  1265. 			midiWidget->deviceSeparator->box.pos = Vec(0.f, 28.f);

  1266. 

  1267. 			midiWidget->driverChoice->font = Font::load(mFONT_FILE);

  1268. 			midiWidget->deviceChoice->font = Font::load(mFONT_FILE);

  1269. 			midiWidget->channelChoice->font = Font::load(mFONT_FILE);

  1270. 

  1271. 			midiWidget->driverChoice->textOffset = Vec(2.f,10.f);

  1272. 			midiWidget->deviceChoice->textOffset = Vec(2.f,10.f);

  1273. 			midiWidget->channelChoice->textOffset = Vec(2.f,10.f);

  1274. 			

  1275. 			midiWidget->driverChoice->color = nvgRGB(0xcc, 0xcc, 0xcc);

  1276. 			midiWidget->deviceChoice->color = nvgRGB(0xcc, 0xcc, 0xcc);

  1277. 			midiWidget->channelChoice->color = nvgRGB(0xcc, 0xcc, 0xcc);

  1278. 			addChild(midiWidget);

  1279. 		}

  1280. 		BlockChannel *blockChannel = Widget::create<BlockChannel>(Vec(8.f,46.f));

  1281. 		blockChannel->p_polyMode = &(module->polyModeIx);

  1282. 		addChild(blockChannel);

  1283. 		

  1284. 		xPos = 102.f;

  1285. 		yPos = 47.f;

  1286. 		addParam(ParamWidget::create<moDllzMidiPanic>(Vec(xPos, yPos), module, MIDI8MPE::RESETMIDI_PARAM, 0.0f, 1.0f, 0.0f));

  1287. 		addChild(ModuleLightWidget::create<SmallLight<RedLight>>(Vec(xPos+3.f, yPos+3.f), module, MIDI8MPE::RESETMIDI_LIGHT));

  1288. 		

  1289. 		xPos = 8.f;

  1290. 		yPos = 62.f;

  1291. 		

  1292. 		{

  1293. 			PolyModeDisplay *polyModeDisplay = new PolyModeDisplay();

  1294. 			polyModeDisplay->box.pos = Vec(xPos, yPos);

  1295. 			polyModeDisplay->box.size = {132.f, 54.f};

  1296. 			polyModeDisplay->p_polyMode = &(module->polyModeIx);

  1297. 			polyModeDisplay->p_MPEmode = &(module->MPEmode);

  1298. 			polyModeDisplay->p_numVo = &(module->numVo);

  1299. 			polyModeDisplay->p_pbMain = &(module->pbMain);

  1300. 			polyModeDisplay->p_pbMPE = &(module->pbMPE);

  1301. 			polyModeDisplay->p_MPEmasterCh = &(module->MPEmasterCh);

  1302. 			polyModeDisplay->p_MPEfirstCh = &(module->MPEfirstCh);

  1303. 			polyModeDisplay->p_YccNumber = &(module->displayYcc);

  1304. 			polyModeDisplay->p_ZccNumber = &(module->displayZcc);

  1305. 			polyModeDisplay->p_cursorIx = &(module->cursorIx);

  1306. 			addChild(polyModeDisplay);

  1307. 		}

  1308. 		

  1309. 		yPos = 20.f;

  1310. 		xPos = 145.f;

  1311. 		addParam(ParamWidget::create<minusButton>(Vec(xPos, yPos), module, MIDI8MPE::MINUSONE_PARAM, 0.0f, 1.0f, 0.0f));

  1312. 		xPos = 169.f;

  1313. 		addParam(ParamWidget::create<plusButton>(Vec(xPos, yPos), module, MIDI8MPE::PLUSONE_PARAM, 0.0f, 1.0f, 0.0f));

  1314. 

  1315. 		

  1316. 		xPos = 147.f;

  1317. 		yPos = 40.f;

  1318. ////DATA KNOB

  1319. 		

  1320. 		{   springDataKnob *sDataKnob = new springDataKnob();

  1321. 			sDataKnob->box.pos = Vec(xPos, yPos);

  1322. 			sDataKnob->box.size = {36.f, 36.f};

  1323. 			sDataKnob->minValue = -1.f;

  1324. 			sDataKnob->maxValue = 1.f;

  1325. 			sDataKnob->defaultValue = 0.f;

  1326. 			sDataKnob->p_frameData = &(module->frameData);

  1327. 			module->dataKnob = &(sDataKnob->value);

  1328. 			addChild(sDataKnob);

  1329. 		}

  1330. 		

  1331. 		yPos = 85.f;

  1332. 		xPos = 145.5f;

  1333. 		addParam(ParamWidget::create<moDllzcursorL>(Vec(xPos, yPos), module, MIDI8MPE::LCURSOR_PARAM, 0.0f, 1.0f, 0.0f));

  1334. 		xPos = 165.5f;

  1335. 		addParam(ParamWidget::create<moDllzcursorR>(Vec(xPos, yPos), module, MIDI8MPE::RCURSOR_PARAM, 0.0f, 1.0f, 0.0f));

  1336. 

  1337. //		yPos = 104.f;

  1338. //		xPos = 59.f;

  1339. //		{

  1340. //			MidiccDisplay *mpeYDisplay = new MidiccDisplay();

  1341. //			mpeYDisplay->box.pos = Vec(xPos, yPos);

  1342. //			mpeYDisplay->box.size = {29.5f, 13.f};

  1343. //			mpeYDisplay->displayID = 5;

  1344. //			mpeYDisplay->p_cursor = &(module->cursorIx);

  1345. //			mpeYDisplay->p_ccNumber = &(module->displayYcc);

  1346. //			mpeYDisplay->p_learnOn = &(module->learnYcc);

  1347. //			addChild(mpeYDisplay);

  1348. //		}

  1349. //

  1350. //		addParam(ParamWidget::create<learnMccButton>(Vec(xPos, yPos), module, MIDI8MPE::LEARNCCY_PARAM, 0.0, 1.0, 0.0));

  1351. //		xPos = 89.5f;

  1352. //		{

  1353. //			MidiccDisplay *mpeZDisplay = new MidiccDisplay();

  1354. //			mpeZDisplay->box.pos = Vec(xPos, yPos);

  1355. //			mpeZDisplay->box.size = {29.5f, 13.f};

  1356. //			mpeZDisplay->displayID = 6;

  1357. //			mpeZDisplay->p_cursor = &(module->cursorIx);

  1358. //			mpeZDisplay->p_ccNumber = &(module->displayZcc);

  1359. //			mpeZDisplay->p_learnOn = &(module->learnZcc);

  1360. //			addChild(mpeZDisplay);

  1361. //		}

  1362. //		addParam(ParamWidget::create<learnMccButton>(Vec(xPos, yPos), module, MIDI8MPE::LEARNCCZ_PARAM, 0.0, 1.0, 0.0));

  1363. 		

  1364. 		

  1365. 		

  1366. 		yPos = 118.f;

  1367. 		float const xOffset = 32.f;

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

  1369. 			xPos = 30.f;

  1370. 			addChild(ModuleLightWidget::create<TinyLight<RedLight>>(Vec(xPos-7.f, yPos+10.f), module, MIDI8MPE::CH_LIGHT + i));

  1371. 			addOutput(Port::create<moDllzPortDark>(Vec(xPos, yPos), Port::OUTPUT, module, MIDI8MPE::X_OUTPUT + i));

  1372. 			xPos += xOffset;

  1373. 			addOutput(Port::create<moDllzPortDark>(Vec(xPos, yPos), Port::OUTPUT, module, MIDI8MPE::Y_OUTPUT + i));

  1374. 			xPos += xOffset;

  1375. 			addOutput(Port::create<moDllzPortDark>(Vec(xPos, yPos), Port::OUTPUT, module, MIDI8MPE::Z_OUTPUT + i));

  1376. 			xPos += xOffset;

  1377. 			addOutput(Port::create<moDllzPortDark>(Vec(xPos, yPos), Port::OUTPUT, module, MIDI8MPE::VEL_OUTPUT + i));

  1378. 			xPos += xOffset;

  1379. 			addOutput(Port::create<moDllzPortDark>(Vec(xPos, yPos), Port::OUTPUT, module, MIDI8MPE::GATE_OUTPUT + i));

  1380. 			yPos += 25.f;

  1381. 		}

  1382. 		yPos = 336.f;

  1383. 		xPos = 10.5f;

  1384. 		for ( int i = 0; i < 6; i++){

  1385. 			addOutput(Port::create<moDllzPort>(Vec(xPos, yPos), Port::OUTPUT, module, MIDI8MPE::MMA_OUTPUT + i));

  1386. 			xPos += 27.f;

  1387. 		}

  1388. 		

  1389. 		yPos = 322.f;

  1390. 		xPos = 9.f;

  1391. 		{

  1392. 			MidiccDisplay *MccADisplay = new MidiccDisplay();

  1393. 			MccADisplay->box.pos = Vec(xPos, yPos);

  1394. 			MccADisplay->box.size = {26.f, 13.f};

  1395. 			MccADisplay->displayID = 7;

  1396. 			MccADisplay->p_cursor = &(module->cursorIx);

  1397. 			MccADisplay->p_ccNumber = &(module->midiCCs[0]);

  1398. 			MccADisplay->p_learnIx = &(module->learnIx);

  1399. 			addChild(MccADisplay);

  1400. 		}

  1401. 		addParam(ParamWidget::create<learnMccButton>(Vec(xPos, yPos), module, MIDI8MPE::LEARNCCA_PARAM, 0.0, 1.0, 0.0));

  1402. 		xPos += 27.f;

  1403. 		{

  1404. 			MidiccDisplay *MccBDisplay = new MidiccDisplay();

  1405. 			MccBDisplay->box.pos = Vec(xPos, yPos);

  1406. 			MccBDisplay->box.size = {26.f, 13.f};

  1407. 			MccBDisplay->displayID = 8;

  1408. 			MccBDisplay->p_cursor = &(module->cursorIx);

  1409. 			MccBDisplay->p_ccNumber = &(module->midiCCs[1]);

  1410. 			MccBDisplay->p_learnIx = &(module->learnIx);

  1411. 			addChild(MccBDisplay);

  1412. 		}

  1413. 		addParam(ParamWidget::create<learnMccButton>(Vec(xPos, yPos), module, MIDI8MPE::LEARNCCB_PARAM, 0.0, 1.0, 0.0));

  1414. 		xPos += 27.f;

  1415. 		{

  1416. 			MidiccDisplay *MccCDisplay = new MidiccDisplay();

  1417. 			MccCDisplay->box.pos = Vec(xPos, yPos);

  1418. 			MccCDisplay->box.size = {26.f, 13.f};

  1419. 			MccCDisplay->displayID = 9;

  1420. 			MccCDisplay->p_cursor = &(module->cursorIx);

  1421. 			MccCDisplay->p_ccNumber = &(module->midiCCs[2]);

  1422. 			MccCDisplay->p_learnIx = &(module->learnIx);

  1423. 			addChild(MccCDisplay);

  1424. 		}

  1425. 		addParam(ParamWidget::create<learnMccButton>(Vec(xPos, yPos), module, MIDI8MPE::LEARNCCC_PARAM, 0.0, 1.0, 0.0));

  1426. 		xPos += 27.f;

  1427. 		{

  1428. 			MidiccDisplay *MccDDisplay = new MidiccDisplay();

  1429. 			MccDDisplay->box.pos = Vec(xPos, yPos);

  1430. 			MccDDisplay->box.size = {26.f, 13.f};

  1431. 			MccDDisplay->displayID = 10;

  1432. 			MccDDisplay->p_cursor = &(module->cursorIx);

  1433. 			MccDDisplay->p_ccNumber = &(module->midiCCs[3]);

  1434. 			MccDDisplay->p_learnIx = &(module->learnIx);

  1435. 			addChild(MccDDisplay);

  1436. 		}

  1437. 		addParam(ParamWidget::create<learnMccButton>(Vec(xPos, yPos), module, MIDI8MPE::LEARNCCD_PARAM, 0.0, 1.0, 0.0));

  1438. 		xPos += 27.f;

  1439. 		{

  1440. 			MidiccDisplay *MccEDisplay = new MidiccDisplay();

  1441. 			MccEDisplay->box.pos = Vec(xPos, yPos);

  1442. 			MccEDisplay->box.size = {26.f, 13.f};

  1443. 			MccEDisplay->displayID = 11;

  1444. 			MccEDisplay->p_cursor = &(module->cursorIx);

  1445. 			MccEDisplay->p_ccNumber = &(module->midiCCs[4]);

  1446. 			MccEDisplay->p_learnIx = &(module->learnIx);

  1447. 			addChild(MccEDisplay);

  1448. 		}

  1449. 		addParam(ParamWidget::create<learnMccButton>(Vec(xPos, yPos), module, MIDI8MPE::LEARNCCE_PARAM, 0.0, 1.0, 0.0));

  1450. 		xPos += 27.f;

  1451. 		{

  1452. 			MidiccDisplay *MccFDisplay = new MidiccDisplay();

  1453. 			MccFDisplay->box.pos = Vec(xPos, yPos);

  1454. 			MccFDisplay->box.size = {26.f, 13.f};

  1455. 			MccFDisplay->displayID = 12;

  1456. 			MccFDisplay->p_cursor = &(module->cursorIx);

  1457. 			MccFDisplay->p_ccNumber = &(module->midiCCs[5]);

  1458. 			MccFDisplay->p_learnIx = &(module->learnIx);

  1459. 			addChild(MccFDisplay);

  1460. 		}

  1461. 		addParam(ParamWidget::create<learnMccButton>(Vec(xPos, yPos), module, MIDI8MPE::LEARNCCF_PARAM, 0.0, 1.0, 0.0));

  1462. 		

  1463. 		

  1464. 		///Sustain hold notes		

  1465. 		xPos = 173.f;

  1466. 		yPos = 338.f;

  1467. 		addParam(ParamWidget::create<moDllzSwitchLed>(Vec(xPos, yPos), module, MIDI8MPE::SUSTHOLD_PARAM, 0.0, 1.0, 1.0));

  1468. 		addChild(ModuleLightWidget::create<TranspOffRedLight>(Vec(xPos, yPos), module, MIDI8MPE::SUSTHOLD_LIGHT));

  1469. 		

  1470. 		

  1471. //		{

  1472. //		        testDisplay *mDisplay = new testDisplay();

  1473. //		        mDisplay->box.pos = Vec(0.0f, 360.0f);

  1474. //		        mDisplay->box.size = {165.0f, 20.0f};

  1475. //		        mDisplay->valP = module->dataKnob;

  1476. //		        addChild(mDisplay);

  1477. //		    }

  1478. 	}

  1479. };

  1480. 

  1481. } // namespace rack_plugin_moDllz

  1482. 

  1483. using namespace rack_plugin_moDllz;

  1484. 

  1485. RACK_PLUGIN_MODEL_INIT(moDllz, MIDI8MPE) {

  1486.    Model *modelMIDI8MPE = Model::create<MIDI8MPE, MIDI8MPEWidget>("moDllz", "MIDI8MPE", "MIDI 8cv MPE", MIDI_TAG, EXTERNAL_TAG, MULTIPLE_TAG);

  1487.    return modelMIDI8MPE;

  1488. }