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.
997 Commits
4 Branches
554MB
Tree: a3dc2e514a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a3dc2e514a'
${ noResults }
Rack/plugins/community/repos/Bidoo/src/BORDL.cpp

1421 lines
54KB
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 StepPlus {

  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. 	float gateProb = 1.0f;

  27. 	float pitchRnd = 0.0f;

  28. 	float accent = 0.0f;

  29. 	float rndAccent = 0.0f;

  30. };

  31. 

  32. struct PatternPlus {

  33. 	int playMode = 0;

  34. 	int countMode = 0;

  35. 	int numberOfSteps = 8;

  36. 	int numberOfStepsParam = 8;

  37. 	int rootNote = 0;

  38. 	int rootNoteParam = 0;

  39. 	int scale = 0;

  40. 	int scaleParam = 0;

  41. 	float gateTime = 0.5f;

  42. 	float slideTime = 0.2f;

  43. 	float sensitivity = 1.0f;

  44. 	int currentStep = 0;

  45. 	int currentPulse = 0;

  46. 	bool forward = true;

  47. 	std::vector<StepPlus> steps {16};

  48. 

  49. 	void Update(int playMode, int countMode, int numberOfSteps, int numberOfStepsParam, int rootNote, int scale,

  50. 		 float gateTime, float slideTime, float sensitivity, std::vector<char> skips, std::vector<char> slides,

  51. 		  std::vector<Param> pulses, std::vector<Param> pitches, std::vector<Param> types, std::vector<Param> probGates,

  52. 			std::vector<Param> rndPitches, std::vector<Param> accents, std::vector<Param> rndAccents)

  53. 			{

  54. 		this->playMode = playMode;

  55. 		this->countMode = countMode;

  56. 		this->numberOfSteps = numberOfSteps;

  57. 		this->numberOfStepsParam = numberOfStepsParam;

  58. 		this->rootNote = rootNote;

  59. 		this->scale = scale;

  60. 		this->rootNoteParam = rootNote;

  61. 		this->scaleParam = scale;

  62. 		this->gateTime = gateTime;

  63. 		this->slideTime = slideTime;

  64. 		this->sensitivity = sensitivity;

  65. 		int pCount = 0;

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

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

  68. 			steps[i].number = i;

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

  70. 				steps[i].skip = (skips[i%8] == 't');

  71. 			}	else {

  72. 				steps[i].skip = true;

  73. 			}

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

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

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

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

  78. 			}	else {

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

  80. 			}

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

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

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

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

  85. 			steps[i].gateProb = probGates[i%8].value;

  86. 			steps[i].pitchRnd = rndPitches[i%8].value;

  87. 			steps[i].accent = accents[i%8].value;

  88. 			steps[i].rndAccent = rndAccents[i%8].value;

  89. 		}

  90. 	}

  91. 

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

  93. 	{

  94. 		if (reset) {

  95. 			if (playMode != 1) {

  96. 				currentStep = GetFirstStep();

  97. 			} else {

  98. 				currentStep = GetLastStep();

  99. 			}

  100. 			currentPulse = 0;

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

  102. 		} else {

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

  104. 				currentPulse++;

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

  106. 			} else {

  107. 				if (playMode == 0) {

  108. 					currentStep = GetNextStepForward(currentStep);

  109. 					currentPulse = 0;

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

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

  112. 					currentStep = GetNextStepBackward(currentStep);

  113. 					currentPulse = 0;

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

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

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

  117. 						forward = false;

  118. 					}

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

  120. 						forward = true;

  121. 					}

  122. 					if (forward) {

  123. 						currentStep = GetNextStepForward(currentStep);

  124. 					} else {

  125. 						currentStep = GetNextStepBackward(currentStep);

  126. 					}

  127. 					currentPulse = 0;

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

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

  130. 					std::vector<StepPlus> tmp (steps.size());

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

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

  133. 					StepPlus tmpStep = *select_randomly(tmp.begin(), tmp.end());

  134. 					currentPulse = 0;

  135. 					currentStep = tmpStep.number;

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

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

  138. 					int next = GetNextStepForward(currentStep);

  139. 					int prev = GetNextStepBackward(currentStep);

  140. 					vector<StepPlus> subPattern;

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

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

  143. 					StepPlus choice = *select_randomly(subPattern.begin(), subPattern.end());

  144. 					currentPulse = 0;

  145. 					currentStep = choice.number;

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

  147. 				} else {

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

  149. 				}

  150. 			}

  151. 		}

  152. 	}

  153. 

  154. 	StepPlus CurrentStep() {

  155. 		return this->steps[currentStep];

  156. 	}

  157. 

  158. 	int GetFirstStep()

  159. 	{

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

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

  162. 					return i;

  163. 				}

  164. 			}

  165. 			return 0;

  166. 	}

  167. 

  168. 	int GetLastStep()

  169. 	{

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

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

  172. 					return i;

  173. 				}

  174. 			}

  175. 			return 15;

  176. 	}

  177. 

  178. 	int GetNextStepForward(int pos)

  179. 	{

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

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

  182. 					return i%16;

  183. 				}

  184. 			}

  185. 			return pos;

  186. 	}

  187. 

  188. 	int GetNextStepBackward(int pos)

  189. 	{

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

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

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

  193. 				}

  194. 			}

  195. 			return pos;

  196. 	}

  197. 

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

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

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

  201. 		return start;

  202. 	}

  203. 

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

  205. 		static std::random_device rd;

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

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

  208. 	}

  209. 

  210. };

  211. 

  212. struct BORDL : Module {

  213. 	enum ParamIds {

  214. 		CLOCK_PARAM,

  215. 		RUN_PARAM,

  216. 		RESET_PARAM,

  217. 		STEPS_PARAM,

  218. 		SLIDE_TIME_PARAM,

  219. 		GATE_TIME_PARAM,

  220. 		ROOT_NOTE_PARAM,

  221. 		SCALE_PARAM,

  222. 		PLAY_MODE_PARAM,

  223. 		COUNT_MODE_PARAM,

  224. 		PATTERN_PARAM,

  225. 		SENSITIVITY_PARAM,

  226. 		TRIG_COUNT_PARAM = SENSITIVITY_PARAM + 8,

  227. 		TRIG_TYPE_PARAM = TRIG_COUNT_PARAM + 8,

  228. 		TRIG_PITCH_PARAM = TRIG_TYPE_PARAM + 8,

  229. 		TRIG_SLIDE_PARAM = TRIG_PITCH_PARAM + 8,

  230. 		TRIG_SKIP_PARAM = TRIG_SLIDE_PARAM + 8,

  231. 		TRIG_GATEPROB_PARAM = TRIG_SKIP_PARAM + 8,

  232. 		TRIG_PITCHRND_PARAM = TRIG_GATEPROB_PARAM + 8,

  233. 		TRIG_ACCENT_PARAM = TRIG_PITCHRND_PARAM + 8,

  234. 		TRIG_RNDACCENT_PARAM = TRIG_ACCENT_PARAM + 8,

  235. 		NUM_PARAMS = TRIG_RNDACCENT_PARAM + 8

  236. 	};

  237. 	enum InputIds {

  238. 		CLOCK_INPUT,

  239. 		EXT_CLOCK_INPUT,

  240. 		RESET_INPUT,

  241. 		STEPS_INPUT,

  242. 		SLIDE_TIME_INPUT,

  243. 		GATE_TIME_INPUT,

  244. 		ROOT_NOTE_INPUT,

  245. 		SCALE_INPUT,

  246. 		EXTGATE1_INPUT,

  247. 		EXTGATE2_INPUT,

  248. 		PATTERN_INPUT,

  249. 		NUM_INPUTS

  250. 	};

  251. 	enum OutputIds {

  252. 		GATE_OUTPUT,

  253. 		PITCH_OUTPUT,

  254. 		ACC_OUTPUT,

  255. 		NUM_OUTPUTS

  256. 	};

  257. 	enum LightIds {

  258. 		RUNNING_LIGHT,

  259. 		RESET_LIGHT,

  260. 		GATE_LIGHT,

  261. 		STEPS_LIGHTS = GATE_LIGHT + 8,

  262. 		SLIDES_LIGHTS = STEPS_LIGHTS + 8,

  263. 		SKIPS_LIGHTS = SLIDES_LIGHTS + 8,

  264. 		NUM_LIGHTS = SKIPS_LIGHTS + 8

  265. 	};

  266. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  285. 

  286. 	enum Notes {

  287. 		NOTE_C,

  288. 		NOTE_C_SHARP,

  289. 		NOTE_D,

  290. 		NOTE_D_SHARP,

  291. 		NOTE_E,

  292. 		NOTE_F,

  293. 		NOTE_F_SHARP,

  294. 		NOTE_G,

  295. 		NOTE_G_SHARP,

  296. 		NOTE_A,

  297. 		NOTE_A_SHARP,

  298. 		NOTE_B,

  299. 		NUM_NOTES

  300. 	};

  301. 

  302. 	enum Scales {

  303. 		AEOLIAN,

  304. 		BLUES,

  305. 		CHROMATIC,

  306. 		DIATONIC_MINOR,

  307. 		DORIAN,

  308. 		HARMONIC_MINOR,

  309. 		INDIAN,

  310. 		LOCRIAN,

  311. 		LYDIAN,

  312. 		MAJOR,

  313. 		MELODIC_MINOR,

  314. 		MINOR,

  315. 		MIXOLYDIAN,

  316. 		NATURAL_MINOR,

  317. 		PENTATONIC,

  318. 		PHRYGIAN,

  319. 		TURKISH,

  320. 		NONE,

  321. 		NUM_SCALES

  322. 	};

  323. 

  324. 	bool running = true;

  325. 	SchmittTrigger clockTrigger;

  326. 	SchmittTrigger runningTrigger;

  327. 	SchmittTrigger resetTrigger;

  328. 	SchmittTrigger slideTriggers[8];

  329. 	SchmittTrigger skipTriggers[8];

  330. 	SchmittTrigger playModeTrigger;

  331. 	SchmittTrigger countModeTrigger;

  332. 	SchmittTrigger PatternTrigger;

  333. 	float phase = 0.0f;

  334. 	int index = 0;

  335. 	int prevIndex = 0;

  336. 	bool reStart = true;

  337. 	int pulse = 0;

  338. 	int rootNote = 0;

  339. 	int curScaleVal = 0;

  340. 	float pitch = 0.0f;

  341. 	float previousPitch = 0.0f;

  342. 	clock_t tCurrent;

  343. 	clock_t tLastTrig;

  344. 	clock_t tPreviousTrig;

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

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

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

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

  349. 	int numSteps = 8;

  350. 	int selectedPattern = 0;

  351. 	int playedPattern = 0;

  352. 	bool pitchMode = false;

  353. 	bool pitchQuantizeMode = true;

  354. 	bool updateFlag = false;

  355. 	bool probGate = true;

  356. 	float rndPitch = 0.0f;

  357. 	float accent = 5.0f;

  358. 	bool loadedFromJson = false;

  359. 	int copyPattern = -1;

  360. 

  361. 	PatternPlus patterns[16];

  362. 

  363. 	BORDL() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {

  364. 	}

  365. 

  366. 	void UpdatePattern() {

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

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

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

  370. 		std::vector<Param> probGates(&params[TRIG_GATEPROB_PARAM],&params[TRIG_GATEPROB_PARAM + 8]);

  371. 		std::vector<Param> rndPitches(&params[TRIG_PITCHRND_PARAM],&params[TRIG_PITCHRND_PARAM + 8]);

  372. 		std::vector<Param> accents(&params[TRIG_ACCENT_PARAM],&params[TRIG_ACCENT_PARAM + 8]);

  373. 		std::vector<Param> rndAccents(&params[TRIG_RNDACCENT_PARAM],&params[TRIG_RNDACCENT_PARAM + 8]);

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

  375. 		 roundf(params[SCALE_PARAM].value), params[GATE_TIME_PARAM].value, params[SLIDE_TIME_PARAM].value, params[SENSITIVITY_PARAM].value ,

  376. 		  skipState, slideState, pulses, pitches, types, probGates, rndPitches, accents, rndAccents);

  377. 	}

  378. 

  379. 	void step() override;

  380. 

  381. 	// persistence, random & init

  382. 

  383. 	json_t *toJson() override {

  384. 		json_t *rootJ = json_object();

  385. 

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

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

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

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

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

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

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

  393. 

  394. 		json_t *trigsJ = json_array();

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

  396. 			json_t *trigJ = json_array();

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

  398. 			json_array_append_new(trigJ, trigJSlide);

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

  400. 			json_array_append_new(trigJ, trigJSkip);

  401. 			json_array_append_new(trigsJ, trigJ);

  402. 		}

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

  404. 

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

  406. 			json_t *patternJ = json_object();

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

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

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

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

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

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

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

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

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

  416. 				json_t *stepJ = json_object();

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

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

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

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

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

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

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

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

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

  426. 				json_object_set_new(stepJ, "gateProb", json_real(patterns[i].steps[j].gateProb));

  427. 				json_object_set_new(stepJ, "pitchRnd", json_real(patterns[i].steps[j].pitchRnd));

  428. 				json_object_set_new(stepJ, "accent", json_real(patterns[i].steps[j].accent));

  429. 				json_object_set_new(stepJ, "rndAccent", json_real(patterns[i].steps[j].rndAccent));

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

  431. 			}

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

  433. 		}

  434. 		return rootJ;

  435. 	}

  436. 

  437. 	void fromJson(json_t *rootJ) override {

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

  439. 		if (runningJ)

  440. 			running = json_is_true(runningJ);

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

  442. 		if (playModeJ)

  443. 			playMode = json_integer_value(playModeJ);

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

  445. 		if (countModeJ)

  446. 			countMode = json_integer_value(countModeJ);

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

  448. 		if (selectedPatternJ)

  449. 			selectedPattern = json_integer_value(selectedPatternJ);

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

  451. 		if (playedPatternJ)

  452. 			playedPattern = json_integer_value(playedPatternJ);

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

  454. 		if (pitchModeJ)

  455. 			pitchMode = json_is_true(pitchModeJ);

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

  457. 		if (pitchQuantizeModeJ)

  458. 			pitchQuantizeMode = json_is_true(pitchQuantizeModeJ);

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

  460. 		if (trigsJ) {

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

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

  463. 				if (trigJ)

  464. 				{

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

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

  467. 				}

  468. 			}

  469. 		}

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

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

  472. 			if (patternJ){

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

  474. 				if (playModeJ)

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

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

  477. 				if (countModeJ)

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

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

  480. 				if (numStepsJ)

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

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

  483. 				if (rootNoteJ)

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

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

  486. 				if (scaleJ)

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

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

  489. 				if (gateTimeJ)

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

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

  492. 				if (slideTimeJ)

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

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

  495. 				if (sensitivityJ)

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

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

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

  499. 					if (stepJ) {

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

  501. 						if (indexJ)

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

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

  504. 						if (numberJ)

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

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

  507. 						if (skipJ)

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

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

  510. 						if (skipParamJ)

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

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

  513. 						if (slideJ)

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

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

  516. 						if (pulsesJ)

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

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

  519. 						if (pulsesParamJ)

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

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

  522. 						if (pitchJ)

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

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

  525. 						if (typeJ)

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

  527. 						json_t *probGateJ= json_object_get(stepJ, "gateProb");

  528. 						if (probGateJ)

  529. 							patterns[i].steps[j].gateProb = json_real_value(probGateJ);

  530. 						json_t *rndPitchJ= json_object_get(stepJ, "pitchRnd");

  531. 						if (rndPitchJ)

  532. 							patterns[i].steps[j].pitchRnd = json_real_value(rndPitchJ);

  533. 						json_t *accentJ= json_object_get(stepJ, "accent");

  534. 						if (accentJ)

  535. 							patterns[i].steps[j].accent = json_real_value(accentJ);

  536. 						json_t *rndAccentJ= json_object_get(stepJ, "rndAccent");

  537. 						if (rndAccentJ)

  538. 							patterns[i].steps[j].rndAccent = json_real_value(rndAccentJ);

  539. 					}

  540. 				}

  541. 			}

  542. 		}

  543. 		updateFlag = true;

  544. 		loadedFromJson = true;

  545. 	}

  546. 

  547. 	void randomize() override {

  548. 		randomizeSlidesSkips();

  549. 	}

  550. 

  551. 	void randomizeSlidesSkips() {

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

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

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

  555. 		}

  556. 	}

  557. 

  558. 	void reset() override {

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

  560. 			slideState[i] = 'f';

  561. 			skipState[i] = 'f';

  562. 		}

  563. 	}

  564. 

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

  566. 

  567. 	float getOneRandomNoteInScale(){

  568. 		rootNote = clamp(patterns[playedPattern].rootNote + inputs[ROOT_NOTE_INPUT].value, 0.0f, NUM_NOTES-1.0f);

  569. 		curScaleVal = clamp(patterns[playedPattern].scale + inputs[SCALE_INPUT].value, 0.0f, NUM_SCALES-1.0f);

  570. 		int *curScaleArr;

  571. 		int notesInScale = 0;

  572. 		switch(curScaleVal){

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  590. 		}

  591. 

  592. 		if(curScaleVal == NONE){

  593. 			return randomUniform() * 6.0f;

  594. 		} else {

  595. 			float voltsOut = 0.0f;

  596. 			int rndOctaveInVolts = int(5 * randomUniform());

  597. 			voltsOut += rndOctaveInVolts;

  598. 			voltsOut += rootNote / 12.0f;

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

  600. 			return voltsOut;

  601. 		}

  602. 	}

  603. 

  604. 	float closestVoltageInScale(float voltsIn){

  605. 		rootNote = clamp(patterns[playedPattern].rootNote + inputs[ROOT_NOTE_INPUT].value, 0.0f, BORDL::NUM_NOTES-1.0f);

  606. 		curScaleVal = clamp(patterns[playedPattern].scale + inputs[SCALE_INPUT].value, 0.0f, BORDL::NUM_SCALES-1.0f);

  607. 		int *curScaleArr;

  608. 		int notesInScale = 0;

  609. 		switch(curScaleVal){

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  627. 			case NONE:           return voltsIn;

  628. 		}

  629. 

  630. 		float closestVal = 10.0f;

  631. 		float closestDist = 10.0f;

  632. 		int octaveInVolts = int(voltsIn);

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

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

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

  636. 			if(distAway < closestDist){

  637. 				closestVal = scaleNoteInVolts;

  638. 				closestDist = distAway;

  639. 			}

  640. 		}

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

  642. 		return closestVal;

  643. 	}

  644. };

  645. 

  646. 

  647. void BORDL::step() {

  648.  	const float lightLambda = 0.075f;

  649. 	// Run

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

  651. 		running = !running;

  652. 	}

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

  654. 	bool nextStep = false;

  655. 	// Phase calculation

  656. 	if (running) {

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

  658. 			tCurrent = clock();

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

  660. 			if (tLastTrig && tPreviousTrig) {

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

  662. 			}

  663. 			else {

  664. 				phase += clockTime / engineGetSampleRate();

  665. 			}

  666. 			// External clock

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

  668. 				tPreviousTrig = tLastTrig;

  669. 				tLastTrig = clock();

  670. 				phase = 0.0f;

  671. 				nextStep = true;

  672. 			}

  673. 		}

  674. 		else {

  675. 			// Internal clock

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

  677. 			phase += clockTime / engineGetSampleRate();

  678. 			if (phase >= 1.0f) {

  679. 				phase--;

  680. 				nextStep = true;

  681. 			}

  682. 		}

  683. 	}

  684. 	// Reset

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

  686. 		phase = 0.0f;

  687. 		reStart = true;

  688. 		nextStep = true;

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

  690. 	}

  691. 	//patternNumber

  692. 	playedPattern = clamp((inputs[PATTERN_INPUT].active ? rescale(inputs[PATTERN_INPUT].value,0.0f,10.0f,1.0f,16.1f) : params[PATTERN_PARAM].value) - 1.0f, 0.0f, 15.0f);

  693. 	// Update Pattern

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

  695. 		// Trigs Update

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

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

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

  699. 			}

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

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

  702. 			}

  703. 		}

  704. 		// playMode

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

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

  707. 		}

  708. 		// countMode

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

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

  711. 		}

  712. 		// numSteps

  713. 		numSteps = clamp(roundf(params[STEPS_PARAM].value + inputs[STEPS_INPUT].value), 1.0f, 16.0f);

  714. 		UpdatePattern();

  715. 		if (!loadedFromJson) {

  716. 			loadedFromJson = true;

  717. 			updateFlag = true;

  718. 		}

  719. 	}

  720. 	// Steps && Pulses Management

  721. 	if (nextStep) {

  722. 		// Advance step

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

  724. 		prevIndex = index;

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

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

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

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

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

  730. 		probGate = index != prevIndex ? randomUniform() <= params[TRIG_GATEPROB_PARAM+index%8].value : probGate;

  731. 		rndPitch = index != prevIndex ? rescale(randomUniform(),0.0f,1.0f,params[TRIG_PITCHRND_PARAM+index%8].value*-5.0f,params[TRIG_PITCHRND_PARAM+index%8].value*5.0f) : rndPitch;

  732. 		accent = index != prevIndex ? clamp(params[TRIG_ACCENT_PARAM+index%8].value + rescale(randomUniform(),0.0f,1.0f,params[TRIG_RNDACCENT_PARAM+index%8].value*-5.0f,params[TRIG_RNDACCENT_PARAM+index%8].value*5.0f),0.0f,10.0f)  : accent;

  733. 	}

  734. 	// Lights

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

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

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

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

  739. 	}

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

  741. 

  742. 	// Caclulate Outputs

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

  744. 	float gateValue = 0.0f;

  745. 	if (gateOn){

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

  747. 			gateOn = false;

  748. 		}

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

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

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

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

  753. 			gateOn = phase < gateCoeff;

  754. 			gateValue = 10.0f;

  755. 		}

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

  757. 			gateOn = true;

  758. 			gateValue = 10.0f;

  759. 		}

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

  761. 			gateOn = true;

  762. 			gateValue = inputs[EXTGATE1_INPUT].value;

  763. 		}

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

  765. 			gateOn = true;

  766. 			gateValue = inputs[EXTGATE2_INPUT].value;

  767. 		}

  768. 		else {

  769. 			gateOn = false;

  770. 			gateValue = 0.0f;

  771. 		}

  772. 	}

  773. 	//pitch management

  774. 	pitch = closestVoltageInScale(clamp(patterns[playedPattern].CurrentStep().pitch + rndPitch,0.0f,10.0f) * patterns[playedPattern].sensitivity);

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

  776. 		if (pulse == 0) {

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

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

  779. 		}

  780. 	}

  781. 

  782. 	// Update Outputs

  783. 	outputs[GATE_OUTPUT].value = gateOn ? (probGate ? gateValue : 0.0f) : 0.0f;

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

  785. 	outputs[ACC_OUTPUT].value = gateOn ? (probGate ? accent : 0.0f) : 0.0f;

  786. }

  787. 

  788. struct BORDLDisplay : TransparentWidget {

  789. 	BORDL *module;

  790. 	int frame = 0;

  791. 	shared_ptr<Font> font;

  792. 

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

  794. 

  795. 	BORDLDisplay() {

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

  797. 	}

  798. 

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

  800. 		nvgFontSize(vg, 18.0f);

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

  802. 		nvgTextLetterSpacing(vg, -2.0f);

  803. 		nvgFillColor(vg, YELLOW_BIDOO);

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

  805. 		nvgFontSize(vg, 14.0f);

  806. 		nvgFillColor(vg, YELLOW_BIDOO);

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

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

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

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

  811. 		nvgFillColor(vg, YELLOW_BIDOO);

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

  813. 	}

  814. 

  815. 	string displayRootNote(int value) {

  816. 		switch(value){

  817. 			case BORDL::NOTE_C:       return "C";

  818. 			case BORDL::NOTE_C_SHARP: return "C#";

  819. 			case BORDL::NOTE_D:       return "D";

  820. 			case BORDL::NOTE_D_SHARP: return "D#";

  821. 			case BORDL::NOTE_E:       return "E";

  822. 			case BORDL::NOTE_F:       return "F";

  823. 			case BORDL::NOTE_F_SHARP: return "F#";

  824. 			case BORDL::NOTE_G:       return "G";

  825. 			case BORDL::NOTE_G_SHARP: return "G#";

  826. 			case BORDL::NOTE_A:       return "A";

  827. 			case BORDL::NOTE_A_SHARP: return "A#";

  828. 			case BORDL::NOTE_B:       return "B";

  829. 			default: return "";

  830. 		}

  831. 	}

  832. 

  833. 	string displayScale(int value) {

  834. 		switch(value){

  835. 			case BORDL::AEOLIAN:        return "Aeolian";

  836. 			case BORDL::BLUES:          return "Blues";

  837. 			case BORDL::CHROMATIC:      return "Chromatic";

  838. 			case BORDL::DIATONIC_MINOR: return "Diatonic Minor";

  839. 			case BORDL::DORIAN:         return "Dorian";

  840. 			case BORDL::HARMONIC_MINOR: return "Harmonic Minor";

  841. 			case BORDL::INDIAN:         return "Indian";

  842. 			case BORDL::LOCRIAN:        return "Locrian";

  843. 			case BORDL::LYDIAN:         return "Lydian";

  844. 			case BORDL::MAJOR:          return "Major";

  845. 			case BORDL::MELODIC_MINOR:  return "Melodic Minor";

  846. 			case BORDL::MINOR:          return "Minor";

  847. 			case BORDL::MIXOLYDIAN:     return "Mixolydian";

  848. 			case BORDL::NATURAL_MINOR:  return "Natural Minor";

  849. 			case BORDL::PENTATONIC:     return "Pentatonic";

  850. 			case BORDL::PHRYGIAN:       return "Phrygian";

  851. 			case BORDL::TURKISH:        return "Turkish";

  852. 			case BORDL::NONE:           return "None";

  853. 			default: return "";

  854. 		}

  855. 	}

  856. 

  857. 	string displayPlayMode(int value) {

  858. 		switch(value){

  859. 			case 0: return "►";

  860. 			case 1: return "◄";

  861. 			case 2: return "►◄";

  862. 			case 3: return "►*";

  863. 			case 4: return "►?";

  864. 			default: return "";

  865. 		}

  866. 	}

  867. 

  868. 	void draw(NVGcontext *vg) override {

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

  870. 			frame = 0;

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

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

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

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

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

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

  877. 		}

  878. 		drawMessage(vg, Vec(0.0f, 20.0f), note, playMode, selectedPattern, playedPattern, steps, scale);

  879. 	}

  880. };

  881. 

  882. struct BORDLGateDisplay : TransparentWidget {

  883. 	BORDL *module;

  884. 	shared_ptr<Font> font;

  885. 

  886. 	int index;

  887. 

  888. 	BORDLGateDisplay() {

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

  890. 	}

  891. 

  892. 	void drawGate(NVGcontext *vg, Vec pos) {

  893. 		int gateType = (int)module->params[BORDL::TRIG_TYPE_PARAM+index].value;

  894. 		nvgStrokeWidth(vg, 1.0f);

  895. 		nvgStrokeColor(vg, YELLOW_BIDOO);

  896. 		nvgFillColor(vg, YELLOW_BIDOO);

  897. 		nvgTextAlign(vg, NVG_ALIGN_CENTER);

  898. 		nvgFontSize(vg, 16.0f);

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

  900. 		nvgTextLetterSpacing(vg, -2.0f);

  901. 		if (gateType == 0) {

  902. 			nvgBeginPath(vg);

  903. 			nvgRoundedRect(vg,pos.x,pos.y,22.0f,6.0f,0.0f);

  904. 			nvgClosePath(vg);

  905. 			nvgStroke(vg);

  906. 		}

  907. 		else if (gateType == 1) {

  908. 			nvgBeginPath(vg);

  909. 			nvgRoundedRect(vg,pos.x,pos.y,22.0f,6.0f,0.0f);

  910. 			nvgClosePath(vg);

  911. 			nvgStroke(vg);

  912. 			nvgBeginPath(vg);

  913. 			nvgRoundedRect(vg,pos.x,pos.y,6.0f,6.0f,0.0f);

  914. 			nvgClosePath(vg);

  915. 			nvgStroke(vg);

  916. 			nvgFill(vg);

  917. 		}

  918. 		else if (gateType == 2) {

  919. 			nvgBeginPath(vg);

  920. 			nvgRoundedRect(vg,pos.x,pos.y,6.0f,6.0f,0.0f);

  921. 			nvgRoundedRect(vg,pos.x+8.0f,pos.y,6.0f,6.0f,0.0f);

  922. 			nvgRoundedRect(vg,pos.x+16.0f,pos.y,6.0f,6.0f,0.0f);

  923. 			nvgClosePath(vg);

  924. 			nvgStroke(vg);

  925. 			nvgFill(vg);

  926. 		}

  927. 		else if (gateType == 3) {

  928. 			nvgBeginPath(vg);

  929. 			nvgRoundedRect(vg,pos.x,pos.y,22.0f,6.0f,0.0f);

  930. 			nvgClosePath(vg);

  931. 			nvgStroke(vg);

  932. 			nvgFill(vg);

  933. 		}

  934. 		else if (gateType == 4) {

  935. 		  nvgText(vg, pos.x+11.0f, pos.y+8.0f, "G1", NULL);

  936. 		}

  937. 		else if (gateType == 5) {

  938. 		  nvgText(vg, pos.x+11.0f, pos.y+8.0f, "G2", NULL);

  939. 		}

  940. 	}

  941. 

  942. 	void draw(NVGcontext *vg) override {

  943. 		drawGate(vg, Vec(0.0f, 0.0f));

  944. 	}

  945. };

  946. 

  947. struct BORDLPulseDisplay : TransparentWidget {

  948. 	BORDL *module;

  949. 	shared_ptr<Font> font;

  950. 

  951. 	int index;

  952. 

  953. 	BORDLPulseDisplay() {

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

  955. 	}

  956. 

  957. 	void drawPulse(NVGcontext *vg, Vec pos) {

  958. 		nvgStrokeWidth(vg, 1.0f);

  959. 		nvgStrokeColor(vg, YELLOW_BIDOO);

  960. 		nvgFillColor(vg, YELLOW_BIDOO);

  961. 		nvgTextAlign(vg, NVG_ALIGN_CENTER);

  962. 		nvgFontSize(vg, 16.0f);

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

  964. 		nvgTextLetterSpacing(vg, -2.0f);

  965. 		char tCount[128],tProb[128];

  966. 		snprintf(tCount, sizeof(tCount), "%1i", (int)module->params[BORDL::TRIG_COUNT_PARAM+index].value);

  967. 		snprintf(tProb, sizeof(tProb), "%1i%%", (int)(module->params[BORDL::TRIG_GATEPROB_PARAM+index].value*100.0f));

  968. 		nvgText(vg, pos.x, pos.y, tCount, NULL);

  969. 		nvgFontSize(vg, 12.0f);

  970. 		nvgText(vg, pos.x, pos.y+12.0f, tProb, NULL);

  971. 	}

  972. 

  973. 	void draw(NVGcontext *vg) override {

  974. 		drawPulse(vg, Vec(0.0f, 0.0f));

  975. 	}

  976. };

  977. 

  978. struct BORDLPitchDisplay : TransparentWidget {

  979. 	BORDL *module;

  980. 	shared_ptr<Font> font;

  981. 

  982. 	int index;

  983. 

  984. 	BORDLPitchDisplay() {

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

  986. 	}

  987. 

  988. 	void drawPitch(NVGcontext *vg, Vec pos) {

  989. 		nvgStrokeWidth(vg, 1.0f);

  990. 		nvgStrokeColor(vg, YELLOW_BIDOO);

  991. 		nvgFillColor(vg, YELLOW_BIDOO);

  992. 		nvgTextAlign(vg, NVG_ALIGN_CENTER);

  993. 		nvgFontSize(vg, 14.0f);

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

  995. 		nvgTextLetterSpacing(vg, -2.0f);

  996. 		char tPitch[128],tPitchRnd[128],tAcc[128],tAccRnd[128];

  997. 		snprintf(tPitch, sizeof(tPitch), "%1.2f", module->closestVoltageInScale(module->params[BORDL::TRIG_PITCH_PARAM+index].value));

  998. 		snprintf(tPitchRnd, sizeof(tPitchRnd), "%1i%%", (int)(module->params[BORDL::TRIG_PITCHRND_PARAM+index].value*100));

  999. 		snprintf(tAcc, sizeof(tAcc), "%1.2f", module->params[BORDL::TRIG_ACCENT_PARAM+index].value);

  1000. 		snprintf(tAccRnd, sizeof(tAccRnd), "%1i%%", (int)(module->params[BORDL::TRIG_RNDACCENT_PARAM+index].value*100));

  1001. 		nvgText(vg, pos.x, pos.y-9.0f, tPitch, NULL);

  1002. 		nvgText(vg, pos.x, pos.y+15.0f, tAcc, NULL);

  1003. 		nvgFontSize(vg, 12.0f);

  1004. 		nvgText(vg, pos.x, pos.y+2.0f, tPitchRnd, NULL);

  1005. 		nvgText(vg, pos.x, pos.y+25.0f, tAccRnd, NULL);

  1006. 	}

  1007. 

  1008. 	void draw(NVGcontext *vg) override {

  1009. 		drawPitch(vg, Vec(0.0f, 0.0f));

  1010. 	}

  1011. };

  1012. 

  1013. struct BORDLWidget : ModuleWidget {

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

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

  1016. 		*pitchParams[8], *pulseParams[8], *typeParams[8], *slideParams[8], *skipParams[8],

  1017. 		 *pitchRndParams[8], *pulseProbParams[8], *accentParams[8], *rndAccentParams[8];

  1018. 

  1019. 	BORDLWidget(BORDL *module);

  1020. 	Menu *createContextMenu() override;

  1021. };

  1022. 

  1023. struct BORDLPatternRoundBlackSnapKnob : RoundBlackSnapKnob {

  1024. 	void onChange(EventChange &e) override {

  1025. 			RoundBlackSnapKnob::onChange(e);

  1026. 			BORDL *module = dynamic_cast<BORDL*>(this->module);

  1027. 			BORDLWidget *parent = dynamic_cast<BORDLWidget*>(this->parent);

  1028. 			int target = clamp(value - 1.0f, 0.0f, 15.0f);

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

  1030. 			{

  1031. 				module->updateFlag = false;

  1032. 				module->selectedPattern = value - 1;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1047. 					parent->pulseProbParams[i]->setValue(module->patterns[target].steps[i].gateProb);

  1048. 					parent->pitchRndParams[i]->setValue(module->patterns[target].steps[i].pitchRnd);

  1049. 					parent->accentParams[i]->setValue(module->patterns[target].steps[i].accent);

  1050. 					parent->rndAccentParams[i]->setValue(module->patterns[target].steps[i].rndAccent);

  1051. 				}

  1052. 				module->updateFlag = true;

  1053. 			}

  1054. 		}

  1055. };

  1056. 

  1057. 

  1058. 

  1059. BORDLWidget::BORDLWidget(BORDL *module) : ModuleWidget(module) {

  1060. 	setPanel(SVG::load(assetPlugin(plugin, "res/BORDL.svg")));

  1061. 

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

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

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

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

  1066. 

  1067. 	{

  1068. 		BORDLDisplay *display = new BORDLDisplay();

  1069. 		display->module = module;

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

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

  1072. 		addChild(display);

  1073. 	}

  1074. 

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

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

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

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

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

  1080. 	stepsParam = ParamWidget::create<BidooBlueSnapKnob>(Vec(134.0f, 52.0f), module, BORDL::STEPS_PARAM, 1.0f, 16.0f, 8.0f);

  1081. 	addParam(stepsParam);

  1082. 

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

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

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

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

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

  1088. 

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

  1090. 	addParam(rootNoteParam);

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

  1092. 	addParam(scaleParam);

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

  1094. 	addParam(gateTimeParam);

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

  1096. 	addParam(slideTimeParam);

  1097. 

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

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

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

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

  1102. 

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

  1104. 	addParam(playModeParam);

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

  1106. 	addParam(countModeParam);

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

  1108. 	patternParam = ParamWidget::create<BORDLPatternRoundBlackSnapKnob>(Vec(portX0[3],230.0f), module, BORDL::PATTERN_PARAM, 1.0f, 16.0f, 1.0f);

  1109. 	addParam(patternParam);

  1110. 

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

  1112. 

  1113. 	sensitivityParam = ParamWidget::create<BidooBlueTrimpot>(Vec(portX1[0]-24.0f, 32.0f), module, BORDL::SENSITIVITY_PARAM, 0.1f, 1.0f, 1.0f);

  1114. 	addParam(sensitivityParam);

  1115. 

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

  1117. 		pitchParams[i] = ParamWidget::create<BidooBlueKnob>(Vec(portX1[i]+1.0f, 76.0f), module, BORDL::TRIG_PITCH_PARAM + i, 0.0f, 10.001f, 3.0f);

  1118. 		addParam(pitchParams[i]);

  1119. 		pitchRndParams[i] = ParamWidget::create<BidooBlueTrimpot>(Vec(portX1[i]+6.5f, 108.0f), module, BORDL::TRIG_PITCHRND_PARAM + i, 0.0f, 1.0f, 0.0f);

  1120. 		addParam(pitchRndParams[i]);

  1121. 		accentParams[i] = ParamWidget::create<BidooBlueKnob>(Vec(portX1[i]+1.0f, 129.0f), module, BORDL::TRIG_ACCENT_PARAM + i, 0.0f, 10.0f, 0.0f);

  1122. 		addParam(accentParams[i]);

  1123. 		rndAccentParams[i] = ParamWidget::create<BidooBlueTrimpot>(Vec(portX1[i]+6.5f, 160.0f), module, BORDL::TRIG_RNDACCENT_PARAM + i, 0.0f, 1.0f, 0.0f);

  1124. 		addParam(rndAccentParams[i]);

  1125. 		{

  1126. 			BORDLPitchDisplay *displayPitch = new BORDLPitchDisplay();

  1127. 			displayPitch->module = module;

  1128. 			displayPitch->box.pos = Vec(portX1[i]+15.0f, 45.0f);

  1129. 			displayPitch->box.size = Vec(20.0f, 10.0f);

  1130. 			displayPitch->index = i;

  1131. 			addChild(displayPitch);

  1132. 		}

  1133. 		pulseParams[i] = ParamWidget::create<BidooBlueSnapKnob>(Vec(portX1[i]+1.0f, 216.0f), module, BORDL::TRIG_COUNT_PARAM + i, 1.0f, 8.0f,  1.0f);

  1134. 		addParam(pulseParams[i]);

  1135. 		pulseProbParams[i] = ParamWidget::create<BidooBlueTrimpot>(Vec(portX1[i]+6.5f, 247.0f), module, BORDL::TRIG_GATEPROB_PARAM + i, 0.0f, 1.0f,  1.0f);

  1136. 		addParam(pulseProbParams[i]);

  1137. 		{

  1138. 			BORDLPulseDisplay *displayPulse = new BORDLPulseDisplay();

  1139. 			displayPulse->module = module;

  1140. 			displayPulse->box.pos = Vec(portX1[i]+15.0f, 197.0f);

  1141. 			displayPulse->box.size = Vec(20.0f, 10.0f);

  1142. 			displayPulse->index = i;

  1143. 			addChild(displayPulse);

  1144. 		}

  1145. 		typeParams[i] = ParamWidget::create<BidooBlueSnapKnob>(Vec(portX1[i]+1.0f, 288.0f), module, BORDL::TRIG_TYPE_PARAM + i, 0.0f, 5.0f,  2.0f);

  1146. 		addParam(typeParams[i]);

  1147. 		{

  1148. 			BORDLGateDisplay *displayGate = new BORDLGateDisplay();

  1149. 			displayGate->module = module;

  1150. 			displayGate->box.pos = Vec(portX1[i]+5.0f, 275.0f);

  1151. 			displayGate->box.size = Vec(20.0f, 10.0f);

  1152. 			displayGate->index = i;

  1153. 			addChild(displayGate);

  1154. 		}

  1155. 		slideParams[i] = ParamWidget::create<LEDButton>(Vec(portX1[i]+7.0f, 320.0f), module, BORDL::TRIG_SLIDE_PARAM + i, 0.0f, 1.0f,  0.0f);

  1156. 		addParam(slideParams[i]);

  1157. 		addChild(ModuleLightWidget::create<SmallLight<BlueLight>>(Vec(portX1[i]+13.0f, 326.0f), module, BORDL::SLIDES_LIGHTS + i));

  1158. 		skipParams[i] = ParamWidget::create<LEDButton>(Vec(portX1[i]+7.0f, 341.0f), module, BORDL::TRIG_SKIP_PARAM + i, 0.0f, 1.0f, 0.0f);

  1159. 		addParam(skipParams[i]);

  1160. 		addChild(ModuleLightWidget::create<SmallLight<BlueLight>>(Vec(portX1[i]+13.0f, 347.0f), module, BORDL::SKIPS_LIGHTS + i));

  1161. 	}

  1162. 

  1163. 	addInput(Port::create<PJ301MPort>(Vec(10.0f, 331.0f), Port::INPUT, module, BORDL::EXTGATE1_INPUT));

  1164. 	addInput(Port::create<PJ301MPort>(Vec(43.0f, 331.0f), Port::INPUT, module, BORDL::EXTGATE2_INPUT));

  1165. 	addOutput(Port::create<PJ301MPort>(Vec(76.5f, 331.0f), Port::OUTPUT, module, BORDL::GATE_OUTPUT));

  1166. 	addOutput(Port::create<PJ301MPort>(Vec(109.5f, 331.0f), Port::OUTPUT, module, BORDL::PITCH_OUTPUT));

  1167. 	addOutput(Port::create<PJ301MPort>(Vec(143.0f, 331.0f), Port::OUTPUT, module, BORDL::ACC_OUTPUT));

  1168. }

  1169. 

  1170. struct BORDLRandPitchItem : MenuItem {

  1171. 	BORDLWidget *bordlWidget;

  1172. 	void onAction(EventAction &e) override {

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

  1174. 			int index = BORDL::TRIG_PITCH_PARAM + i;

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

  1176. 			if (it != bordlWidget->params.end())

  1177. 			{

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

  1179. 				bordlWidget->params[index]->randomize();

  1180. 			}

  1181. 		}

  1182. 	}

  1183. };

  1184. 

  1185. struct BORDLRandGatesItem : MenuItem {

  1186. 	BORDLWidget *bordlWidget;

  1187. 	void onAction(EventAction &e) override {

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

  1189. 			int index = BORDL::TRIG_COUNT_PARAM + i;

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

  1191. 			if (it != bordlWidget->params.end())

  1192. 			{

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

  1194. 				bordlWidget->params[index]->randomize();

  1195. 			}

  1196. 		}

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

  1198. 				int index = BORDL::TRIG_TYPE_PARAM + i;

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

  1200. 				if (it != bordlWidget->params.end())

  1201. 				{

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

  1203. 				bordlWidget->params[index]->randomize();

  1204. 			}

  1205. 		}

  1206. 	}

  1207. };

  1208. 

  1209. struct BORDLRandSlideSkipItem : MenuItem {

  1210. 	BORDL *bordlModule;

  1211. 	void onAction(EventAction &e) override {

  1212. 		bordlModule->randomizeSlidesSkips();

  1213. 	}

  1214. };

  1215. 

  1216. struct BORDLPitchModeItem : MenuItem {

  1217. 	BORDL *bordlModule;

  1218. 	void onAction(EventAction &e) override {

  1219. 		bordlModule->pitchMode = !bordlModule->pitchMode;

  1220. 	}

  1221. 	void step() override {

  1222. 		rightText = bordlModule->pitchMode ? "✔" : "";

  1223. 		MenuItem::step();

  1224. 	}

  1225. };

  1226. 

  1227. struct BORDLPitchQuantizeModeItem : MenuItem {

  1228. 	BORDL *bordlModule;

  1229. 	void onAction(EventAction &e) override {

  1230. 		bordlModule->pitchQuantizeMode = !bordlModule->pitchQuantizeMode;

  1231. 	}

  1232. 	void step() override {

  1233. 		rightText = bordlModule->pitchQuantizeMode ? "✔" : "";

  1234. 		MenuItem::step();

  1235. 	}

  1236. };

  1237. 

  1238. struct DisconnectMenuItem : MenuItem {

  1239. 	ModuleWidget *moduleWidget;

  1240. 	void onAction(EventAction &e) override {

  1241. 		moduleWidget->disconnect();

  1242. 	}

  1243. };

  1244. 

  1245. struct ResetMenuItem : MenuItem {

  1246. 	BORDLWidget *bordlWidget;

  1247. 	BORDL *bordlModule;

  1248. 	void onAction(EventAction &e) override {

  1249. 		for (int i = 0; i < BORDL::NUM_PARAMS; i++){

  1250. 			if (i != BORDL::PATTERN_PARAM) {

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

  1252. 				if (it != bordlWidget->params.end())

  1253. 				{

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

  1255. 					bordlWidget->params[index]->setValue(bordlWidget->params[index]->defaultValue);

  1256. 				}

  1257. 			}

  1258. 		}

  1259. 		bordlModule->updateFlag = false;

  1260. 		bordlModule->reset();

  1261. 		bordlModule->playMode = 0;

  1262. 		bordlModule->countMode = 0;

  1263. 		bordlModule->updateFlag = true;

  1264. 	}

  1265. };

  1266. 

  1267. struct RandomizeMenuItem : MenuItem {

  1268. 	ModuleWidget *moduleWidget;

  1269. 	void onAction(EventAction &e) override {

  1270. 		moduleWidget->randomize();

  1271. 	}

  1272. };

  1273. 

  1274. struct CloneMenuItem : MenuItem {

  1275. 	ModuleWidget *moduleWidget;

  1276. 	void onAction(EventAction &e) override {

  1277. 		RACK_PLUGIN_UI_RACKWIDGET->cloneModule(moduleWidget);

  1278. 	}

  1279. };

  1280. 

  1281. struct DeleteMenuItem : MenuItem {

  1282. 	ModuleWidget *moduleWidget;

  1283. 	void onAction(EventAction &e) override {

  1284. 		RACK_PLUGIN_UI_RACKWIDGET->deleteModule(moduleWidget);

  1285. 		moduleWidget->finalizeEvents();

  1286. 		delete moduleWidget;

  1287. 	}

  1288. };

  1289. 

  1290. struct BORDLCopyItem : MenuItem {

  1291. 	BORDL *bordlModule;

  1292. 	void onAction(EventAction &e) override {

  1293. 		bordlModule->copyPattern = bordlModule->selectedPattern;

  1294. 	}

  1295. };

  1296. 

  1297. struct BORDLPasteItem : MenuItem {

  1298. 	BORDL *bordlModule;

  1299. 	BORDLWidget *bordlWidget;

  1300. 	void onAction(EventAction &e) override {

  1301. 		if (bordlModule && bordlWidget && (bordlModule->copyPattern != bordlModule->selectedPattern) && bordlModule->updateFlag)

  1302. 		{

  1303. 			bordlModule->updateFlag = false;

  1304. 			bordlWidget->stepsParam->setValue(bordlModule->patterns[bordlModule->copyPattern].numberOfStepsParam);

  1305. 			bordlWidget->rootNoteParam->setValue(bordlModule->patterns[bordlModule->copyPattern].rootNote);

  1306. 			bordlWidget->scaleParam->setValue(bordlModule->patterns[bordlModule->copyPattern].scale);

  1307. 			bordlWidget->gateTimeParam->setValue(bordlModule->patterns[bordlModule->copyPattern].gateTime);

  1308. 			bordlWidget->slideTimeParam->setValue(bordlModule->patterns[bordlModule->copyPattern].slideTime);

  1309. 			bordlWidget->sensitivityParam->setValue(bordlModule->patterns[bordlModule->copyPattern].sensitivity);

  1310. 			bordlModule->playMode = bordlModule->patterns[bordlModule->copyPattern].playMode;

  1311. 			bordlModule->countMode = bordlModule->patterns[bordlModule->copyPattern].countMode;

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

  1313. 				bordlWidget->pitchParams[i]->setValue(bordlModule->patterns[bordlModule->copyPattern].steps[i].pitch);

  1314. 				bordlWidget->pulseParams[i]->setValue(bordlModule->patterns[bordlModule->copyPattern].steps[i].pulsesParam);

  1315. 				bordlWidget->typeParams[i]->setValue(bordlModule->patterns[bordlModule->copyPattern].steps[i].type);

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

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

  1318. 				bordlWidget->pulseProbParams[i]->setValue(bordlModule->patterns[bordlModule->copyPattern].steps[i].gateProb);

  1319. 				bordlWidget->pitchRndParams[i]->setValue(bordlModule->patterns[bordlModule->copyPattern].steps[i].pitchRnd);

  1320. 				bordlWidget->accentParams[i]->setValue(bordlModule->patterns[bordlModule->copyPattern].steps[i].accent);

  1321. 				bordlWidget->rndAccentParams[i]->setValue(bordlModule->patterns[bordlModule->copyPattern].steps[i].rndAccent);

  1322. 			}

  1323. 			bordlModule->updateFlag = true;

  1324. 		}

  1325. 	}

  1326. };

  1327. 

  1328. Menu *BORDLWidget::createContextMenu() {

  1329. 	BORDLWidget *bordlWidget = dynamic_cast<BORDLWidget*>(this);

  1330. 	assert(bordlWidget);

  1331. 

  1332. 	BORDL *bordlModule = dynamic_cast<BORDL*>(module);

  1333. 	assert(bordlModule);

  1334. 

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

  1336. 

  1337. 	MenuLabel *menuLabel = new MenuLabel();

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

  1339. 	menu->addChild(menuLabel);

  1340. 

  1341. 	ResetMenuItem *resetItem = new ResetMenuItem();

  1342. 	resetItem->text = "Initialize";

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

  1344. 	resetItem->bordlWidget = this;

  1345. 	resetItem->bordlModule = bordlModule;

  1346. 	menu->addChild(resetItem);

  1347. 

  1348. 	DisconnectMenuItem *disconnectItem = new DisconnectMenuItem();

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

  1350. 	disconnectItem->moduleWidget = this;

  1351. 	menu->addChild(disconnectItem);

  1352. 

  1353. 	CloneMenuItem *cloneItem = new CloneMenuItem();

  1354. 	cloneItem->text = "Duplicate";

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

  1356. 	cloneItem->moduleWidget = this;

  1357. 	menu->addChild(cloneItem);

  1358. 

  1359. 	DeleteMenuItem *deleteItem = new DeleteMenuItem();

  1360. 	deleteItem->text = "Delete";

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

  1362. 	deleteItem->moduleWidget = this;

  1363. 	menu->addChild(deleteItem);

  1364. 

  1365. 	MenuLabel *spacerLabel = new MenuLabel();

  1366. 	menu->addChild(spacerLabel);

  1367. 

  1368. 	BORDLRandPitchItem *randomizePitchItem = new BORDLRandPitchItem();

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

  1370. 	randomizePitchItem->bordlWidget = bordlWidget;

  1371. 	menu->addChild(randomizePitchItem);

  1372. 

  1373. 	BORDLRandGatesItem *randomizeGatesItem = new BORDLRandGatesItem();

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

  1375. 	randomizeGatesItem->bordlWidget = bordlWidget;

  1376. 	menu->addChild(randomizeGatesItem);

  1377. 

  1378. 	BORDLRandSlideSkipItem *randomizeSlideSkipItem = new BORDLRandSlideSkipItem();

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

  1380. 	randomizeSlideSkipItem->bordlModule = bordlModule;

  1381. 	menu->addChild(randomizeSlideSkipItem);

  1382. 

  1383. 	MenuLabel *spacerLabel2 = new MenuLabel();

  1384. 	menu->addChild(spacerLabel2);

  1385. 

  1386. 	BORDLCopyItem *copyItem = new BORDLCopyItem();

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

  1388. 	copyItem->bordlModule = bordlModule;

  1389. 	menu->addChild(copyItem);

  1390. 

  1391. 	BORDLPasteItem *pasteItem = new BORDLPasteItem();

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

  1393. 	pasteItem->bordlModule = bordlModule;

  1394. 	pasteItem->bordlWidget = bordlWidget;

  1395. 	menu->addChild(pasteItem);

  1396. 

  1397. 	MenuLabel *spacerLabel3 = new MenuLabel();

  1398. 	menu->addChild(spacerLabel3);

  1399. 

  1400. 	BORDLPitchModeItem *pitchModeItem = new BORDLPitchModeItem();

  1401. 	pitchModeItem->text = "Pitch mode continuous/triggered";

  1402. 	pitchModeItem->bordlModule = bordlModule;

  1403. 	menu->addChild(pitchModeItem);

  1404. 

  1405. 	BORDLPitchQuantizeModeItem *pitchQuantizeModeItem = new BORDLPitchQuantizeModeItem();

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

  1407. 	pitchQuantizeModeItem->bordlModule = bordlModule;

  1408. 	menu->addChild(pitchQuantizeModeItem);

  1409. 

  1410. 	return menu;

  1411. }

  1412. 

  1413. } // namespace rack_plugin_Bidoo

  1414. 

  1415. using namespace rack_plugin_Bidoo;

  1416. 

  1417. RACK_PLUGIN_MODEL_INIT(Bidoo, BORDL) {

  1418.    Model *modelBORDL = Model::create<BORDL, BORDLWidget>("Bidoo", "bordL", "bordL sequencer", SEQUENCER_TAG);

  1419.    return modelBORDL;

  1420. }