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

1784 lines
71KB
Raw Blame History 

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

  2. //Multi-phrase 32 step 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 inspired by the SA-100 Stepper Acid sequencer by Transistor Sounds Labs

  10. //

  11. //Acknowledgements: please see README.md

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

  13. 

  14. 

  15. #include "ImpromptuModular.hpp"

  16. #include "PhraseSeqUtil.hpp"

  17. 

  18. namespace rack_plugin_ImpromptuModular {

  19. 

  20. struct PhraseSeq32 : Module {

  21. 	enum ParamIds {

  22. 		LEFT_PARAM,

  23. 		RIGHT_PARAM,

  24. 		RIGHT8_PARAM,// not used

  25. 		EDIT_PARAM,

  26. 		SEQUENCE_PARAM,

  27. 		RUN_PARAM,

  28. 		COPY_PARAM,

  29. 		PASTE_PARAM,

  30. 		RESET_PARAM,

  31. 		ENUMS(OCTAVE_PARAM, 7),

  32. 		GATE1_PARAM,

  33. 		GATE2_PARAM,

  34. 		SLIDE_BTN_PARAM,

  35. 		SLIDE_KNOB_PARAM,

  36. 		ATTACH_PARAM,

  37. 		AUTOSTEP_PARAM,

  38. 		ENUMS(KEY_PARAMS, 12),

  39. 		RUNMODE_PARAM,

  40. 		TRAN_ROT_PARAM,

  41. 		GATE1_KNOB_PARAM,

  42. 		GATE1_PROB_PARAM,

  43. 		TIE_PARAM,// Legato

  44. 		CPMODE_PARAM,

  45. 		ENUMS(STEP_PHRASE_PARAMS, 32),

  46. 		CONFIG_PARAM,

  47. 		// -- 0.6.4 ^^

  48. 		NUM_PARAMS

  49. 	};

  50. 	enum InputIds {

  51. 		WRITE_INPUT,

  52. 		CV_INPUT,

  53. 		RESET_INPUT,

  54. 		CLOCK_INPUT,

  55. 		LEFTCV_INPUT,

  56. 		RIGHTCV_INPUT,

  57. 		RUNCV_INPUT,

  58. 		SEQCV_INPUT,

  59. 		// -- 0.6.4 ^^

  60. 		MODECV_INPUT,

  61. 		GATE1CV_INPUT,

  62. 		GATE2CV_INPUT,

  63. 		TIEDCV_INPUT,

  64. 		SLIDECV_INPUT,

  65. 		NUM_INPUTS

  66. 	};

  67. 	enum OutputIds {

  68. 		CVA_OUTPUT,

  69. 		GATE1A_OUTPUT,

  70. 		GATE2A_OUTPUT,

  71. 		CVB_OUTPUT,

  72. 		GATE1B_OUTPUT,

  73. 		GATE2B_OUTPUT,

  74. 		NUM_OUTPUTS

  75. 	};

  76. 	enum LightIds {

  77. 		ENUMS(STEP_PHRASE_LIGHTS, 32 * 2),// room for GreenRed

  78. 		ENUMS(OCTAVE_LIGHTS, 7),// octaves 1 to 7

  79. 		ENUMS(KEY_LIGHTS, 12 * 2),// room for GreenRed

  80. 		RUN_LIGHT,

  81. 		RESET_LIGHT,

  82. 		ENUMS(GATE1_LIGHT, 2),// room for GreenRed

  83. 		ENUMS(GATE2_LIGHT, 2),// room for GreenRed

  84. 		SLIDE_LIGHT,

  85. 		ATTACH_LIGHT,

  86. 		GATE1_PROB_LIGHT,

  87. 		TIE_LIGHT,

  88. 		NUM_LIGHTS

  89. 	};

  90. 	

  91. 	enum DisplayStateIds {DISP_NORMAL, DISP_MODE, DISP_LENGTH, DISP_TRANSPOSE, DISP_ROTATE};

  92. 

  93. 	

  94. 	// Need to save

  95. 	int panelTheme = 0;

  96. 	int expansion = 0;

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

  98. 	bool running;

  99. 	int runModeSeq[32];

  100. 	int runModeSong;

  101. 	//

  102. 	int sequence;

  103. 	int lengths[32];//1 to 32

  104. 	//

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

  106. 	int phrases;//1 to 32

  107. 	//

  108. 	float cv[32][32];// [-3.0 : 3.917]. First index is patten number, 2nd index is step

  109. 	int attributes[32][32];// First index is patten number, 2nd index is step (see enum AttributeBitMasks for details)

  110. 	//

  111. 	bool resetOnRun;

  112. 	bool attached;

  113. 

  114. 	// No need to save

  115. 	float resetLight = 0.0f;

  116. 	int stepIndexEdit;

  117. 	int stepIndexRun;

  118. 	int phraseIndexEdit;

  119. 	int phraseIndexRun;

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

  121. 	unsigned long editingGate;// 0 when no edit gate, downward step counter timer when edit gate

  122. 	float editingGateCV;// no need to initialize, this is a companion to editingGate (output this only when editingGate > 0)

  123. 	int editingGateKeyLight;// no need to initialize, this is a companion to editingGate (use this only when editingGate > 0)

  124. 	int editingChannel;// 0 means channel A, 1 means channel B. no need to initialize, this is a companion to editingGate

  125. 	int stepIndexRunHistory;// no need to initialize

  126. 	int phraseIndexRunHistory;// no need to initialize

  127. 	int displayState;

  128. 	unsigned long slideStepsRemain[2];// 0 when no slide under way, downward step counter when sliding

  129. 	float slideCVdelta[2];// no need to initialize, this is a companion to slideStepsRemain

  130. 	float cvCPbuffer[32];// copy paste buffer for CVs

  131. 	int attributesCPbuffer[32];// copy paste buffer for attributes

  132. 	int lengthCPbuffer;

  133. 	int modeCPbuffer;

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

  135. 	int transposeOffset;// no need to initialize, this is companion to displayMode = DISP_TRANSPOSE

  136. 	int rotateOffset;// no need to initialize, this is companion to displayMode = DISP_ROTATE

  137. 	long clockIgnoreOnReset;

  138. 	const float clockIgnoreOnResetDuration = 0.001f;// disable clock on powerup and reset for 1 ms (so that the first step plays)

  139. 	unsigned long clockPeriod;// counts number of step() calls upward from last clock (reset after clock processed)

  140. 	long tiedWarning;// 0 when no warning, positive downward step counter timer when warning

  141. 	int sequenceKnob = 0;

  142. 	int gate1Code[2];

  143. 	int gate2Code[2];

  144. 	bool attachedChanB;

  145. 	long revertDisplay;

  146. 	long editingGateLength;// 0 when no info, positive downward step counter timer when gate1, negative upward when gate2

  147. 	long editGateLengthTimeInitMult;// multiplier for extended setting of advanced gates

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

  149. 	int ppqnCount;

  150. 	int lightRefreshCounter;

  151. 	

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

  153. 	int stepConfigLast;

  154. 	static constexpr float EDIT_PARAM_INIT_VALUE = 1.0f;// so that module constructor is coherent with widget initialization, since module created before widget

  155. 	bool editingSequence;

  156. 	bool editingSequenceLast;

  157. 	

  158. 

  159. 	SchmittTrigger resetTrigger;

  160. 	SchmittTrigger leftTrigger;

  161. 	SchmittTrigger rightTrigger;

  162. 	SchmittTrigger runningTrigger;

  163. 	SchmittTrigger clockTrigger;

  164. 	SchmittTrigger octTriggers[7];

  165. 	SchmittTrigger octmTrigger;

  166. 	SchmittTrigger gate1Trigger;

  167. 	SchmittTrigger gate1ProbTrigger;

  168. 	SchmittTrigger gate2Trigger;

  169. 	SchmittTrigger slideTrigger;

  170. 	SchmittTrigger keyTriggers[12];

  171. 	SchmittTrigger writeTrigger;

  172. 	SchmittTrigger attachedTrigger;

  173. 	SchmittTrigger copyTrigger;

  174. 	SchmittTrigger pasteTrigger;

  175. 	SchmittTrigger modeTrigger;

  176. 	SchmittTrigger rotateTrigger;

  177. 	SchmittTrigger transposeTrigger;

  178. 	SchmittTrigger tiedTrigger;

  179. 	SchmittTrigger stepTriggers[32];

  180. 	HoldDetect modeHoldDetect;

  181. 	HoldDetect gate1HoldDetect;

  182. 	HoldDetect gate2HoldDetect;

  183. 	

  184. 

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

  186. 	inline bool getGate1(int seq, int step) {return getGate1a(attributes[seq][step]);}

  187. 	inline bool getGate1P(int seq, int step) {return getGate1Pa(attributes[seq][step]);}

  188. 	inline bool getGate2(int seq, int step) {return getGate2a(attributes[seq][step]);}

  189. 	inline bool getSlide(int seq, int step) {return getSlideA(attributes[seq][step]);}

  190. 	inline bool getTied(int seq, int step) {return getTiedA(attributes[seq][step]);}

  191. 	inline int getGate1Mode(int seq, int step) {return getGate1aMode(attributes[seq][step]);}

  192. 	inline int getGate2Mode(int seq, int step) {return getGate2aMode(attributes[seq][step]);}

  193. 	

  194. 	inline void setGate1Mode(int seq, int step, int gateMode) {attributes[seq][step] &= ~ATT_MSK_GATE1MODE; attributes[seq][step] |= (gateMode << gate1ModeShift);}

  195. 	inline void setGate2Mode(int seq, int step, int gateMode) {attributes[seq][step] &= ~ATT_MSK_GATE2MODE; attributes[seq][step] |= (gateMode << gate2ModeShift);}

  196. 	

  197. 		

  198. 	PhraseSeq32() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {

  199. 		onReset();

  200. 	}

  201. 

  202. 	

  203. 	// widgets are not yet created when module is created (and when onReset() is called by constructor)

  204. 	// onReset() is also called when right-click initialization of module

  205. 	void onReset() override {

  206. 		int stepConfig = 1;// 2x16

  207. 		if (CONFIG_PARAM_INIT_VALUE < 0.5f)// 1x32

  208. 			stepConfig = 2;

  209. 		stepConfigLast = stepConfig;

  210. 		pulsesPerStep = 1;

  211. 		running = false;

  212. 		runModeSong = MODE_FWD;

  213. 		stepIndexEdit = 0;

  214. 		phraseIndexEdit = 0;

  215. 		sequence = 0;

  216. 		phrases = 4;

  217. 		for (int i = 0; i < 32; i++) {

  218. 			for (int s = 0; s < 32; s++) {

  219. 				cv[i][s] = 0.0f;

  220. 				attributes[i][s] = ATT_MSK_GATE1;

  221. 			}

  222. 			runModeSeq[i] = MODE_FWD;

  223. 			phrase[i] = 0;

  224. 			lengths[i] = 16 * stepConfig;

  225. 			cvCPbuffer[i] = 0.0f;

  226. 			attributesCPbuffer[i] = ATT_MSK_GATE1;

  227. 		}

  228. 		initRun(stepConfig, true);

  229. 		lengthCPbuffer = 32;

  230. 		modeCPbuffer = MODE_FWD;

  231. 		countCP = 32;

  232. 		editingGate = 0ul;

  233. 		infoCopyPaste = 0l;

  234. 		displayState = DISP_NORMAL;

  235. 		slideStepsRemain[0] = 0ul;

  236. 		slideStepsRemain[1] = 0ul;

  237. 		attached = true;

  238. 		clockPeriod = 0ul;

  239. 		tiedWarning = 0ul;

  240. 		attachedChanB = false;

  241. 		revertDisplay = 0l;

  242. 		editingSequence = EDIT_PARAM_INIT_VALUE > 0.5f;

  243. 		editingSequenceLast = editingSequence;

  244. 		resetOnRun = false;

  245. 		modeHoldDetect.reset();

  246. 		gate1HoldDetect.reset();

  247. 		gate2HoldDetect.reset();

  248. 		editGateLengthTimeInitMult = 1l;

  249. 		editingPpqn = 0l;

  250. 		lightRefreshCounter = 0;

  251. 	}

  252. 	

  253. 	

  254. 	// widgets randomized before onRandomize() is called

  255. 	void onRandomize() override {

  256. 		int stepConfig = 1;// 2x16

  257. 		if (params[CONFIG_PARAM].value < 0.5f)// 1x32

  258. 			stepConfig = 2;

  259. 		stepConfigLast = stepConfig;			

  260. 		running = false;

  261. 		runModeSong = randomu32() % 5;

  262. 		stepIndexEdit = 0;

  263. 		phraseIndexEdit = 0;

  264. 		sequence = randomu32() % 32;

  265. 		phrases = 1 + (randomu32() % 32);

  266. 		for (int i = 0; i < 32; i++) {

  267. 			for (int s = 0; s < 32; s++) {

  268. 				cv[i][s] = ((float)(randomu32() % 7)) + ((float)(randomu32() % 12)) / 12.0f - 3.0f;

  269. 				attributes[i][s] = randomu32() & 0x1FFF;// 5 bit for normal attributes + 2 * 4 bits for advanced gate modes

  270. 				if (getTied(i,s)) {

  271. 					attributes[i][s] = ATT_MSK_TIED;// clear other attributes if tied

  272. 					applyTiedStep(i, s, lengths[i]);

  273. 				}

  274. 			}

  275. 			runModeSeq[i] = randomu32() % NUM_MODES;

  276. 			phrase[i] = randomu32() % 32;

  277. 			lengths[i] = 1 + (randomu32() % (16 * stepConfig));

  278. 			cvCPbuffer[i] = 0.0f;

  279. 			attributesCPbuffer[i] = ATT_MSK_GATE1;

  280. 		}

  281. 		initRun(stepConfig, true);

  282. 		lengthCPbuffer = 32;

  283. 		modeCPbuffer = MODE_FWD;

  284. 		countCP = 32;

  285. 		editingGate = 0ul;

  286. 		infoCopyPaste = 0l;

  287. 		displayState = DISP_NORMAL;

  288. 		slideStepsRemain[0] = 0ul;

  289. 		slideStepsRemain[1] = 0ul;

  290. 		attached = true;

  291. 		clockPeriod = 0ul;

  292. 		tiedWarning = 0ul;

  293. 		attachedChanB = false;

  294. 		revertDisplay = 0l;

  295. 		editingSequence = isEditingSequence();

  296. 		editingSequenceLast = editingSequence;

  297. 		resetOnRun = false;

  298. 		modeHoldDetect.reset();

  299. 		gate1HoldDetect.reset();

  300. 		gate2HoldDetect.reset();

  301. 		editGateLengthTimeInitMult = 1l;

  302. 		editingPpqn = 0l;

  303. 	}

  304. 	

  305. 	

  306. 	void initRun(int stepConfig, bool hard) {// run button activated or run edge in run input jack or edit mode toggled

  307. 		if (hard)

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

  309. 		int seq = (editingSequence ? sequence : phrase[phraseIndexRun]);

  310. 		if (hard)

  311. 				stepIndexRun = (runModeSeq[seq] == MODE_REV ? lengths[seq] - 1 : 0);

  312. 		ppqnCount = 0;

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

  314. 			gate1Code[i] = calcGate1Code(attributes[seq][(i * 16) + stepIndexRun], 0, pulsesPerStep, params[GATE1_KNOB_PARAM].value);

  315. 			gate2Code[i] = calcGate2Code(attributes[seq][(i * 16) + stepIndexRun], 0, pulsesPerStep);

  316. 		}

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

  318. 		editingGateLength = 0l;

  319. 	}

  320. 	

  321. 	

  322. 	json_t *toJson() override {

  323. 		json_t *rootJ = json_object();

  324. 

  325. 		// panelTheme

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

  327. 

  328. 		// expansion

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

  330. 

  331. 		// pulsesPerStep

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

  333. 

  334. 		// running

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

  336. 		

  337. 		// runModeSeq

  338. 		json_t *runModeSeqJ = json_array();

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

  340. 			json_array_insert_new(runModeSeqJ, i, json_integer(runModeSeq[i]));

  341. 		json_object_set_new(rootJ, "runModeSeq2", runModeSeqJ);// "2" appended so no break patches

  342. 

  343. 		// runModeSong

  344. 		json_object_set_new(rootJ, "runModeSong", json_integer(runModeSong));

  345. 

  346. 		// sequence

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

  348. 

  349. 		// lengths

  350. 		json_t *lengthsJ = json_array();

  351. 		for (int i = 0; i < 32; i++)

  352. 			json_array_insert_new(lengthsJ, i, json_integer(lengths[i]));

  353. 		json_object_set_new(rootJ, "lengths", lengthsJ);

  354. 

  355. 		// phrase 

  356. 		json_t *phraseJ = json_array();

  357. 		for (int i = 0; i < 32; i++)

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

  359. 		json_object_set_new(rootJ, "phrase", phraseJ);

  360. 

  361. 		// phrases

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

  363. 

  364. 		// CV

  365. 		json_t *cvJ = json_array();

  366. 		for (int i = 0; i < 32; i++)

  367. 			for (int s = 0; s < 32; s++) {

  368. 				json_array_insert_new(cvJ, s + (i * 32), json_real(cv[i][s]));

  369. 			}

  370. 		json_object_set_new(rootJ, "cv", cvJ);

  371. 

  372. 		// attributes

  373. 		json_t *attributesJ = json_array();

  374. 		for (int i = 0; i < 32; i++)

  375. 			for (int s = 0; s < 32; s++) {

  376. 				json_array_insert_new(attributesJ, s + (i * 32), json_integer(attributes[i][s]));

  377. 			}

  378. 		json_object_set_new(rootJ, "attributes", attributesJ);

  379. 

  380. 		// attached

  381. 		json_object_set_new(rootJ, "attached", json_boolean(attached));

  382. 

  383. 		// resetOnRun

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

  385. 		

  386. 		return rootJ;

  387. 	}

  388. 

  389. 	

  390. 	// widgets loaded before this fromJson() is called

  391. 	void fromJson(json_t *rootJ) override {

  392. 		// panelTheme

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

  394. 		if (panelThemeJ)

  395. 			panelTheme = json_integer_value(panelThemeJ);

  396. 

  397. 		// expansion

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

  399. 		if (expansionJ)

  400. 			expansion = json_integer_value(expansionJ);

  401. 

  402. 		// pulsesPerStep

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

  404. 		if (pulsesPerStepJ)

  405. 			pulsesPerStep = json_integer_value(pulsesPerStepJ);

  406. 

  407. 		// running

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

  409. 		if (runningJ)

  410. 			running = json_is_true(runningJ);

  411. 

  412. 		// runModeSeq

  413. 		json_t *runModeSeqJ = json_object_get(rootJ, "runModeSeq2");// "2" appended so no break patches

  414. 		if (runModeSeqJ) {

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

  416. 			{

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

  418. 				if (runModeSeqArrayJ)

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

  420. 			}			

  421. 		}		

  422. 		

  423. 		// runModeSong

  424. 		json_t *runModeSongJ = json_object_get(rootJ, "runModeSong");

  425. 		if (runModeSongJ)

  426. 			runModeSong = json_integer_value(runModeSongJ);

  427. 		

  428. 		// sequence

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

  430. 		if (sequenceJ)

  431. 			sequence = json_integer_value(sequenceJ);

  432. 		

  433. 		// lengths

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

  435. 		if (lengthsJ)

  436. 			for (int i = 0; i < 32; i++)

  437. 			{

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

  439. 				if (lengthsArrayJ)

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

  441. 			}

  442. 			

  443. 		// phrase

  444. 		json_t *phraseJ = json_object_get(rootJ, "phrase");

  445. 		if (phraseJ)

  446. 			for (int i = 0; i < 32; i++)

  447. 			{

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

  449. 				if (phraseArrayJ)

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

  451. 			}

  452. 		

  453. 		// phrases

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

  455. 		if (phrasesJ)

  456. 			phrases = json_integer_value(phrasesJ);

  457. 		

  458. 		// CV

  459. 		json_t *cvJ = json_object_get(rootJ, "cv");

  460. 		if (cvJ) {

  461. 			for (int i = 0; i < 32; i++)

  462. 				for (int s = 0; s < 32; s++) {

  463. 					json_t *cvArrayJ = json_array_get(cvJ, s + (i * 32));

  464. 					if (cvArrayJ)

  465. 						cv[i][s] = json_real_value(cvArrayJ);

  466. 				}

  467. 		}

  468. 		

  469. 		// attributes

  470. 		json_t *attributesJ = json_object_get(rootJ, "attributes");

  471. 		if (attributesJ) {

  472. 			for (int i = 0; i < 32; i++)

  473. 				for (int s = 0; s < 32; s++) {

  474. 					json_t *attributesArrayJ = json_array_get(attributesJ, s + (i * 32));

  475. 					if (attributesArrayJ)

  476. 						attributes[i][s] = json_integer_value(attributesArrayJ);

  477. 				}

  478. 		}

  479. 		

  480. 		// attached

  481. 		json_t *attachedJ = json_object_get(rootJ, "attached");

  482. 		if (attachedJ)

  483. 			attached = json_is_true(attachedJ);

  484. 		

  485. 		// resetOnRun

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

  487. 		if (resetOnRunJ)

  488. 			resetOnRun = json_is_true(resetOnRunJ);

  489. 

  490. 		// Initialize dependants after everything loaded (widgets already loaded when reach here)

  491. 		int stepConfig = 1;// 2x16

  492. 		if (params[CONFIG_PARAM].value < 0.5f)// 1x32

  493. 			stepConfig = 2;

  494. 		stepConfigLast = stepConfig;			

  495. 		initRun(stepConfig, true);

  496. 		editingSequence = isEditingSequence();

  497. 		editingSequenceLast = editingSequence;

  498. 	}

  499. 

  500. 	void rotateSeq(int seqNum, bool directionRight, int seqLength, bool chanB_16) {

  501. 		// set chanB_16 to false to rotate chan A in 2x16 config (length will be <= 16) or single chan in 1x32 config (length will be <= 32)

  502. 		// set chanB_16 to true  to rotate chan B in 2x16 config (length must be <= 16)

  503. 		float rotCV;

  504. 		int rotAttributes;

  505. 		int iStart = chanB_16 ? 16 : 0;

  506. 		int iEnd = iStart + seqLength - 1;

  507. 		int iRot = iStart;

  508. 		int iDelta = 1;

  509. 		if (directionRight) {

  510. 			iRot = iEnd;

  511. 			iDelta = -1;

  512. 		}

  513. 		rotCV = cv[seqNum][iRot];

  514. 		rotAttributes = attributes[seqNum][iRot];

  515. 		for ( ; ; iRot += iDelta) {

  516. 			if (iDelta == 1 && iRot >= iEnd) break;

  517. 			if (iDelta == -1 && iRot <= iStart) break;

  518. 			cv[seqNum][iRot] = cv[seqNum][iRot + iDelta];

  519. 			attributes[seqNum][iRot] = attributes[seqNum][iRot + iDelta];

  520. 		}

  521. 		cv[seqNum][iRot] = rotCV;

  522. 		attributes[seqNum][iRot] = rotAttributes;

  523. 	}

  524. 	

  525. 	// Advances the module by 1 audio frame with duration 1.0 / engineGetSampleRate()

  526. 	void step() override {

  527. 		float sampleRate = engineGetSampleRate();

  528. 		static const float gateTime = 0.4f;// seconds

  529. 		static const float copyPasteInfoTime = 0.5f;// seconds

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

  531. 		static const float tiedWarningTime = 0.7f;// seconds

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

  533. 		static const float editGateLengthTime = 4.0f;// seconds

  534. 		

  535. 		

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

  537. 		

  538. 		// Notes: 

  539. 		// * a tied step's attributes can not be modified by any of the following: 

  540. 		//   write input, oct and keyboard buttons, gate1Prob and slide buttons

  541. 		//   however, paste, transpose, rotate obviously can, and gate1/2 can be turned back on if desired.

  542. 		// * Whenever cv[][] is modified or tied[] is activated for a step, call applyTiedStep(sequence,stepIndexEdit,steps)

  543. 		

  544. 

  545. 		// Config switch

  546. 		int stepConfig = 1;// 2x16

  547. 		if (params[CONFIG_PARAM].value < 0.5f)// 1x32

  548. 			stepConfig = 2;

  549. 		// Config: set lengths to their new max when move switch

  550. 		if (stepConfigLast != stepConfig) {

  551. 			for (int i = 0; i < 32; i++)

  552. 				lengths[i] = 16 * stepConfig;

  553. 			attachedChanB = false;

  554. 			stepConfigLast = stepConfig;

  555. 		}

  556. 

  557. 		// Edit mode

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

  559. 		if (editingSequenceLast != editingSequence) {

  560. 			if (running)

  561. 				initRun(stepConfig, true);

  562. 			displayState = DISP_NORMAL;

  563. 			editingSequenceLast = editingSequence;

  564. 		}

  565. 		

  566. 		// Seq CV input

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

  568. 			sequence = (int) clamp( round(inputs[SEQCV_INPUT].value * (32.0f - 1.0f) / 10.0f), 0.0f, (32.0f - 1.0f) );

  569. 		}

  570. 		// Mode CV input

  571. 		if (inputs[MODECV_INPUT].active) {

  572. 			if (editingSequence)

  573. 				runModeSeq[sequence] = (int) clamp( round(inputs[MODECV_INPUT].value * ((float)NUM_MODES - 1.0f) / 10.0f), 0.0f, (float)NUM_MODES - 1.0f );

  574. 		}

  575. 		

  576. 		// Run button

  577. 		if (runningTrigger.process(params[RUN_PARAM].value + inputs[RUNCV_INPUT].value)) {

  578. 			running = !running;

  579. 			if (running)

  580. 				initRun(stepConfig, resetOnRun);

  581. 			displayState = DISP_NORMAL;

  582. 		}

  583. 

  584. 		// Attach button

  585. 		if (attachedTrigger.process(params[ATTACH_PARAM].value)) {

  586. 			if (running) {

  587. 				attached = !attached;

  588. 				if (attached && editingSequence && stepConfig == 1 ) 

  589. 					attachedChanB = stepIndexEdit >= 16;

  590. 			}

  591. 			displayState = DISP_NORMAL;			

  592. 		}

  593. 		if (running && attached) {

  594. 			if (editingSequence)

  595. 				stepIndexEdit = stepIndexRun + ((attachedChanB && stepConfig == 1) ? 16 : 0);

  596. 			else

  597. 				phraseIndexEdit = phraseIndexRun;

  598. 		}

  599. 		

  600. 		// Copy button

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

  602. 			if (editingSequence) {

  603. 				infoCopyPaste = (long) (copyPasteInfoTime * sampleRate / displayRefreshStepSkips);

  604. 				int sStart = stepIndexEdit;

  605. 				int sCount = 32;

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

  607. 					sStart = 0;

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

  609. 					sCount = 4;

  610. 				else// 8

  611. 					sCount = 8;

  612. 				countCP = sCount;

  613. 				for (int i = 0, s = sStart; i < countCP; i++, s++) {

  614. 					if (s >= 32) s = 0;

  615. 					cvCPbuffer[i] = cv[sequence][s];

  616. 					attributesCPbuffer[i] = attributes[sequence][s];

  617. 					if ((--sCount) <= 0)

  618. 						break;

  619. 				}

  620. 				lengthCPbuffer = lengths[sequence];

  621. 				modeCPbuffer = runModeSeq[sequence];

  622. 			}

  623. 			displayState = DISP_NORMAL;

  624. 		}

  625. 		// Paste button

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

  627. 			if (editingSequence) {

  628. 				infoCopyPaste = (long) (-1 * copyPasteInfoTime * sampleRate / displayRefreshStepSkips);

  629. 				int sStart = ((countCP == 32) ? 0 : stepIndexEdit);

  630. 				int sCount = countCP;

  631. 				for (int i = 0, s = sStart; i < countCP; i++, s++) {

  632. 					if (s >= 32) break;

  633. 					cv[sequence][s] = cvCPbuffer[i];

  634. 					attributes[sequence][s] = attributesCPbuffer[i];

  635. 					if ((--sCount) <= 0)

  636. 						break;

  637. 				}	

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

  639. 					lengths[sequence] = lengthCPbuffer;

  640. 					if (lengths[sequence] > 16 * stepConfig)

  641. 						lengths[sequence] = 16 * stepConfig;

  642. 					runModeSeq[sequence] = modeCPbuffer;

  643. 				}

  644. 			}

  645. 			displayState = DISP_NORMAL;

  646. 		}

  647. 

  648. 		// Write input (must be before Left and Right in case route gate simultaneously to Right and Write for example)

  649. 		//  (write must be to correct step)

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

  651. 		if (writeTrig) {

  652. 			if (editingSequence) {

  653. 				cv[sequence][stepIndexEdit] = inputs[CV_INPUT].value;

  654. 				// Extra CVs from expansion panel:

  655. 				if (inputs[TIEDCV_INPUT].active)

  656. 					setTiedA(&attributes[sequence][stepIndexEdit], inputs[TIEDCV_INPUT].value > 1.0f);

  657. 				if (inputs[GATE1CV_INPUT].active)

  658. 					setGate1a(&attributes[sequence][stepIndexEdit], inputs[GATE1CV_INPUT].value > 1.0f);

  659. 				if (inputs[GATE2CV_INPUT].active)

  660. 					setGate2a(&attributes[sequence][stepIndexEdit], inputs[GATE2CV_INPUT].value > 1.0f);

  661. 				if (inputs[SLIDECV_INPUT].active)

  662. 					setSlideA(&attributes[sequence][stepIndexEdit], inputs[SLIDECV_INPUT].value > 1.0f);			

  663. 				applyTiedStep(sequence, stepIndexEdit, ((stepIndexEdit >= 16 && stepConfig == 1) ? 16 : 0) + lengths[sequence]);

  664. 				editingGate = (unsigned long) (gateTime * sampleRate / displayRefreshStepSkips);

  665. 				editingGateCV = cv[sequence][stepIndexEdit];

  666. 				editingGateKeyLight = -1;

  667. 				editingChannel = (stepIndexEdit >= 16 * stepConfig) ? 1 : 0;

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

  669. 				if (params[AUTOSTEP_PARAM].value > 0.5f)

  670. 					stepIndexEdit = moveIndex(stepIndexEdit, stepIndexEdit + 1, 32);

  671. 			}

  672. 			displayState = DISP_NORMAL;

  673. 		}

  674. 		// Left and right CV inputs

  675. 		int delta = 0;

  676. 		if (leftTrigger.process(inputs[LEFTCV_INPUT].value)) { 

  677. 			delta = -1;

  678. 			if (displayState != DISP_LENGTH)

  679. 				displayState = DISP_NORMAL;

  680. 		}

  681. 		if (rightTrigger.process(inputs[RIGHTCV_INPUT].value)) {

  682. 			delta = +1;

  683. 			if (displayState != DISP_LENGTH)

  684. 				displayState = DISP_NORMAL;

  685. 		}

  686. 		if (delta != 0) {

  687. 			if (displayState == DISP_LENGTH) {

  688. 				if (editingSequence) {

  689. 					lengths[sequence] += delta;

  690. 					if (lengths[sequence] > (16 * stepConfig)) lengths[sequence] = (16 * stepConfig);

  691. 					if (lengths[sequence] < 1 ) lengths[sequence] = 1;

  692. 					lengths[sequence] = ((lengths[sequence] - 1) % (16 * stepConfig)) + 1;

  693. 				}

  694. 				else {

  695. 					phrases += delta;

  696. 					if (phrases > 32) phrases = 32;

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

  698. 				}

  699. 			}

  700. 			else {

  701. 				if (!running || !attached) {// don't move heads when attach and running

  702. 					if (editingSequence) {

  703. 						stepIndexEdit += delta;

  704. 						if (stepIndexEdit < 0)

  705. 							stepIndexEdit = ((stepConfig == 1) ? 16 : 0) + lengths[sequence] - 1;

  706. 						if (stepIndexEdit >= 32)

  707. 							stepIndexEdit = 0;

  708. 						if (!getTied(sequence,stepIndexEdit)) {// play if non-tied step

  709. 							if (!writeTrig) {// in case autostep when simultaneous writeCV and stepCV (keep what was done in Write Input block above)

  710. 								editingGate = (unsigned long) (gateTime * sampleRate / displayRefreshStepSkips);

  711. 								editingGateCV = cv[sequence][stepIndexEdit];

  712. 								editingGateKeyLight = -1;

  713. 								editingChannel = (stepIndexEdit >= 16 * stepConfig) ? 1 : 0;

  714. 							}

  715. 						}

  716. 					}

  717. 					else

  718. 						phraseIndexEdit = moveIndex(phraseIndexEdit, phraseIndexEdit + delta, 32);

  719. 				}

  720. 			}

  721. 		}

  722. 

  723. 		// Step button presses

  724. 		int stepPressed = -1;

  725. 		for (int i = 0; i < 32; i++) {

  726. 			if (stepTriggers[i].process(params[STEP_PHRASE_PARAMS + i].value))

  727. 				stepPressed = i;

  728. 		}

  729. 		if (stepPressed != -1) {

  730. 			if (displayState == DISP_LENGTH) {

  731. 				if (editingSequence)

  732. 					lengths[sequence] = (stepPressed % (16 * stepConfig)) + 1;

  733. 				else

  734. 					phrases = stepPressed + 1;

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

  736. 			}

  737. 			else {

  738. 				if (!running || !attached) {// not running or detached

  739. 					if (editingSequence) {

  740. 						stepIndexEdit = stepPressed;

  741. 						if (!getTied(sequence,stepIndexEdit)) {// play if non-tied step

  742. 							editingGate = (unsigned long) (gateTime * sampleRate / displayRefreshStepSkips);

  743. 							editingGateCV = cv[sequence][stepIndexEdit];

  744. 							editingGateKeyLight = -1;

  745. 							editingChannel = (stepIndexEdit >= 16 * stepConfig) ? 1 : 0;

  746. 						}

  747. 					}

  748. 					else {

  749. 						phraseIndexEdit = stepPressed;

  750. 					}

  751. 				}

  752. 				else {// attached and running

  753. 					if (editingSequence) {

  754. 						if ((stepPressed < 16) && attachedChanB)

  755. 							attachedChanB = false;

  756. 						if ((stepPressed >= 16) && !attachedChanB)

  757. 							attachedChanB = true;					

  758. 					}

  759. 				}

  760. 				displayState = DISP_NORMAL;

  761. 			}

  762. 		} 

  763. 		

  764. 		// Mode/Length button

  765. 		if (modeTrigger.process(params[RUNMODE_PARAM].value)) {

  766. 			if (displayState == DISP_NORMAL || displayState == DISP_TRANSPOSE || displayState == DISP_ROTATE)

  767. 				displayState = DISP_LENGTH;

  768. 			else if (displayState == DISP_LENGTH)

  769. 				displayState = DISP_MODE;

  770. 			else

  771. 				displayState = DISP_NORMAL;

  772. 			//if (!running) {

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

  774. 			//}

  775. 		}

  776. 		

  777. 		// Transpose/Rotate button

  778. 		if (transposeTrigger.process(params[TRAN_ROT_PARAM].value)) {

  779. 			if (editingSequence) {

  780. 				if (displayState == DISP_NORMAL || displayState == DISP_MODE || displayState == DISP_LENGTH) {

  781. 					displayState = DISP_TRANSPOSE;

  782. 					transposeOffset = 0;

  783. 				}

  784. 				else if (displayState == DISP_TRANSPOSE) {

  785. 					displayState = DISP_ROTATE;

  786. 					rotateOffset = 0;

  787. 				}

  788. 				else 

  789. 					displayState = DISP_NORMAL;

  790. 			}

  791. 		}			

  792. 		

  793. 		// Sequence knob 

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

  795.       int newSequenceKnob = int(seqParamValue * 7.0f + 0.5f);

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

  797. 		 	sequenceKnob = newSequenceKnob;

  798.       int deltaKnob = newSequenceKnob - sequenceKnob;

  799. 		if (deltaKnob != 0) {

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

  801. 				if (editingPpqn != 0) {

  802. 					pulsesPerStep = indexToPps(ppsToIndex(pulsesPerStep) + deltaKnob);// indexToPps() does clamping

  803. 					editingPpqn = (long) (editGateLengthTime * sampleRate / displayRefreshStepSkips);

  804. 				}

  805. 				else if (displayState == DISP_MODE) {

  806. 					if (editingSequence) {

  807. 						if (!inputs[MODECV_INPUT].active) {

  808. 							runModeSeq[sequence] += deltaKnob;

  809. 							if (runModeSeq[sequence] < 0) runModeSeq[sequence] = 0;

  810. 							if (runModeSeq[sequence] >= NUM_MODES) runModeSeq[sequence] = NUM_MODES - 1;

  811. 						}

  812. 					}

  813. 					else {

  814. 						runModeSong += deltaKnob;

  815. 						if (runModeSong < 0) runModeSong = 0;

  816. 						if (runModeSong >= 5) runModeSong = 5 - 1;

  817. 					}

  818. 				}

  819. 				else if (displayState == DISP_LENGTH) {

  820. 					if (editingSequence) {

  821. 						lengths[sequence] += deltaKnob;

  822. 						if (lengths[sequence] > (16 * stepConfig)) lengths[sequence] = (16 * stepConfig);

  823. 						if (lengths[sequence] < 1 ) lengths[sequence] = 1;

  824. 					}

  825. 					else {

  826. 						phrases += deltaKnob;

  827. 						if (phrases > 32) phrases = 32;

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

  829. 					}

  830. 				}

  831. 				else if (displayState == DISP_TRANSPOSE) {

  832. 					if (editingSequence) {

  833. 						transposeOffset += deltaKnob;

  834. 						if (transposeOffset > 99) transposeOffset = 99;

  835. 						if (transposeOffset < -99) transposeOffset = -99;						

  836. 						// Tranpose by this number of semi-tones: deltaKnob

  837. 						float transposeOffsetCV = ((float)(deltaKnob))/12.0f;

  838. 						if (stepConfig == 1){ // 2x16 (transpose only the 16 steps corresponding to row where stepIndexEdit is located)

  839. 							int offset = stepIndexEdit < 16 ? 0 : 16;

  840. 							for (int s = offset; s < offset + 16; s++) 

  841. 								cv[sequence][s] += transposeOffsetCV;

  842. 						}

  843. 						else { // 1x32 (transpose all 32 steps)

  844. 							for (int s = 0; s < 32; s++) 

  845. 								cv[sequence][s] += transposeOffsetCV;

  846. 						}

  847. 					}

  848. 				}

  849. 				else if (displayState == DISP_ROTATE) {

  850. 					if (editingSequence) {

  851. 						rotateOffset += deltaKnob;

  852. 						if (rotateOffset > 99) rotateOffset = 99;

  853. 						if (rotateOffset < -99) rotateOffset = -99;	

  854. 						if (deltaKnob > 0 && deltaKnob < 99) {// Rotate right, 99 is safety

  855. 							for (int i = deltaKnob; i > 0; i--)

  856. 								rotateSeq(sequence, true, lengths[sequence], stepConfig == 1 && stepIndexEdit >= 16);

  857. 						}

  858. 						if (deltaKnob < 0 && deltaKnob > -99) {// Rotate left, 99 is safety

  859. 							for (int i = deltaKnob; i < 0; i++)

  860. 								rotateSeq(sequence, false, lengths[sequence], stepConfig == 1 && stepIndexEdit >= 16);

  861. 						}

  862. 					}						

  863. 				}

  864. 				else {// DISP_NORMAL

  865. 					if (editingSequence) {

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

  867. 							sequence += deltaKnob;

  868. 							if (sequence < 0) sequence = 0;

  869. 							if (sequence >= 32) sequence = (32 - 1);

  870. 						}

  871. 					}

  872. 					else {

  873. 						// // no roll over

  874. 						// phrase[phraseIndexEdit] += deltaKnob;

  875. 						// if (phrase[phraseIndexEdit] < 0) phrase[phraseIndexEdit] = 0;

  876. 						// if (phrase[phraseIndexEdit] >= 32) phrase[phraseIndexEdit] = (32 - 1);

  877. 

  878. 						// roll over

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

  880. 						if (newPhrase < 0)

  881. 							newPhrase += (1 - newPhrase / 32) * 32;// newPhrase now positive

  882. 						newPhrase = newPhrase % 32;

  883. 						phrase[phraseIndexEdit] = newPhrase;

  884. 

  885. 					}

  886. 				}

  887. 			}

  888.          sequenceKnob = newSequenceKnob;

  889. 		}	

  890. 		

  891. 		// Octave buttons

  892. 		int newOct = -1;

  893. 		for (int i = 0; i < 7; i++) {

  894. 			if (octTriggers[i].process(params[OCTAVE_PARAM + i].value)) {

  895. 				newOct = 6 - i;

  896. 				displayState = DISP_NORMAL;

  897. 			}

  898. 		}

  899. 		if (newOct >= 0 && newOct <= 6) {

  900. 			if (editingSequence) {

  901. 				if (getTied(sequence,stepIndexEdit))

  902. 					tiedWarning = (long) (tiedWarningTime * sampleRate / displayRefreshStepSkips);

  903. 				else {			

  904. 					float newCV = cv[sequence][stepIndexEdit] + 10.0f;//to properly handle negative note voltages

  905. 					newCV = newCV - floor(newCV) + (float) (newOct - 3);

  906. 					if (newCV >= -3.0f && newCV < 4.0f) {

  907. 						cv[sequence][stepIndexEdit] = newCV;

  908. 						applyTiedStep(sequence, stepIndexEdit, ((stepIndexEdit >= 16 && stepConfig == 1) ? 16 : 0) + lengths[sequence]);

  909. 					}

  910. 					editingGate = (unsigned long) (gateTime * sampleRate / displayRefreshStepSkips);

  911. 					editingGateCV = cv[sequence][stepIndexEdit];

  912. 					editingGateKeyLight = -1;

  913. 					editingChannel = (stepIndexEdit >= 16 * stepConfig) ? 1 : 0;

  914. 				}

  915. 			}

  916. 		}		

  917. 		

  918. 		// Keyboard buttons

  919. 		for (int i = 0; i < 12; i++) {

  920. 			if (keyTriggers[i].process(params[KEY_PARAMS + i].value)) {

  921. 				if (editingSequence) {

  922. 					if (editingGateLength != 0l) {

  923. 						int newMode = keyIndexToGateMode(i, pulsesPerStep);

  924. 						if (editingGateLength > 0l) {

  925. 							if (newMode != -1)

  926. 								setGate1Mode(sequence, stepIndexEdit, newMode);

  927. 							else

  928. 								editingPpqn = (long) (editGateLengthTime * sampleRate / displayRefreshStepSkips);

  929. 							editingGateLength = ((long) (editGateLengthTime * sampleRate / displayRefreshStepSkips) * editGateLengthTimeInitMult);

  930. 						}

  931. 						else {

  932. 							if (newMode != -1)

  933. 								setGate2Mode(sequence, stepIndexEdit, newMode);

  934. 							else

  935. 								editingPpqn = (long) (editGateLengthTime * sampleRate / displayRefreshStepSkips);

  936. 							editingGateLength = -1l * ((long) (editGateLengthTime * sampleRate / displayRefreshStepSkips) * editGateLengthTimeInitMult);

  937. 						}

  938. 					}

  939. 					else if (getTied(sequence,stepIndexEdit)) {

  940. 						if (params[KEY_PARAMS + i].value > 1.5f)

  941. 							stepIndexEdit = moveIndex(stepIndexEdit, stepIndexEdit + 1, 32);

  942. 						else

  943. 							tiedWarning = (long) (tiedWarningTime * sampleRate / displayRefreshStepSkips);

  944. 					}

  945. 					else {			

  946. 						cv[sequence][stepIndexEdit] = floor(cv[sequence][stepIndexEdit]) + ((float) i) / 12.0f;

  947. 						applyTiedStep(sequence, stepIndexEdit, ((stepIndexEdit >= 16 && stepConfig == 1) ? 16 : 0) + lengths[sequence]);

  948. 						editingGate = (unsigned long) (gateTime * sampleRate / displayRefreshStepSkips);

  949. 						editingGateCV = cv[sequence][stepIndexEdit];

  950. 						editingGateKeyLight = -1;

  951. 						editingChannel = (stepIndexEdit >= 16 * stepConfig) ? 1 : 0;

  952. 						if (params[KEY_PARAMS + i].value > 1.5f) {

  953. 							stepIndexEdit = moveIndex(stepIndexEdit, stepIndexEdit + 1, 32);

  954. 							editingGateKeyLight = i;

  955. 						}

  956. 					}						

  957. 				}

  958. 				displayState = DISP_NORMAL;

  959. 			}

  960. 		}

  961. 				

  962. 		// Gate1, Gate1Prob, Gate2, Slide and Tied buttons

  963. 		if (gate1Trigger.process(params[GATE1_PARAM].value)) {

  964. 			if (editingSequence) {

  965. 				toggleGate1a(&attributes[sequence][stepIndexEdit]);

  966. 				//if (!running) {

  967. 					if (pulsesPerStep != 1) {

  968. 						editingGateLength = getGate1(sequence,stepIndexEdit) ? ((long) (editGateLengthTime * sampleRate / displayRefreshStepSkips) * editGateLengthTimeInitMult) : 0l;

  969. 						gate1HoldDetect.start((long) (holdDetectTime * sampleRate / displayRefreshStepSkips));

  970. 					}

  971. 				//}

  972. 			}

  973. 			displayState = DISP_NORMAL;

  974. 		}		

  975. 		if (gate1ProbTrigger.process(params[GATE1_PROB_PARAM].value)) {

  976. 			if (editingSequence) {

  977. 				if (getTied(sequence,stepIndexEdit))

  978. 					tiedWarning = (long) (tiedWarningTime * sampleRate / displayRefreshStepSkips);

  979. 				else

  980. 					toggleGate1Pa(&attributes[sequence][stepIndexEdit]);

  981. 			}

  982. 			displayState = DISP_NORMAL;

  983. 		}		

  984. 		if (gate2Trigger.process(params[GATE2_PARAM].value)) {

  985. 			if (editingSequence) {

  986. 				toggleGate2a(&attributes[sequence][stepIndexEdit]);

  987. 				//if (!running) {

  988. 					if (pulsesPerStep != 1) {

  989. 						editingGateLength = getGate2(sequence,stepIndexEdit) ? -1l * ((long) (editGateLengthTime * sampleRate / displayRefreshStepSkips) * editGateLengthTimeInitMult) : 0l;

  990. 						gate2HoldDetect.start((long) (holdDetectTime * sampleRate / displayRefreshStepSkips));

  991. 					}

  992. 				//}

  993. 			}

  994. 			displayState = DISP_NORMAL;

  995. 		}		

  996. 		if (slideTrigger.process(params[SLIDE_BTN_PARAM].value)) {

  997. 			if (editingSequence) {

  998. 				if (getTied(sequence,stepIndexEdit))

  999. 					tiedWarning = (long) (tiedWarningTime * sampleRate / displayRefreshStepSkips);

  1000. 				else

  1001. 					toggleSlideA(&attributes[sequence][stepIndexEdit]);

  1002. 			}

  1003. 			displayState = DISP_NORMAL;

  1004. 		}		

  1005. 		if (tiedTrigger.process(params[TIE_PARAM].value)) {

  1006. 			if (editingSequence) {

  1007. 				toggleTiedA(&attributes[sequence][stepIndexEdit]);

  1008. 				if (getTied(sequence,stepIndexEdit)) {

  1009. 					setGate1a(&attributes[sequence][stepIndexEdit], false);

  1010. 					setGate2a(&attributes[sequence][stepIndexEdit], false);

  1011. 					setSlideA(&attributes[sequence][stepIndexEdit], false);

  1012. 					applyTiedStep(sequence, stepIndexEdit, ((stepIndexEdit >= 16 && stepConfig == 1) ? 16 : 0) + lengths[sequence]);

  1013. 				}

  1014. 			}

  1015. 			displayState = DISP_NORMAL;

  1016. 		}		

  1017. 		

  1018. 		

  1019. 		//********** Clock and reset **********

  1020. 		

  1021. 		// Clock

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

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

  1024. 				ppqnCount++;

  1025. 				if (ppqnCount >= pulsesPerStep)

  1026. 					ppqnCount = 0;

  1027. 

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

  1029. 				if (ppqnCount == 0) {

  1030. 					float slideFromCV[2] = {0.0f, 0.0f};

  1031. 					if (editingSequence) {

  1032. 						for (int i = 0; i < 2; i += stepConfig)

  1033. 							slideFromCV[i] = cv[sequence][(i * 16) + stepIndexRun];

  1034. 						moveIndexRunMode(&stepIndexRun, lengths[sequence], runModeSeq[sequence], &stepIndexRunHistory);

  1035. 					}

  1036. 					else {

  1037. 						for (int i = 0; i < 2; i += stepConfig)

  1038. 							slideFromCV[i] = cv[phrase[phraseIndexRun]][(i * 16) + stepIndexRun];

  1039. 						if (moveIndexRunMode(&stepIndexRun, lengths[phrase[phraseIndexRun]], runModeSeq[phrase[phraseIndexRun]], &stepIndexRunHistory)) {

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

  1041. 							stepIndexRun = (runModeSeq[phrase[phraseIndexRun]] == MODE_REV ? lengths[phrase[phraseIndexRun]] - 1 : 0);// must always refresh after phraseIndexRun has changed

  1042. 						}

  1043. 						newSeq = phrase[phraseIndexRun];

  1044. 					}

  1045. 					

  1046. 					// Slide

  1047. 					for (int i = 0; i < 2; i += stepConfig) {

  1048. 						if (getSlide(newSeq, (i * 16) + stepIndexRun)) {

  1049. 							// activate sliding (slideStepsRemain can be reset, else runs down to 0, either way, no need to reinit)

  1050. 							slideStepsRemain[i] =   (unsigned long) (((float)clockPeriod  * pulsesPerStep)   * params[SLIDE_KNOB_PARAM].value / 2.0f);// 0-T slide, where T is clock period (can be too long when user does clock gating)

  1051. 							//slideStepsRemain[i] = (unsigned long)  (engineGetSampleRate() * params[SLIDE_KNOB_PARAM].value );// 0-2s slide

  1052. 							float slideToCV = cv[newSeq][(i * 16) + stepIndexRun];

  1053. 							slideCVdelta[i] = (slideToCV - slideFromCV[i])/(float)slideStepsRemain[i];

  1054. 						}

  1055. 					}

  1056. 				}

  1057. 				else {

  1058. 					if (!editingSequence)

  1059. 						newSeq = phrase[phraseIndexRun];

  1060. 				}

  1061. 				for (int i = 0; i < 2; i += stepConfig) {

  1062. 					if (gate1Code[i] != -1 || ppqnCount == 0)

  1063. 						gate1Code[i] = calcGate1Code(attributes[newSeq][(i * 16) + stepIndexRun], ppqnCount, pulsesPerStep, params[GATE1_KNOB_PARAM].value);

  1064. 					gate2Code[i] = calcGate2Code(attributes[newSeq][(i * 16) + stepIndexRun], ppqnCount, pulsesPerStep);	

  1065. 				}

  1066. 			}

  1067. 			clockPeriod = 0ul;

  1068. 		}

  1069. 		clockPeriod++;

  1070. 		

  1071. 		// Reset

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

  1073. 			//stepIndexEdit = 0;

  1074. 			//sequence = 0;

  1075. 			initRun(stepConfig, true);// must be after sequence reset

  1076. 			resetLight = 1.0f;

  1077. 			displayState = DISP_NORMAL;

  1078. 			clockTrigger.reset();

  1079. 		}

  1080. 		

  1081. 		

  1082. 		//********** Outputs and lights **********

  1083. 				

  1084. 		// CV and gates outputs

  1085. 		int seq = editingSequence ? (sequence) : (running ? phrase[phraseIndexRun] : phrase[phraseIndexEdit]);

  1086. 		int step = editingSequence ? (running ? stepIndexRun : stepIndexEdit) : (stepIndexRun);

  1087. 		if (running) {

  1088. 			float slideOffset[2];

  1089. 			for (int i = 0; i < 2; i += stepConfig)

  1090. 				slideOffset[i] = (slideStepsRemain[i] > 0ul ? (slideCVdelta[i] * (float)slideStepsRemain[i]) : 0.0f);

  1091. 			outputs[CVA_OUTPUT].value = cv[seq][step] - slideOffset[0];

  1092. 			outputs[GATE1A_OUTPUT].value = calcGate(gate1Code[0], clockTrigger, clockPeriod, sampleRate) ? 10.0f : 0.0f;

  1093. 			outputs[GATE2A_OUTPUT].value = calcGate(gate2Code[0], clockTrigger, clockPeriod, sampleRate) ? 10.0f : 0.0f;

  1094. 			if (stepConfig == 1) {

  1095. 				outputs[CVB_OUTPUT].value = cv[seq][16 + step] - slideOffset[1];

  1096. 				outputs[GATE1B_OUTPUT].value = calcGate(gate1Code[1], clockTrigger, clockPeriod, sampleRate) ? 10.0f : 0.0f;

  1097. 				outputs[GATE2B_OUTPUT].value = calcGate(gate2Code[1], clockTrigger, clockPeriod, sampleRate) ? 10.0f : 0.0f;

  1098. 			} 

  1099. 			else {

  1100. 				outputs[CVB_OUTPUT].value = 0.0f;

  1101. 				outputs[GATE1B_OUTPUT].value = 0.0f;

  1102. 				outputs[GATE2B_OUTPUT].value = 0.0f;

  1103. 			}

  1104. 		}

  1105. 		else {// not running 

  1106. 			if (editingChannel == 0) {

  1107. 				outputs[CVA_OUTPUT].value = (editingGate > 0ul) ? editingGateCV : cv[seq][step];

  1108. 				outputs[GATE1A_OUTPUT].value = (editingGate > 0ul) ? 10.0f : 0.0f;

  1109. 				outputs[GATE2A_OUTPUT].value = (editingGate > 0ul) ? 10.0f : 0.0f;

  1110. 				outputs[CVB_OUTPUT].value = 0.0f;

  1111. 				outputs[GATE1B_OUTPUT].value = 0.0f;

  1112. 				outputs[GATE2B_OUTPUT].value = 0.0f;

  1113. 			}

  1114. 			else {

  1115. 				outputs[CVA_OUTPUT].value = 0.0f;

  1116. 				outputs[GATE1A_OUTPUT].value = 0.0f;

  1117. 				outputs[GATE2A_OUTPUT].value = 0.0f;

  1118. 				outputs[CVB_OUTPUT].value = (editingGate > 0ul) ? editingGateCV : cv[seq][step];

  1119. 				outputs[GATE1B_OUTPUT].value = (editingGate > 0ul) ? 10.0f : 0.0f;

  1120. 				outputs[GATE2B_OUTPUT].value = (editingGate > 0ul) ? 10.0f : 0.0f;

  1121. 			}

  1122. 		}

  1123. 		for (int i = 0; i < 2; i++)

  1124. 			if (slideStepsRemain[i] > 0ul)

  1125. 				slideStepsRemain[i]--;

  1126. 

  1127. 		

  1128. 		lightRefreshCounter++;

  1129. 		if (lightRefreshCounter > displayRefreshStepSkips) {

  1130. 			lightRefreshCounter = 0;

  1131. 		

  1132. 			// Step/phrase lights

  1133. 			if (infoCopyPaste != 0l) {

  1134. 				for (int i = 0; i < 32; i++) {

  1135. 					if ( (i >= stepIndexEdit && i < (stepIndexEdit + countCP)) || (countCP == 32) )

  1136. 						lights[STEP_PHRASE_LIGHTS + (i<<1)].value = 0.5f;// Green when copy interval

  1137. 					else

  1138. 						lights[STEP_PHRASE_LIGHTS + (i<<1)].value = 0.0f; // Green (nothing)

  1139. 					lights[STEP_PHRASE_LIGHTS + (i<<1) + 1].value = 0.0f;// Red (nothing)

  1140. 				}

  1141. 			}

  1142. 			else {

  1143. 				for (int i = 0; i < 32; i++) {

  1144. 					int col = (stepConfig == 1 ? (i & 0xF) : i);//i % (16 * stepConfig);// optimized

  1145. 					if (displayState == DISP_LENGTH) {

  1146. 						if (editingSequence) {

  1147. 							if (col < (lengths[sequence] - 1))

  1148. 								setGreenRed(STEP_PHRASE_LIGHTS + i * 2, 0.1f, 0.0f);

  1149. 							else if (col == (lengths[sequence] - 1))

  1150. 								setGreenRed(STEP_PHRASE_LIGHTS + i * 2, 1.0f, 0.0f);

  1151. 							else 

  1152. 								setGreenRed(STEP_PHRASE_LIGHTS + i * 2, 0.0f, 0.0f);

  1153. 						}

  1154. 						else {

  1155. 							if (i < phrases - 1)

  1156. 								setGreenRed(STEP_PHRASE_LIGHTS + i * 2, 0.1f, 0.0f);

  1157. 							else

  1158. 								setGreenRed(STEP_PHRASE_LIGHTS + i * 2, (i == phrases - 1) ? 1.0f : 0.0f, 0.0f);

  1159. 						}

  1160. 					}

  1161. 					else {// normal led display (i.e. not length)

  1162. 						float red = 0.0f;

  1163. 						float green = 0.0f;

  1164. 						

  1165. 						// Run cursor (green)

  1166. 						if (editingSequence)

  1167. 							green = ((running && (col == stepIndexRun)) ? 1.0f : 0.0f);

  1168. 						else {

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

  1170. 							green += ((running && (col == stepIndexRun) && i != phraseIndexEdit) ? 0.1f : 0.0f);

  1171. 							green = clamp(green, 0.0f, 1.0f);

  1172. 						}

  1173. 						// Edit cursor (red)

  1174. 						if (editingSequence)

  1175. 							red = (i == stepIndexEdit ? 1.0f : 0.0f);

  1176. 						else

  1177. 							red = (i == phraseIndexEdit ? 1.0f : 0.0f);

  1178. 						

  1179. 						setGreenRed(STEP_PHRASE_LIGHTS + i * 2, green, red);

  1180. 					}

  1181. 				}

  1182. 			}

  1183. 		

  1184. 			// Octave lights

  1185. 			float octCV = 0.0f;

  1186. 			if (editingSequence)

  1187. 				octCV = cv[sequence][stepIndexEdit];

  1188. 			else

  1189. 				octCV = cv[phrase[phraseIndexEdit]][stepIndexRun];

  1190. 			int octLightIndex = (int) floor(octCV + 3.0f);

  1191. 			for (int i = 0; i < 7; i++) {

  1192. 				if (!editingSequence && (!attached || !running || (stepConfig == 1)))// no oct lights when song mode and either (detached [1] or stopped [2] or 2x16config [3])

  1193. 												// [1] makes no sense, can't mod steps and stepping though seq that may not be playing

  1194. 												// [2] CV is set to 0V when not running and in song mode, so cv[][] makes no sense to display

  1195. 												// [3] makes no sense, which sequence would be displayed, top or bottom row!

  1196. 					lights[OCTAVE_LIGHTS + i].value = 0.0f;

  1197. 				else {

  1198. 					if (tiedWarning > 0l) {

  1199. 						bool warningFlashState = calcWarningFlash(tiedWarning, (long) (tiedWarningTime * sampleRate / displayRefreshStepSkips));

  1200. 						lights[OCTAVE_LIGHTS + i].value = (warningFlashState && (i == (6 - octLightIndex))) ? 1.0f : 0.0f;

  1201. 					}

  1202. 					else				

  1203. 						lights[OCTAVE_LIGHTS + i].value = (i == (6 - octLightIndex) ? 1.0f : 0.0f);

  1204. 				}

  1205. 			}

  1206. 			

  1207. 			// Keyboard lights (can only show channel A when running attached in 1x16 mode, does not pose problem for all other situations)

  1208. 			float cvValOffset;

  1209. 			if (editingSequence) 

  1210. 				cvValOffset = cv[sequence][stepIndexEdit] + 10.0f;//to properly handle negative note voltages

  1211. 			else	

  1212. 				cvValOffset = cv[phrase[phraseIndexEdit]][stepIndexRun] + 10.0f;//to properly handle negative note voltages

  1213. 			int keyLightIndex = (int) clamp(  roundf( (cvValOffset-floor(cvValOffset)) * 12.0f ),  0.0f,  11.0f);

  1214. 			if (editingGateLength != 0 && editingSequence) {

  1215. 				int modeLightIndex = gateModeToKeyLightIndex(attributes[sequence][stepIndexEdit], editingGateLength > 0l);

  1216. 				for (int i = 0; i < 12; i++) {

  1217. 					if (i == modeLightIndex) {

  1218. 						lights[KEY_LIGHTS + i * 2 + 0].value = editingGateLength > 0l ? 1.0f : 0.2f;

  1219. 						lights[KEY_LIGHTS + i * 2 + 1].value = editingGateLength > 0l ? 0.2f : 1.0f;

  1220. 					}

  1221. 					else { 

  1222. 						lights[KEY_LIGHTS + i * 2 + 0].value = 0.0f;

  1223. 						if (i == keyLightIndex) 

  1224. 							lights[KEY_LIGHTS + i * 2 + 1].value = 0.1f;	

  1225. 						else 

  1226. 							lights[KEY_LIGHTS + i * 2 + 1].value = 0.0f;

  1227. 					}

  1228. 				}

  1229. 			}

  1230. 			else {

  1231. 				for (int i = 0; i < 12; i++) {

  1232. 					lights[KEY_LIGHTS + i * 2 + 0].value = 0.0f;

  1233. 					if (!editingSequence && (!attached || !running || (stepConfig == 1)))// no oct lights when song mode and either (detached [1] or stopped [2] or 2x16config [3])

  1234. 													// [1] makes no sense, can't mod steps and stepping though seq that may not be playing

  1235. 													// [2] CV is set to 0V when not running and in song mode, so cv[][] makes no sense to display

  1236. 													// [3] makes no sense, which sequence would be displayed, top or bottom row!

  1237. 						lights[KEY_LIGHTS + i * 2 + 1].value = 0.0f;

  1238. 					else {

  1239. 						if (tiedWarning > 0l) {

  1240. 							bool warningFlashState = calcWarningFlash(tiedWarning, (long) (tiedWarningTime * sampleRate / displayRefreshStepSkips));

  1241. 							lights[KEY_LIGHTS + i * 2 + 1].value = (warningFlashState && i == keyLightIndex) ? 1.0f : 0.0f;

  1242. 						}

  1243. 						else {

  1244. 							if (editingGate > 0ul && editingGateKeyLight != -1)

  1245. 								lights[KEY_LIGHTS + i * 2 + 1].value = (i == editingGateKeyLight ? ((float) editingGate / (float)(gateTime * sampleRate / displayRefreshStepSkips)) : 0.0f);

  1246. 							else

  1247. 								lights[KEY_LIGHTS + i * 2 + 1].value = (i == keyLightIndex ? 1.0f : 0.0f);

  1248. 						}

  1249. 					}

  1250. 				}

  1251. 			}			

  1252. 			

  1253. 			// Gate1, Gate1Prob, Gate2, Slide and Tied lights (can only show channel A when running attached in 1x16 mode, does not pose problem for all other situations)

  1254. 			int attributesVal = attributes[sequence][stepIndexEdit];

  1255. 			if (!editingSequence)

  1256. 				attributesVal = attributes[phrase[phraseIndexEdit]][stepIndexRun];

  1257. 			//

  1258. 			setGateLight(getGate1a(attributesVal), GATE1_LIGHT);

  1259. 			setGateLight(getGate2a(attributesVal), GATE2_LIGHT);

  1260. 			lights[GATE1_PROB_LIGHT].value = getGate1Pa(attributesVal) ? 1.0f : 0.0f;

  1261. 			lights[SLIDE_LIGHT].value = getSlideA(attributesVal) ? 1.0f : 0.0f;

  1262. 			if (tiedWarning > 0l) {

  1263. 				bool warningFlashState = calcWarningFlash(tiedWarning, (long) (tiedWarningTime * sampleRate / displayRefreshStepSkips));

  1264. 				lights[TIE_LIGHT].value = (warningFlashState) ? 1.0f : 0.0f;

  1265. 			}

  1266. 			else

  1267. 				lights[TIE_LIGHT].value = getTiedA(attributesVal) ? 1.0f : 0.0f;

  1268. 

  1269. 			// Attach light

  1270. 			lights[ATTACH_LIGHT].value = (running && attached) ? 1.0f : 0.0f;

  1271. 			

  1272. 			// Reset light

  1273. 			lights[RESET_LIGHT].value =	resetLight;

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

  1275. 			

  1276. 			// Run light

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

  1278. 

  1279. 			if (editingGate > 0ul)

  1280. 				editingGate--;

  1281. 			if (infoCopyPaste != 0l) {

  1282. 				if (infoCopyPaste > 0l)

  1283. 					infoCopyPaste --;

  1284. 				if (infoCopyPaste < 0l)

  1285. 					infoCopyPaste ++;

  1286. 			}

  1287. 			if (editingGateLength != 0l) {

  1288. 				if (editingGateLength > 0l)

  1289. 					editingGateLength --;

  1290. 				if (editingGateLength < 0l)

  1291. 					editingGateLength ++;

  1292. 			}

  1293. 			if (editingPpqn > 0l)

  1294. 				editingPpqn--;

  1295. 			if (tiedWarning > 0l)

  1296. 				tiedWarning--;

  1297. 			if (modeHoldDetect.process(params[RUNMODE_PARAM].value)) {

  1298. 				displayState = DISP_NORMAL;

  1299. 				editingPpqn = (long) (editGateLengthTime * sampleRate / displayRefreshStepSkips);

  1300. 			}

  1301. 			if (gate1HoldDetect.process(params[GATE1_PARAM].value)) {

  1302. 				toggleGate1a(&attributes[sequence][stepIndexEdit]);

  1303. 				editGateLengthTimeInitMult = 1;

  1304. 			}

  1305. 			if (gate2HoldDetect.process(params[GATE2_PARAM].value)) {

  1306. 				toggleGate2a(&attributes[sequence][stepIndexEdit]);

  1307. 				editGateLengthTimeInitMult = 100;

  1308. 			}

  1309. 			if (revertDisplay > 0l) {

  1310. 				if (revertDisplay == 1)

  1311. 					displayState = DISP_NORMAL;

  1312. 				revertDisplay--;

  1313. 			}

  1314. 		}// lightRefreshCounter

  1315. 				

  1316. 		if (clockIgnoreOnReset > 0l)

  1317. 			clockIgnoreOnReset--;

  1318. 	}// step()

  1319. 	

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

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

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

  1323. 	}

  1324. 

  1325. 	void applyTiedStep(int seqNum, int indexTied, int seqLength) {

  1326. 		// Start on indexTied and loop until seqLength

  1327. 		// Called because either:

  1328. 		//   case A: tied was activated for given step

  1329. 		//   case B: the given step's CV was modified

  1330. 		// These cases are mutually exclusive

  1331. 		

  1332. 		// copy previous CV over to current step if tied

  1333. 		if (getTied(seqNum,indexTied) && (indexTied > 0))

  1334. 			cv[seqNum][indexTied] = cv[seqNum][indexTied - 1];

  1335. 		

  1336. 		// Affect downstream CVs of subsequent tied note chain (can be 0 length if next note is not tied)

  1337. 		for (int i = indexTied + 1; i < seqLength && getTied(seqNum,i); i++) 

  1338. 			cv[seqNum][i] = cv[seqNum][indexTied];

  1339. 	}

  1340. 	

  1341. 	int calcNewGateMode(int currentGateMode, int deltaKnob) {

  1342. 		return clamp(currentGateMode + deltaKnob, 0, NUM_GATES - 1); 

  1343. 	}

  1344. 	

  1345. 	inline void setGateLight(bool gateOn, int lightIndex) {

  1346. 		if (!gateOn) {

  1347. 			lights[lightIndex + 0].value = 0.0f;

  1348. 			lights[lightIndex + 1].value = 0.0f;

  1349. 		}

  1350. 		else if (pulsesPerStep == 1) {

  1351. 			lights[lightIndex + 0].value = 0.0f;

  1352. 			lights[lightIndex + 1].value = 1.0f;

  1353. 		}

  1354. 		else {

  1355. 			lights[lightIndex + 0].value = lightIndex == GATE1_LIGHT ? 1.0f : 0.2f;

  1356. 			lights[lightIndex + 1].value = lightIndex == GATE1_LIGHT ? 0.2f : 1.0f;

  1357. 		}

  1358. 	}

  1359. 

  1360. };

  1361. 

  1362. 

  1363. 

  1364. struct PhraseSeq32Widget : ModuleWidget {

  1365. 	PhraseSeq32 *module;

  1366. 	DynamicSVGPanel *panel;

  1367. 	int oldExpansion;

  1368. 	int expWidth = 60;

  1369. 	IMPort* expPorts[5];

  1370. 	

  1371. 	struct SequenceDisplayWidget : TransparentWidget {

  1372. 		PhraseSeq32 *module;

  1373. 		std::shared_ptr<Font> font;

  1374. 		char displayStr[4];

  1375. 		

  1376. 		SequenceDisplayWidget() {

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

  1378. 		}

  1379. 		

  1380. 		void runModeToStr(int num) {

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

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

  1383. 		}

  1384. 

  1385. 		void draw(NVGcontext *vg) override {

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

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

  1388. 			//nvgTextLetterSpacing(vg, 2.5);

  1389. 

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

  1391. 			nvgFillColor(vg, nvgTransRGBA(textColor, 16));

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

  1393. 			nvgFillColor(vg, textColor);

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

  1395. 				if (module->infoCopyPaste > 0l)

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

  1397. 				else

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

  1399. 			}

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

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

  1402. 			}

  1403. 			else if (module->displayState == PhraseSeq32::DISP_MODE) {

  1404. 				if (module->editingSequence)

  1405. 					runModeToStr(module->runModeSeq[module->sequence]);

  1406. 				else

  1407. 					runModeToStr(module->runModeSong);

  1408. 			}

  1409. 			else if (module->displayState == PhraseSeq32::DISP_LENGTH) {

  1410. 				if (module->editingSequence)

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

  1412. 				else

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

  1414. 			}

  1415. 			else if (module->displayState == PhraseSeq32::DISP_TRANSPOSE) {

  1416. 				snprintf(displayStr, 4, "+%2u", (unsigned) abs(module->transposeOffset));

  1417. 				if (module->transposeOffset < 0)

  1418. 					displayStr[0] = '-';

  1419. 			}

  1420. 			else if (module->displayState == PhraseSeq32::DISP_ROTATE) {

  1421. 				snprintf(displayStr, 4, ")%2u", (unsigned) abs(module->rotateOffset));

  1422. 				if (module->rotateOffset < 0)

  1423. 					displayStr[0] = '(';

  1424. 			}

  1425. 			else {// DISP_NORMAL

  1426. 				snprintf(displayStr, 4, " %2u", (unsigned) (module->editingSequence ? 

  1427. 					module->sequence : module->phrase[module->phraseIndexEdit]) + 1 );

  1428. 			}

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

  1430. 		}

  1431. 	};		

  1432. 	

  1433. 	struct PanelThemeItem : MenuItem {

  1434. 		PhraseSeq32 *module;

  1435. 		int theme;

  1436. 		void onAction(EventAction &e) override {

  1437. 			module->panelTheme = theme;

  1438. 		}

  1439. 		void step() override {

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

  1441. 		}

  1442. 	};

  1443. 	struct ExpansionItem : MenuItem {

  1444. 		PhraseSeq32 *module;

  1445. 		void onAction(EventAction &e) override {

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

  1447. 		}

  1448. 	};

  1449. 	struct ResetOnRunItem : MenuItem {

  1450. 		PhraseSeq32 *module;

  1451. 		void onAction(EventAction &e) override {

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

  1453. 		}

  1454. 	};

  1455. 	Menu *createContextMenu() override {

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

  1457. 

  1458. 		MenuLabel *spacerLabel = new MenuLabel();

  1459. 		menu->addChild(spacerLabel);

  1460. 

  1461. 		PhraseSeq32 *module = dynamic_cast<PhraseSeq32*>(this->module);

  1462. 		assert(module);

  1463. 

  1464. 		MenuLabel *themeLabel = new MenuLabel();

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

  1466. 		menu->addChild(themeLabel);

  1467. 

  1468. 		PanelThemeItem *lightItem = new PanelThemeItem();

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

  1470. 		lightItem->module = module;

  1471. 		lightItem->theme = 0;

  1472. 		menu->addChild(lightItem);

  1473. 

  1474. 		PanelThemeItem *darkItem = new PanelThemeItem();

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

  1476. 		darkItem->module = module;

  1477. 		darkItem->theme = 1;

  1478. 		menu->addChild(darkItem);

  1479. 

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

  1481. 		

  1482. 		MenuLabel *settingsLabel = new MenuLabel();

  1483. 		settingsLabel->text = "Settings";

  1484. 		menu->addChild(settingsLabel);

  1485. 		

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

  1487. 		rorItem->module = module;

  1488. 		menu->addChild(rorItem);

  1489. 

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

  1491. 		

  1492. 		MenuLabel *expansionLabel = new MenuLabel();

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

  1494. 		menu->addChild(expansionLabel);

  1495. 

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

  1497. 		expItem->module = module;

  1498. 		menu->addChild(expItem);

  1499. 		

  1500. 		return menu;

  1501. 	}	

  1502. 	

  1503. 	void step() override {

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

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

  1506. 				for (int i = 0; i < 5; i++)

  1507. 					rack::global_ui->app.gRackWidget->wireContainer->removeAllWires(expPorts[i]);

  1508. 			}

  1509. 			oldExpansion = module->expansion;		

  1510. 		}

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

  1512. 		Widget::step();

  1513. 	}

  1514. 	

  1515. 	PhraseSeq32Widget(PhraseSeq32 *module) : ModuleWidget(module) {

  1516. 		this->module = module;

  1517. 		oldExpansion = -1;

  1518. 		

  1519. 		// Main panel from Inkscape

  1520.         panel = new DynamicSVGPanel();

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

  1522. 		panel->expWidth = &expWidth;

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

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

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

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

  1527.         addChild(panel);

  1528. 		

  1529. 		// Screws

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

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

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

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

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

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

  1536. 

  1537. 		

  1538. 		

  1539. 		// ****** Top row ******

  1540. 		

  1541. 		static const int rowRulerT0 = 48;

  1542. 		static const int columnRulerT0 = 18;//30;// Step/Phase LED buttons

  1543. 		static const int columnRulerT3 = 377;// Attach 

  1544. 		static const int columnRulerT4 = 430;// Config 

  1545. 

  1546. 		// Step/Phrase LED buttons

  1547. 		int posX = columnRulerT0;

  1548. 		static int spacingSteps = 20;

  1549. 		static int spacingSteps4 = 4;

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

  1551. 			// First row

  1552. 			addParam(ParamWidget::create<LEDButton>(Vec(posX, rowRulerT0 - 10 + 3 - 4.4f), module, PhraseSeq32::STEP_PHRASE_PARAMS + x, 0.0f, 1.0f, 0.0f));

  1553. 			addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(posX + 4.4f, rowRulerT0 - 10 + 3), module, PhraseSeq32::STEP_PHRASE_LIGHTS + (x * 2)));

  1554. 			// Second row

  1555. 			addParam(ParamWidget::create<LEDButton>(Vec(posX, rowRulerT0 + 10 + 3 - 4.4f), module, PhraseSeq32::STEP_PHRASE_PARAMS + x + 16, 0.0f, 1.0f, 0.0f));

  1556. 			addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(posX + 4.4f, rowRulerT0 + 10 + 3), module, PhraseSeq32::STEP_PHRASE_LIGHTS + ((x + 16) * 2)));

  1557. 			// step position to next location and handle groups of four

  1558. 			posX += spacingSteps;

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

  1560. 				posX += spacingSteps4;

  1561. 		}

  1562. 		// Attach button and light

  1563. 		addParam(ParamWidget::create<TL1105>(Vec(columnRulerT3 - 4, rowRulerT0 - 6 + 2 + offsetTL1105), module, PhraseSeq32::ATTACH_PARAM, 0.0f, 1.0f, 0.0f));

  1564. 		addChild(ModuleLightWidget::create<MediumLight<RedLight>>(Vec(columnRulerT3 + 12 + offsetMediumLight, rowRulerT0 - 6 + offsetMediumLight), module, PhraseSeq32::ATTACH_LIGHT));		

  1565. 		// Config switch

  1566. 		addParam(ParamWidget::create<CKSS>(Vec(columnRulerT4 + hOffsetCKSS + 1, rowRulerT0 - 6 + vOffsetCKSS), module, PhraseSeq32::CONFIG_PARAM, 0.0f, 1.0f, PhraseSeq32::CONFIG_PARAM_INIT_VALUE));

  1567. 

  1568. 		

  1569. 		

  1570. 		// ****** Octave and keyboard area ******

  1571. 		

  1572. 		// Octave LED buttons

  1573. 		static const float octLightsIntY = 20.0f;

  1574. 		for (int i = 0; i < 7; i++) {

  1575. 			addParam(ParamWidget::create<LEDButton>(Vec(15 + 3, 82 + 24 + i * octLightsIntY- 4.4f), module, PhraseSeq32::OCTAVE_PARAM + i, 0.0f, 1.0f, 0.0f));

  1576. 			addChild(ModuleLightWidget::create<MediumLight<RedLight>>(Vec(15 + 3 + 4.4f, 82 + 24 + i * octLightsIntY), module, PhraseSeq32::OCTAVE_LIGHTS + i));

  1577. 		}

  1578. 		// Keys and Key lights

  1579. 		static const int keyNudgeX = 7;

  1580. 		static const int KeyBlackY = 103;

  1581. 		static const int KeyWhiteY = 141;

  1582. 		static const int offsetKeyLEDx = 6;

  1583. 		static const int offsetKeyLEDy = 16;

  1584. 		// Black keys and lights

  1585. 		addParam(ParamWidget::create<InvisibleKeySmall>(			Vec(65+keyNudgeX, KeyBlackY), module, PhraseSeq32::KEY_PARAMS + 1, 0.0, 1.0, 0.0));

  1586. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(65+keyNudgeX+offsetKeyLEDx, KeyBlackY+offsetKeyLEDy), module, PhraseSeq32::KEY_LIGHTS + 1 * 2));

  1587. 		addParam(ParamWidget::create<InvisibleKeySmall>(			Vec(93+keyNudgeX, KeyBlackY), module, PhraseSeq32::KEY_PARAMS + 3, 0.0, 1.0, 0.0));

  1588. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(93+keyNudgeX+offsetKeyLEDx, KeyBlackY+offsetKeyLEDy), module, PhraseSeq32::KEY_LIGHTS + 3 * 2));

  1589. 		addParam(ParamWidget::create<InvisibleKeySmall>(			Vec(150+keyNudgeX, KeyBlackY), module, PhraseSeq32::KEY_PARAMS + 6, 0.0, 1.0, 0.0));

  1590. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(150+keyNudgeX+offsetKeyLEDx, KeyBlackY+offsetKeyLEDy), module, PhraseSeq32::KEY_LIGHTS + 6 * 2));

  1591. 		addParam(ParamWidget::create<InvisibleKeySmall>(			Vec(178+keyNudgeX, KeyBlackY), module, PhraseSeq32::KEY_PARAMS + 8, 0.0, 1.0, 0.0));

  1592. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(178+keyNudgeX+offsetKeyLEDx, KeyBlackY+offsetKeyLEDy), module, PhraseSeq32::KEY_LIGHTS + 8 * 2));

  1593. 		addParam(ParamWidget::create<InvisibleKeySmall>(			Vec(206+keyNudgeX, KeyBlackY), module, PhraseSeq32::KEY_PARAMS + 10, 0.0, 1.0, 0.0));

  1594. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(206+keyNudgeX+offsetKeyLEDx, KeyBlackY+offsetKeyLEDy), module, PhraseSeq32::KEY_LIGHTS + 10 * 2));

  1595. 		// White keys and lights

  1596. 		addParam(ParamWidget::create<InvisibleKeySmall>(			Vec(51+keyNudgeX, KeyWhiteY), module, PhraseSeq32::KEY_PARAMS + 0, 0.0, 1.0, 0.0));

  1597. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(51+keyNudgeX+offsetKeyLEDx, KeyWhiteY+offsetKeyLEDy), module, PhraseSeq32::KEY_LIGHTS + 0 * 2));

  1598. 		addParam(ParamWidget::create<InvisibleKeySmall>(			Vec(79+keyNudgeX, KeyWhiteY), module, PhraseSeq32::KEY_PARAMS + 2, 0.0, 1.0, 0.0));

  1599. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(79+keyNudgeX+offsetKeyLEDx, KeyWhiteY+offsetKeyLEDy), module, PhraseSeq32::KEY_LIGHTS + 2 * 2));

  1600. 		addParam(ParamWidget::create<InvisibleKeySmall>(			Vec(107+keyNudgeX, KeyWhiteY), module, PhraseSeq32::KEY_PARAMS + 4, 0.0, 1.0, 0.0));

  1601. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(107+keyNudgeX+offsetKeyLEDx, KeyWhiteY+offsetKeyLEDy), module, PhraseSeq32::KEY_LIGHTS + 4 * 2));

  1602. 		addParam(ParamWidget::create<InvisibleKeySmall>(			Vec(136+keyNudgeX, KeyWhiteY), module, PhraseSeq32::KEY_PARAMS + 5, 0.0, 1.0, 0.0));

  1603. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(136+keyNudgeX+offsetKeyLEDx, KeyWhiteY+offsetKeyLEDy), module, PhraseSeq32::KEY_LIGHTS + 5 * 2));

  1604. 		addParam(ParamWidget::create<InvisibleKeySmall>(			Vec(164+keyNudgeX, KeyWhiteY), module, PhraseSeq32::KEY_PARAMS + 7, 0.0, 1.0, 0.0));

  1605. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(164+keyNudgeX+offsetKeyLEDx, KeyWhiteY+offsetKeyLEDy), module, PhraseSeq32::KEY_LIGHTS + 7 * 2));

  1606. 		addParam(ParamWidget::create<InvisibleKeySmall>(			Vec(192+keyNudgeX, KeyWhiteY), module, PhraseSeq32::KEY_PARAMS + 9, 0.0, 1.0, 0.0));

  1607. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(192+keyNudgeX+offsetKeyLEDx, KeyWhiteY+offsetKeyLEDy), module, PhraseSeq32::KEY_LIGHTS + 9 * 2));

  1608. 		addParam(ParamWidget::create<InvisibleKeySmall>(			Vec(220+keyNudgeX, KeyWhiteY), module, PhraseSeq32::KEY_PARAMS + 11, 0.0, 1.0, 0.0));

  1609. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(220+keyNudgeX+offsetKeyLEDx, KeyWhiteY+offsetKeyLEDy), module, PhraseSeq32::KEY_LIGHTS + 11 * 2));

  1610. 		

  1611. 		

  1612. 		

  1613. 		// ****** Right side control area ******

  1614. 

  1615. 		static const int rowRulerMK0 = 101;// Edit mode row

  1616. 		static const int rowRulerMK1 = rowRulerMK0 + 56; // Run row

  1617. 		static const int rowRulerMK2 = rowRulerMK1 + 54; // Copy-paste Tran/rot row

  1618. 		static const int columnRulerMK0 = 278;// Edit mode column

  1619. 		static const int columnRulerMK2 = columnRulerT4;// Mode/Len column

  1620. 		static const int columnRulerMK1 = 353;// Display column

  1621. 		

  1622. 		// Edit mode switch

  1623. 		addParam(ParamWidget::create<CKSS>(Vec(columnRulerMK0 + 2 + hOffsetCKSS, rowRulerMK0 + vOffsetCKSS), module, PhraseSeq32::EDIT_PARAM, 0.0f, 1.0f, PhraseSeq32::EDIT_PARAM_INIT_VALUE));

  1624. 		// Sequence display

  1625. 		SequenceDisplayWidget *displaySequence = new SequenceDisplayWidget();

  1626. 		displaySequence->box.pos = Vec(columnRulerMK1-15, rowRulerMK0 + 3 + vOffsetDisplay);

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

  1628. 		displaySequence->module = module;

  1629. 		addChild(displaySequence);

  1630. 		// Run mode button

  1631. 		addParam(createDynamicParam<IMBigPushButton>(Vec(columnRulerMK2 + offsetCKD6b, rowRulerMK0 + 0 + offsetCKD6b), module, PhraseSeq32::RUNMODE_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1632. 

  1633. 		// Autostep

  1634. 		addParam(ParamWidget::create<CKSS>(Vec(columnRulerMK0 + 2 + hOffsetCKSS, rowRulerMK1 + 7 + vOffsetCKSS), module, PhraseSeq32::AUTOSTEP_PARAM, 0.0f, 1.0f, 1.0f));		

  1635. 		// Sequence knob

  1636.       addParam(createDynamicParam<IMBigKnobInf>(Vec(columnRulerMK1 + 1 + offsetIMBigKnob, rowRulerMK0 + 55 + offsetIMBigKnob), module, PhraseSeq32::SEQUENCE_PARAM, -INFINITY, INFINITY, 0.0f, &module->panelTheme));		

  1637. 		// Transpose/rotate button

  1638. 		addParam(createDynamicParam<IMBigPushButton>(Vec(columnRulerMK2 + offsetCKD6b, rowRulerMK1 + 4 + offsetCKD6b), module, PhraseSeq32::TRAN_ROT_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1639. 		

  1640. 		// Reset LED bezel and light

  1641. 		addParam(ParamWidget::create<LEDBezel>(Vec(columnRulerMK0 - 15 + offsetLEDbezel, rowRulerMK2 + 5 + offsetLEDbezel), module, PhraseSeq32::RESET_PARAM, 0.0f, 1.0f, 0.0f));

  1642. 		addChild(ModuleLightWidget::create<MuteLight<GreenLight>>(Vec(columnRulerMK0 - 15 + offsetLEDbezel + offsetLEDbezelLight, rowRulerMK2 + 5 + offsetLEDbezel + offsetLEDbezelLight), module, PhraseSeq32::RESET_LIGHT));

  1643. 		// Run LED bezel and light

  1644. 		addParam(ParamWidget::create<LEDBezel>(Vec(columnRulerMK0 + 20 + offsetLEDbezel, rowRulerMK2 + 5 + offsetLEDbezel), module, PhraseSeq32::RUN_PARAM, 0.0f, 1.0f, 0.0f));

  1645. 		addChild(ModuleLightWidget::create<MuteLight<GreenLight>>(Vec(columnRulerMK0 + 20 + offsetLEDbezel + offsetLEDbezelLight, rowRulerMK2 + 5 + offsetLEDbezel + offsetLEDbezelLight), module, PhraseSeq32::RUN_LIGHT));

  1646. 		// Copy/paste buttons

  1647. 		addParam(ParamWidget::create<TL1105>(Vec(columnRulerMK1 - 10, rowRulerMK2 + 5 + offsetTL1105), module, PhraseSeq32::COPY_PARAM, 0.0f, 1.0f, 0.0f));

  1648. 		addParam(ParamWidget::create<TL1105>(Vec(columnRulerMK1 + 20, rowRulerMK2 + 5 + offsetTL1105), module, PhraseSeq32::PASTE_PARAM, 0.0f, 1.0f, 0.0f));

  1649. 		// Copy-paste mode switch (3 position)

  1650. 		addParam(ParamWidget::create<CKSSThreeInv>(Vec(columnRulerMK2 + hOffsetCKSS + 1, rowRulerMK2 - 3 + vOffsetCKSSThree), module, PhraseSeq32::CPMODE_PARAM, 0.0f, 2.0f, 2.0f));	// 0.0f is top position

  1651. 

  1652. 		

  1653. 		

  1654. 		// ****** Gate and slide section ******

  1655. 		

  1656. 		static const int rowRulerMB0 = 214;

  1657. 		static const int columnRulerMBspacing = 70;

  1658. 		static const int columnRulerMB2 = 130;// Gate2

  1659. 		static const int columnRulerMB1 = columnRulerMB2 - columnRulerMBspacing;// Gate1 

  1660. 		static const int columnRulerMB3 = columnRulerMB2 + columnRulerMBspacing;// Tie

  1661. 		static const int posLEDvsButton = + 25;

  1662. 		

  1663. 		// Gate 1 light and button

  1664. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(columnRulerMB1 + posLEDvsButton + offsetMediumLight, rowRulerMB0 + 4 + offsetMediumLight), module, PhraseSeq32::GATE1_LIGHT));		

  1665. 		addParam(createDynamicParam<IMBigPushButton>(Vec(columnRulerMB1 + offsetCKD6b, rowRulerMB0 + 4 + offsetCKD6b), module, PhraseSeq32::GATE1_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1666. 		// Gate 2 light and button

  1667. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(columnRulerMB2 + posLEDvsButton + offsetMediumLight, rowRulerMB0 + 4 + offsetMediumLight), module, PhraseSeq32::GATE2_LIGHT));		

  1668. 		addParam(createDynamicParam<IMBigPushButton>(Vec(columnRulerMB2 + offsetCKD6b, rowRulerMB0 + 4 + offsetCKD6b), module, PhraseSeq32::GATE2_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1669. 		// Tie light and button

  1670. 		addChild(ModuleLightWidget::create<MediumLight<RedLight>>(Vec(columnRulerMB3 + posLEDvsButton + offsetMediumLight, rowRulerMB0 + 4 + offsetMediumLight), module, PhraseSeq32::TIE_LIGHT));		

  1671. 		addParam(createDynamicParam<IMBigPushButton>(Vec(columnRulerMB3 + offsetCKD6b, rowRulerMB0 + 4 + offsetCKD6b), module, PhraseSeq32::TIE_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1672. 

  1673. 						

  1674. 		

  1675. 		// ****** Bottom two rows ******

  1676. 		

  1677. 		static const int inputJackSpacingX = 54;

  1678. 		static const int outputJackSpacingX = 45;

  1679. 		static const int rowRulerB0 = 323;

  1680. 		static const int rowRulerB1 = 269;

  1681. 		static const int columnRulerB0 = 22;

  1682. 		static const int columnRulerB1 = columnRulerB0 + inputJackSpacingX;

  1683. 		static const int columnRulerB2 = columnRulerB1 + inputJackSpacingX;

  1684. 		static const int columnRulerB3 = columnRulerB2 + inputJackSpacingX;

  1685. 		static const int columnRulerB4 = columnRulerB3 + inputJackSpacingX;

  1686. 		static const int columnRulerB8 = columnRulerMK2 + 1;

  1687. 		static const int columnRulerB7 = columnRulerB8 - outputJackSpacingX;

  1688. 		static const int columnRulerB6 = columnRulerB7 - outputJackSpacingX;

  1689. 		static const int columnRulerB5 = columnRulerB6 - outputJackSpacingX - 4;// clock and reset

  1690. 

  1691. 		

  1692. 		// Gate 1 probability light and button

  1693. 		addChild(ModuleLightWidget::create<MediumLight<RedLight>>(Vec(columnRulerB0 + posLEDvsButton + offsetMediumLight, rowRulerB1 + offsetMediumLight), module, PhraseSeq32::GATE1_PROB_LIGHT));		

  1694. 		addParam(createDynamicParam<IMBigPushButton>(Vec(columnRulerB0 + offsetCKD6b, rowRulerB1 + offsetCKD6b), module, PhraseSeq32::GATE1_PROB_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1695. 		// Gate 1 probability knob

  1696. 		addParam(createDynamicParam<IMSmallKnob>(Vec(columnRulerB1 + offsetIMSmallKnob, rowRulerB1 + offsetIMSmallKnob), module, PhraseSeq32::GATE1_KNOB_PARAM, 0.0f, 1.0f, 1.0f, &module->panelTheme));

  1697. 		// Slide light and button

  1698. 		addChild(ModuleLightWidget::create<MediumLight<RedLight>>(Vec(columnRulerB2 + posLEDvsButton + offsetMediumLight, rowRulerB1 + offsetMediumLight), module, PhraseSeq32::SLIDE_LIGHT));		

  1699. 		addParam(createDynamicParam<IMBigPushButton>(Vec(columnRulerB2 + offsetCKD6b, rowRulerB1 + offsetCKD6b), module, PhraseSeq32::SLIDE_BTN_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1700. 		// Slide knob

  1701. 		addParam(createDynamicParam<IMSmallKnob>(Vec(columnRulerB3 + offsetIMSmallKnob, rowRulerB1 + offsetIMSmallKnob), module, PhraseSeq32::SLIDE_KNOB_PARAM, 0.0f, 2.0f, 0.2f, &module->panelTheme));

  1702. 		// CV in

  1703. 		addInput(createDynamicPort<IMPort>(Vec(columnRulerB4, rowRulerB1), Port::INPUT, module, PhraseSeq32::CV_INPUT, &module->panelTheme));

  1704. 		// Clock input

  1705. 		addInput(createDynamicPort<IMPort>(Vec(columnRulerB5, rowRulerB1), Port::INPUT, module, PhraseSeq32::CLOCK_INPUT, &module->panelTheme));

  1706. 		// Channel A outputs

  1707. 		addOutput(createDynamicPort<IMPort>(Vec(columnRulerB6, rowRulerB1), Port::OUTPUT, module, PhraseSeq32::CVA_OUTPUT, &module->panelTheme));

  1708. 		addOutput(createDynamicPort<IMPort>(Vec(columnRulerB7, rowRulerB1), Port::OUTPUT, module, PhraseSeq32::GATE1A_OUTPUT, &module->panelTheme));

  1709. 		addOutput(createDynamicPort<IMPort>(Vec(columnRulerB8, rowRulerB1), Port::OUTPUT, module, PhraseSeq32::GATE2A_OUTPUT, &module->panelTheme));

  1710. 

  1711. 

  1712. 		// CV control Inputs 

  1713. 		addInput(createDynamicPort<IMPort>(Vec(columnRulerB0, rowRulerB0), Port::INPUT, module, PhraseSeq32::LEFTCV_INPUT, &module->panelTheme));

  1714. 		addInput(createDynamicPort<IMPort>(Vec(columnRulerB1, rowRulerB0), Port::INPUT, module, PhraseSeq32::RIGHTCV_INPUT, &module->panelTheme));

  1715. 		addInput(createDynamicPort<IMPort>(Vec(columnRulerB2, rowRulerB0), Port::INPUT, module, PhraseSeq32::SEQCV_INPUT, &module->panelTheme));

  1716. 		addInput(createDynamicPort<IMPort>(Vec(columnRulerB3, rowRulerB0), Port::INPUT, module, PhraseSeq32::RUNCV_INPUT, &module->panelTheme));

  1717. 		addInput(createDynamicPort<IMPort>(Vec(columnRulerB4, rowRulerB0), Port::INPUT, module, PhraseSeq32::WRITE_INPUT, &module->panelTheme));

  1718. 		// Reset input

  1719. 		addInput(createDynamicPort<IMPort>(Vec(columnRulerB5, rowRulerB0), Port::INPUT, module, PhraseSeq32::RESET_INPUT, &module->panelTheme));

  1720. 		// Channel B outputs

  1721. 		addOutput(createDynamicPort<IMPort>(Vec(columnRulerB6, rowRulerB0), Port::OUTPUT, module, PhraseSeq32::CVB_OUTPUT, &module->panelTheme));

  1722. 		addOutput(createDynamicPort<IMPort>(Vec(columnRulerB7, rowRulerB0), Port::OUTPUT, module, PhraseSeq32::GATE1B_OUTPUT, &module->panelTheme));

  1723. 		addOutput(createDynamicPort<IMPort>(Vec(columnRulerB8, rowRulerB0), Port::OUTPUT, module, PhraseSeq32::GATE2B_OUTPUT, &module->panelTheme));

  1724. 		

  1725. 		

  1726. 		// Expansion module

  1727. 		static const int rowRulerExpTop = 65;

  1728. 		static const int rowSpacingExp = 60;

  1729. 		static const int colRulerExp = 497;

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

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

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

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

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

  1735. 	}

  1736. };

  1737. 

  1738. } // namespace rack_plugin_ImpromptuModular

  1739. 

  1740. using namespace rack_plugin_ImpromptuModular;

  1741. 

  1742. RACK_PLUGIN_MODEL_INIT(ImpromptuModular, PhraseSeq32) {

  1743.    Model *modelPhraseSeq32 = Model::create<PhraseSeq32, PhraseSeq32Widget>("Impromptu Modular", "Phrase-Seq-32", "SEQ - Phrase-Seq-32", SEQUENCER_TAG);

  1744.    return modelPhraseSeq32;

  1745. }

  1746. 

  1747. /*CHANGE LOG

  1748. 

  1749. 0.6.11:

  1750. step optimization of lights refresh

  1751. 

  1752. 0.6.10:

  1753. add advanced gate mode

  1754. unlock gates when tied (turn off when press tied, but allow to be turned back on)

  1755. 

  1756. 0.6.9:

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

  1758. right click on notes now does same as left click but with autostep

  1759. 

  1760. 0.6.8:

  1761. allow rollover when selecting sequences in a song phrase (easier access to higher numbered seqs)

  1762. 

  1763. 0.6.7:

  1764. allow full edit capabilities in Seq and song mode

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

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

  1767. gate 2 is off by default

  1768. fix emitted monitoring gates to depend on gate states instead of always triggering

  1769. 

  1770. 0.6.6:

  1771. config and knob bug fixes when loading patch

  1772. 

  1773. 0.6.5:

  1774. paste 4, 8 doesn't loop over to overwrite first steps

  1775. small adjustements to gates and CVs used in monitoring write operations

  1776. add GATE1, GATE2, TIED, SLIDE CV inputs 

  1777. add MODE CV input (affects only selected sequence and in Seq mode)

  1778. add expansion panel option

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

  1780. 

  1781. 0.6.4:

  1782. initial release of PS32

  1783. */