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

1200 lines
45KB
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, std::vector<char> skips, std::vector<char> slides, std::vector<Param> pulses, std::vector<Param> pitches, std::vector<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[i%8] == 't');

  63. 			}	else {

  64. 				steps[i].skip = true;

  65. 			}

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

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

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

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

  70. 			}	else {

  71. 				steps[i].pulses = (int)pulses[i%8].value;

  72. 			}

  73. 			steps[i].pulsesParam = (int)pulses[i%8].value;

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

  75. 			steps[i].pitch = pitches[i%8].value;

  76. 			steps[i].type = (int)types[i%8].value;

  77. 		}

  78. 	}

  79. 

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

  81. 	{

  82. 		if (reset) {

  83. 			if (playMode != 1) {

  84. 				currentStep = GetFirstStep();

  85. 			} else {

  86. 				currentStep = GetLastStep();

  87. 			}

  88. 			currentPulse = 0;

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

  90. 		} else {

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

  92. 				currentPulse++;

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

  94. 			} else {

  95. 				if (playMode == 0) {

  96. 					currentStep = GetNextStepForward(currentStep);

  97. 					currentPulse = 0;

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

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

  100. 					currentStep = GetNextStepBackward(currentStep);

  101. 					currentPulse = 0;

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

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

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

  105. 						forward = false;

  106. 					}

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

  108. 						forward = true;

  109. 					}

  110. 					if (forward) {

  111. 						currentStep = GetNextStepForward(currentStep);

  112. 					} else {

  113. 						currentStep = GetNextStepBackward(currentStep);

  114. 					}

  115. 					currentPulse = 0;

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

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

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

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

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

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

  122. 					currentPulse = 0;

  123. 					currentStep = tmpStep.number;

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

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

  126. 					int next = GetNextStepForward(currentStep);

  127. 					int prev = GetNextStepBackward(currentStep);

  128. 					vector<Step> subPattern;

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

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

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

  132. 					currentPulse = 0;

  133. 					currentStep = choice.number;

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

  135. 				} else {

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

  137. 				}

  138. 			}

  139. 		}

  140. 	}

  141. 

  142. 	Step CurrentStep() {

  143. 		return this->steps[currentStep];

  144. 	}

  145. 

  146. 	int GetFirstStep()

  147. 	{

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

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

  150. 					return i;

  151. 				}

  152. 			}

  153. 			return 0;

  154. 	}

  155. 

  156. 	int GetLastStep()

  157. 	{

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

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

  160. 					return i;

  161. 				}

  162. 			}

  163. 			return 15;

  164. 	}

  165. 

  166. 	int GetNextStepForward(int pos)

  167. 	{

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

  169. 				if (!steps[i%16].skip) {

  170. 					return i%16;

  171. 				}

  172. 			}

  173. 			return pos;

  174. 	}

  175. 

  176. 	int GetNextStepBackward(int pos)

  177. 	{

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

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

  180. 					return i%16 + (i<0?16:0);

  181. 				}

  182. 			}

  183. 			return pos;

  184. 	}

  185. 

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

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

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

  189. 		return start;

  190. 	}

  191. 

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

  193. 		static std::random_device rd;

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

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

  196. 	}

  197. 

  198. };

  199. 

  200. struct DTROY : Module {

  201. 	enum ParamIds {

  202. 		CLOCK_PARAM,

  203. 		RUN_PARAM,

  204. 		RESET_PARAM,

  205. 		STEPS_PARAM,

  206. 		SLIDE_TIME_PARAM,

  207. 		GATE_TIME_PARAM,

  208. 		ROOT_NOTE_PARAM,

  209. 		SCALE_PARAM,

  210. 		PLAY_MODE_PARAM,

  211. 		COUNT_MODE_PARAM,

  212. 		PATTERN_PARAM,

  213. 		SENSITIVITY_PARAM,

  214. 		TRIG_COUNT_PARAM = SENSITIVITY_PARAM + 8,

  215. 		TRIG_TYPE_PARAM = TRIG_COUNT_PARAM + 8,

  216. 		TRIG_PITCH_PARAM = TRIG_TYPE_PARAM + 8,

  217. 		TRIG_SLIDE_PARAM = TRIG_PITCH_PARAM + 8,

  218. 		TRIG_SKIP_PARAM = TRIG_SLIDE_PARAM + 8,

  219. 		NUM_PARAMS = TRIG_SKIP_PARAM + 8

  220. 	};

  221. 	enum InputIds {

  222. 		CLOCK_INPUT,

  223. 		EXT_CLOCK_INPUT,

  224. 		RESET_INPUT,

  225. 		STEPS_INPUT,

  226. 		SLIDE_TIME_INPUT,

  227. 		GATE_TIME_INPUT,

  228. 		ROOT_NOTE_INPUT,

  229. 		SCALE_INPUT,

  230. 		EXTGATE1_INPUT,

  231. 		EXTGATE2_INPUT,

  232. 		PATTERN_INPUT,

  233. 		NUM_INPUTS

  234. 	};

  235. 	enum OutputIds {

  236. 		GATE_OUTPUT,

  237. 		PITCH_OUTPUT,

  238. 		NUM_OUTPUTS

  239. 	};

  240. 	enum LightIds {

  241. 		RUNNING_LIGHT,

  242. 		RESET_LIGHT,

  243. 		GATE_LIGHT,

  244. 		STEPS_LIGHTS = GATE_LIGHT + 8,

  245. 		SLIDES_LIGHTS = STEPS_LIGHTS + 8,

  246. 		SKIPS_LIGHTS = SLIDES_LIGHTS + 8,

  247. 		NUM_LIGHTS = SKIPS_LIGHTS + 8

  248. 	};

  249. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  268. 

  269. 	enum Notes {

  270. 		NOTE_C,

  271. 		NOTE_C_SHARP,

  272. 		NOTE_D,

  273. 		NOTE_D_SHARP,

  274. 		NOTE_E,

  275. 		NOTE_F,

  276. 		NOTE_F_SHARP,

  277. 		NOTE_G,

  278. 		NOTE_G_SHARP,

  279. 		NOTE_A,

  280. 		NOTE_A_SHARP,

  281. 		NOTE_B,

  282. 		NUM_NOTES

  283. 	};

  284. 

  285. 	enum Scales {

  286. 		AEOLIAN,

  287. 		BLUES,

  288. 		CHROMATIC,

  289. 		DIATONIC_MINOR,

  290. 		DORIAN,

  291. 		HARMONIC_MINOR,

  292. 		INDIAN,

  293. 		LOCRIAN,

  294. 		LYDIAN,

  295. 		MAJOR,

  296. 		MELODIC_MINOR,

  297. 		MINOR,

  298. 		MIXOLYDIAN,

  299. 		NATURAL_MINOR,

  300. 		PENTATONIC,

  301. 		PHRYGIAN,

  302. 		TURKISH,

  303. 		NONE,

  304. 		NUM_SCALES

  305. 	};

  306. 

  307. 	bool running = true;

  308. 	SchmittTrigger clockTrigger;

  309. 	SchmittTrigger runningTrigger;

  310. 	SchmittTrigger resetTrigger;

  311. 	SchmittTrigger slideTriggers[8];

  312. 	SchmittTrigger skipTriggers[8];

  313. 	SchmittTrigger playModeTrigger;

  314. 	SchmittTrigger countModeTrigger;

  315. 	SchmittTrigger PatternTrigger;

  316. 	float phase = 0.0f;

  317. 	int index = 0;

  318. 	bool reStart = true;

  319. 	int pulse = 0;

  320. 	int rootNote = 0;

  321. 	int curScaleVal = 0;

  322. 	float pitch = 0.0f;

  323. 	float previousPitch = 0.0f;

  324. 	clock_t tCurrent;

  325. 	clock_t tLastTrig;

  326. 	clock_t tPreviousTrig;

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

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

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

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

  331. 	int numSteps = 8;

  332. 	int selectedPattern = 0;

  333. 	int playedPattern = 0;

  334. 	bool pitchMode = false;

  335. 	bool pitchQuantizeMode = true;

  336. 	bool updateFlag = false;

  337. 	bool first = true;

  338. 	bool loadedFromJson = false;

  339. 	int copyPattern = -1;

  340. 

  341. 	Pattern patterns[16];

  342. 

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

  344. 	}

  345. 

  346. 	void UpdatePattern() {

  347. 		std::vector<Param> pulses(&params[TRIG_COUNT_PARAM],&params[TRIG_COUNT_PARAM + 8]);

  348. 		std::vector<Param> pitches(&params[TRIG_PITCH_PARAM],&params[TRIG_PITCH_PARAM + 8]);

  349. 		std::vector<Param> types(&params[TRIG_TYPE_PARAM],&params[TRIG_TYPE_PARAM + 8]);

  350. 		patterns[selectedPattern].Update(playMode, countMode, numSteps, roundf(params[STEPS_PARAM].value), roundf(params[ROOT_NOTE_PARAM].value), roundf(params[SCALE_PARAM].value), params[GATE_TIME_PARAM].value, params[SLIDE_TIME_PARAM].value, params[SENSITIVITY_PARAM].value , skipState, slideState, pulses, pitches, types);

  351. 	}

  352. 

  353. 	void step() override;

  354. 

  355. 	// persistence, random & init

  356. 

  357. 	json_t *toJson() override {

  358. 		json_t *rootJ = json_object();

  359. 

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

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

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

  363. 		json_object_set_new(rootJ, "pitchMode", json_boolean(pitchMode));

  364. 		json_object_set_new(rootJ, "pitchQuantizeMode", json_boolean(pitchQuantizeMode));

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

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

  367. 

  368. 		json_t *trigsJ = json_array();

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

  370. 			json_t *trigJ = json_array();

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

  372. 			json_array_append_new(trigJ, trigJSlide);

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

  374. 			json_array_append_new(trigJ, trigJSkip);

  375. 			json_array_append_new(trigsJ, trigJ);

  376. 		}

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

  378. 

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

  380. 			json_t *patternJ = json_object();

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

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

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

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

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

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

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

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

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

  390. 				json_t *stepJ = json_object();

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

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

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

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

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

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

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

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

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

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

  401. 			}

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

  403. 		}

  404. 		return rootJ;

  405. 	}

  406. 

  407. 	void fromJson(json_t *rootJ) override {

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

  409. 		if (runningJ)

  410. 			running = json_is_true(runningJ);

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

  412. 		if (playModeJ)

  413. 			playMode = json_integer_value(playModeJ);

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

  415. 		if (countModeJ)

  416. 			countMode = json_integer_value(countModeJ);

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

  418. 		if (selectedPatternJ)

  419. 			selectedPattern = json_integer_value(selectedPatternJ);

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

  421. 		if (playedPatternJ)

  422. 			playedPattern = json_integer_value(playedPatternJ);

  423. 		json_t *pitchModeJ = json_object_get(rootJ, "pitchMode");

  424. 		if (pitchModeJ)

  425. 			pitchMode = json_is_true(pitchModeJ);

  426. 		json_t *pitchQuantizeModeJ = json_object_get(rootJ, "pitchQuantizeMode");

  427. 		if (pitchQuantizeModeJ)

  428. 			pitchQuantizeMode = json_is_true(pitchQuantizeModeJ);

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

  430. 		if (trigsJ) {

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

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

  433. 				if (trigJ)

  434. 				{

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

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

  437. 				}

  438. 			}

  439. 		}

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

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

  442. 			if (patternJ){

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

  444. 				if (playModeJ)

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

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

  447. 				if (countModeJ)

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

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

  450. 				if (numStepsJ)

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

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

  453. 				if (rootNoteJ)

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

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

  456. 				if (scaleJ)

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

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

  459. 				if (gateTimeJ)

  460. 					patterns[i].gateTime = json_real_value(gateTimeJ);

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

  462. 				if (slideTimeJ)

  463. 					patterns[i].slideTime = json_real_value(slideTimeJ);

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

  465. 				if (sensitivityJ)

  466. 					patterns[i].sensitivity = json_real_value(sensitivityJ);

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

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

  469. 					if (stepJ) {

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

  471. 						if (indexJ)

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

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

  474. 						if (numberJ)

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

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

  477. 						if (skipJ)

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

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

  480. 						if (skipParamJ)

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

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

  483. 						if (slideJ)

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

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

  486. 						if (pulsesJ)

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

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

  489. 						if (pulsesParamJ)

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

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

  492. 						if (pitchJ)

  493. 							patterns[i].steps[j].pitch = json_real_value(pitchJ);

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

  495. 						if (typeJ)

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

  497. 					}

  498. 				}

  499. 			}

  500. 		}

  501. 		updateFlag = true;

  502. 		loadedFromJson = true;

  503. 	}

  504. 

  505. 	void randomize() override {

  506. 		randomizeSlidesSkips();

  507. 	}

  508. 

  509. 	void randomizeSlidesSkips() {

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

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

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

  513. 		}

  514. 	}

  515. 

  516. 	void reset() override {

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

  518. 			slideState[i] = 'f';

  519. 			skipState[i] = 'f';

  520. 		}

  521. 	}

  522. 

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

  524. 

  525. 	float getOneRandomNoteInScale(){

  526. 		rootNote = clamp((int)(patterns[playedPattern].rootNote + inputs[ROOT_NOTE_INPUT].value), 0, NUM_NOTES-1);

  527. 		curScaleVal = clamp((int)(patterns[playedPattern].scale + inputs[SCALE_INPUT].value), 0, NUM_SCALES-1);

  528. 		int *curScaleArr;

  529. 		int notesInScale = 0;

  530. 		switch(curScaleVal){

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  548. 		}

  549. 

  550. 		if(curScaleVal == NONE){

  551. 			return randomUniform() * 6.0f;

  552. 		} else {

  553. 			float voltsOut = 0.0f;

  554. 			int rndOctaveInVolts = int(5.0f * randomUniform());

  555. 			voltsOut += rndOctaveInVolts;

  556. 			voltsOut += rootNote / 12.0f;

  557. 			voltsOut += curScaleArr[int(notesInScale * randomUniform())] / 12.0f;

  558. 			return voltsOut;

  559. 		}

  560. 	}

  561. 

  562. 	float closestVoltageInScale(float voltsIn){

  563. 		rootNote = clamp((int)(patterns[playedPattern].rootNote + inputs[ROOT_NOTE_INPUT].value), 0, DTROY::NUM_NOTES-1);

  564. 		curScaleVal = clamp((int)(patterns[playedPattern].scale + inputs[SCALE_INPUT].value), 0, DTROY::NUM_SCALES-1);

  565. 		int *curScaleArr;

  566. 		int notesInScale = 0;

  567. 		switch(curScaleVal){

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  585. 			case NONE:           return voltsIn;

  586. 		}

  587. 

  588. 		float closestVal = 10.0f;

  589. 		float closestDist = 10.0f;

  590. 		int octaveInVolts = int(voltsIn);

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

  592. 			float scaleNoteInVolts = octaveInVolts + (((pitchQuantizeMode ? rootNote : 0.0f) + curScaleArr[i]) / 12.0f);

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

  594. 			if(distAway < closestDist) {

  595. 				closestVal = scaleNoteInVolts;

  596. 				closestDist = distAway;

  597. 			}

  598. 		}

  599. 		closestVal += pitchQuantizeMode ? 0.0f : (rootNote / 12.0f);

  600. 		return closestVal;

  601. 	}

  602. };

  603. 

  604. 

  605. void DTROY::step() {

  606.  	const float lightLambda = 0.075f;

  607. 

  608. 	// Run

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

  610. 		running = !running;

  611. 	}

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

  613. 	bool nextStep = false;

  614. 	// Phase calculation

  615. 	if (running) {

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

  617. 			tCurrent = clock();

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

  619. 			if (tLastTrig && tPreviousTrig) {

  620. 				phase = float(tCurrent - tLastTrig) / float(tLastTrig - tPreviousTrig);

  621. 			}

  622. 			else {

  623. 				phase += clockTime / engineGetSampleRate();

  624. 			}

  625. 			// External clock

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

  627. 				tPreviousTrig = tLastTrig;

  628. 				tLastTrig = clock();

  629. 				phase = 0.0f;

  630. 				nextStep = true;

  631. 			}

  632. 		}

  633. 		else {

  634. 			// Internal clock

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

  636. 			phase += clockTime / engineGetSampleRate();

  637. 			if (phase >= 1.0f) {

  638. 				phase--;

  639. 				nextStep = true;

  640. 			}

  641. 		}

  642. 	}

  643. 	// Reset

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

  645. 		phase = 0.0f;

  646. 		reStart = true;

  647. 		nextStep = true;

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

  649. 	}

  650. 	//patternNumber

  651. 	playedPattern = 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);

  652. 	// Update Pattern

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

  654. 		// Trigs Update

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

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

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

  658. 			}

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

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

  661. 			}

  662. 		}

  663. 		// playMode

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

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

  666. 		}

  667. 		// countMode

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

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

  670. 		}

  671. 		// numSteps

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

  673. 		UpdatePattern();

  674. 		if (!loadedFromJson) {

  675. 			loadedFromJson = true;

  676. 			updateFlag = true;

  677. 		}

  678. 	}

  679. 	// Steps && Pulses Management

  680. 	if (nextStep) {

  681. 		// Advance step

  682. 		previousPitch = closestVoltageInScale(patterns[playedPattern].CurrentStep().pitch);

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

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

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

  686. 		if (reStart) { reStart = false; }

  687. 		lights[STEPS_LIGHTS+index%8].value = 1.0f;

  688. 	}

  689. 	// Lights

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

  691. 		lights[STEPS_LIGHTS + i].value -= lights[STEPS_LIGHTS + i].value / lightLambda / engineGetSampleRate();

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

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

  694. 	}

  695. 	lights[RESET_LIGHT].value -= lights[RESET_LIGHT].value / lightLambda / engineGetSampleRate();

  696. 

  697. 	// Caclulate Outputs

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

  699. 	float gateValue = 0.0f;

  700. 	if (gateOn){

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

  702. 			gateOn = false;

  703. 		}

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

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

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

  707. 				float gateCoeff = clamp(patterns[playedPattern].gateTime - 0.02f + inputs[GATE_TIME_INPUT].value /10.0f, 0.0f, 0.99f);

  708. 			gateOn = phase < gateCoeff;

  709. 			gateValue = 10.0f;

  710. 		}

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

  712. 			gateOn = true;

  713. 			gateValue = 10.0f;

  714. 		}

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

  716. 			gateOn = true;

  717. 			gateValue = inputs[EXTGATE1_INPUT].value;

  718. 		}

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

  720. 			gateOn = true;

  721. 			gateValue = inputs[EXTGATE2_INPUT].value;

  722. 		}

  723. 		else {

  724. 			gateOn = false;

  725. 			gateValue = 0.0f;

  726. 		}

  727. 	}

  728. 	//pitch management

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

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

  731. 		if (pulse == 0) {

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

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

  734. 		}

  735. 	}

  736. 	// Update Outputs

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

  738. 	outputs[PITCH_OUTPUT].value = pitchMode ? pitch : (gateOn ? pitch : 0.0f);

  739. }

  740. 

  741. struct DTROYDisplay : TransparentWidget {

  742. 	DTROY *module;

  743. 	int frame = 0;

  744. 	shared_ptr<Font> font;

  745. 

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

  747. 

  748. 	DTROYDisplay() {

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

  750. 	}

  751. 

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

  753. 		nvgFontSize(vg, 18.0f);

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

  755. 		nvgTextLetterSpacing(vg, -2.0f);

  756. 		nvgFillColor(vg, YELLOW_BIDOO);

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

  758. 		nvgFontSize(vg, 14.0f);

  759. 		nvgFillColor(vg, YELLOW_BIDOO);

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

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

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

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

  764. 		nvgFillColor(vg, YELLOW_BIDOO);

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

  766. 	}

  767. 

  768. 	string displayRootNote(int value) {

  769. 		switch(value){

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

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

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

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

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

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

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

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

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

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

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

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

  782. 			default: return "";

  783. 		}

  784. 	}

  785. 

  786. 	string displayScale(int value) {

  787. 		switch(value){

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  806. 			default: return "";

  807. 		}

  808. 	}

  809. 

  810. 	string displayPlayMode(int value) {

  811. 		switch(value){

  812. 			case 0: return "►";

  813. 			case 1: return "◄";

  814. 			case 2: return "►◄";

  815. 			case 3: return "►*";

  816. 			case 4: return "►?";

  817. 			default: return "";

  818. 		}

  819. 	}

  820. 

  821. 	void draw(NVGcontext *vg) override {

  822. 		if (++frame >= 4) {

  823. 			frame = 0;

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

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

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

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

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

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

  830. 		}

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

  832. 	}

  833. };

  834. 

  835. struct DTROYWidget : ModuleWidget {

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

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

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

  839. 

  840. 	DTROYWidget(DTROY *module);

  841. 	Menu *createContextMenu() override;

  842. };

  843. 

  844. struct DTROYPatternRoundBlackSnapKnob : RoundBlackSnapKnob {

  845. 	void onChange(EventChange &e) override {

  846. 			RoundBlackSnapKnob::onChange(e);

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

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

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

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

  851. 			{

  852. 				module->updateFlag = false;

  853. 				module->selectedPattern = value - 1;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  868. 				}

  869. 				module->updateFlag = true;

  870. 			}

  871. 		}

  872. };

  873. 

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

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

  876. 

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

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

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

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

  881. 

  882. 	{

  883. 		DTROYDisplay *display = new DTROYDisplay();

  884. 		display->module = module;

  885. 		display->box.pos = Vec(20.0f, 253.0f);

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

  887. 		addChild(display);

  888. 	}

  889. 

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

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

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

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

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

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

  896. 	addParam(stepsParam);

  897. 

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

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

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

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

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

  903. 

  904. 	rootNoteParam = ParamWidget::create<BidooBlueSnapKnob>(Vec(portX0[0]-2.0f, 140.0f), module, DTROY::ROOT_NOTE_PARAM, 0.0f, DTROY::NUM_NOTES-0.9f, 0.0f);

  905. 	addParam(rootNoteParam);

  906. 	scaleParam = ParamWidget::create<BidooBlueSnapKnob>(Vec(portX0[1]-2.0f, 140.0f), module, DTROY::SCALE_PARAM, 0.0f, DTROY::NUM_SCALES-0.9f, 0.0f);

  907. 	addParam(scaleParam);

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

  909. 	addParam(gateTimeParam);

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

  911. 	addParam(slideTimeParam);

  912. 

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

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

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

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

  917. 

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

  919. 	addParam(playModeParam);

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

  921. 	addParam(countModeParam);

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

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

  924. 	addParam(patternParam);

  925. 

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

  927. 

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

  929. 	addParam(sensitivityParam);

  930. 

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

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

  933. 		addParam(pitchParams[i]);

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

  935. 		addParam(pulseParams[i]);

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

  937. 		addParam(typeParams[i]);

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

  939. 		addParam(slideParams[i]);

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

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

  942. 		addParam(skipParams[i]);

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

  944. 	}

  945. 

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

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

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

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

  950. }

  951. 

  952. 

  953. struct DTROYRandPitchItem : MenuItem {

  954. 	DTROYWidget *dtroyWidget;

  955. 	void onAction(EventAction &e) override {

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

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

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

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

  960. 			{

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

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

  963. 			}

  964. 		}

  965. 	}

  966. };

  967. 

  968. struct DTROYRandGatesItem : MenuItem {

  969. 	DTROYWidget *dtroyWidget;

  970. 	void onAction(EventAction &e) override {

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

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

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

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

  975. 			{

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

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

  978. 			}

  979. 		}

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

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

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

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

  984. 				{

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

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

  987. 			}

  988. 		}

  989. 	}

  990. };

  991. 

  992. struct DTROYRandSlideSkipItem : MenuItem {

  993. 	DTROY *dtroyModule;

  994. 	void onAction(EventAction &e) override {

  995. 		dtroyModule->randomizeSlidesSkips();

  996. 	}

  997. };

  998. 

  999. struct DTROYPitchModeItem : MenuItem {

  1000. 	DTROY *dtroyModule;

  1001. 	void onAction(EventAction &e) override {

  1002. 		dtroyModule->pitchMode = !dtroyModule->pitchMode;

  1003. 	}

  1004. 	void step() override {

  1005. 		rightText = dtroyModule->pitchMode ? "✔" : "";

  1006. 		MenuItem::step();

  1007. 	}

  1008. };

  1009. 

  1010. struct DTROYPitchQuantizeModeItem : MenuItem {

  1011. 	DTROY *dtroyModule;

  1012. 	void onAction(EventAction &e) override {

  1013. 		dtroyModule->pitchQuantizeMode = !dtroyModule->pitchQuantizeMode;

  1014. 	}

  1015. 	void step() override {

  1016. 		rightText = dtroyModule->pitchQuantizeMode ? "✔" : "";

  1017. 		MenuItem::step();

  1018. 	}

  1019. };

  1020. 

  1021. struct DisconnectMenuItem : MenuItem {

  1022. 	ModuleWidget *moduleWidget;

  1023. 	void onAction(EventAction &e) override {

  1024. 		moduleWidget->disconnect();

  1025. 	}

  1026. };

  1027. 

  1028. struct ResetMenuItem : MenuItem {

  1029. 	DTROYWidget *dtroyWidget;

  1030. 	DTROY *dtroy;

  1031. 	void onAction(EventAction &e) override {

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

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

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

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

  1036. 				{

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

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

  1039. 				}

  1040. 			}

  1041. 		}

  1042. 		dtroy->updateFlag = false;

  1043. 		dtroy->reset();

  1044. 		dtroy->playMode = 0;

  1045. 		dtroy->countMode = 0;

  1046. 		dtroy->updateFlag = true;

  1047. 	}

  1048. };

  1049. 

  1050. struct RandomizeMenuItem : MenuItem {

  1051. 	ModuleWidget *moduleWidget;

  1052. 	void onAction(EventAction &e) override {

  1053. 		moduleWidget->randomize();

  1054. 	}

  1055. };

  1056. 

  1057. struct CloneMenuItem : MenuItem {

  1058. 	ModuleWidget *moduleWidget;

  1059. 	void onAction(EventAction &e) override {

  1060. 		RACK_PLUGIN_UI_RACKWIDGET->cloneModule(moduleWidget);

  1061. 	}

  1062. };

  1063. 

  1064. struct DeleteMenuItem : MenuItem {

  1065. 	ModuleWidget *moduleWidget;

  1066. 	void onAction(EventAction &e) override {

  1067. 		RACK_PLUGIN_UI_RACKWIDGET->deleteModule(moduleWidget);

  1068. 		moduleWidget->finalizeEvents();

  1069. 		delete moduleWidget;

  1070. 	}

  1071. };

  1072. 

  1073. struct DTROYCopyItem : MenuItem {

  1074. 	DTROY *dtroyModule;

  1075. 	void onAction(EventAction &e) override {

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

  1077. 	}

  1078. };

  1079. 

  1080. struct DTROYPasteItem : MenuItem {

  1081. 	DTROY *dtroyModule;

  1082. 	DTROYWidget *dtroyWidget;

  1083. 	void onAction(EventAction &e) override {

  1084. 		if (dtroyModule && dtroyWidget && (dtroyModule->copyPattern != dtroyModule->selectedPattern) && dtroyModule->updateFlag)

  1085. 		{

  1086. 			dtroyModule->updateFlag = false;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1101. 			}

  1102. 			dtroyModule->updateFlag = true;

  1103. 		}

  1104. 	}

  1105. };

  1106. 

  1107. Menu *DTROYWidget::createContextMenu() {

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

  1109. 	assert(dtroyWidget);

  1110. 

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

  1112. 	assert(dtroyModule);

  1113. 

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

  1115. 

  1116. 	MenuLabel *menuLabel = new MenuLabel();

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

  1118. 	menu->addChild(menuLabel);

  1119. 

  1120. 	ResetMenuItem *resetItem = new ResetMenuItem();

  1121. 	resetItem->text = "Initialize";

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

  1123. 	resetItem->dtroyWidget = this;

  1124. 	resetItem->dtroy = dtroyModule;

  1125. 	menu->addChild(resetItem);

  1126. 

  1127. 	DisconnectMenuItem *disconnectItem = new DisconnectMenuItem();

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

  1129. 	disconnectItem->moduleWidget = this;

  1130. 	menu->addChild(disconnectItem);

  1131. 

  1132. 	CloneMenuItem *cloneItem = new CloneMenuItem();

  1133. 	cloneItem->text = "Duplicate";

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

  1135. 	cloneItem->moduleWidget = this;

  1136. 	menu->addChild(cloneItem);

  1137. 

  1138. 	DeleteMenuItem *deleteItem = new DeleteMenuItem();

  1139. 	deleteItem->text = "Delete";

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

  1141. 	deleteItem->moduleWidget = this;

  1142. 	menu->addChild(deleteItem);

  1143. 

  1144. 	MenuLabel *spacerLabel = new MenuLabel();

  1145. 	menu->addChild(spacerLabel);

  1146. 

  1147. 	DTROYRandPitchItem *randomizePitchItem = new DTROYRandPitchItem();

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

  1149. 	randomizePitchItem->dtroyWidget = dtroyWidget;

  1150. 	menu->addChild(randomizePitchItem);

  1151. 

  1152. 	DTROYRandGatesItem *randomizeGatesItem = new DTROYRandGatesItem();

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

  1154. 	randomizeGatesItem->dtroyWidget = dtroyWidget;

  1155. 	menu->addChild(randomizeGatesItem);

  1156. 

  1157. 	DTROYRandSlideSkipItem *randomizeSlideSkipItem = new DTROYRandSlideSkipItem();

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

  1159. 	randomizeSlideSkipItem->dtroyModule = dtroyModule;

  1160. 	menu->addChild(randomizeSlideSkipItem);

  1161. 

  1162. 	MenuLabel *spacerLabel2 = new MenuLabel();

  1163. 	menu->addChild(spacerLabel2);

  1164. 

  1165. 	DTROYCopyItem *copyItem = new DTROYCopyItem();

  1166. 	copyItem->text = "Copy pattern";

  1167. 	copyItem->dtroyModule = dtroyModule;

  1168. 	menu->addChild(copyItem);

  1169. 

  1170. 	DTROYPasteItem *pasteItem = new DTROYPasteItem();

  1171. 	pasteItem->text = "Paste pattern";

  1172. 	pasteItem->dtroyModule = dtroyModule;

  1173. 	pasteItem->dtroyWidget = dtroyWidget;

  1174. 	menu->addChild(pasteItem);

  1175. 

  1176. 	MenuLabel *spacerLabel3 = new MenuLabel();

  1177. 	menu->addChild(spacerLabel3);

  1178. 

  1179. 	DTROYPitchModeItem *pitchModeItem = new DTROYPitchModeItem();

  1180. 	pitchModeItem->text = "Pitch mode continuous (vs. triggered)";

  1181. 	pitchModeItem->dtroyModule = dtroyModule;

  1182. 	menu->addChild(pitchModeItem);

  1183. 

  1184. 	DTROYPitchQuantizeModeItem *pitchQuantizeModeItem = new DTROYPitchQuantizeModeItem();

  1185. 	pitchQuantizeModeItem->text = "Pitch full quantize";

  1186. 	pitchQuantizeModeItem->dtroyModule = dtroyModule;

  1187. 	menu->addChild(pitchQuantizeModeItem);

  1188. 

  1189. 	return menu;

  1190. }

  1191. 

  1192. } // namespace rack_plugin_Bidoo

  1193. 

  1194. using namespace rack_plugin_Bidoo;

  1195. 

  1196. RACK_PLUGIN_MODEL_INIT(Bidoo, DTROY) {

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

  1198.    return modelDTROY;

  1199. }