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.
1304 Commits
4 Branches
541MB
Tree: e9f1388e73
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e9f1388e73'
${ noResults }
Rack/plugins/community/repos/ImpromptuModular/src/GateSeq64.cpp

1565 lines
54KB
Raw Blame History 

  1. //***********************************************************************************************

  2. //Gate sequencer module for VCV Rack by Marc Boulé

  3. //

  4. //Based on code from the Fundamental and AudibleInstruments plugins by Andrew Belt 

  5. //and graphics from the Component Library by Wes Milholen 

  6. //See ./LICENSE.txt for all licenses

  7. //See ./res/fonts/ for font licenses

  8. //

  9. //Module concept by Nigel Sixsmith and Marc Boulé

  10. //

  11. //Acknowledgements: please see README.md

  12. //***********************************************************************************************

  13. 

  14. 

  15. #include "GateSeq64Util.hpp"

  16. 

  17. namespace rack_plugin_ImpromptuModular {

  18. 

  19. struct GateSeq64 : Module {

  20. 	enum ParamIds {

  21. 		ENUMS(STEP_PARAMS, 64),

  22. 		MODES_PARAM,

  23. 		RUN_PARAM,

  24. 		CONFIG_PARAM,

  25. 		COPY_PARAM,

  26. 		PASTE_PARAM,

  27. 		RESET_PARAM,

  28. 		PROB_PARAM,

  29. 		EDIT_PARAM,

  30. 		SEQUENCE_PARAM,

  31. 		CPMODE_PARAM,

  32. 		// -- 0.6.9 ^^

  33. 		GMODELEFT_PARAM,// no longer used

  34. 		GMODERIGHT_PARAM,// no longer used

  35. 		// -- 0.6.11 ^^

  36. 		ENUMS(GMODE_PARAMS, 8),

  37. 		NUM_PARAMS

  38. 	};

  39. 	enum InputIds {

  40. 		CLOCK_INPUT,

  41. 		RESET_INPUT,

  42. 		RUNCV_INPUT,

  43. 		SEQCV_INPUT,

  44. 		// -- 0.6.7 ^^

  45. 		WRITE_INPUT,

  46. 		GATE_INPUT,

  47. 		PROB_INPUT,

  48. 		WRITE1_INPUT,

  49. 		WRITE0_INPUT,

  50. 		// -- 0.6.10 ^^

  51. 		STEPL_INPUT,

  52. 		NUM_INPUTS

  53. 	};

  54. 	enum OutputIds {

  55. 		ENUMS(GATE_OUTPUTS, 4),

  56. 		NUM_OUTPUTS

  57. 	};

  58. 	enum LightIds {

  59. 		ENUMS(STEP_LIGHTS, 64 * 3),// room for GreenRedWhite

  60. 		P_LIGHT,

  61. 		RUN_LIGHT,

  62. 		RESET_LIGHT,

  63. 		ENUMS(GMODE_LIGHTS, 8 * 2),// room for GreenRed

  64. 		NUM_LIGHTS

  65. 	};

  66. 	

  67. 	// Constants

  68. 	enum DisplayStateIds {DISP_GATE, DISP_LENGTH, DISP_MODES};

  69. 	static const int MAX_SEQS = 32;

  70. 	//										1/4		DUO			D2			TR1		TR2		TR3 		TR23	   TRI

  71. 	const uint32_t advGateHitMaskGS[8] = {0x00003F, 0x03F03F, 0x03F000, 0x00000F, 0x000F00, 0x0F0000, 0x0F0F00, 0x0F0F0F};

  72. 	static const int blinkNumInit = 15;// init number of blink cycles for cursor

  73. 	static constexpr float CONFIG_PARAM_INIT_VALUE = 0.0f;// so that module constructor is coherent with widget initialization, since module created before widget

  74. 

  75. 	// Need to save

  76. 	int panelTheme = 0;

  77. 	int expansion = 0;

  78. 	bool autoseq;

  79. 	int seqCVmethod;// 0 is 0-10V, 1 is C4-D5#, 2 is TrigIncr

  80. 	int pulsesPerStep;// 1 means normal gate mode, alt choices are 4, 6, 12, 24 PPS (Pulses per step)

  81. 	bool running;

  82. 	SeqAttributesGS sequences[MAX_SEQS];

  83. 	int runModeSong;

  84. 	int sequence;

  85. 	int phrase[64];// This is the song (series of phases; a phrase is a patten number)

  86. 	int phrases;// 1 to 64

  87. 	StepAttributesGS attributes[MAX_SEQS][64];

  88. 	bool resetOnRun;

  89. 

  90. 	// No need to save

  91. 	int displayState;

  92. 	int stepIndexEdit;

  93. 	int stepIndexRun[4];

  94. 	int phraseIndexEdit;	

  95. 	int phraseIndexRun;

  96. 	unsigned long stepIndexRunHistory;

  97. 	unsigned long phraseIndexRunHistory;

  98. 	StepAttributesGS attribCPbuffer[64];

  99. 	SeqAttributesGS seqAttribCPbuffer;

  100. 	bool seqCopied;

  101. 	int phraseCPbuffer[64];

  102. 	int countCP;// number of steps to paste (in case CPMODE_PARAM changes between copy and paste)

  103. 	int startCP;

  104. 	long infoCopyPaste;// 0 when no info, positive downward step counter timer when copy, negative upward when paste

  105. 	long clockIgnoreOnReset;

  106. 	long displayProbInfo;// downward step counter for displayProb feedback

  107. 	int gateCode[4];

  108. 	long revertDisplay;

  109. 	long editingPpqn;// 0 when no info, positive downward step counter timer when editing ppqn

  110. 	int ppqnCount;

  111. 	long blinkCount;// positive upward counter, reset to 0 when max reached

  112. 	int blinkNum;// number of blink cycles to do, downward counter

  113. 	int stepConfig;

  114. 	long editingPhraseSongRunning;// downward step counter

  115. 

  116. 

  117. 	int stepConfigSync = 0;// 0 means no sync requested, 1 means soft sync (no reset lengths), 2 means hard (reset lengths)

  118. 	unsigned int lightRefreshCounter = 0;

  119. 	float resetLight = 0.0f;

  120. 	int sequenceKnob = 0;

  121. 	Trigger modesTrigger;

  122. 	Trigger stepTriggers[64];

  123. 	Trigger copyTrigger;

  124. 	Trigger pasteTrigger;

  125. 	Trigger runningTrigger;

  126. 	Trigger clockTrigger;

  127. 	Trigger resetTrigger;

  128. 	Trigger writeTrigger;

  129. 	Trigger write0Trigger;

  130. 	Trigger write1Trigger;

  131. 	Trigger stepLTrigger;

  132. 	Trigger gModeTriggers[8];

  133. 	Trigger probTrigger;

  134. 	Trigger seqCVTrigger;

  135. 	BooleanTrigger editingSequenceTrigger;

  136. 	HoldDetect modeHoldDetect;

  137. 	SeqAttributesGS seqAttribBuffer[MAX_SEQS];// buffer from Json for thread safety

  138. 

  139. 	

  140. 	inline bool isEditingSequence(void) {return params[EDIT_PARAM].value > 0.5f;}

  141. 	inline int getStepConfig(float paramValue) {// 1 = 4x16 = 0.0f,  2 = 2x32 = 1.0f,  4 = 1x64 = 2.0f

  142. 		if (paramValue < 0.5f) return 1;

  143. 		else if (paramValue < 1.5f) return 2;

  144. 		return 4;

  145. 	}

  146. 	

  147. 	inline int getAdvGateGS(int ppqnCount, int pulsesPerStep, int gateMode) { 

  148. 		uint32_t shiftAmt = ppqnCount * (24 / pulsesPerStep);

  149. 		return (int)((advGateHitMaskGS[gateMode] >> shiftAmt) & (uint32_t)0x1);

  150. 	}	

  151. 	inline int calcGateCode(StepAttributesGS attribute, int ppqnCount, int pulsesPerStep) {

  152. 		// -1 = gate off for whole step, 0 = gate off for current ppqn, 1 = gate on, 2 = clock high

  153. 		if (ppqnCount == 0 && attribute.getGateP() && !(randomUniform() < ((float)(attribute.getGatePVal())/100.0f)))// randomUniform is [0.0, 1.0), see include/util/common.hpp

  154. 			return -1;

  155. 		if (!attribute.getGate())

  156. 			return 0;

  157. 		if (pulsesPerStep == 1)

  158. 			return 2;// clock high

  159. 		return getAdvGateGS(ppqnCount, pulsesPerStep, attribute.getGateMode());

  160. 	}		

  161. 	inline void fillStepIndexRunVector(int runMode, int len) {

  162. 		if (runMode != MODE_RN2) {

  163. 			stepIndexRun[1] = stepIndexRun[0];

  164. 			stepIndexRun[2] = stepIndexRun[0];

  165. 			stepIndexRun[3] = stepIndexRun[0];

  166. 		}

  167. 		else {

  168. 			stepIndexRun[1] = randomu32() % len;

  169. 			stepIndexRun[2] = randomu32() % len;

  170. 			stepIndexRun[3] = randomu32() % len;

  171. 		}

  172. 	}

  173. 	inline bool ppsRequirementMet(int gateButtonIndex) {

  174. 		return !( (pulsesPerStep < 2) || (pulsesPerStep == 4 && gateButtonIndex > 2) || (pulsesPerStep == 6 && gateButtonIndex <= 2) ); 

  175. 	}

  176. 		

  177. 	GateSeq64() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {

  178. 		for (int i = 0; i < MAX_SEQS; i++)

  179. 			seqAttribBuffer[i].init(16, MODE_FWD);

  180. 		onReset();

  181. 	}

  182. 

  183. 	

  184. 	void onReset() override {

  185. 		stepConfig = getStepConfig(CONFIG_PARAM_INIT_VALUE);

  186. 		autoseq = false;

  187. 		seqCVmethod = 0;

  188. 		pulsesPerStep = 1;

  189. 		running = true;

  190. 		runModeSong = MODE_FWD;

  191. 		stepIndexEdit = 0;

  192. 		phraseIndexEdit = 0;

  193. 		sequence = 0;

  194. 		phrases = 4;

  195. 		for (int i = 0; i < MAX_SEQS; i++) {

  196. 			for (int s = 0; s < 64; s++) {

  197. 				attributes[i][s].init();

  198. 			}

  199. 			sequences[i].init(16 * stepConfig, MODE_FWD);

  200. 		}

  201. 		for (int i = 0; i < 64; i++) {

  202. 			phrase[i] = 0;

  203. 			attribCPbuffer[i].init();

  204. 			phraseCPbuffer[i] = 0;

  205. 		}

  206. 		initRun();

  207. 		seqAttribCPbuffer.init(16, MODE_FWD);

  208. 		seqCopied = true;

  209. 		countCP = 64;

  210. 		startCP = 0;

  211. 		displayState = DISP_GATE;

  212. 		displayProbInfo = 0l;

  213. 		infoCopyPaste = 0l;

  214. 		revertDisplay = 0l;

  215. 		resetOnRun = false;

  216. 		editingPpqn = 0l;

  217. 		blinkCount = 0l;

  218. 		blinkNum = blinkNumInit;

  219. 		editingPhraseSongRunning = 0l;

  220. 		clockIgnoreOnReset = (long) (clockIgnoreOnResetDuration * engineGetSampleRate());

  221. 	}

  222. 

  223. 	

  224. 	void onRandomize() override {

  225. 		// stepConfig = getStepConfig(params[CONFIG_PARAM].value);

  226. 		// runModeSong = randomu32() % 5;

  227. 		// stepIndexEdit = 0;

  228. 		// phraseIndexEdit = 0;

  229. 		// sequence = randomu32() % MAX_SEQS;

  230. 		// phrases = 1 + (randomu32() % 64);

  231. 		// for (int i = 0; i < MAX_SEQS; i++) {

  232. 			// for (int s = 0; s < 64; s++) {

  233. 				// attributes[i][s].randomize();

  234. 			// }

  235. 			// sequences[i].randomize(16 * stepConfig, NUM_MODES);

  236. 		// }

  237. 		// for (int i = 0; i < 64; i++)

  238. 			// phrase[i] = randomu32() % MAX_SEQS;

  239. 		// initRun();

  240. 		if (isEditingSequence()) {

  241. 			for (int s = 0; s < 64; s++) {

  242. 				attributes[sequence][s].randomize();

  243. 			}

  244. 			sequences[sequence].randomize(16 * stepConfig, NUM_MODES);// ok to use stepConfig since CONFIG_PARAM is not randomizable		

  245. 		}

  246. 	}

  247. 

  248. 

  249. 	void initRun() {// run button activated or run edge in run input jack

  250. 		phraseIndexRun = (runModeSong == MODE_REV ? phrases - 1 : 0);

  251. 		phraseIndexRunHistory = 0;

  252. 

  253. 		int seq = (isEditingSequence() ? sequence : phrase[phraseIndexRun]);

  254. 		stepIndexRun[0] = (sequences[seq].getRunMode() == MODE_REV ? sequences[seq].getLength() - 1 : 0);

  255. 		fillStepIndexRunVector(sequences[seq].getRunMode(), sequences[seq].getLength());

  256. 		stepIndexRunHistory = 0;

  257. 

  258. 		ppqnCount = 0;

  259. 		for (int i = 0; i < 4; i += stepConfig)

  260. 			gateCode[i] = calcGateCode(attributes[seq][(i * 16) + stepIndexRun[i]], 0, pulsesPerStep);

  261. 	}

  262. 	

  263. 	

  264. 	json_t *toJson() override {

  265. 		json_t *rootJ = json_object();

  266. 

  267. 		// panelTheme

  268. 		json_object_set_new(rootJ, "panelTheme", json_integer(panelTheme));

  269. 

  270. 		// expansion

  271. 		json_object_set_new(rootJ, "expansion", json_integer(expansion));

  272. 

  273. 		// autoseq

  274. 		json_object_set_new(rootJ, "autoseq", json_boolean(autoseq));

  275. 		

  276. 		// seqCVmethod

  277. 		json_object_set_new(rootJ, "seqCVmethod", json_integer(seqCVmethod));

  278. 

  279. 		// pulsesPerStep

  280. 		json_object_set_new(rootJ, "pulsesPerStep", json_integer(pulsesPerStep));

  281. 

  282. 		// running

  283. 		json_object_set_new(rootJ, "running", json_boolean(running));

  284. 		

  285. 		// runModeSong

  286. 		json_object_set_new(rootJ, "runModeSong3", json_integer(runModeSong));

  287. 

  288. 		// sequence

  289. 		json_object_set_new(rootJ, "sequence", json_integer(sequence));

  290. 

  291. 		// phrase 

  292. 		json_t *phraseJ = json_array();

  293. 		for (int i = 0; i < 64; i++)

  294. 			json_array_insert_new(phraseJ, i, json_integer(phrase[i]));

  295. 		json_object_set_new(rootJ, "phrase2", phraseJ);// "2" appended so no break patches

  296. 

  297. 		// phrases

  298. 		json_object_set_new(rootJ, "phrases", json_integer(phrases));

  299. 

  300. 		// attributes

  301. 		json_t *attributesJ = json_array();

  302. 		for (int i = 0; i < MAX_SEQS; i++)

  303. 			for (int s = 0; s < 64; s++) {

  304. 				json_array_insert_new(attributesJ, s + (i * 64), json_integer(attributes[i][s].getAttribute()));

  305. 			}

  306. 		json_object_set_new(rootJ, "attributes2", attributesJ);// "2" appended so no break patches

  307. 		

  308. 		// resetOnRun

  309. 		json_object_set_new(rootJ, "resetOnRun", json_boolean(resetOnRun));

  310. 		

  311. 		// stepIndexEdit

  312. 		json_object_set_new(rootJ, "stepIndexEdit", json_integer(stepIndexEdit));

  313. 	

  314. 		// phraseIndexEdit

  315. 		json_object_set_new(rootJ, "phraseIndexEdit", json_integer(phraseIndexEdit));

  316. 		

  317. 		// sequences

  318. 		json_t *sequencesJ = json_array();

  319. 		for (int i = 0; i < MAX_SEQS; i++)

  320. 			json_array_insert_new(sequencesJ, i, json_integer(sequences[i].getSeqAttrib()));

  321. 		json_object_set_new(rootJ, "sequences", sequencesJ);

  322. 

  323. 		return rootJ;

  324. 	}

  325. 

  326. 	

  327. 	void fromJson(json_t *rootJ) override {

  328. 		// panelTheme

  329. 		json_t *panelThemeJ = json_object_get(rootJ, "panelTheme");

  330. 		if (panelThemeJ)

  331. 			panelTheme = json_integer_value(panelThemeJ);

  332. 		

  333. 		// expansion

  334. 		json_t *expansionJ = json_object_get(rootJ, "expansion");

  335. 		if (expansionJ)

  336. 			expansion = json_integer_value(expansionJ);

  337. 

  338. 		// autoseq

  339. 		json_t *autoseqJ = json_object_get(rootJ, "autoseq");

  340. 		if (autoseqJ)

  341. 			autoseq = json_is_true(autoseqJ);

  342. 

  343. 		// seqCVmethod

  344. 		json_t *seqCVmethodJ = json_object_get(rootJ, "seqCVmethod");

  345. 		if (seqCVmethodJ)

  346. 			seqCVmethod = json_integer_value(seqCVmethodJ);

  347. 

  348. 		// pulsesPerStep

  349. 		json_t *pulsesPerStepJ = json_object_get(rootJ, "pulsesPerStep");

  350. 		if (pulsesPerStepJ)

  351. 			pulsesPerStep = json_integer_value(pulsesPerStepJ);

  352. 

  353. 		// running

  354. 		json_t *runningJ = json_object_get(rootJ, "running");

  355. 		if (runningJ)

  356. 			running = json_is_true(runningJ);

  357. 		

  358. 		

  359. 		// sequences

  360. 		json_t *sequencesJ = json_object_get(rootJ, "sequences");

  361. 		if (sequencesJ) {

  362. 			for (int i = 0; i < MAX_SEQS; i++)

  363. 			{

  364. 				json_t *sequencesArrayJ = json_array_get(sequencesJ, i);

  365. 				if (sequencesArrayJ)

  366. 					seqAttribBuffer[i].setSeqAttrib(json_integer_value(sequencesArrayJ));

  367. 			}			

  368. 		}

  369. 		else {// legacy

  370. 			int lengths[16];// 1 to 16

  371. 			int runModeSeq[16]; 

  372. 		

  373. 			// runModeSeq

  374. 			json_t *runModeSeqJ = json_object_get(rootJ, "runModeSeq3");

  375. 			if (runModeSeqJ) {

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

  377. 				{

  378. 					json_t *runModeSeqArrayJ = json_array_get(runModeSeqJ, i);

  379. 					if (runModeSeqArrayJ)

  380. 						runModeSeq[i] = json_integer_value(runModeSeqArrayJ);

  381. 				}			

  382. 			}		

  383. 			else {// legacy

  384. 				runModeSeqJ = json_object_get(rootJ, "runModeSeq2");

  385. 				if (runModeSeqJ) {

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

  387. 					{

  388. 						json_t *runModeSeqArrayJ = json_array_get(runModeSeqJ, i);

  389. 						if (runModeSeqArrayJ) {

  390. 							runModeSeq[i] = json_integer_value(runModeSeqArrayJ);

  391. 							if (runModeSeq[i] >= MODE_PEN)// this mode was not present in version runModeSeq2

  392. 								runModeSeq[i]++;

  393. 						}

  394. 					}			

  395. 				}		

  396. 			}

  397. 			// lengths

  398. 			json_t *lengthsJ = json_object_get(rootJ, "lengths");

  399. 			if (lengthsJ) {

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

  401. 				{

  402. 					json_t *lengthsArrayJ = json_array_get(lengthsJ, i);

  403. 					if (lengthsArrayJ)

  404. 						lengths[i] = json_integer_value(lengthsArrayJ);

  405. 				}			

  406. 			}

  407. 			

  408. 			// now write into new object

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

  410. 					seqAttribBuffer[i].init(lengths[i], runModeSeq[i]);

  411. 			for (int i = 16; i < MAX_SEQS; i++)

  412. 					seqAttribBuffer[i].init(16, MODE_FWD);

  413. 		}

  414. 		

  415. 		

  416. 		// runModeSong

  417. 		json_t *runModeSongJ = json_object_get(rootJ, "runModeSong3");

  418. 		if (runModeSongJ)

  419. 			runModeSong = json_integer_value(runModeSongJ);

  420. 		else {// legacy

  421. 			runModeSongJ = json_object_get(rootJ, "runModeSong");

  422. 			if (runModeSongJ) {

  423. 				runModeSong = json_integer_value(runModeSongJ);

  424. 				if (runModeSong >= MODE_PEN)// this mode was not present in original version

  425. 					runModeSong++;

  426. 			}

  427. 		}

  428. 		

  429. 		// sequence

  430. 		json_t *sequenceJ = json_object_get(rootJ, "sequence");

  431. 		if (sequenceJ)

  432. 			sequence = json_integer_value(sequenceJ);

  433. 		

  434. 		// phrase

  435. 		json_t *phraseJ = json_object_get(rootJ, "phrase2");// "2" appended so no break patches

  436. 		if (phraseJ) {

  437. 			for (int i = 0; i < 64; i++)

  438. 			{

  439. 				json_t *phraseArrayJ = json_array_get(phraseJ, i);

  440. 				if (phraseArrayJ)

  441. 					phrase[i] = json_integer_value(phraseArrayJ);

  442. 			}

  443. 		}

  444. 		else {// legacy

  445. 			phraseJ = json_object_get(rootJ, "phrase");

  446. 			if (phraseJ) {

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

  448. 				{

  449. 					json_t *phraseArrayJ = json_array_get(phraseJ, i);

  450. 					if (phraseArrayJ)

  451. 						phrase[i] = json_integer_value(phraseArrayJ);

  452. 				}

  453. 				for (int i = 16; i < 64; i++)

  454. 					phrase[i] = 0;

  455. 			}

  456. 		}

  457. 		

  458. 		// phrases

  459. 		json_t *phrasesJ = json_object_get(rootJ, "phrases");

  460. 		if (phrasesJ)

  461. 			phrases = json_integer_value(phrasesJ);

  462. 	

  463. 		// attributes

  464. 		json_t *attributesJ = json_object_get(rootJ, "attributes2");

  465. 		if (attributesJ) {

  466. 			for (int i = 0; i < MAX_SEQS; i++)

  467. 				for (int s = 0; s < 64; s++) {

  468. 					json_t *attributesArrayJ = json_array_get(attributesJ, s + (i * 64));

  469. 					if (attributesArrayJ)

  470. 						attributes[i][s].setAttribute((unsigned short)json_integer_value(attributesArrayJ));

  471. 				}

  472. 		}

  473. 		else {

  474. 			attributesJ = json_object_get(rootJ, "attributes");

  475. 			if (attributesJ) {

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

  477. 					for (int s = 0; s < 64; s++) {

  478. 						json_t *attributesArrayJ = json_array_get(attributesJ, s + (i * 64));

  479. 						if (attributesArrayJ)

  480. 							attributes[i][s].setAttribute((unsigned short)json_integer_value(attributesArrayJ));

  481. 					}

  482. 				}

  483. 				for (int i = 16; i < MAX_SEQS; i++) {

  484. 					for (int s = 0; s < 64; s++)

  485. 						attributes[i][s].init();

  486. 				}

  487. 			}

  488. 		}

  489. 		

  490. 		// resetOnRun

  491. 		json_t *resetOnRunJ = json_object_get(rootJ, "resetOnRun");

  492. 		if (resetOnRunJ)

  493. 			resetOnRun = json_is_true(resetOnRunJ);

  494. 

  495. 		// stepIndexEdit

  496. 		json_t *stepIndexEditJ = json_object_get(rootJ, "stepIndexEdit");

  497. 		if (stepIndexEditJ)

  498. 			stepIndexEdit = json_integer_value(stepIndexEditJ);

  499. 		

  500. 		// phraseIndexEdit

  501. 		json_t *phraseIndexEditJ = json_object_get(rootJ, "phraseIndexEdit");

  502. 		if (phraseIndexEditJ)

  503. 			phraseIndexEdit = json_integer_value(phraseIndexEditJ);

  504. 		

  505. 		stepConfigSync = 1;// signal a sync from fromJson so that step will get lengths from seqAttribBuffer

  506. 	}

  507. 

  508. 	

  509. 	void step() override {

  510. 		static const float displayProbInfoTime = 3.0f;// seconds

  511. 		static const float revertDisplayTime = 0.7f;// seconds

  512. 		static const float holdDetectTime = 2.0f;// seconds

  513. 		static const float editingPhraseSongRunningTime = 4.0f;// seconds

  514. 		static const float editingPpqnTime = 3.5f;// seconds

  515. 		float sampleRate = engineGetSampleRate();

  516. 		

  517. 

  518. 		

  519. 		//********** Buttons, knobs, switches and inputs **********

  520. 

  521. 		// Edit mode		

  522. 		bool editingSequence = isEditingSequence();// true = editing sequence, false = editing song

  523. 		

  524. 		// Run state button

  525. 		if (runningTrigger.process(params[RUN_PARAM].value + inputs[RUNCV_INPUT].value)) {// no input refresh here, don't want to introduce startup skew

  526. 			running = !running;

  527. 			if (running) {

  528. 				if (resetOnRun)

  529. 					initRun();

  530. 				if (resetOnRun || clockIgnoreOnRun)

  531. 					clockIgnoreOnReset = (long) (clockIgnoreOnResetDuration * sampleRate);

  532. 			}

  533. 			else

  534. 				blinkNum = blinkNumInit;

  535. 			displayState = DISP_GATE;

  536. 		}

  537. 		

  538. 		if ((lightRefreshCounter & userInputsStepSkipMask) == 0) {

  539. 			

  540. 			// Edit mode blink when change

  541. 			if (editingSequenceTrigger.process(editingSequence))

  542. 				blinkNum = blinkNumInit;

  543. 

  544. 			// Config switch

  545. 			if (stepConfigSync != 0) {

  546. 				stepConfig = getStepConfig(params[CONFIG_PARAM].value);

  547. 				if (stepConfigSync == 1) {// sync from fromJson, so read lengths from seqAttribBuffer

  548. 					for (int i = 0; i < MAX_SEQS; i++)

  549. 						sequences[i].setSeqAttrib(seqAttribBuffer[i].getSeqAttrib());

  550. 				}

  551. 				else if (stepConfigSync == 2) {// sync from a real mouse drag event on the switch itself, so init lengths

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

  553. 						sequences[i].setLength(16 * stepConfig);

  554. 				}

  555. 				initRun();	

  556. 				stepConfigSync = 0;

  557. 			}

  558. 			

  559. 			// Seq CV input

  560. 			if (inputs[SEQCV_INPUT].active) {

  561. 				if (seqCVmethod == 0) {// 0-10 V

  562. 					int newSeq = (int)( inputs[SEQCV_INPUT].value * (((float)MAX_SEQS) - 1.0f) / 10.0f + 0.5f );

  563. 					sequence = clamp(newSeq, 0, MAX_SEQS - 1);

  564. 				}

  565. 				else if (seqCVmethod == 1) {// C4-G6

  566. 					int newSeq = (int)( (inputs[SEQCV_INPUT].value) * 12.0f + 0.5f );

  567. 					sequence = clamp(newSeq, 0, MAX_SEQS - 1);

  568. 				}

  569. 				else {// TrigIncr

  570. 					if (seqCVTrigger.process(inputs[SEQCV_INPUT].value))

  571. 						sequence = clamp(sequence + 1, 0, MAX_SEQS - 1);

  572. 				}	

  573. 			}

  574. 			

  575. 			// Copy button

  576. 			if (copyTrigger.process(params[COPY_PARAM].value)) {

  577. 				startCP = editingSequence ? stepIndexEdit : phraseIndexEdit;

  578. 				countCP = 64;

  579. 				if (params[CPMODE_PARAM].value > 1.5f)// ALL

  580. 					startCP = 0;			

  581. 				else if (params[CPMODE_PARAM].value < 0.5f)// 4

  582. 					countCP = min(4, 64 - startCP);

  583. 				else// 8

  584. 					countCP = min(8, 64 - startCP);

  585. 				if (editingSequence) {	

  586. 					for (int i = 0, s = startCP; i < countCP; i++, s++)

  587. 						attribCPbuffer[i] = attributes[sequence][s];

  588. 					seqAttribCPbuffer.setSeqAttrib(sequences[sequence].getSeqAttrib());

  589. 					seqCopied = true;

  590. 				}

  591. 				else {

  592. 					for (int i = 0, p = startCP; i < countCP; i++, p++)

  593. 						phraseCPbuffer[i] = phrase[p];

  594. 					seqCopied = false;// so that a cross paste can be detected

  595. 				}

  596. 				infoCopyPaste = (long) (revertDisplayTime * sampleRate / displayRefreshStepSkips);

  597. 				displayState = DISP_GATE;

  598. 				blinkNum = blinkNumInit;

  599. 			}

  600. 			// Paste button

  601. 			if (pasteTrigger.process(params[PASTE_PARAM].value)) {

  602. 				infoCopyPaste = (long) (-1 * revertDisplayTime * sampleRate / displayRefreshStepSkips);

  603. 				startCP = 0;

  604. 				if (countCP <= 8) {

  605. 					startCP = editingSequence ? stepIndexEdit : phraseIndexEdit;

  606. 					countCP = min(countCP, 64 - startCP);

  607. 				}

  608. 				// else nothing to do for ALL

  609. 					

  610. 				if (editingSequence) {

  611. 					if (seqCopied) {// non-crossed paste (seq vs song)

  612. 						for (int i = 0, s = startCP; i < countCP; i++, s++)

  613. 							attributes[sequence][s] = attribCPbuffer[i];

  614. 						if (params[CPMODE_PARAM].value > 1.5f) {// all

  615. 							sequences[sequence].setSeqAttrib(seqAttribCPbuffer.getSeqAttrib());

  616. 							if (sequences[sequence].getLength() > 16 * stepConfig)

  617. 								sequences[sequence].setLength(16 * stepConfig);

  618. 						}

  619. 					}

  620. 					else {// crossed paste to seq (seq vs song)

  621. 						if (params[CPMODE_PARAM].value > 1.5f) { // ALL (init steps)

  622. 							for (int s = 0; s < 64; s++)

  623. 								attributes[sequence][s].init();

  624. 						}

  625. 						else if (params[CPMODE_PARAM].value < 0.5f) {// 4 (randomize gates)

  626. 							for (int s = 0; s < 64; s++)

  627. 								if ( (randomu32() & 0x1) != 0)

  628. 									attributes[sequence][s].toggleGate();

  629. 						}

  630. 						else {// 8 (randomize probs)

  631. 							for (int s = 0; s < 64; s++) {

  632. 								attributes[sequence][s].setGateP((randomu32() & 0x1) != 0);

  633. 								attributes[sequence][s].setGatePVal(randomu32() % 101);

  634. 							}

  635. 						}

  636. 						startCP = 0;

  637. 						countCP = 64;

  638. 						infoCopyPaste *= 2l;

  639. 					}

  640. 				}

  641. 				else {// song

  642. 					if (!seqCopied) {// non-crossed paste (seq vs song)

  643. 						for (int i = 0, p = startCP; i < countCP; i++, p++)

  644. 							phrase[p] = phraseCPbuffer[i] & 0xF;

  645. 					}

  646. 					else {// crossed paste to song (seq vs song)

  647. 						if (params[CPMODE_PARAM].value > 1.5f) { // ALL (init phrases)

  648. 							for (int p = 0; p < 64; p++)

  649. 								phrase[p] = 0;

  650. 						}

  651. 						else if (params[CPMODE_PARAM].value < 0.5f) {// 4 (phrases increase from 1 to 64)

  652. 							for (int p = 0; p < 64; p++)

  653. 								phrase[p] = p;						

  654. 						}

  655. 						else {// 8 (randomize phrases)

  656. 							for (int p = 0; p < 64; p++)

  657. 								phrase[p] = randomu32() % 64;

  658. 						}

  659. 						startCP = 0;

  660. 						countCP = 64;

  661. 						infoCopyPaste *= 2l;

  662. 					}

  663. 				}

  664. 				displayState = DISP_GATE;

  665. 				blinkNum = blinkNumInit;

  666. 			}

  667. 			

  668. 			// Write CV inputs 

  669. 			bool writeTrig = writeTrigger.process(inputs[WRITE_INPUT].value);

  670. 			bool write0Trig = write0Trigger.process(inputs[WRITE0_INPUT].value);

  671. 			bool write1Trig = write1Trigger.process(inputs[WRITE1_INPUT].value);

  672. 			if (writeTrig || write0Trig || write1Trig) {

  673. 				if (editingSequence) {

  674. 					blinkNum = blinkNumInit;

  675. 					if (writeTrig) {// higher priority than write0 and write1

  676. 						if (inputs[PROB_INPUT].active) {

  677. 							attributes[sequence][stepIndexEdit].setGatePVal(clamp( (int)round(inputs[PROB_INPUT].value * 10.0f), 0, 100) );

  678. 							attributes[sequence][stepIndexEdit].setGateP(true);

  679. 						}

  680. 						else{

  681. 							attributes[sequence][stepIndexEdit].setGateP(false);

  682. 						}

  683. 						if (inputs[GATE_INPUT].active)

  684. 							attributes[sequence][stepIndexEdit].setGate(inputs[GATE_INPUT].value >= 1.0f);

  685. 					}

  686. 					else {// write1 or write0			

  687. 						attributes[sequence][stepIndexEdit].setGate(write1Trig);

  688. 					}

  689. 					// Autostep (after grab all active inputs)

  690. 					stepIndexEdit = moveIndex(stepIndexEdit, stepIndexEdit + 1, 64);

  691. 					if (stepIndexEdit == 0 && autoseq && !inputs[SEQCV_INPUT].active)

  692. 						sequence = moveIndex(sequence, sequence + 1, MAX_SEQS);			

  693. 				}

  694. 			}

  695. 

  696. 			// Step left CV input

  697. 			if (stepLTrigger.process(inputs[STEPL_INPUT].value)) {

  698. 				if (editingSequence) {

  699. 					blinkNum = blinkNumInit;

  700. 					stepIndexEdit = moveIndex(stepIndexEdit, stepIndexEdit - 1, 64);					

  701. 				}

  702. 			}

  703. 

  704. 			// Step LED button presses

  705. 			int stepPressed = -1;

  706. 			for (int i = 0; i < 64; i++) {

  707. 				if (stepTriggers[i].process(params[STEP_PARAMS + i].value))

  708. 					stepPressed = i;

  709. 			}		

  710. 			if (stepPressed != -1) {

  711. 				if (editingSequence) {

  712. 					if (displayState == DISP_LENGTH) {

  713. 						sequences[sequence].setLength(stepPressed % (16 * stepConfig) + 1);

  714. 						revertDisplay = (long) (revertDisplayTime * sampleRate / displayRefreshStepSkips);

  715. 					}

  716. 					else if (displayState == DISP_MODES) {

  717. 					}

  718. 					else {

  719. 						if (params[STEP_PARAMS + stepPressed].value > 1.5f) {// right button click

  720. 							attributes[sequence][stepPressed].setGate(false);

  721. 							displayProbInfo = 0l;

  722. 						}

  723. 						else if (!attributes[sequence][stepPressed].getGate()) {// clicked inactive, so turn gate on

  724. 							attributes[sequence][stepPressed].setGate(true);

  725. 							if (attributes[sequence][stepPressed].getGateP())

  726. 								displayProbInfo = (long) (displayProbInfoTime * sampleRate / displayRefreshStepSkips);

  727. 							else

  728. 								displayProbInfo = 0l;

  729. 						}

  730. 						else {// clicked active

  731. 							if (stepIndexEdit == stepPressed && blinkNum != 0) {// only if coming from current step, turn off

  732. 								attributes[sequence][stepPressed].setGate(false);

  733. 								displayProbInfo = 0l;

  734. 							}

  735. 							else {

  736. 								if (attributes[sequence][stepPressed].getGateP())

  737. 									displayProbInfo = (long) (displayProbInfoTime * sampleRate / displayRefreshStepSkips);

  738. 								else

  739. 									displayProbInfo = 0l;

  740. 							}

  741. 						}

  742. 						stepIndexEdit = stepPressed;

  743. 					}

  744. 					blinkNum = blinkNumInit;

  745. 				}

  746. 				else {// editing song

  747. 					if (displayState == DISP_LENGTH) {

  748. 						phrases = stepPressed + 1;

  749. 						if (phrases > 64) phrases = 64;

  750. 						if (phrases < 1 ) phrases = 1;

  751. 						revertDisplay = (long) (revertDisplayTime * sampleRate / displayRefreshStepSkips);

  752. 					}

  753. 					else if (displayState == DISP_MODES) {

  754. 					}

  755. 					else {

  756. 						phraseIndexEdit = stepPressed;

  757. 						if (running)

  758. 							editingPhraseSongRunning = (long) (editingPhraseSongRunningTime * sampleRate / displayRefreshStepSkips);

  759. 						else

  760. 							phraseIndexRun = stepPressed;

  761. 					}

  762. 				}

  763. 			}

  764. 

  765. 			// Mode/Length button

  766. 			if (modesTrigger.process(params[MODES_PARAM].value)) {

  767. 				blinkNum = blinkNumInit;

  768. 				if (editingPpqn != 0l)

  769. 					editingPpqn = 0l;			

  770. 				if (displayState == DISP_GATE)

  771. 					displayState = DISP_LENGTH;

  772. 				else if (displayState == DISP_LENGTH)

  773. 					displayState = DISP_MODES;

  774. 				else

  775. 					displayState = DISP_GATE;

  776. 				modeHoldDetect.start((long) (holdDetectTime * sampleRate / displayRefreshStepSkips));

  777. 			}

  778. 

  779. 			// Prob button

  780. 			if (probTrigger.process(params[PROB_PARAM].value)) {

  781. 				blinkNum = blinkNumInit;

  782. 				if (editingSequence && attributes[sequence][stepIndexEdit].getGate()) {

  783. 					if (attributes[sequence][stepIndexEdit].getGateP()) {

  784. 						displayProbInfo = 0l;

  785. 						attributes[sequence][stepIndexEdit].setGateP(false);

  786. 					}

  787. 					else {

  788. 						displayProbInfo = (long) (displayProbInfoTime * sampleRate / displayRefreshStepSkips);

  789. 						attributes[sequence][stepIndexEdit].setGateP(true);

  790. 					}

  791. 				}

  792. 			}

  793. 			

  794. 			// GateMode buttons

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

  796. 				if (gModeTriggers[i].process(params[GMODE_PARAMS + i].value)) {

  797. 					blinkNum = blinkNumInit;

  798. 					if (editingSequence && attributes[sequence][stepIndexEdit].getGate()) {

  799. 						if (ppsRequirementMet(i)) {

  800. 							editingPpqn = 0l;

  801. 							attributes[sequence][stepIndexEdit].setGateMode(i);

  802. 						}

  803. 						else {

  804. 							editingPpqn = (long) (editingPpqnTime * sampleRate / displayRefreshStepSkips);

  805. 						}

  806. 					}

  807. 				}

  808. 			}

  809. 

  810. 			

  811. 			// Sequence knob (Main knob)

  812. 			float seqParamValue = params[SEQUENCE_PARAM].value;

  813. 			int newSequenceKnob = (int)roundf(seqParamValue * 7.0f);

  814. 			if (seqParamValue == 0.0f)// true when constructor or fromJson() occured

  815. 				sequenceKnob = newSequenceKnob;

  816. 			int deltaKnob = newSequenceKnob - sequenceKnob;

  817. 			if (deltaKnob != 0) {

  818. 				if (abs(deltaKnob) <= 3) {// avoid discontinuous step (initialize for example)

  819. 					if (displayProbInfo != 0l && editingSequence) {

  820. 						blinkNum = blinkNumInit;

  821. 						int pval = attributes[sequence][stepIndexEdit].getGatePVal();

  822. 						pval += deltaKnob * 2;

  823. 						if (pval > 100)

  824. 							pval = 100;

  825. 						if (pval < 0)

  826. 							pval = 0;

  827. 						attributes[sequence][stepIndexEdit].setGatePVal(pval);

  828. 						displayProbInfo = (long) (displayProbInfoTime * sampleRate / displayRefreshStepSkips);

  829. 					}

  830. 					else if (editingPpqn != 0) {

  831. 						pulsesPerStep = indexToPpsGS(ppsToIndexGS(pulsesPerStep) + deltaKnob);// indexToPps() does clamping

  832. 						editingPpqn = (long) (editingPpqnTime * sampleRate / displayRefreshStepSkips);

  833. 					}

  834. 					else if (displayState == DISP_MODES) {

  835. 						if (editingSequence) {

  836. 							sequences[sequence].setRunMode(clamp(sequences[sequence].getRunMode() + deltaKnob, 0, NUM_MODES - 1));

  837. 						}

  838. 						else {

  839. 							runModeSong = clamp(runModeSong + deltaKnob, 0, 6 - 1);

  840. 						}

  841. 					}

  842. 					else if (displayState == DISP_LENGTH) {

  843. 						if (editingSequence) {

  844. 							sequences[sequence].setLength(clamp(sequences[sequence].getLength() + deltaKnob, 1, (16 * stepConfig)));

  845. 						}

  846. 						else {

  847. 							phrases = clamp(phrases + deltaKnob, 1, 64);

  848. 						}

  849. 					}

  850. 					else {

  851. 						if (editingSequence) {

  852. 							blinkNum = blinkNumInit;

  853. 							if (!inputs[SEQCV_INPUT].active) {

  854. 								sequence = clamp(sequence + deltaKnob, 0, MAX_SEQS - 1);

  855. 							}

  856. 						}

  857. 						else {

  858. 							if (editingPhraseSongRunning > 0l || !running) {

  859. 								int newPhrase = phrase[phraseIndexEdit] + deltaKnob;

  860. 								if (newPhrase < 0)

  861. 									newPhrase += (1 - newPhrase / MAX_SEQS) * MAX_SEQS;// newPhrase now positive

  862. 								newPhrase = newPhrase % MAX_SEQS;

  863. 								phrase[phraseIndexEdit] = newPhrase;

  864. 								if (running)

  865. 									editingPhraseSongRunning = (long) (editingPhraseSongRunningTime * sampleRate / displayRefreshStepSkips);

  866. 							}

  867. 						}	

  868. 					}					

  869. 				}

  870. 				sequenceKnob = newSequenceKnob;

  871. 			}		

  872. 		

  873. 		}// userInputs refresh

  874. 		

  875. 		

  876. 		

  877. 		//********** Clock and reset **********

  878. 		

  879. 		// Clock

  880. 		if (running && clockIgnoreOnReset == 0l) {

  881. 			if (clockTrigger.process(inputs[CLOCK_INPUT].value)) {

  882. 				ppqnCount++;

  883. 				if (ppqnCount >= pulsesPerStep)

  884. 					ppqnCount = 0;

  885. 				

  886. 				int newSeq = sequence;// good value when editingSequence, overwrite if not editingSequence

  887. 				if (ppqnCount == 0) {

  888. 					if (editingSequence) {

  889. 						moveIndexRunMode(&stepIndexRun[0], sequences[sequence].getLength(), sequences[sequence].getRunMode(), &stepIndexRunHistory);

  890. 					}

  891. 					else {

  892. 						if (moveIndexRunMode(&stepIndexRun[0], sequences[phrase[phraseIndexRun]].getLength(), sequences[phrase[phraseIndexRun]].getRunMode(), &stepIndexRunHistory)) {

  893. 							moveIndexRunMode(&phraseIndexRun, phrases, runModeSong, &phraseIndexRunHistory);

  894. 							stepIndexRun[0] = (sequences[phrase[phraseIndexRun]].getRunMode() == MODE_REV ? sequences[phrase[phraseIndexRun]].getLength() - 1 : 0);// must always refresh after phraseIndexRun has changed

  895. 						}

  896. 						newSeq = phrase[phraseIndexRun];

  897. 					}

  898. 					fillStepIndexRunVector(sequences[newSeq].getRunMode(), sequences[newSeq].getLength());

  899. 				}

  900. 				else {

  901. 					if (!editingSequence)

  902. 						newSeq = phrase[phraseIndexRun];

  903. 				}

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

  905. 					if (gateCode[i] != -1 || ppqnCount == 0)

  906. 						gateCode[i] = calcGateCode(attributes[newSeq][(i * 16) + stepIndexRun[i]], ppqnCount, pulsesPerStep);

  907. 				}

  908. 			}

  909. 		}	

  910. 		

  911. 		// Reset

  912. 		if (resetTrigger.process(inputs[RESET_INPUT].value + params[RESET_PARAM].value)) {

  913. 			initRun();// must be before SEQCV_INPUT below

  914. 			resetLight = 1.0f;

  915. 			displayState = DISP_GATE;

  916. 			clockIgnoreOnReset = (long) (clockIgnoreOnResetDuration * sampleRate);

  917. 			clockTrigger.reset();

  918. 			if (inputs[SEQCV_INPUT].active && seqCVmethod == 2)

  919. 				sequence = 0;

  920. 		}

  921. 	

  922. 		

  923. 		//********** Outputs and lights **********

  924. 				

  925. 		// Gate outputs

  926. 		if (running) {

  927. 			bool retriggingOnReset = (clockIgnoreOnReset != 0l && retrigGatesOnReset);

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

  929. 				outputs[GATE_OUTPUTS + i].value = (calcGate(gateCode[i], clockTrigger) && !retriggingOnReset)  ? 10.0f : 0.0f;

  930. 		}

  931. 		else {// not running (no gates, no need to hear anything)

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

  933. 				outputs[GATE_OUTPUTS + i].value = 0.0f;	

  934. 		}

  935. 

  936. 		lightRefreshCounter++;

  937. 		if (lightRefreshCounter >= displayRefreshStepSkips) {

  938. 			lightRefreshCounter = 0;

  939. 

  940. 			// Step LED button lights

  941. 			if (infoCopyPaste != 0l) {

  942. 				for (int i = 0; i < 64; i++) {

  943. 					if (i >= startCP && i < (startCP + countCP))

  944. 						setGreenRed3(STEP_LIGHTS + i * 3, 0.5f, 0.0f);

  945. 					else

  946. 						setGreenRed3(STEP_LIGHTS + i * 3, 0.0f, 0.0f);

  947. 				}

  948. 			}

  949. 			else {

  950. 				int row = -1;

  951. 				int col = -1;

  952. 				for (int i = 0; i < 64; i++) {

  953. 					row = i >> (3 + stepConfig);//i / (16 * stepConfig);// optimized (not equivalent code, but in this case has same effect)

  954. 					if (stepConfig == 2 && row == 1) 

  955. 						row++;

  956. 					col = (((stepConfig - 1) << 4) | 0xF) & i;//i % (16 * stepConfig);// optimized			

  957. 					if (editingSequence) {

  958. 						if (displayState == DISP_LENGTH) {

  959. 							if (col < (sequences[sequence].getLength() - 1))

  960. 								setGreenRed3(STEP_LIGHTS + i * 3, 0.1f, 0.0f);

  961. 							else if (col == (sequences[sequence].getLength() - 1))

  962. 								setGreenRed3(STEP_LIGHTS + i * 3, 1.0f, 0.0f);

  963. 							else 

  964. 								setGreenRed3(STEP_LIGHTS + i * 3, 0.0f, 0.0f);

  965. 						}

  966. 						else {

  967. 							float stepHereOffset = ((stepIndexRun[row] == col) && running) ? 0.5f : 1.0f;

  968. 							long blinkCountMarker = (long) (0.67f * sampleRate / displayRefreshStepSkips);							

  969. 							if (attributes[sequence][i].getGate()) {

  970. 								bool blinkEnableOn = (displayState != DISP_MODES) && (blinkCount < blinkCountMarker);

  971. 								if (attributes[sequence][i].getGateP()) {

  972. 									if (i == stepIndexEdit)// more orange than yellow

  973. 										setGreenRed3(STEP_LIGHTS + i * 3, blinkEnableOn ? 1.0f : 0.0f, blinkEnableOn ? 1.0f : 0.0f);

  974. 									else// more yellow

  975. 										setGreenRed3(STEP_LIGHTS + i * 3, stepHereOffset, stepHereOffset);

  976. 								}

  977. 								else {

  978. 									if (i == stepIndexEdit)

  979. 										setGreenRed3(STEP_LIGHTS + i * 3, blinkEnableOn ? 1.0f : 0.0f, 0.0f);

  980. 									else

  981. 										setGreenRed3(STEP_LIGHTS + i * 3, stepHereOffset, 0.0f);

  982. 								}

  983. 							}

  984. 							else {

  985. 								if (i == stepIndexEdit && blinkCount > blinkCountMarker && displayState != DISP_MODES)

  986. 									setGreenRed3(STEP_LIGHTS + i * 3, 0.05f, 0.0f);

  987. 								else

  988. 									setGreenRed3(STEP_LIGHTS + i * 3, ((stepIndexRun[row] == col) && running) ? 0.1f : 0.0f, 0.0f);

  989. 							}

  990. 						}

  991. 					}

  992. 					else {// editing Song

  993. 						if (displayState == DISP_LENGTH) {

  994. 							col = i & 0xF;//i % 16;// optimized

  995. 							if (i < (phrases - 1))

  996. 								setGreenRed3(STEP_LIGHTS + i * 3, 0.1f, 0.0f);

  997. 							else if (i == (phrases - 1))

  998. 								setGreenRed3(STEP_LIGHTS + i * 3, 1.0f, 0.0f);

  999. 							else 

  1000. 								setGreenRed3(STEP_LIGHTS + i * 3, 0.0f, 0.0f);

  1001. 						}

  1002. 						else {

  1003. 							float green = (i == (phraseIndexRun) && running) ? 1.0f : 0.0f;

  1004. 							float red = (i == (phraseIndexEdit) && ((editingPhraseSongRunning > 0l) || !running)) ? 1.0f : 0.0f;

  1005. 							green += ((running && (col == stepIndexRun[row]) && i != (phraseIndexEdit)) ? 0.1f : 0.0f);

  1006. 							setGreenRed3(STEP_LIGHTS + i * 3, clamp(green, 0.0f, 1.0f), red);

  1007. 							if (green == 0.0f && red == 0.0f && displayState != DISP_MODES){

  1008. 								lights[STEP_LIGHTS + i * 3 + 2].value = (attributes[phrase[phraseIndexRun]][i].getGate() ? 0.2f : 0.0f);

  1009. 								lights[STEP_LIGHTS + i * 3 + 2].value -= (attributes[phrase[phraseIndexRun]][i].getGateP() ? 0.18f : 0.0f);

  1010. 							}

  1011. 						}				

  1012. 					}

  1013. 				}

  1014. 			}

  1015. 			

  1016. 			// GateType lights

  1017. 			if (pulsesPerStep != 1 && editingSequence && attributes[sequence][stepIndexEdit].getGate()) {

  1018. 				if (editingPpqn != 0) {

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

  1020. 						if (ppsRequirementMet(i))

  1021. 							setGreenRed(GMODE_LIGHTS + i * 2, 1.0f, 0.0f);

  1022. 						else 

  1023. 							setGreenRed(GMODE_LIGHTS + i * 2, 0.0f, 0.0f);

  1024. 					}

  1025. 				}

  1026. 				else {		

  1027. 					int gmode = attributes[sequence][stepIndexEdit].getGateMode();

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

  1029. 						if (i == gmode) {

  1030. 							if ( (pulsesPerStep == 4 && i > 2) || (pulsesPerStep == 6 && i <= 2) ) // pps requirement not met

  1031. 								setGreenRed(GMODE_LIGHTS + i * 2, 0.0f, 1.0f);

  1032. 							else

  1033. 								setGreenRed(GMODE_LIGHTS + i * 2, 1.0f, 0.0f);

  1034. 						}

  1035. 						else

  1036. 							setGreenRed(GMODE_LIGHTS + i * 2, 0.0f, 0.0f);

  1037. 					}

  1038. 				}

  1039. 			}

  1040. 			else {

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

  1042. 					setGreenRed(GMODE_LIGHTS + i * 2, 0.0f, 0.0f);

  1043. 			}

  1044. 		

  1045. 			// Reset light

  1046. 			lights[RESET_LIGHT].value =	resetLight;	

  1047. 			resetLight -= (resetLight / lightLambda) * engineGetSampleTime() * displayRefreshStepSkips;

  1048. 

  1049. 			// Run lights

  1050. 			lights[RUN_LIGHT].value = running ? 1.0f : 0.0f;

  1051. 		

  1052. 			if (infoCopyPaste != 0l) {

  1053. 				if (infoCopyPaste > 0l)

  1054. 					infoCopyPaste --;

  1055. 				if (infoCopyPaste < 0l)

  1056. 					infoCopyPaste ++;

  1057. 			}

  1058. 			if (displayProbInfo > 0l)

  1059. 				displayProbInfo--;

  1060. 			if (modeHoldDetect.process(params[MODES_PARAM].value)) {

  1061. 				displayState = DISP_GATE;

  1062. 				editingPpqn = (long) (editingPpqnTime * sampleRate / displayRefreshStepSkips);

  1063. 			}

  1064. 			if (editingPpqn > 0l)

  1065. 				editingPpqn--;

  1066. 			if (editingPhraseSongRunning > 0l)

  1067. 				editingPhraseSongRunning--;

  1068. 			if (revertDisplay > 0l) {

  1069. 				if (revertDisplay == 1)

  1070. 					displayState = DISP_GATE;

  1071. 				revertDisplay--;

  1072. 			}

  1073. 			if (blinkNum > 0) {

  1074. 				blinkCount++;

  1075. 				if (blinkCount >= (long) (1.0f * sampleRate / displayRefreshStepSkips)) {

  1076. 					blinkCount = 0l;

  1077. 					blinkNum--;

  1078. 				}

  1079. 			}

  1080. 		}// lightRefreshCounter

  1081. 

  1082. 		if (clockIgnoreOnReset > 0l)

  1083. 			clockIgnoreOnReset--;

  1084. 

  1085. 	}// step()

  1086. 	

  1087. 	inline void setGreenRed(int id, float green, float red) {

  1088. 		lights[id + 0].value = green;

  1089. 		lights[id + 1].value = red;

  1090. 	}

  1091. 	inline void setGreenRed3(int id, float green, float red) {

  1092. 		setGreenRed(id, green, red);

  1093. 		lights[id + 2].value = 0.0f;

  1094. 	}

  1095. 

  1096. };// GateSeq64 : module

  1097. 

  1098. struct GateSeq64Widget : ModuleWidget {

  1099. 	GateSeq64 *module;

  1100. 	DynamicSVGPanel *panel;

  1101. 	int oldExpansion;

  1102. 	int expWidth = 60;

  1103. 	IMPort* expPorts[6];

  1104. 		

  1105. 	struct SequenceDisplayWidget : TransparentWidget {

  1106. 		GateSeq64 *module;

  1107. 		std::shared_ptr<Font> font;

  1108. 		char displayStr[4];

  1109. 		

  1110. 		SequenceDisplayWidget() {

  1111. 			font = Font::load(assetPlugin(plugin, "res/fonts/Segment14.ttf"));

  1112. 		}

  1113. 		

  1114. 		void runModeToStr(int num) {

  1115. 			if (num >= 0 && num < NUM_MODES)

  1116. 				snprintf(displayStr, 4, "%s", modeLabels[num].c_str());

  1117. 		}

  1118. 

  1119. 		void draw(NVGcontext *vg) override {

  1120. 			NVGcolor textColor = prepareDisplay(vg, &box, 18);

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

  1122. 			bool editingSequence = module->isEditingSequence();

  1123. 

  1124. 			Vec textPos = Vec(6, 24);

  1125. 			nvgFillColor(vg, nvgTransRGBA(textColor, displayAlpha));

  1126. 			nvgText(vg, textPos.x, textPos.y, "~~~", NULL);

  1127. 			nvgFillColor(vg, textColor);				

  1128. 			if (module->infoCopyPaste != 0l) {

  1129. 				if (module->infoCopyPaste > 0l)// if copy display "CPY"

  1130. 					snprintf(displayStr, 4, "CPY");

  1131. 				else {

  1132. 					float cpMode = module->params[GateSeq64::CPMODE_PARAM].value;

  1133. 					if (editingSequence && !module->seqCopied) {// cross paste to seq

  1134. 						if (cpMode > 1.5f)// All = init

  1135. 							snprintf(displayStr, 4, "CLR");

  1136. 						else if (cpMode < 0.5f)// 4 = random gate

  1137. 							snprintf(displayStr, 4, "RGT");

  1138. 						else// 8 = random probs

  1139. 							snprintf(displayStr, 4, "RPR");

  1140. 					}

  1141. 					else if (!editingSequence && module->seqCopied) {// cross paste to song

  1142. 						if (cpMode > 1.5f)// All = init

  1143. 							snprintf(displayStr, 4, "CLR");

  1144. 						else if (cpMode < 0.5f)// 4 = increase by 1

  1145. 							snprintf(displayStr, 4, "INC");

  1146. 						else// 8 = random phrases

  1147. 							snprintf(displayStr, 4, "RPH");

  1148. 					}

  1149. 					else

  1150. 						snprintf(displayStr, 4, "PST");

  1151. 				}

  1152. 			}

  1153. 			else if (module->displayProbInfo != 0l) {

  1154. 				int prob = module->attributes[module->sequence][module->stepIndexEdit].getGatePVal();

  1155. 				if ( prob>= 100)

  1156. 					snprintf(displayStr, 4, "1,0");

  1157. 				else if (prob >= 1)

  1158. 					snprintf(displayStr, 4, ",%02u", (unsigned) prob);

  1159. 				else

  1160. 					snprintf(displayStr, 4, "  0");

  1161. 			}

  1162. 			else if (module->editingPpqn != 0ul) {

  1163. 				snprintf(displayStr, 4, "x%2u", (unsigned) module->pulsesPerStep);

  1164. 			}

  1165. 			else if (module->displayState == GateSeq64::DISP_LENGTH) {

  1166. 				if (editingSequence)

  1167. 					snprintf(displayStr, 4, "L%2u", (unsigned) module->sequences[module->sequence].getLength());

  1168. 				else

  1169. 					snprintf(displayStr, 4, "L%2u", (unsigned) module->phrases);

  1170. 			}

  1171. 			else if (module->displayState == GateSeq64::DISP_MODES) {

  1172. 				if (editingSequence)

  1173. 					runModeToStr(module->sequences[module->sequence].getRunMode());

  1174. 				else

  1175. 					runModeToStr(module->runModeSong);

  1176. 			}

  1177. 			else {

  1178. 				int dispVal = 0;

  1179. 				char specialCode = ' ';

  1180. 				if (editingSequence)

  1181. 					dispVal = module->sequence;

  1182. 				else {

  1183. 					if (module->editingPhraseSongRunning > 0l || !module->running) {

  1184. 						dispVal = module->phrase[module->phraseIndexEdit];

  1185. 						if (module->editingPhraseSongRunning > 0l)

  1186. 							specialCode = '*';

  1187. 					}

  1188. 					else

  1189. 						dispVal = module->phrase[module->phraseIndexRun];

  1190. 				}

  1191. 				snprintf(displayStr, 4, "%c%2u", specialCode, (unsigned)(dispVal) + 1 );

  1192. 			}

  1193. 			nvgText(vg, textPos.x, textPos.y, displayStr, NULL);

  1194. 		}

  1195. 	};	

  1196. 		

  1197. 	struct PanelThemeItem : MenuItem {

  1198. 		GateSeq64 *module;

  1199. 		int theme;

  1200. 		void onAction(EventAction &e) override {

  1201. 			module->panelTheme = theme;

  1202. 		}

  1203. 		void step() override {

  1204. 			rightText = (module->panelTheme == theme) ? "✔" : "";

  1205. 		}

  1206. 	};

  1207. 	struct ExpansionItem : MenuItem {

  1208. 		GateSeq64 *module;

  1209. 		void onAction(EventAction &e) override {

  1210. 			module->expansion = module->expansion == 1 ? 0 : 1;

  1211. 		}

  1212. 	};

  1213. 	struct ResetOnRunItem : MenuItem {

  1214. 		GateSeq64 *module;

  1215. 		void onAction(EventAction &e) override {

  1216. 			module->resetOnRun = !module->resetOnRun;

  1217. 		}

  1218. 	};

  1219. 	struct AutoseqItem : MenuItem {

  1220. 		GateSeq64 *module;

  1221. 		void onAction(EventAction &e) override {

  1222. 			module->autoseq = !module->autoseq;

  1223. 		}

  1224. 	};

  1225. 	struct SeqCVmethodItem : MenuItem {

  1226. 		GateSeq64 *module;

  1227. 		void onAction(EventAction &e) override {

  1228. 			module->seqCVmethod++;

  1229. 			if (module->seqCVmethod > 2)

  1230. 				module->seqCVmethod = 0;

  1231. 		}

  1232. 		void step() override {

  1233. 			if (module->seqCVmethod == 0)

  1234. 				text = "Seq CV in: <0-10V>,  C4-G6,  Trig-Incr";

  1235. 			else if (module->seqCVmethod == 1)

  1236. 				text = "Seq CV in: 0-10V,  <C4-G6>,  Trig-Incr";

  1237. 			else

  1238. 				text = "Seq CV in: 0-10V,  C4-G6,  <Trig-Incr>";

  1239. 		}	

  1240. 	};

  1241. 	Menu *createContextMenu() override {

  1242. 		Menu *menu = ModuleWidget::createContextMenu();

  1243. 

  1244. 		MenuLabel *spacerLabel = new MenuLabel();

  1245. 		menu->addChild(spacerLabel);

  1246. 

  1247. 		GateSeq64 *module = dynamic_cast<GateSeq64*>(this->module);

  1248. 		assert(module);

  1249. 

  1250. 		MenuLabel *themeLabel = new MenuLabel();

  1251. 		themeLabel->text = "Panel Theme";

  1252. 		menu->addChild(themeLabel);

  1253. 

  1254. 		PanelThemeItem *lightItem = new PanelThemeItem();

  1255. 		lightItem->text = lightPanelID;// ImpromptuModular.hpp

  1256. 		lightItem->module = module;

  1257. 		lightItem->theme = 0;

  1258. 		menu->addChild(lightItem);

  1259. 

  1260. 		PanelThemeItem *darkItem = new PanelThemeItem();

  1261. 		darkItem->text = darkPanelID;// ImpromptuModular.hpp

  1262. 		darkItem->module = module;

  1263. 		darkItem->theme = 1;

  1264. 		menu->addChild(darkItem);

  1265. 

  1266. 		menu->addChild(new MenuLabel());// empty line

  1267. 		

  1268. 		MenuLabel *settingsLabel = new MenuLabel();

  1269. 		settingsLabel->text = "Settings";

  1270. 		menu->addChild(settingsLabel);

  1271. 		

  1272. 		ResetOnRunItem *rorItem = MenuItem::create<ResetOnRunItem>("Reset on run", CHECKMARK(module->resetOnRun));

  1273. 		rorItem->module = module;

  1274. 		menu->addChild(rorItem);

  1275. 		

  1276. 		AutoseqItem *aseqItem = MenuItem::create<AutoseqItem>("AutoSeq when writing via CV inputs", CHECKMARK(module->autoseq));

  1277. 		aseqItem->module = module;

  1278. 		menu->addChild(aseqItem);

  1279. 

  1280. 		SeqCVmethodItem *seqcvItem = MenuItem::create<SeqCVmethodItem>("Seq CV in: ", "");

  1281. 		seqcvItem->module = module;

  1282. 		menu->addChild(seqcvItem);

  1283. 		

  1284. 		menu->addChild(new MenuLabel());// empty line

  1285. 		

  1286. 		MenuLabel *expansionLabel = new MenuLabel();

  1287. 		expansionLabel->text = "Expansion module";

  1288. 		menu->addChild(expansionLabel);

  1289. 

  1290. 		ExpansionItem *expItem = MenuItem::create<ExpansionItem>(expansionMenuLabel, CHECKMARK(module->expansion != 0));

  1291. 		expItem->module = module;

  1292. 		menu->addChild(expItem);

  1293. 

  1294. 		return menu;

  1295. 	}	

  1296. 	

  1297. 	void step() override {

  1298. 		if(module->expansion != oldExpansion) {

  1299. 			if (oldExpansion!= -1 && module->expansion == 0) {// if just removed expansion panel, disconnect wires to those jacks

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

  1301. 					RACK_PLUGIN_UI_RACKWIDGET->wireContainer->removeAllWires(expPorts[i]);

  1302. 			}

  1303. 			oldExpansion = module->expansion;		

  1304. 		}

  1305. 		box.size.x = panel->box.size.x - (1 - module->expansion) * expWidth;

  1306. 		Widget::step();

  1307. 	}

  1308. 

  1309. 	struct CKSSThreeInvNotify : CKSSThreeInvNoRandom {// Not randomizable

  1310. 		CKSSThreeInvNotify() {}

  1311. 		void onDragStart(EventDragStart &e) override {

  1312. 			ToggleSwitch::onDragStart(e);

  1313. 			((GateSeq64*)(module))->stepConfigSync = 2;// signal a sync from switch so that steps get initialized

  1314. 		}	

  1315. 	};

  1316. 	

  1317. 	struct SequenceKnob : IMBigKnobInf {

  1318. 		SequenceKnob() {};		

  1319. 		void onMouseDown(EventMouseDown &e) override {// from ParamWidget.cpp

  1320. 			GateSeq64* module = dynamic_cast<GateSeq64*>(this->module);

  1321. 			if (e.button == 1) {

  1322. 				// same code structure below as in sequence knob in main step()

  1323. 				bool editingSequence = module->isEditingSequence();

  1324. 				if (module->displayProbInfo != 0l && editingSequence) {

  1325. 					//blinkNum = blinkNumInit;

  1326. 					module->attributes[module->sequence][module->stepIndexEdit].setGatePVal(50);

  1327. 					//displayProbInfo = (long) (displayProbInfoTime * sampleRate / displayRefreshStepSkips);

  1328. 				}

  1329. 				else if (module->editingPpqn != 0) {

  1330. 					module->pulsesPerStep = 1;

  1331. 					//editingPpqn = (long) (editingPpqnTime * sampleRate / displayRefreshStepSkips);

  1332. 				}

  1333. 				else if (module->displayState == GateSeq64::DISP_MODES) {

  1334. 					if (editingSequence) {

  1335. 						module->sequences[module->sequence].setRunMode(MODE_FWD);

  1336. 					}

  1337. 					else {

  1338. 						module->runModeSong = MODE_FWD;

  1339. 					}

  1340. 				}

  1341. 				else if (module->displayState == GateSeq64::DISP_LENGTH) {

  1342. 					if (editingSequence) {

  1343. 						module->sequences[module->sequence].setLength(16 * module->stepConfig);

  1344. 					}

  1345. 					else {

  1346. 						module->phrases = 4;

  1347. 					}

  1348. 				}

  1349. 				else {

  1350. 					if (editingSequence) {

  1351. 						//blinkNum = blinkNumInit;

  1352. 						if (!module->inputs[GateSeq64::SEQCV_INPUT].active) {

  1353. 							module->sequence = 0;

  1354. 						}

  1355. 					}

  1356. 					else {

  1357. 						if (module->editingPhraseSongRunning > 0l || !module->running) {

  1358. 							module->phrase[module->phraseIndexEdit] = 0;

  1359. 							// if (running)

  1360. 								// editingPhraseSongRunning = (long) (editingPhraseSongRunningTime * sampleRate / displayRefreshStepSkips);

  1361. 						}

  1362. 					}	

  1363. 				}			

  1364. 			}

  1365. 			ParamWidget::onMouseDown(e);

  1366. 		}

  1367. 	};			

  1368. 

  1369. 	GateSeq64Widget(GateSeq64 *module) : ModuleWidget(module) {		

  1370. 		this->module = module;

  1371. 		oldExpansion = -1;

  1372. 		

  1373. 		// Main panel from Inkscape

  1374.         panel = new DynamicSVGPanel();

  1375.         panel->mode = &module->panelTheme;

  1376. 		panel->expWidth = &expWidth;

  1377.         panel->addPanel(SVG::load(assetPlugin(plugin, "res/light/GateSeq64.svg")));

  1378.         panel->addPanel(SVG::load(assetPlugin(plugin, "res/dark/GateSeq64_dark.svg")));

  1379.         box.size = panel->box.size;

  1380. 		box.size.x = box.size.x - (1 - module->expansion) * expWidth;

  1381.         addChild(panel);		

  1382. 		

  1383. 		// Screws

  1384. 		addChild(createDynamicScrew<IMScrew>(Vec(15, 0), &module->panelTheme));

  1385. 		addChild(createDynamicScrew<IMScrew>(Vec(15, 365), &module->panelTheme));

  1386. 		addChild(createDynamicScrew<IMScrew>(Vec(panel->box.size.x-30, 0), &module->panelTheme));

  1387. 		addChild(createDynamicScrew<IMScrew>(Vec(panel->box.size.x-30, 365), &module->panelTheme));

  1388. 		addChild(createDynamicScrew<IMScrew>(Vec(panel->box.size.x-30-expWidth, 0), &module->panelTheme));

  1389. 		addChild(createDynamicScrew<IMScrew>(Vec(panel->box.size.x-30-expWidth, 365), &module->panelTheme));

  1390. 		

  1391. 		

  1392. 		// ****** Top portion (LED button array and gate type LED buttons) ******

  1393. 		

  1394. 		static const int rowRuler0 = 32;

  1395. 		static const int spacingRows = 32;

  1396. 		static const int colRulerSteps = 15;

  1397. 		static const int spacingSteps = 20;

  1398. 		static const int spacingSteps4 = 4;

  1399. 		

  1400. 		

  1401. 		// Step LED buttons and GateMode lights

  1402. 		for (int y = 0; y < 4; y++) {

  1403. 			int posX = colRulerSteps;

  1404. 			for (int x = 0; x < 16; x++) {

  1405. 				addParam(createParam<LEDButtonWithRClick>(Vec(posX, rowRuler0 + 8 + y * spacingRows - 4.4f), module, GateSeq64::STEP_PARAMS + y * 16 + x, 0.0f, 1.0f, 0.0f));

  1406. 				addChild(createLight<MediumLight<GreenRedWhiteLight>>(Vec(posX + 4.4f, rowRuler0 + 8 + y * spacingRows), module, GateSeq64::STEP_LIGHTS + (y * 16 + x) * 3));

  1407. 				posX += spacingSteps;

  1408. 				if ((x + 1) % 4 == 0)

  1409. 					posX += spacingSteps4;

  1410. 			}

  1411. 		}

  1412. 					

  1413. 		// Gate type LED buttons (bottom left to top left to top right)

  1414. 		static const int rowRulerG0 = 166;

  1415. 		static const int rowSpacingG = 26;

  1416. 		static const int colSpacingG = 56;

  1417. 		static const int colRulerG0 = 15 + 28;

  1418. 		

  1419. 		addParam(createParam<LEDButton>(Vec(colRulerG0, rowRulerG0 + rowSpacingG * 2 - 4.4f), module, GateSeq64::GMODE_PARAMS + 2, 0.0f, 1.0f, 0.0f));

  1420. 		addChild(createLight<MediumLight<GreenRedLight>>(Vec(colRulerG0 + 4.4f, rowRulerG0 + rowSpacingG * 2), module, GateSeq64::GMODE_LIGHTS + 2 * 2));

  1421. 		addParam(createParam<LEDButton>(Vec(colRulerG0, rowRulerG0 + rowSpacingG - 4.4f), module, GateSeq64::GMODE_PARAMS + 1, 0.0f, 1.0f, 0.0f));

  1422. 		addChild(createLight<MediumLight<GreenRedLight>>(Vec(colRulerG0 + 4.4f, rowRulerG0 + rowSpacingG), module, GateSeq64::GMODE_LIGHTS + 1 * 2));

  1423. 		addParam(createParam<LEDButton>(Vec(colRulerG0, rowRulerG0 - 4.4f), module, GateSeq64::GMODE_PARAMS + 0, 0.0f, 1.0f, 0.0f));

  1424. 		addChild(createLight<MediumLight<GreenRedLight>>(Vec(colRulerG0 + 4.4f, rowRulerG0), module, GateSeq64::GMODE_LIGHTS + 0 * 2));		

  1425. 		for (int x = 1; x < 6; x++) {

  1426. 			addParam(createParam<LEDButton>(Vec(colRulerG0 + colSpacingG * x, rowRulerG0 - 4.4f), module, GateSeq64::GMODE_PARAMS + 2 + x, 0.0f, 1.0f, 0.0f));

  1427. 			addChild(createLight<MediumLight<GreenRedLight>>(Vec(colRulerG0 + colSpacingG * x + 4.4f, rowRulerG0), module, GateSeq64::GMODE_LIGHTS + (2 + x) * 2));

  1428. 		}

  1429. 		

  1430. 		

  1431. 		

  1432. 		

  1433. 		// ****** 5x3 Main bottom half Control section ******

  1434. 		

  1435. 		static const int colRulerC0 = 25;

  1436. 		static const int colRulerC1 = 78;

  1437. 		static const int colRulerC2 = 126;

  1438. 		static const int colRulerC3 = 189;

  1439. 		static const int colRulerC4 = 241;

  1440. 		static const int rowRulerC0 = 206; 

  1441. 		static const int rowRulerSpacing = 58;

  1442. 		static const int rowRulerC1 = rowRulerC0 + rowRulerSpacing;

  1443. 		static const int rowRulerC2 = rowRulerC1 + rowRulerSpacing;

  1444. 				

  1445. 		

  1446. 		// Clock input

  1447. 		addInput(createDynamicPort<IMPort>(Vec(colRulerC0, rowRulerC1), Port::INPUT, module, GateSeq64::CLOCK_INPUT, &module->panelTheme));

  1448. 		// Reset CV

  1449. 		addInput(createDynamicPort<IMPort>(Vec(colRulerC0, rowRulerC2), Port::INPUT, module, GateSeq64::RESET_INPUT, &module->panelTheme));

  1450. 		

  1451. 				

  1452. 		// Prob button

  1453. 		addParam(createDynamicParam<IMBigPushButton>(Vec(colRulerC1 + offsetCKD6b, rowRulerC0 + offsetCKD6b), module, GateSeq64::PROB_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1454. 		// Reset LED bezel and light

  1455. 		addParam(createParam<LEDBezel>(Vec(colRulerC1 + offsetLEDbezel, rowRulerC1 + offsetLEDbezel), module, GateSeq64::RESET_PARAM, 0.0f, 1.0f, 0.0f));

  1456. 		addChild(createLight<MuteLight<GreenLight>>(Vec(colRulerC1 + offsetLEDbezel + offsetLEDbezelLight, rowRulerC1 + offsetLEDbezel + offsetLEDbezelLight), module, GateSeq64::RESET_LIGHT));

  1457. 		// Seq CV

  1458. 		addInput(createDynamicPort<IMPort>(Vec(colRulerC1, rowRulerC2), Port::INPUT, module, GateSeq64::SEQCV_INPUT, &module->panelTheme));

  1459. 		

  1460. 		// Sequence knob

  1461. 		addParam(createDynamicParam<SequenceKnob>(Vec(colRulerC2 + 1 + offsetIMBigKnob, rowRulerC0 + offsetIMBigKnob), module, GateSeq64::SEQUENCE_PARAM, -INFINITY, INFINITY, 0.0f, &module->panelTheme));		

  1462. 		// Run LED bezel and light

  1463. 		addParam(createParam<LEDBezel>(Vec(colRulerC2 + offsetLEDbezel, rowRulerC1 + offsetLEDbezel), module, GateSeq64::RUN_PARAM, 0.0f, 1.0f, 0.0f));

  1464. 		addChild(createLight<MuteLight<GreenLight>>(Vec(colRulerC2 + offsetLEDbezel + offsetLEDbezelLight, rowRulerC1 + offsetLEDbezel + offsetLEDbezelLight), module, GateSeq64::RUN_LIGHT));

  1465. 		// Run CV

  1466. 		addInput(createDynamicPort<IMPort>(Vec(colRulerC2, rowRulerC2), Port::INPUT, module, GateSeq64::RUNCV_INPUT, &module->panelTheme));

  1467. 

  1468. 		

  1469. 		// Sequence display

  1470. 		SequenceDisplayWidget *displaySequence = new SequenceDisplayWidget();

  1471. 		displaySequence->box.pos = Vec(colRulerC3 - 15, rowRulerC0 + vOffsetDisplay);

  1472. 		displaySequence->box.size = Vec(55, 30);// 3 characters

  1473. 		displaySequence->module = module;

  1474. 		addChild(displaySequence);

  1475. 		// Modes button

  1476. 		addParam(createDynamicParam<IMBigPushButton>(Vec(colRulerC3 + offsetCKD6b, rowRulerC1 + offsetCKD6b), module, GateSeq64::MODES_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1477. 		// Copy/paste buttons

  1478. 		addParam(createDynamicParam<IMPushButton>(Vec(colRulerC3 - 10, rowRulerC2 + offsetTL1105), module, GateSeq64::COPY_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1479. 		addParam(createDynamicParam<IMPushButton>(Vec(colRulerC3 + 20, rowRulerC2 + offsetTL1105), module, GateSeq64::PASTE_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1480. 		

  1481. 

  1482. 		// Seq/Song selector

  1483. 		addParam(createParam<CKSSNoRandom>(Vec(colRulerC4 + 2 + hOffsetCKSS, rowRulerC0 + vOffsetCKSS), module, GateSeq64::EDIT_PARAM, 0.0f, 1.0f, 1.0f));

  1484. 		// Config switch (3 position)

  1485. 		addParam(createParam<CKSSThreeInvNotify>(Vec(colRulerC4 + 2 + hOffsetCKSS, rowRulerC1 - 2 + vOffsetCKSSThree), module, GateSeq64::CONFIG_PARAM, 0.0f, 2.0f, GateSeq64::CONFIG_PARAM_INIT_VALUE));// 0.0f is top position

  1486. 		// Copy paste mode

  1487. 		addParam(createParam<CKSSThreeInvNoRandom>(Vec(colRulerC4 + 2 + hOffsetCKSS, rowRulerC2 + vOffsetCKSSThree), module, GateSeq64::CPMODE_PARAM, 0.0f, 2.0f, 2.0f));

  1488. 

  1489. 		// Outputs

  1490. 		for (int iSides = 0; iSides < 4; iSides++)

  1491. 			addOutput(createDynamicPort<IMPort>(Vec(311, rowRulerC0 + iSides * 40), Port::OUTPUT, module, GateSeq64::GATE_OUTPUTS + iSides, &module->panelTheme));

  1492. 		

  1493. 		// Expansion module

  1494. 		static const int rowRulerExpTop = 60;

  1495. 		static const int rowSpacingExp = 50;

  1496. 		static const int colRulerExp = 497 - 30 - 90;// GS64 is (2+6)HP less than PS32

  1497. 		addInput(expPorts[0] = createDynamicPort<IMPort>(Vec(colRulerExp, rowRulerExpTop + rowSpacingExp * 0), Port::INPUT, module, GateSeq64::WRITE_INPUT, &module->panelTheme));

  1498. 		addInput(expPorts[1] = createDynamicPort<IMPort>(Vec(colRulerExp, rowRulerExpTop + rowSpacingExp * 1), Port::INPUT, module, GateSeq64::GATE_INPUT, &module->panelTheme));

  1499. 		addInput(expPorts[2] = createDynamicPort<IMPort>(Vec(colRulerExp, rowRulerExpTop + rowSpacingExp * 2), Port::INPUT, module, GateSeq64::PROB_INPUT, &module->panelTheme));

  1500. 		addInput(expPorts[3] = createDynamicPort<IMPort>(Vec(colRulerExp, rowRulerExpTop + rowSpacingExp * 3), Port::INPUT, module, GateSeq64::WRITE0_INPUT, &module->panelTheme));

  1501. 		addInput(expPorts[4] = createDynamicPort<IMPort>(Vec(colRulerExp, rowRulerExpTop + rowSpacingExp * 4), Port::INPUT, module, GateSeq64::WRITE1_INPUT, &module->panelTheme));

  1502. 		addInput(expPorts[5] = createDynamicPort<IMPort>(Vec(colRulerExp, rowRulerExpTop + rowSpacingExp * 5), Port::INPUT, module, GateSeq64::STEPL_INPUT, &module->panelTheme));

  1503. 

  1504. 	}

  1505. };

  1506. 

  1507. } // namespace rack_plugin_ImpromptuModular

  1508. 

  1509. using namespace rack_plugin_ImpromptuModular;

  1510. 

  1511. RACK_PLUGIN_MODEL_INIT(ImpromptuModular, GateSeq64) {

  1512.    Model *modelGateSeq64 = Model::create<GateSeq64, GateSeq64Widget>("Impromptu Modular", "Gate-Seq-64", "SEQ - Gate-Seq-64", SEQUENCER_TAG);

  1513.    return modelGateSeq64;

  1514. }

  1515. 

  1516. /*CHANGE LOG

  1517. 

  1518. 0.6.16:

  1519. support for 32 sequences instead of 16

  1520. add step indication in song mode (white lights), and add right-click initialization on main knob

  1521. 

  1522. 0.6.14:

  1523. allow right click to turn steps off

  1524. 

  1525. 0.6.13:

  1526. fix run mode bug (history not reset when hard reset)

  1527. fix initRun() timing bug when turn off-and-then-on running button (it was resetting ppqnCount)

  1528. add two extra modes for Seq CV input (right-click menu): note-voltage-levels and trigger-increment

  1529. 

  1530. 0.6.12:

  1531. input refresh optimization

  1532. add separate buttons for each advanced-gate (remove left right buttons)

  1533. change behavior of write CV input in exp pannel (prob not reset when ProbIn unconnected, and gate not written when GateIn unconnected)

  1534. 

  1535. 0.6.11:

  1536. step optimization of lights refresh

  1537. add RN2 run mode

  1538. add step-left CV input in expansion panel

  1539. implement copy-paste in song mode and change 4/ROW/ALL to 4/8/ALL

  1540. implement cross paste trick for init and randomize seq/song

  1541. add AutoSeq option when writing via CV inputs 

  1542. make song mode 64 sequences long

  1543. 

  1544. 0.6.10:

  1545. add advanced gate mode

  1546. 

  1547. 0.6.9:

  1548. add FW2, FW3 and FW4 run modes for sequences (but not for song)

  1549. 

  1550. 0.6.7:

  1551. add expansion panel with extra CVs for writing steps into the module

  1552. allow full edit capabilities in song mode

  1553. no reset on run by default, with switch added in context menu

  1554. reset does not revert seq or song number to 1

  1555. 

  1556. 0.6.6:

  1557. config and knob bug fixes when loading patch

  1558. 

  1559. 0.6.5:

  1560. swap MODE/LEN so that length happens first (update manual)

  1561. 

  1562. 0.6.4:

  1563. initial release of GS64

  1564. */