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.
1247 Commits
4 Branches
541MB
Tree: 0135b09423
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0135b09423'
${ noResults }
Rack/plugins/community/repos/Bidoo/src/DTROY.cpp

1277 lines
47KB
Raw Blame History 

  1. #include "global_pre.hpp"

  2. #include "Bidoo.hpp"

  3. #include "dsp/digital.hpp"

  4. #include "BidooComponents.hpp"

  5. #include "global_ui.hpp"

  6. #include <ctime>

  7. #include <iostream>

  8. #include <vector>

  9. #include <random>

  10. #include <algorithm>

  11. 

  12. using namespace std;

  13. 

  14. namespace rack_plugin_Bidoo {

  15. 

  16. struct Step {

  17. 	int index = 0;

  18. 	int number = 0;

  19. 	bool skip = false;

  20. 	bool skipParam = false;

  21. 	bool slide = false;

  22. 	int pulses = 1;

  23. 	int pulsesParam = 1;

  24. 	float pitch = 3.0f;

  25. 	int type = 2;

  26. };

  27. 

  28. struct Pattern {

  29. 	int playMode = 0;

  30. 	int countMode = 0;

  31. 	int numberOfSteps = 8;

  32. 	int numberOfStepsParam = 8;

  33. 	int rootNote = 0;

  34. 	int rootNoteParam = 0;

  35. 	int scale = 0;

  36. 	int scaleParam = 0;

  37. 	float gateTime = 0.5f;

  38. 	float slideTime = 0.2f;

  39. 	float sensitivity = 1.0f;

  40. 	int currentStep = 0;

  41. 	int currentPulse = 0;

  42. 	bool forward = true;

  43. 	std::vector<Step> steps {16};

  44. 

  45. 	void Update(int playMode, int countMode, int numberOfSteps, int numberOfStepsParam, int rootNote, int scale, float gateTime, float slideTime, float sensitivity, vector<char> skips, vector<char> slides, Param *pulses, Param *pitches, Param *types) {

  46. 		this->playMode = playMode;

  47. 		this->countMode = countMode;

  48. 		this->numberOfSteps = numberOfSteps;

  49. 		this->numberOfStepsParam = numberOfStepsParam;

  50. 		this->rootNote = rootNote;

  51. 		this->scale = scale;

  52. 		this->rootNoteParam = rootNote;

  53. 		this->scaleParam = scale;

  54. 		this->gateTime = gateTime;

  55. 		this->slideTime = slideTime;

  56. 		this->sensitivity = sensitivity;

  57. 		int pCount = 0;

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

  59. 			steps[i].index = i%8;

  60. 			steps[i].number = i;

  61. 			if (((countMode == 0) && (i < numberOfSteps)) || ((countMode == 1) && (pCount < numberOfSteps))) {

  62. 				steps[i].skip = (skips[steps[i].index] == 't');

  63. 			}	else {

  64. 				steps[i].skip = true;

  65. 			}

  66. 			steps[i].skipParam = (skips[steps[i].index] == 't');

  67. 			steps[i].slide = (slides[steps[i].index] == 't');

  68. 			if ((countMode == 1) && ((pCount + (int)pulses[steps[i].index].value) >= numberOfSteps)) {

  69. 				steps[i].pulses = max(numberOfSteps - pCount, 0);

  70. 			}	else {

  71. 				steps[i].pulses = (int)(pulses + steps[i].index)->value;

  72. 			}

  73. 			steps[i].pulsesParam = (int)(pulses + steps[i].index)->value;

  74. 			steps[i].pitch = (pitches + steps[i].index)->value;

  75. 			steps[i].type = (int)(types + steps[i].index)->value;

  76. 

  77. 			pCount = pCount + steps[i].pulses;

  78. 		}

  79. 	}

  80. 

  81. 	std::tuple<int, int> GetNextStep(bool reset)

  82. 	{

  83. 		if (reset) {

  84. 			if (playMode != 1) {

  85. 				currentStep = GetFirstStep();

  86. 			} else {

  87. 				currentStep = GetLastStep();

  88. 			}

  89. 			currentPulse = 0;

  90. 			return std::make_tuple(currentStep,currentPulse);

  91. 		} else {

  92. 			if (currentPulse < steps[currentStep].pulses - 1) {

  93. 				currentPulse++;

  94. 				return std::make_tuple(steps[currentStep%16].index,currentPulse);

  95. 			} else {

  96. 				if (playMode == 0) {

  97. 					currentStep = GetNextStepForward(currentStep);

  98. 					currentPulse = 0;

  99. 					return std::make_tuple(steps[currentStep%16].index,currentPulse);

  100. 				} else if (playMode == 1) {

  101. 					currentStep = GetNextStepBackward(currentStep);

  102. 					currentPulse = 0;

  103. 					return std::make_tuple(steps[currentStep%16].index,currentPulse);

  104. 				} else if (playMode == 2) {

  105. 					if (currentStep == GetLastStep()) {

  106. 						forward = false;

  107. 					}

  108. 					if (currentStep == GetFirstStep()) {

  109. 						forward = true;

  110. 					}

  111. 					if (forward) {

  112. 						currentStep = GetNextStepForward(currentStep);

  113. 					} else {

  114. 						currentStep = GetNextStepBackward(currentStep);

  115. 					}

  116. 					currentPulse = 0;

  117. 					return std::make_tuple(steps[currentStep%16].index,currentPulse);

  118. 				} else if (playMode == 3) {

  119. 					std::vector<Step> tmp (steps.size());

  120. 				  auto it = std::copy_if (steps.begin(), steps.end(), tmp.begin(), [](Step i){return !(i.skip);} );

  121. 				  tmp.resize(std::distance(tmp.begin(),it));  // shrink container to new size

  122. 					Step tmpStep = *select_randomly(tmp.begin(), tmp.end());

  123. 					currentPulse = 0;

  124. 					currentStep = tmpStep.number;

  125. 					return std::make_tuple(steps[currentStep%16].index,currentPulse);

  126. 				} else if (playMode == 4) {

  127. 					int next = GetNextStepForward(currentStep);

  128. 					int prev = GetNextStepBackward(currentStep);

  129. 					vector<Step> subPattern;

  130. 					subPattern.push_back(steps[prev]);

  131. 					subPattern.push_back(steps[next]);

  132. 					Step choice = *select_randomly(subPattern.begin(), subPattern.end());

  133. 					currentPulse = 0;

  134. 					currentStep = choice.number;

  135. 					return std::make_tuple(steps[currentStep%16].index,currentPulse);

  136. 				} else {

  137. 					return std::make_tuple(0,0);

  138. 				}

  139. 			}

  140. 		}

  141. 	}

  142. 

  143. 	inline Step CurrentStep() {

  144. 		return this->steps[currentStep];

  145. 	}

  146. 

  147. 	inline int GetFirstStep()

  148. 	{

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

  150. 				if (!steps[i].skip) {

  151. 					return i;

  152. 				}

  153. 			}

  154. 			return 0;

  155. 	}

  156. 

  157. 	inline int GetLastStep()

  158. 	{

  159. 			for (int i = 15; i >= 0  ; i--) {

  160. 				if (!steps[i].skip) {

  161. 					return i;

  162. 				}

  163. 			}

  164. 			return 15;

  165. 	}

  166. 

  167. 	inline int GetNextStepForward(int pos)

  168. 	{

  169. 			for (int i = pos + 1; i < pos + 16; i++) {

  170. 				int j = i%16;

  171. 				if (!steps[j].skip) {

  172. 					return j;

  173. 				}

  174. 			}

  175. 			return pos;

  176. 	}

  177. 

  178. 	inline int GetNextStepBackward(int pos)

  179. 	{

  180. 			for (int i = pos - 1; i > pos - 16; i--) {

  181. 				int j = i%16;

  182. 				if (!steps[j + (i<0?16:0)].skip) {

  183. 					return j + (i<0?16:0);

  184. 				}

  185. 			}

  186. 			return pos;

  187. 	}

  188. 

  189. 	template<typename Iter, typename RandomGenerator> Iter select_randomly(Iter start, Iter end, RandomGenerator& g) {

  190. 		std::uniform_int_distribution<> dis(0, std::distance(start, end) - 1);

  191. 		std::advance(start, dis(g));

  192. 		return start;

  193. 	}

  194. 

  195. 	template<typename Iter> Iter select_randomly(Iter start, Iter end) {

  196. 		static std::random_device rd;

  197. 		static std::mt19937 gen(rd());

  198. 		return select_randomly(start, end, gen);

  199. 	}

  200. };

  201. 

  202. struct DTROY : Module {

  203. 	enum ParamIds {

  204. 		CLOCK_PARAM,

  205. 		RUN_PARAM,

  206. 		RESET_PARAM,

  207. 		STEPS_PARAM,

  208. 		SLIDE_TIME_PARAM,

  209. 		GATE_TIME_PARAM,

  210. 		ROOT_NOTE_PARAM,

  211. 		SCALE_PARAM,

  212. 		PLAY_MODE_PARAM,

  213. 		COUNT_MODE_PARAM,

  214. 		PATTERN_PARAM,

  215. 		SENSITIVITY_PARAM,

  216. 		TRIG_COUNT_PARAM = SENSITIVITY_PARAM + 8,

  217. 		TRIG_TYPE_PARAM = TRIG_COUNT_PARAM + 8,

  218. 		TRIG_PITCH_PARAM = TRIG_TYPE_PARAM + 8,

  219. 		TRIG_SLIDE_PARAM = TRIG_PITCH_PARAM + 8,

  220. 		TRIG_SKIP_PARAM = TRIG_SLIDE_PARAM + 8,

  221. 		LEFT_PARAM = TRIG_SKIP_PARAM + 8,

  222. 		RIGHT_PARAM,

  223. 		UP_PARAM,

  224. 		DOWN_PARAM,

  225. 		COPY_PARAM,

  226. 		NUM_PARAMS

  227. 	};

  228. 	enum InputIds {

  229. 		CLOCK_INPUT,

  230. 		EXT_CLOCK_INPUT,

  231. 		RESET_INPUT,

  232. 		STEPS_INPUT,

  233. 		SLIDE_TIME_INPUT,

  234. 		GATE_TIME_INPUT,

  235. 		ROOT_NOTE_INPUT,

  236. 		SCALE_INPUT,

  237. 		EXTGATE1_INPUT,

  238. 		EXTGATE2_INPUT,

  239. 		PATTERN_INPUT,

  240. 		TRANSPOSE_INPUT,

  241. 		NUM_INPUTS

  242. 	};

  243. 	enum OutputIds {

  244. 		GATE_OUTPUT,

  245. 		PITCH_OUTPUT,

  246. 		STEP_OUTPUT,

  247. 		NUM_OUTPUTS = STEP_OUTPUT + 8

  248. 	};

  249. 	enum LightIds {

  250. 		RUNNING_LIGHT,

  251. 		RESET_LIGHT,

  252. 		GATE_LIGHT,

  253. 		STEPS_LIGHTS = GATE_LIGHT + 8,

  254. 		SLIDES_LIGHTS = STEPS_LIGHTS + 8,

  255. 		SKIPS_LIGHTS = SLIDES_LIGHTS + 8,

  256. 		COPY_LIGHT = SKIPS_LIGHTS + 8,

  257. 		NUM_LIGHTS

  258. 	};

  259. 

  260. 	//copied from http://www.grantmuller.com/MidiReference/doc/midiReference/ScaleReference.html

  261. 	int SCALE_AEOLIAN        [7] = {0, 2, 3, 5, 7, 8, 10};

  262. 	int SCALE_BLUES          [9] = {0, 2, 3, 4, 5, 7, 9, 10, 11};

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

  264. 	int SCALE_DIATONIC_MINOR [7] = {0, 2, 3, 5, 7, 8, 10};

  265. 	int SCALE_DORIAN         [7] = {0, 2, 3, 5, 7, 9, 10};

  266. 	int SCALE_HARMONIC_MINOR [7] = {0, 2, 3, 5, 7, 8, 11};

  267. 	int SCALE_INDIAN         [7] = {0, 1, 1, 4, 5, 8, 10};

  268. 	int SCALE_LOCRIAN        [7] = {0, 1, 3, 5, 6, 8, 10};

  269. 	int SCALE_LYDIAN         [7] = {0, 2, 4, 6, 7, 9, 10};

  270. 	int SCALE_MAJOR          [7] = {0, 2, 4, 5, 7, 9, 11};

  271. 	int SCALE_MELODIC_MINOR  [9] = {0, 2, 3, 5, 7, 8, 9, 10, 11};

  272. 	int SCALE_MINOR          [7] = {0, 2, 3, 5, 7, 8, 10};

  273. 	int SCALE_MIXOLYDIAN     [7] = {0, 2, 4, 5, 7, 9, 10};

  274. 	int SCALE_NATURAL_MINOR  [7] = {0, 2, 3, 5, 7, 8, 10};

  275. 	int SCALE_PENTATONIC     [5] = {0, 2, 4, 7, 9};

  276. 	int SCALE_PHRYGIAN       [7] = {0, 1, 3, 5, 7, 8, 10};

  277. 	int SCALE_TURKISH        [7] = {0, 1, 3, 5, 7, 10, 11};

  278. 

  279. 	enum Notes {

  280. 		NOTE_C,

  281. 		NOTE_C_SHARP,

  282. 		NOTE_D,

  283. 		NOTE_D_SHARP,

  284. 		NOTE_E,

  285. 		NOTE_F,

  286. 		NOTE_F_SHARP,

  287. 		NOTE_G,

  288. 		NOTE_G_SHARP,

  289. 		NOTE_A,

  290. 		NOTE_A_SHARP,

  291. 		NOTE_B,

  292. 		NUM_NOTES

  293. 	};

  294. 

  295. 	enum Scales {

  296. 		AEOLIAN,

  297. 		BLUES,

  298. 		CHROMATIC,

  299. 		DIATONIC_MINOR,

  300. 		DORIAN,

  301. 		HARMONIC_MINOR,

  302. 		INDIAN,

  303. 		LOCRIAN,

  304. 		LYDIAN,

  305. 		MAJOR,

  306. 		MELODIC_MINOR,

  307. 		MINOR,

  308. 		MIXOLYDIAN,

  309. 		NATURAL_MINOR,

  310. 		PENTATONIC,

  311. 		PHRYGIAN,

  312. 		TURKISH,

  313. 		NONE,

  314. 		NUM_SCALES

  315. 	};

  316. 

  317. 	bool running = true;

  318. 	SchmittTrigger clockTrigger;

  319. 	SchmittTrigger runningTrigger;

  320. 	SchmittTrigger resetTrigger;

  321. 	SchmittTrigger slideTriggers[8];

  322. 	SchmittTrigger skipTriggers[8];

  323. 	SchmittTrigger playModeTrigger;

  324. 	SchmittTrigger countModeTrigger;

  325. 	float phase = 0.0f;

  326. 	int index = 0;

  327. 	bool reStart = true;

  328. 	int pulse = 0;

  329. 	int rootNote = 0;

  330. 	int curScaleVal = 0;

  331. 	float pitch = 0.0f;

  332. 	float previousPitch = 0.0f;

  333. 	float candidateForPreviousPitch = 0.0f;

  334. 	float tCurrent = 0.0f;

  335. 	float tLastTrig = 0.0f;

  336. 	std::vector<char> slideState = {'f','f','f','f','f','f','f','f'};

  337. 	std::vector<char> skipState = {'f','f','f','f','f','f','f','f'};

  338. 	int playMode = 0; // 0 forward, 1 backward, 2 pingpong, 3 random, 4 brownian

  339. 	int countMode = 0; // 0 steps, 1 pulses

  340. 	int numSteps = 8;

  341. 	int selectedPattern = 0;

  342. 	int playedPattern = 0;

  343. 	bool updateFlag = false;

  344. 	bool first = true;

  345. 	bool loadedFromJson = false;

  346. 	int copyPattern = -1;

  347. 	PulseGenerator stepPulse[8];

  348. 	bool stepOutputsMode = false;

  349. 	bool gateOn = false;

  350. 	const float invLightLambda = 13.333333333333333333333f;

  351. 	bool copyState = false;

  352. 

  353. 	Pattern patterns[16];

  354. 

  355. 	DTROY() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {

  356. 	}

  357. 

  358. 	void UpdatePattern();

  359. 

  360. 	void step() override;

  361. 

  362. 	// persistence, random & init

  363. 

  364. 	json_t *toJson() override {

  365. 		json_t *rootJ = json_object();

  366. 

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

  368. 		json_object_set_new(rootJ, "playMode", json_integer(playMode));

  369. 		json_object_set_new(rootJ, "countMode", json_integer(countMode));

  370. 		json_object_set_new(rootJ, "stepOutputsMode", json_boolean(stepOutputsMode));

  371. 		json_object_set_new(rootJ, "selectedPattern", json_integer(selectedPattern));

  372. 		json_object_set_new(rootJ, "playedPattern", json_integer(playedPattern));

  373. 

  374. 		json_t *trigsJ = json_array();

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

  376. 			json_t *trigJ = json_array();

  377. 			json_t *trigJSlide = json_boolean(slideState[i] == 't');

  378. 			json_array_append_new(trigJ, trigJSlide);

  379. 			json_t *trigJSkip = json_boolean(skipState[i] == 't');

  380. 			json_array_append_new(trigJ, trigJSkip);

  381. 			json_array_append_new(trigsJ, trigJ);

  382. 		}

  383. 		json_object_set_new(rootJ, "trigs", trigsJ);

  384. 

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

  386. 			json_t *patternJ = json_object();

  387. 			json_object_set_new(patternJ, "playMode", json_integer(patterns[i].playMode));

  388. 			json_object_set_new(patternJ, "countMode", json_integer(patterns[i].countMode));

  389. 			json_object_set_new(patternJ, "numSteps", json_integer(patterns[i].numberOfStepsParam));

  390. 			json_object_set_new(patternJ, "rootNote", json_integer(patterns[i].rootNote));

  391. 			json_object_set_new(patternJ, "scale", json_integer(patterns[i].scale));

  392. 			json_object_set_new(patternJ, "gateTime", json_real(patterns[i].gateTime));

  393. 			json_object_set_new(patternJ, "slideTime", json_real(patterns[i].slideTime));

  394. 			json_object_set_new(patternJ, "sensitivity", json_real(patterns[i].sensitivity));

  395. 			for (int j = 0; j < 16; j++) {

  396. 				json_t *stepJ = json_object();

  397. 				json_object_set_new(stepJ, "index", json_integer(patterns[i].steps[j].index));

  398. 				json_object_set_new(stepJ, "number", json_integer(patterns[i].steps[j].number));

  399. 				json_object_set_new(stepJ, "skip", json_integer((int)patterns[i].steps[j].skip));

  400. 				json_object_set_new(stepJ, "skipParam", json_integer((int)patterns[i].steps[j].skipParam));

  401. 				json_object_set_new(stepJ, "slide", json_integer((int)patterns[i].steps[j].slide));

  402. 				json_object_set_new(stepJ, "pulses", json_integer(patterns[i].steps[j].pulses));

  403. 				json_object_set_new(stepJ, "pulsesParam", json_integer(patterns[i].steps[j].pulsesParam));

  404. 				json_object_set_new(stepJ, "pitch", json_real(patterns[i].steps[j].pitch));

  405. 				json_object_set_new(stepJ, "type", json_integer(patterns[i].steps[j].type));

  406. 				json_object_set_new(patternJ, ("step" + to_string(j)).c_str() , stepJ);

  407. 			}

  408. 			json_object_set_new(rootJ, ("pattern" + to_string(i)).c_str(), patternJ);

  409. 		}

  410. 		return rootJ;

  411. 	}

  412. 

  413. 	void fromJson(json_t *rootJ) override {

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

  415. 		if (runningJ)

  416. 			running = json_is_true(runningJ);

  417. 		json_t *playModeJ = json_object_get(rootJ, "playMode");

  418. 		if (playModeJ)

  419. 			playMode = json_integer_value(playModeJ);

  420. 		json_t *countModeJ = json_object_get(rootJ, "countMode");

  421. 		if (countModeJ)

  422. 			countMode = json_integer_value(countModeJ);

  423. 		json_t *selectedPatternJ = json_object_get(rootJ, "selectedPattern");

  424. 		if (selectedPatternJ)

  425. 			selectedPattern = json_integer_value(selectedPatternJ);

  426. 		json_t *playedPatternJ = json_object_get(rootJ, "playedPattern");

  427. 		if (playedPatternJ)

  428. 			playedPattern = json_integer_value(playedPatternJ);

  429. 		json_t *stepOutputsModeJ = json_object_get(rootJ, "stepOutputsMode");

  430. 		if (stepOutputsModeJ)

  431. 			stepOutputsMode = json_is_true(stepOutputsModeJ);

  432. 		json_t *trigsJ = json_object_get(rootJ, "trigs");

  433. 		if (trigsJ) {

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

  435. 				json_t *trigJ = json_array_get(trigsJ, i);

  436. 				if (trigJ)

  437. 				{

  438. 					slideState[i] = json_is_true(json_array_get(trigJ, 0)) ? 't' : 'f';

  439. 					skipState[i] = json_is_true(json_array_get(trigJ, 1)) ? 't' : 'f';

  440. 				}

  441. 			}

  442. 		}

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

  444. 			json_t *patternJ = json_object_get(rootJ, ("pattern" + to_string(i)).c_str());

  445. 			if (patternJ){

  446. 				json_t *playModeJ = json_object_get(patternJ, "playMode");

  447. 				if (playModeJ)

  448. 					patterns[i].playMode = json_integer_value(playModeJ);

  449. 				json_t *countModeJ = json_object_get(patternJ, "countMode");

  450. 				if (countModeJ)

  451. 					patterns[i].countMode = json_integer_value(countModeJ);

  452. 				json_t *numStepsJ = json_object_get(patternJ, "numSteps");

  453. 				if (numStepsJ)

  454. 					patterns[i].numberOfStepsParam = json_integer_value(numStepsJ);

  455. 				json_t *rootNoteJ = json_object_get(patternJ, "rootNote");

  456. 				if (rootNoteJ)

  457. 					patterns[i].rootNote = json_integer_value(rootNoteJ);

  458. 				json_t *scaleJ = json_object_get(patternJ, "scale");

  459. 				if (scaleJ)

  460. 					patterns[i].scale = json_integer_value(scaleJ);

  461. 				json_t *gateTimeJ = json_object_get(patternJ, "gateTime");

  462. 				if (gateTimeJ)

  463. 					patterns[i].gateTime = json_number_value(gateTimeJ);

  464. 				json_t *slideTimeJ = json_object_get(patternJ, "slideTime");

  465. 				if (slideTimeJ)

  466. 					patterns[i].slideTime = json_number_value(slideTimeJ);

  467. 				json_t *sensitivityJ = json_object_get(patternJ, "sensitivity");

  468. 				if (sensitivityJ)

  469. 					patterns[i].sensitivity = json_number_value(sensitivityJ);

  470. 				for (int j = 0; j < 16; j++) {

  471. 					json_t *stepJ = json_object_get(patternJ, ("step" + to_string(j)).c_str());

  472. 					if (stepJ) {

  473. 						json_t *indexJ= json_object_get(stepJ, "index");

  474. 						if (indexJ)

  475. 							patterns[i].steps[j].index = json_integer_value(indexJ);

  476. 						json_t *numberJ= json_object_get(stepJ, "numer");

  477. 						if (numberJ)

  478. 							patterns[i].steps[j].number = json_integer_value(numberJ);

  479. 						json_t *skipJ= json_object_get(stepJ, "skip");

  480. 						if (skipJ)

  481. 							patterns[i].steps[j].skip = !!json_integer_value(skipJ);

  482. 						json_t *skipParamJ= json_object_get(stepJ, "skipParam");

  483. 						if (skipParamJ)

  484. 							patterns[i].steps[j].skipParam = !!json_integer_value(skipParamJ);

  485. 						json_t *slideJ= json_object_get(stepJ, "slide");

  486. 						if (slideJ)

  487. 							patterns[i].steps[j].slide = !!json_integer_value(slideJ);

  488. 						json_t *pulsesJ= json_object_get(stepJ, "pulses");

  489. 						if (pulsesJ)

  490. 							patterns[i].steps[j].pulses = json_integer_value(pulsesJ);

  491. 						json_t *pulsesParamJ= json_object_get(stepJ, "pulsesParam");

  492. 						if (pulsesParamJ)

  493. 							patterns[i].steps[j].pulsesParam = json_integer_value(pulsesParamJ);

  494. 						json_t *pitchJ= json_object_get(stepJ, "pitch");

  495. 						if (pitchJ)

  496. 							patterns[i].steps[j].pitch = json_number_value(pitchJ);

  497. 						json_t *typeJ= json_object_get(stepJ, "type");

  498. 						if (typeJ)

  499. 							patterns[i].steps[j].type = json_integer_value(typeJ);

  500. 					}

  501. 				}

  502. 			}

  503. 		}

  504. 		updateFlag = true;

  505. 		loadedFromJson = true;

  506. 	}

  507. 

  508. 	void randomize() override {

  509. 		randomizeSlidesSkips();

  510. 	}

  511. 

  512. 	void randomizeSlidesSkips() {

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

  514. 			slideState[i] = (randomUniform() > 0.8f) ? 't' : 'f';

  515. 			skipState[i] = (randomUniform() > 0.85f) ? 't' : 'f';

  516. 		}

  517. 	}

  518. 

  519. 	void reset() override {

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

  521. 			slideState[i] = 'f';

  522. 			skipState[i] = 'f';

  523. 		}

  524. 	}

  525. 

  526. 	// Quantization inspired from  https://github.com/jeremywen/JW-Modules

  527. 

  528. 	float closestVoltageInScale(float voltsIn){

  529. 		rootNote = (int)clamp(patterns[playedPattern].rootNote + inputs[ROOT_NOTE_INPUT].value, 0.0f, 11.0f);

  530. 		curScaleVal = (int)clamp(patterns[playedPattern].scale + inputs[SCALE_INPUT].value, 0.0f, 17.0f);

  531. 		int *curScaleArr;

  532. 		int notesInScale = 0;

  533. 		switch(curScaleVal){

  534. 			case AEOLIAN:        curScaleArr = SCALE_AEOLIAN;       notesInScale=LENGTHOF(SCALE_AEOLIAN); break;

  535. 			case BLUES:          curScaleArr = SCALE_BLUES;         notesInScale=LENGTHOF(SCALE_BLUES); break;

  536. 			case CHROMATIC:      curScaleArr = SCALE_CHROMATIC;     notesInScale=LENGTHOF(SCALE_CHROMATIC); break;

  537. 			case DIATONIC_MINOR: curScaleArr = SCALE_DIATONIC_MINOR;notesInScale=LENGTHOF(SCALE_DIATONIC_MINOR); break;

  538. 			case DORIAN:         curScaleArr = SCALE_DORIAN;        notesInScale=LENGTHOF(SCALE_DORIAN); break;

  539. 			case HARMONIC_MINOR: curScaleArr = SCALE_HARMONIC_MINOR;notesInScale=LENGTHOF(SCALE_HARMONIC_MINOR); break;

  540. 			case INDIAN:         curScaleArr = SCALE_INDIAN;        notesInScale=LENGTHOF(SCALE_INDIAN); break;

  541. 			case LOCRIAN:        curScaleArr = SCALE_LOCRIAN;       notesInScale=LENGTHOF(SCALE_LOCRIAN); break;

  542. 			case LYDIAN:         curScaleArr = SCALE_LYDIAN;        notesInScale=LENGTHOF(SCALE_LYDIAN); break;

  543. 			case MAJOR:          curScaleArr = SCALE_MAJOR;         notesInScale=LENGTHOF(SCALE_MAJOR); break;

  544. 			case MELODIC_MINOR:  curScaleArr = SCALE_MELODIC_MINOR; notesInScale=LENGTHOF(SCALE_MELODIC_MINOR); break;

  545. 			case MINOR:          curScaleArr = SCALE_MINOR;         notesInScale=LENGTHOF(SCALE_MINOR); break;

  546. 			case MIXOLYDIAN:     curScaleArr = SCALE_MIXOLYDIAN;    notesInScale=LENGTHOF(SCALE_MIXOLYDIAN); break;

  547. 			case NATURAL_MINOR:  curScaleArr = SCALE_NATURAL_MINOR; notesInScale=LENGTHOF(SCALE_NATURAL_MINOR); break;

  548. 			case PENTATONIC:     curScaleArr = SCALE_PENTATONIC;    notesInScale=LENGTHOF(SCALE_PENTATONIC); break;

  549. 			case PHRYGIAN:       curScaleArr = SCALE_PHRYGIAN;      notesInScale=LENGTHOF(SCALE_PHRYGIAN); break;

  550. 			case TURKISH:        curScaleArr = SCALE_TURKISH;       notesInScale=LENGTHOF(SCALE_TURKISH); break;

  551. 			case NONE:           return voltsIn;

  552. 		}

  553. 

  554. 		float closestVal = 10.0f;

  555. 		float closestDist = 10.0f;

  556. 		int octaveInVolts = int(voltsIn);

  557. 		for (int i = 0; i < notesInScale; i++) {

  558. 			float scaleNoteInVolts = octaveInVolts +  curScaleArr[i] / 12.0f;

  559. 			float distAway = fabs(voltsIn - scaleNoteInVolts);

  560. 			if(distAway < closestDist) {

  561. 				closestVal = scaleNoteInVolts;

  562. 				closestDist = distAway;

  563. 			}

  564. 		}

  565. 		float transposeVolatge = inputs[TRANSPOSE_INPUT].active ? ((((int)rescale(clamp(inputs[TRANSPOSE_INPUT].value,-10.0f,10.0f),-10.0f,10.0f,-48.0f,48.0f)) / 12.0f)) : 0.0f;

  566. 		return clamp(closestVal + (rootNote / 12.0f) + transposeVolatge,0.0f,10.0f);

  567. 	}

  568. };

  569. 

  570. void DTROY::UpdatePattern() {

  571. 	patterns[selectedPattern].Update(playMode, countMode, numSteps, roundf(params[STEPS_PARAM].value),

  572. 		 roundf(params[ROOT_NOTE_PARAM].value), roundf(params[SCALE_PARAM].value), params[GATE_TIME_PARAM].value,

  573. 		 params[SLIDE_TIME_PARAM].value, params[SENSITIVITY_PARAM].value , skipState, slideState,

  574. 		 &params[TRIG_COUNT_PARAM], &params[TRIG_PITCH_PARAM], &params[TRIG_TYPE_PARAM]);

  575. }

  576. 

  577. void DTROY::step() {

  578. 

  579. 	float invESR = 1 / engineGetSampleRate();

  580. 

  581. 	// Run

  582. 	if (runningTrigger.process(params[RUN_PARAM].value)) {

  583. 		running = !running;

  584. 	}

  585. 	lights[RUNNING_LIGHT].value = running ? 1.0f : 0.0f;

  586. 	bool nextStep = false;

  587. 	// Phase calculation

  588. 	if (running) {

  589. 		if (inputs[EXT_CLOCK_INPUT].active) {

  590. 			tCurrent += invESR;

  591. 			if (tLastTrig > 0.0f) {

  592. 				phase = tCurrent / tLastTrig;

  593. 			}

  594. 			else {

  595. 				float clockTime = powf(2.0f, params[CLOCK_PARAM].value + inputs[CLOCK_INPUT].value);

  596. 				phase += clockTime * invESR;

  597. 			}

  598. 			// External clock

  599. 			if (clockTrigger.process(inputs[EXT_CLOCK_INPUT].value)) {

  600. 				tLastTrig = tCurrent;

  601. 				tCurrent = 0.0f;

  602. 				phase = 0.0f;

  603. 				nextStep = true;

  604. 			}

  605. 		}

  606. 		else {

  607. 			// Internal clock

  608. 			float clockTime = powf(2.0f, params[CLOCK_PARAM].value + inputs[CLOCK_INPUT].value);

  609. 			phase += clockTime * invESR;

  610. 			if (phase >= 1.0f) {

  611. 				phase--;

  612. 				nextStep = true;

  613. 			}

  614. 		}

  615. 	}

  616. 	// Reset

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

  618. 		phase = 0.0f;

  619. 		reStart = true;

  620. 		nextStep = true;

  621. 		lights[RESET_LIGHT].value = 1.0f;

  622. 	}

  623. 

  624. 	//copy/paste

  625. 	lights[COPY_LIGHT].value = copyState ? 1.0f : 0.0f;

  626. 

  627. 	//patternNumber

  628. 	int newPattern = clamp((inputs[PATTERN_INPUT].active ? (int)(rescale(inputs[PATTERN_INPUT].value,0.0f,10.0f,1.0f,16.1f)) : (int)(params[PATTERN_PARAM].value)) - 1, 0, 15);

  629. 	if (newPattern != playedPattern) {

  630. 		int cStep = patterns[playedPattern].currentStep;

  631. 		int cPulse = patterns[playedPattern].currentPulse;

  632. 		playedPattern = newPattern;

  633. 		patterns[playedPattern].currentStep = cStep;

  634. 		patterns[playedPattern].currentPulse = cPulse;

  635. 	}

  636. 

  637. 

  638. 	// Update Pattern

  639. 	if ((updateFlag) || (!loadedFromJson)) {

  640. 		// Trigs Update

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

  642. 			if (slideTriggers[i].process(params[TRIG_SLIDE_PARAM + i].value)) {

  643. 				slideState[i] = slideState[i] == 't' ? 'f' : 't';

  644. 			}

  645. 			if (skipTriggers[i].process(params[TRIG_SKIP_PARAM + i].value)) {

  646. 				skipState[i] = skipState[i] == 't' ? 'f' : 't';

  647. 			}

  648. 		}

  649. 		// playMode

  650. 		if (playModeTrigger.process(params[PLAY_MODE_PARAM].value)) {

  651. 			playMode = (((int)playMode + 1) % 5);

  652. 		}

  653. 		// countMode

  654. 		if (countModeTrigger.process(params[COUNT_MODE_PARAM].value)) {

  655. 			countMode = (((int)countMode + 1) % 2);

  656. 		}

  657. 		// numSteps

  658. 		numSteps = clamp((int)(params[STEPS_PARAM].value + inputs[STEPS_INPUT].value), 1, 16);

  659. 

  660. 		UpdatePattern();

  661. 		if (!loadedFromJson) {

  662. 			loadedFromJson = true;

  663. 			updateFlag = true;

  664. 		}

  665. 	}

  666. 

  667. 	// Steps && Pulses Management

  668. 	if (nextStep) {

  669. 		// Advance step

  670. 		candidateForPreviousPitch = closestVoltageInScale(patterns[playedPattern].CurrentStep().pitch * patterns[playedPattern].sensitivity);

  671. 

  672. 		auto nextT = patterns[playedPattern].GetNextStep(reStart);

  673. 		index = std::get<0>(nextT);

  674. 		pulse = std::get<1>(nextT);

  675. 

  676. 		if (reStart)

  677. 			reStart = false;

  678. 

  679. 		if (((!stepOutputsMode) && (pulse == 0)) || (stepOutputsMode))

  680. 			stepPulse[patterns[playedPattern].CurrentStep().index].trigger(10 * invESR);

  681. 

  682. 		lights[STEPS_LIGHTS+patterns[playedPattern].CurrentStep().index].value = 1.0f;

  683. 	}

  684. 

  685. 	// Lights & steps outputs

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

  687. 		lights[STEPS_LIGHTS + i].value -= lights[STEPS_LIGHTS + i].value * invLightLambda * invESR;

  688. 		lights[SLIDES_LIGHTS + i].value = slideState[i] == 't' ? 1.0f - lights[STEPS_LIGHTS + i].value : lights[STEPS_LIGHTS + i].value;

  689. 		lights[SKIPS_LIGHTS + i].value = skipState[i]== 't' ? 1.0f - lights[STEPS_LIGHTS + i].value : lights[STEPS_LIGHTS + i].value;

  690. 		outputs[STEP_OUTPUT+i].value = stepPulse[i].process(invESR) ? 10.0f : 0.0f;

  691. 	}

  692. 	lights[RESET_LIGHT].value -= lights[RESET_LIGHT].value * invLightLambda * invESR;

  693. 	lights[COPY_LIGHT].value = (copyPattern >= 0) ? 1 : 0;

  694. 

  695. 	// Caclulate Outputs

  696. 	gateOn = running && (!patterns[playedPattern].CurrentStep().skip);

  697. 	float gateValue = 0.0f;

  698. 	if (gateOn){

  699. 		if (patterns[playedPattern].CurrentStep().type == 0) {

  700. 			gateOn = false;

  701. 		}

  702. 		else if (((patterns[playedPattern].CurrentStep().type == 1) && (pulse == 0))

  703. 				|| (patterns[playedPattern].CurrentStep().type == 2)

  704. 				|| ((patterns[playedPattern].CurrentStep().type == 3) && (pulse == patterns[playedPattern].CurrentStep().pulses))) {

  705. 				float gateCoeff = clamp(patterns[playedPattern].gateTime - 0.02f + inputs[GATE_TIME_INPUT].value * 0.1f, 0.0f, 0.99f);

  706. 			gateOn = phase < gateCoeff;

  707. 			gateValue = 10.0f;

  708. 		}

  709. 		else if (patterns[playedPattern].CurrentStep().type == 3) {

  710. 			gateOn = true;

  711. 			gateValue = 10.0f;

  712. 		}

  713. 		else if (patterns[playedPattern].CurrentStep().type == 4) {

  714. 			gateOn = true;

  715. 			gateValue = inputs[EXTGATE1_INPUT].value;

  716. 		}

  717. 		else if (patterns[playedPattern].CurrentStep().type == 5) {

  718. 			gateOn = true;

  719. 			gateValue = inputs[EXTGATE2_INPUT].value;

  720. 		}

  721. 		else {

  722. 			gateOn = false;

  723. 			gateValue = 0.0f;

  724. 		}

  725. 	}

  726. 

  727. 	//pitch management

  728. 	pitch = closestVoltageInScale(patterns[playedPattern].CurrentStep().pitch * patterns[playedPattern].sensitivity);

  729. 	if (patterns[playedPattern].CurrentStep().slide) {

  730. 		if (pulse == 0) {

  731. 			float slideCoeff = clamp(patterns[playedPattern].slideTime - 0.01f + inputs[SLIDE_TIME_INPUT].value * 0.1f, -0.1f, 0.99f);

  732. 			pitch = pitch - (1.0f - powf(phase, slideCoeff)) * (pitch - previousPitch);

  733. 		}

  734. 	}

  735. 

  736. 	// Update Outputs

  737. 	outputs[GATE_OUTPUT].value = gateOn ? gateValue : 0.0f;

  738. 	outputs[PITCH_OUTPUT].value = pitch;

  739. 

  740. 	if (nextStep && gateOn)

  741. 		previousPitch = candidateForPreviousPitch;

  742. }

  743. 

  744. struct DTROYDisplay : TransparentWidget {

  745. 	DTROY *module;

  746. 	int frame = 0;

  747. 	shared_ptr<Font> font;

  748. 

  749. 	string note, scale, steps, playMode, selectedPattern, playedPattern;

  750. 

  751. 	DTROYDisplay() {

  752. 		font = Font::load(assetPlugin(plugin, "res/DejaVuSansMono.ttf"));

  753. 	}

  754. 

  755. 	void drawMessage(NVGcontext *vg, Vec pos, string note, string playMode, string selectedPattern, string playedPattern, string steps, string scale) {

  756. 		nvgFontSize(vg, 18.0f);

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

  758. 		nvgTextLetterSpacing(vg, -2.0f);

  759. 		nvgFillColor(vg, YELLOW_BIDOO);

  760. 		nvgText(vg, pos.x + 4.0f, pos.y + 8.0f, playMode.c_str(), NULL);

  761. 		nvgFontSize(vg, 14.0f);

  762. 		nvgText(vg, pos.x + 118.0f, pos.y + 7.0f, selectedPattern.c_str(), NULL);

  763. 

  764. 		nvgText(vg, pos.x + 27.0f, pos.y + 7.0f, steps.c_str(), NULL);

  765. 		nvgText(vg, pos.x + 3.0f, pos.y + 21.0f, note.c_str(), NULL);

  766. 		nvgText(vg, pos.x + 25.0f, pos.y + 21.0f, scale.c_str(), NULL);

  767. 

  768. 		if (++frame <= 30) {

  769. 			nvgText(vg, pos.x + 89.0f, pos.y + 7.0f, playedPattern.c_str(), NULL);

  770. 		}

  771. 		else if (++frame>60) {

  772. 			frame = 0;

  773. 		}

  774. 	}

  775. 

  776. 	string displayRootNote(int value) {

  777. 		switch(value){

  778. 			case DTROY::NOTE_C:       return "C";

  779. 			case DTROY::NOTE_C_SHARP: return "C#";

  780. 			case DTROY::NOTE_D:       return "D";

  781. 			case DTROY::NOTE_D_SHARP: return "D#";

  782. 			case DTROY::NOTE_E:       return "E";

  783. 			case DTROY::NOTE_F:       return "F";

  784. 			case DTROY::NOTE_F_SHARP: return "F#";

  785. 			case DTROY::NOTE_G:       return "G";

  786. 			case DTROY::NOTE_G_SHARP: return "G#";

  787. 			case DTROY::NOTE_A:       return "A";

  788. 			case DTROY::NOTE_A_SHARP: return "A#";

  789. 			case DTROY::NOTE_B:       return "B";

  790. 			default: return "";

  791. 		}

  792. 	}

  793. 

  794. 	string displayScale(int value) {

  795. 		switch(value){

  796. 			case DTROY::AEOLIAN:        return "Aeolian";

  797. 			case DTROY::BLUES:          return "Blues";

  798. 			case DTROY::CHROMATIC:      return "Chromatic";

  799. 			case DTROY::DIATONIC_MINOR: return "Diatonic Minor";

  800. 			case DTROY::DORIAN:         return "Dorian";

  801. 			case DTROY::HARMONIC_MINOR: return "Harmonic Minor";

  802. 			case DTROY::INDIAN:         return "Indian";

  803. 			case DTROY::LOCRIAN:        return "Locrian";

  804. 			case DTROY::LYDIAN:         return "Lydian";

  805. 			case DTROY::MAJOR:          return "Major";

  806. 			case DTROY::MELODIC_MINOR:  return "Melodic Minor";

  807. 			case DTROY::MINOR:          return "Minor";

  808. 			case DTROY::MIXOLYDIAN:     return "Mixolydian";

  809. 			case DTROY::NATURAL_MINOR:  return "Natural Minor";

  810. 			case DTROY::PENTATONIC:     return "Pentatonic";

  811. 			case DTROY::PHRYGIAN:       return "Phrygian";

  812. 			case DTROY::TURKISH:        return "Turkish";

  813. 			case DTROY::NONE:           return "None";

  814. 			default: return "";

  815. 		}

  816. 	}

  817. 

  818. 	string displayPlayMode(int value) {

  819. 		switch(value){

  820. 			case 0: return "►";

  821. 			case 1: return "◄";

  822. 			case 2: return "►◄";

  823. 			case 3: return "►*";

  824. 			case 4: return "►?";

  825. 			default: return "";

  826. 		}

  827. 	}

  828. 

  829. 	void draw(NVGcontext *vg) override {

  830. 		note = displayRootNote(module->patterns[module->selectedPattern].rootNote);

  831. 		steps = (module->patterns[module->selectedPattern].countMode == 0 ? "steps:" : "pulses:" ) + to_string(module->patterns[module->selectedPattern].numberOfStepsParam);

  832. 		playMode = displayPlayMode(module->patterns[module->selectedPattern].playMode);

  833. 		scale = displayScale(module->patterns[module->selectedPattern].scale);

  834. 		selectedPattern = "P" + to_string(module->selectedPattern + 1);

  835. 		playedPattern = "P" + to_string(module->playedPattern + 1);

  836. 		drawMessage(vg, Vec(0, 20), note, playMode, selectedPattern, playedPattern, steps, scale);

  837. 	}

  838. };

  839. 

  840. struct DTROYWidget : ModuleWidget {

  841. 	ParamWidget *stepsParam, *scaleParam, *rootNoteParam, *sensitivityParam,

  842. 	 *gateTimeParam, *slideTimeParam, *playModeParam, *countModeParam, *patternParam,

  843. 	  *pitchParams[8], *pulseParams[8], *typeParams[8], *slideParams[8], *skipParams[8];

  844. 

  845. 	DTROYWidget(DTROY *module);

  846. 	Menu *createContextMenu() override;

  847. };

  848. 

  849. struct DTROYPatternRoundBlackSnapKnob : RoundBlackSnapKnob {

  850. 	void onChange(EventChange &e) override {

  851. 			RoundBlackSnapKnob::onChange(e);

  852. 			DTROY *module = dynamic_cast<DTROY*>(this->module);

  853. 			DTROYWidget *parent = dynamic_cast<DTROYWidget*>(this->parent);

  854. 			int target = clamp((int)(value) - 1, 0, 15);

  855. 			if (module && parent && (target != module->selectedPattern) && module->updateFlag)

  856. 			{

  857. 				module->updateFlag = false;

  858. 				module->selectedPattern = value - 1;

  859. 				parent->stepsParam->setValue(module->patterns[target].numberOfStepsParam);

  860. 				parent->rootNoteParam->setValue(module->patterns[target].rootNote);

  861. 				parent->scaleParam->setValue(module->patterns[target].scale);

  862. 				parent->gateTimeParam->setValue(module->patterns[target].gateTime);

  863. 				parent->slideTimeParam->setValue(module->patterns[target].slideTime);

  864. 				parent->sensitivityParam->setValue(module->patterns[target].sensitivity);

  865. 				module->playMode = module->patterns[module->selectedPattern].playMode;

  866. 				module->countMode = module->patterns[module->selectedPattern].countMode;

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

  868. 					parent->pitchParams[i]->setValue(module->patterns[target].steps[i].pitch);

  869. 					parent->pulseParams[i]->setValue(module->patterns[target].steps[i].pulsesParam);

  870. 					parent->typeParams[i]->setValue(module->patterns[target].steps[i].type);

  871. 					module->skipState[i] = module->patterns[target].steps[i].skipParam ? 't' : 'f';

  872. 					module->slideState[i] = module->patterns[target].steps[i].slide ? 't' : 'f';

  873. 				}

  874. 				module->updateFlag = true;

  875. 			}

  876. 		}

  877. };

  878. 

  879. struct DTROYCOPYPASTECKD6 : BlueCKD6 {

  880. 	void onMouseDown(EventMouseDown &e) override {

  881. 		DTROYWidget *dtroyWidget = dynamic_cast<DTROYWidget*>(this->parent);

  882. 		DTROY *dtroyModule = dynamic_cast<DTROY*>(this->module);

  883. 		if (!dtroyModule->copyState) {

  884. 			dtroyModule->copyPattern = dtroyModule->selectedPattern;

  885. 			dtroyModule->copyState = true;

  886. 		}

  887. 		else if (dtroyModule && dtroyWidget && (dtroyModule->copyState) && (dtroyModule->copyPattern != dtroyModule->selectedPattern) && dtroyModule->updateFlag)

  888. 		{

  889. 			dtroyModule->updateFlag = false;

  890. 			dtroyWidget->stepsParam->setValue(dtroyModule->patterns[dtroyModule->copyPattern].numberOfStepsParam);

  891. 			dtroyWidget->rootNoteParam->setValue(dtroyModule->patterns[dtroyModule->copyPattern].rootNote);

  892. 			dtroyWidget->scaleParam->setValue(dtroyModule->patterns[dtroyModule->copyPattern].scale);

  893. 			dtroyWidget->gateTimeParam->setValue(dtroyModule->patterns[dtroyModule->copyPattern].gateTime);

  894. 			dtroyWidget->slideTimeParam->setValue(dtroyModule->patterns[dtroyModule->copyPattern].slideTime);

  895. 			dtroyWidget->sensitivityParam->setValue(dtroyModule->patterns[dtroyModule->copyPattern].sensitivity);

  896. 			dtroyModule->playMode = dtroyModule->patterns[dtroyModule->copyPattern].playMode;

  897. 			dtroyModule->countMode = dtroyModule->patterns[dtroyModule->copyPattern].countMode;

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

  899. 				dtroyWidget->pitchParams[i]->setValue(dtroyModule->patterns[dtroyModule->copyPattern].steps[i].pitch);

  900. 				dtroyWidget->pulseParams[i]->setValue(dtroyModule->patterns[dtroyModule->copyPattern].steps[i].pulsesParam);

  901. 				dtroyWidget->typeParams[i]->setValue(dtroyModule->patterns[dtroyModule->copyPattern].steps[i].type);

  902. 				dtroyModule->skipState[i] = dtroyModule->patterns[dtroyModule->copyPattern].steps[i].skipParam ? 't' : 'f';

  903. 				dtroyModule->slideState[i] = dtroyModule->patterns[dtroyModule->copyPattern].steps[i].slide ? 't' : 'f';

  904. 			}

  905. 			dtroyModule->copyState = false;

  906. 			dtroyModule->copyPattern = -1;

  907. 			dtroyModule->updateFlag = true;

  908. 		}

  909. 		BlueCKD6::onMouseDown(e);

  910. 	}

  911. };

  912. 

  913. struct DTROYShiftUpBtn : UpBtn {

  914. 	void onMouseDown(EventMouseDown &e) override {

  915. 		DTROYWidget *dtroyWidget = dynamic_cast<DTROYWidget*>(this->parent);

  916. 		DTROY *dtroyModule = dynamic_cast<DTROY*>(this->module);

  917. 		if (dtroyModule && dtroyWidget && dtroyModule->updateFlag)

  918. 		{

  919. 			dtroyModule->updateFlag = false;

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

  921. 				dtroyWidget->pitchParams[i]->setValue(min(dtroyWidget->pitchParams[i]->value + 0.1f,10.0f));

  922. 			}

  923. 			dtroyModule->updateFlag = true;

  924. 		}

  925. 		UpBtn::onMouseDown(e);

  926. 	}

  927. };

  928. 

  929. struct DTROYShiftDownBtn : DownBtn {

  930. 	void onMouseDown(EventMouseDown &e) override {

  931. 		DTROYWidget *dtroyWidget = dynamic_cast<DTROYWidget*>(this->parent);

  932. 		DTROY *dtroyModule = dynamic_cast<DTROY*>(this->module);

  933. 		if (dtroyModule && dtroyWidget && dtroyModule->updateFlag)

  934. 		{

  935. 			dtroyModule->updateFlag = false;

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

  937. 				dtroyWidget->pitchParams[i]->setValue(max(dtroyWidget->pitchParams[i]->value - 0.1f,0.0f));

  938. 			}

  939. 			dtroyModule->updateFlag = true;

  940. 		}

  941. 		DownBtn::onMouseDown(e);

  942. 	}

  943. };

  944. 

  945. struct DTROYShiftLeftBtn : LeftBtn {

  946. 	void onMouseDown(EventMouseDown &e) override {

  947. 		DTROYWidget *dtroyWidget = dynamic_cast<DTROYWidget*>(this->parent);

  948. 		DTROY *dtroyModule = dynamic_cast<DTROY*>(this->module);

  949. 		if (dtroyModule && dtroyWidget && dtroyModule->updateFlag)

  950. 		{

  951. 			dtroyModule->updateFlag = false;

  952. 			float pitch = dtroyWidget->pitchParams[0]->value;

  953. 			float pulse = dtroyWidget->pulseParams[0]->value;

  954. 			float type = dtroyWidget->typeParams[0]->value;

  955. 			char skip = dtroyModule->skipState[0];

  956. 			char slide = dtroyModule->slideState[0];

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

  958. 				dtroyWidget->pitchParams[i]->setValue(dtroyWidget->pitchParams[i+1]->value);

  959. 				dtroyWidget->pulseParams[i]->setValue(dtroyWidget->pulseParams[i+1]->value);

  960. 				dtroyWidget->typeParams[i]->setValue(dtroyWidget->typeParams[i+1]->value);

  961. 				dtroyModule->skipState[i] = dtroyModule->skipState[i+1];

  962. 				dtroyModule->slideState[i] = dtroyModule->slideState[i+1];

  963. 			}

  964. 			dtroyWidget->pitchParams[7]->setValue(pitch);

  965. 			dtroyWidget->pulseParams[7]->setValue(pulse);

  966. 			dtroyWidget->typeParams[7]->setValue(type);

  967. 			dtroyModule->skipState[7] = skip;

  968. 			dtroyModule->slideState[7] = slide;

  969. 			dtroyModule->updateFlag = true;

  970. 		}

  971. 		LeftBtn::onMouseDown(e);

  972. 	}

  973. };

  974. 

  975. struct DTROYShiftRightBtn : RightBtn {

  976. 	void onMouseDown(EventMouseDown &e) override {

  977. 		DTROYWidget *dtroyWidget = dynamic_cast<DTROYWidget*>(this->parent);

  978. 		DTROY *dtroyModule = dynamic_cast<DTROY*>(this->module);

  979. 		if (dtroyModule && dtroyWidget && dtroyModule->updateFlag)

  980. 		{

  981. 			dtroyModule->updateFlag = false;

  982. 			float pitch = dtroyWidget->pitchParams[7]->value;

  983. 			float pulse = dtroyWidget->pulseParams[7]->value;

  984. 			float type = dtroyWidget->typeParams[7]->value;

  985. 			char skip = dtroyModule->skipState[7];

  986. 			char slide = dtroyModule->slideState[7];

  987. 			for (int i = 7; i > 0; i--) {

  988. 				dtroyWidget->pitchParams[i]->setValue(dtroyWidget->pitchParams[i-1]->value);

  989. 				dtroyWidget->pulseParams[i]->setValue(dtroyWidget->pulseParams[i-1]->value);

  990. 				dtroyWidget->typeParams[i]->setValue(dtroyWidget->typeParams[i-1]->value);

  991. 				dtroyModule->skipState[i] = dtroyModule->skipState[i-1];

  992. 				dtroyModule->slideState[i] = dtroyModule->slideState[i-1];

  993. 			}

  994. 			dtroyWidget->pitchParams[0]->setValue(pitch);

  995. 			dtroyWidget->pulseParams[0]->setValue(pulse);

  996. 			dtroyWidget->typeParams[0]->setValue(type);

  997. 			dtroyModule->skipState[0] = skip;

  998. 			dtroyModule->slideState[0] = slide;

  999. 			dtroyModule->updateFlag = true;

  1000. 		}

  1001. 		RightBtn::onMouseDown(e);

  1002. 	}

  1003. };

  1004. 

  1005. DTROYWidget::DTROYWidget(DTROY *module) : ModuleWidget(module) {

  1006. 	setPanel(SVG::load(assetPlugin(plugin, "res/DTROY.svg")));

  1007. 

  1008. 	addChild(Widget::create<ScrewSilver>(Vec(RACK_GRID_WIDTH, 0)));

  1009. 	addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 2 * RACK_GRID_WIDTH, 0)));

  1010. 	addChild(Widget::create<ScrewSilver>(Vec(RACK_GRID_WIDTH, RACK_GRID_HEIGHT - RACK_GRID_WIDTH)));

  1011. 	addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 2 * RACK_GRID_WIDTH, RACK_GRID_HEIGHT - RACK_GRID_WIDTH)));

  1012. 

  1013. 	{

  1014. 		DTROYDisplay *display = new DTROYDisplay();

  1015. 		display->module = module;

  1016. 		display->box.pos = Vec(20.0f, 217.0f);

  1017. 		display->box.size = Vec(250.0f, 60.0f);

  1018. 		addChild(display);

  1019. 	}

  1020. 

  1021. 	addParam(ParamWidget::create<RoundBlackKnob>(Vec(17.0f, 36.0f), module, DTROY::CLOCK_PARAM, -2.0f, 6.0f, 2.0f));

  1022. 	addParam(ParamWidget::create<LEDButton>(Vec(61.0f, 40.0f), module, DTROY::RUN_PARAM, 0.0f, 1.0f, 0.0f));

  1023. 	addChild(ModuleLightWidget::create<SmallLight<GreenLight>>(Vec(67.0f, 46.0f), module, DTROY::RUNNING_LIGHT));

  1024. 	addParam(ParamWidget::create<LEDButton>(Vec(99.0f, 40.0f), module, DTROY::RESET_PARAM, 0.0f, 1.0f, 0.0f));

  1025. 	addChild(ModuleLightWidget::create<SmallLight<GreenLight>>(Vec(105.0f, 46.0f), module, DTROY::RESET_LIGHT));

  1026. 	stepsParam = ParamWidget::create<BidooBlueSnapKnob>(Vec(132.0f, 36.0f), module, DTROY::STEPS_PARAM, 1.0f, 16.0f, 8.0f);

  1027. 	addParam(stepsParam);

  1028. 

  1029. 	static const float portX0[4] = {20.0f, 58.0f, 96.0f, 135.0f};

  1030.  	addInput(Port::create<PJ301MPort>(Vec(portX0[0], 69.0f), Port::INPUT, module, DTROY::CLOCK_INPUT));

  1031. 	addInput(Port::create<PJ301MPort>(Vec(portX0[1], 69.0f), Port::INPUT, module, DTROY::EXT_CLOCK_INPUT));

  1032. 	addInput(Port::create<PJ301MPort>(Vec(portX0[2], 69.0f), Port::INPUT, module, DTROY::RESET_INPUT));

  1033. 	addInput(Port::create<PJ301MPort>(Vec(portX0[3], 69.0f), Port::INPUT, module, DTROY::STEPS_INPUT));

  1034. 

  1035. 	rootNoteParam = ParamWidget::create<BidooBlueSnapKnob>(Vec(portX0[0]-2.0f, 116.0f), module, DTROY::ROOT_NOTE_PARAM, 0.0f, 11.0f, 0.0f);

  1036. 	addParam(rootNoteParam);

  1037. 	scaleParam = ParamWidget::create<BidooBlueSnapKnob>(Vec(portX0[1]-2.0f, 116.0f), module, DTROY::SCALE_PARAM, 0.0f, 17.0f, 0.0f);

  1038. 	addParam(scaleParam);

  1039. 	gateTimeParam = ParamWidget::create<BidooBlueKnob>(Vec(portX0[2]-2.0f, 116.0f), module, DTROY::GATE_TIME_PARAM, 0.1f, 1.0f, 0.5f);

  1040. 	addParam(gateTimeParam);

  1041. 	slideTimeParam = ParamWidget::create<BidooBlueKnob>(Vec(portX0[3]-2.0f, 116.0f), module, DTROY::SLIDE_TIME_PARAM	, 0.1f, 1.0f, 0.2f);

  1042. 	addParam(slideTimeParam);

  1043. 

  1044. 	addInput(Port::create<PJ301MPort>(Vec(portX0[0], 149.0f), Port::INPUT, module, DTROY::ROOT_NOTE_INPUT));

  1045. 	addInput(Port::create<PJ301MPort>(Vec(portX0[1], 149.0f), Port::INPUT, module, DTROY::SCALE_INPUT));

  1046. 	addInput(Port::create<PJ301MPort>(Vec(portX0[2], 149.0f), Port::INPUT, module, DTROY::GATE_TIME_INPUT));

  1047. 	addInput(Port::create<PJ301MPort>(Vec(portX0[3], 149.0f), Port::INPUT, module, DTROY::SLIDE_TIME_INPUT));

  1048. 

  1049. 	playModeParam = ParamWidget::create<BlueCKD6>(Vec(portX0[0]-1.0f, 196.0f), module, DTROY::PLAY_MODE_PARAM, 0.0f, 4.0f, 0.0f);

  1050. 	addParam(playModeParam);

  1051. 	countModeParam = ParamWidget::create<BlueCKD6>(Vec(portX0[1]-1.0f, 196.0f), module, DTROY::COUNT_MODE_PARAM, 0.0f, 4.0f, 0.0f);

  1052. 	addParam(countModeParam);

  1053. 	addInput(Port::create<PJ301MPort>(Vec(portX0[2], 198.0f), Port::INPUT, module, DTROY::PATTERN_INPUT));

  1054. 	patternParam = ParamWidget::create<DTROYPatternRoundBlackSnapKnob>(Vec(portX0[3]-1,196.0f), module, DTROY::PATTERN_PARAM, 1.0f, 16.0f, 1.0f);

  1055. 	addParam(patternParam);

  1056. 

  1057. 	static const float portX1[8] = {200.0f, 238.0f, 276.0f, 315.0f, 353.0f, 392.0f, 430.0f, 469.0f};

  1058. 

  1059. 	sensitivityParam = ParamWidget::create<BidooBlueTrimpot>(Vec(portX1[6]+21.0f, 18.0f), module, DTROY::SENSITIVITY_PARAM, 0.1f, 1.0f, 1.0f);

  1060. 	addParam(sensitivityParam);

  1061. 

  1062. 	addInput(Port::create<PJ301MPort>(Vec(portX0[0], 286.0f), Port::INPUT, module, DTROY::TRANSPOSE_INPUT));

  1063. 	addParam(ParamWidget::create<DTROYCOPYPASTECKD6>(Vec(portX0[1]-1.0f, 285.0f), module, DTROY::COPY_PARAM, 0.0f, 1.0f, 0.0f));

  1064. 	addChild(ModuleLightWidget::create<SmallLight<GreenLight>>(Vec(portX0[1]+23.0f, 283.0f), module, DTROY::COPY_LIGHT));

  1065. 

  1066. 	addParam(ParamWidget::create<DTROYShiftLeftBtn>(Vec(104.0f, 290.0f), module, DTROY::LEFT_PARAM, 0.0f, 1.0f, 0.0f));

  1067. 	addParam(ParamWidget::create<DTROYShiftRightBtn>(Vec(134.0f, 290.0f), module, DTROY::RIGHT_PARAM, 0.0f, 1.0f, 0.0f));

  1068. 	addParam(ParamWidget::create<DTROYShiftUpBtn>(Vec(119.0f, 282.0f), module, DTROY::UP_PARAM, 0.0f, 1.0f, 0.0f));

  1069. 	addParam(ParamWidget::create<DTROYShiftDownBtn>(Vec(119.0f, 297.0f), module, DTROY::DOWN_PARAM, 0.0f, 1.0f, 0.0f));

  1070. 

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

  1072. 		pitchParams[i] = ParamWidget::create<BidooBlueKnob>(Vec(portX1[i]-3.0f, 36.0f), module, DTROY::TRIG_PITCH_PARAM + i, 0.0f, 10.0f, 3.0f);

  1073. 		addParam(pitchParams[i]);

  1074. 		pulseParams[i] = ParamWidget::create<BidooSlidePotLong>(Vec(portX1[i]+2.0f, 87.0f), module, DTROY::TRIG_COUNT_PARAM + i, 1.0f, 8.0f,  1.0f);

  1075. 		addParam(pulseParams[i]);

  1076. 		typeParams[i] = ParamWidget::create<BidooSlidePotShort>(Vec(portX1[i]+2.0f, 204.0f), module, DTROY::TRIG_TYPE_PARAM + i, 0.0f, 5.0f,  2.0f);

  1077. 		addParam(typeParams[i]);

  1078. 		slideParams[i] = ParamWidget::create<LEDButton>(Vec(portX1[i]+2.0f, 297.0f), module, DTROY::TRIG_SLIDE_PARAM + i, 0.0f, 1.0f,  0.0f);

  1079. 		addParam(slideParams[i]);

  1080. 		addChild(ModuleLightWidget::create<SmallLight<BlueLight>>(Vec(portX1[i]+8.0f, 303.0f), module, DTROY::SLIDES_LIGHTS + i));

  1081. 		skipParams[i] = ParamWidget::create<LEDButton>(Vec(portX1[i]+2.0f, 321.0f), module, DTROY::TRIG_SKIP_PARAM + i, 0.0f, 1.0f,  0.0f);

  1082. 		addParam(skipParams[i]);

  1083. 		addChild(ModuleLightWidget::create<SmallLight<BlueLight>>(Vec(portX1[i]+8.0f, 327.0f), module, DTROY::SKIPS_LIGHTS + i));

  1084. 		addOutput(Port::create<TinyPJ301MPort>(Vec(portX1[i]+4.0f, 344.0f), Port::OUTPUT, module, DTROY::STEP_OUTPUT + i));

  1085. 	}

  1086. 

  1087. 	addInput(Port::create<PJ301MPort>(Vec(portX0[0], 331.0f), Port::INPUT, module, DTROY::EXTGATE1_INPUT));

  1088. 	addInput(Port::create<PJ301MPort>(Vec(portX0[1], 331.0f), Port::INPUT, module, DTROY::EXTGATE2_INPUT));

  1089. 	addOutput(Port::create<PJ301MPort>(Vec(portX0[2]-1, 331.0f), Port::OUTPUT, module, DTROY::GATE_OUTPUT));

  1090. 	addOutput(Port::create<PJ301MPort>(Vec(portX0[3]-1, 331.0f), Port::OUTPUT, module, DTROY::PITCH_OUTPUT));

  1091. }

  1092. 

  1093. 

  1094. struct DTROYRandPitchItem : MenuItem {

  1095. 	DTROYWidget *dtroyWidget;

  1096. 	void onAction(EventAction &e) override {

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

  1098. 			int index = DTROY::TRIG_PITCH_PARAM + i;

  1099. 			auto it = std::find_if(dtroyWidget->params.begin(), dtroyWidget->params.end(), [&index](const ParamWidget* m) -> bool { return m->paramId == index; });

  1100. 			if (it != dtroyWidget->params.end())

  1101. 			{

  1102. 				auto index = std::distance(dtroyWidget->params.begin(), it);

  1103. 				dtroyWidget->params[index]->randomize();

  1104. 			}

  1105. 		}

  1106. 	}

  1107. };

  1108. 

  1109. struct DTROYRandGatesItem : MenuItem {

  1110. 	DTROYWidget *dtroyWidget;

  1111. 	void onAction(EventAction &e) override {

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

  1113. 			int index = DTROY::TRIG_COUNT_PARAM + i;

  1114. 			auto it = std::find_if(dtroyWidget->params.begin(), dtroyWidget->params.end(), [&index](const ParamWidget* m) -> bool { return m->paramId == index; });

  1115. 			if (it != dtroyWidget->params.end())

  1116. 			{

  1117. 				auto index = std::distance(dtroyWidget->params.begin(), it);

  1118. 				dtroyWidget->params[index]->randomize();

  1119. 			}

  1120. 		}

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

  1122. 				int index = DTROY::TRIG_TYPE_PARAM + i;

  1123. 				auto it = std::find_if(dtroyWidget->params.begin(), dtroyWidget->params.end(), [&index](const ParamWidget* m) -> bool { return m->paramId == index; });

  1124. 				if (it != dtroyWidget->params.end())

  1125. 				{

  1126. 					auto index = std::distance(dtroyWidget->params.begin(), it);

  1127. 				dtroyWidget->params[index]->randomize();

  1128. 			}

  1129. 		}

  1130. 	}

  1131. };

  1132. 

  1133. struct DTROYRandSlideSkipItem : MenuItem {

  1134. 	DTROY *dtroyModule;

  1135. 	void onAction(EventAction &e) override {

  1136. 		dtroyModule->randomizeSlidesSkips();

  1137. 	}

  1138. };

  1139. 

  1140. struct DTROYStepOutputsModeItem : MenuItem {

  1141. 	DTROY *dtroyModule;

  1142. 	void onAction(EventAction &e) override {

  1143. 		dtroyModule->stepOutputsMode = !dtroyModule->stepOutputsMode;

  1144. 	}

  1145. 	void step() override {

  1146. 		rightText = dtroyModule->stepOutputsMode ? "✔" : "";

  1147. 		MenuItem::step();

  1148. 	}

  1149. };

  1150. 

  1151. struct DisconnectMenuItem : MenuItem {

  1152. 	ModuleWidget *moduleWidget;

  1153. 	void onAction(EventAction &e) override {

  1154. 		moduleWidget->disconnect();

  1155. 	}

  1156. };

  1157. 

  1158. struct ResetMenuItem : MenuItem {

  1159. 	DTROYWidget *dtroyWidget;

  1160. 	DTROY *dtroy;

  1161. 	void onAction(EventAction &e) override {

  1162. 		for (int i = 0; i < DTROY::NUM_PARAMS; i++){

  1163. 			if (i != DTROY::PATTERN_PARAM) {

  1164. 				auto it = std::find_if(dtroyWidget->params.begin(), dtroyWidget->params.end(), [&i](const ParamWidget* m) -> bool { return m->paramId == i; });

  1165. 				if (it != dtroyWidget->params.end())

  1166. 				{

  1167. 					auto index = std::distance(dtroyWidget->params.begin(), it);

  1168. 					dtroyWidget->params[index]->setValue(dtroyWidget->params[index]->defaultValue);

  1169. 				}

  1170. 			}

  1171. 		}

  1172. 		dtroy->updateFlag = false;

  1173. 		dtroy->reset();

  1174. 		dtroy->playMode = 0;

  1175. 		dtroy->countMode = 0;

  1176. 		dtroy->updateFlag = true;

  1177. 	}

  1178. };

  1179. 

  1180. struct RandomizeMenuItem : MenuItem {

  1181. 	ModuleWidget *moduleWidget;

  1182. 	void onAction(EventAction &e) override {

  1183. 		moduleWidget->randomize();

  1184. 	}

  1185. };

  1186. 

  1187. struct CloneMenuItem : MenuItem {

  1188. 	ModuleWidget *moduleWidget;

  1189. 	void onAction(EventAction &e) override {

  1190. 		RACK_PLUGIN_UI_RACKWIDGET->cloneModule(moduleWidget);

  1191. 	}

  1192. };

  1193. 

  1194. struct DeleteMenuItem : MenuItem {

  1195. 	ModuleWidget *moduleWidget;

  1196. 	void onAction(EventAction &e) override {

  1197. 		RACK_PLUGIN_UI_RACKWIDGET->deleteModule(moduleWidget);

  1198. 		moduleWidget->finalizeEvents();

  1199. 		delete moduleWidget;

  1200. 	}

  1201. };

  1202. 

  1203. Menu *DTROYWidget::createContextMenu() {

  1204. 	DTROYWidget *dtroyWidget = dynamic_cast<DTROYWidget*>(this);

  1205. 	assert(dtroyWidget);

  1206. 

  1207. 	DTROY *dtroyModule = dynamic_cast<DTROY*>(module);

  1208. 	assert(dtroyModule);

  1209. 

  1210. 	Menu *menu = rack::global_ui->ui.gScene->createMenu();

  1211. 

  1212. 	MenuLabel *menuLabel = new MenuLabel();

  1213. 	menuLabel->text = model->author + " " + model->name;

  1214. 	menu->addChild(menuLabel);

  1215. 

  1216. 	ResetMenuItem *resetItem = new ResetMenuItem();

  1217. 	resetItem->text = "Initialize";

  1218. 	resetItem->rightText = "+I";

  1219. 	resetItem->dtroyWidget = this;

  1220. 	resetItem->dtroy = dtroyModule;

  1221. 	menu->addChild(resetItem);

  1222. 

  1223. 	DisconnectMenuItem *disconnectItem = new DisconnectMenuItem();

  1224. 	disconnectItem->text = "Disconnect cables";

  1225. 	disconnectItem->moduleWidget = this;

  1226. 	menu->addChild(disconnectItem);

  1227. 

  1228. 	CloneMenuItem *cloneItem = new CloneMenuItem();

  1229. 	cloneItem->text = "Duplicate";

  1230. 	cloneItem->rightText = "+D";

  1231. 	cloneItem->moduleWidget = this;

  1232. 	menu->addChild(cloneItem);

  1233. 

  1234. 	DeleteMenuItem *deleteItem = new DeleteMenuItem();

  1235. 	deleteItem->text = "Delete";

  1236. 	deleteItem->rightText = "Backspace/Delete";

  1237. 	deleteItem->moduleWidget = this;

  1238. 	menu->addChild(deleteItem);

  1239. 

  1240. 	MenuLabel *spacerLabel = new MenuLabel();

  1241. 	menu->addChild(spacerLabel);

  1242. 

  1243. 	DTROYRandPitchItem *randomizePitchItem = new DTROYRandPitchItem();

  1244. 	randomizePitchItem->text = "Randomize pitch";

  1245. 	randomizePitchItem->dtroyWidget = dtroyWidget;

  1246. 	menu->addChild(randomizePitchItem);

  1247. 

  1248. 	DTROYRandGatesItem *randomizeGatesItem = new DTROYRandGatesItem();

  1249. 	randomizeGatesItem->text = "Randomize gates";

  1250. 	randomizeGatesItem->dtroyWidget = dtroyWidget;

  1251. 	menu->addChild(randomizeGatesItem);

  1252. 

  1253. 	DTROYRandSlideSkipItem *randomizeSlideSkipItem = new DTROYRandSlideSkipItem();

  1254. 	randomizeSlideSkipItem->text = "Randomize slides and skips";

  1255. 	randomizeSlideSkipItem->dtroyModule = dtroyModule;

  1256. 	menu->addChild(randomizeSlideSkipItem);

  1257. 

  1258. 	MenuLabel *spacerLabel2 = new MenuLabel();

  1259. 	menu->addChild(spacerLabel2);

  1260. 

  1261. 	DTROYStepOutputsModeItem *stepOutputsModeItem = new DTROYStepOutputsModeItem();

  1262. 	stepOutputsModeItem->text = "Step trigs on steps (vs. pulses)";

  1263. 	stepOutputsModeItem->dtroyModule = dtroyModule;

  1264. 	menu->addChild(stepOutputsModeItem);

  1265. 

  1266. 	return menu;

  1267. }

  1268. 

  1269. } // namespace rack_plugin_Bidoo

  1270. 

  1271. using namespace rack_plugin_Bidoo;

  1272. 

  1273. RACK_PLUGIN_MODEL_INIT(Bidoo, DTROY) {

  1274.    Model *modelDTROY = Model::create<DTROY, DTROYWidget>("Bidoo", "dTrOY", "dTrOY sequencer", SEQUENCER_TAG);

  1275.    return modelDTROY;

  1276. }