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.
984 Commits
4 Branches
541MB
Tree: 0a41bb286f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0a41bb286f'
${ noResults }
Rack/plugins/community/repos/FrozenWasteland/src/QuadEuclideanRhythm.cpp

625 lines
23KB
Raw Blame History 

  1. #include <string.h>

  2. #include "FrozenWasteland.hpp"

  3. #include "dsp/digital.hpp"

  4. #define NUM_RULERS 10

  5. #define MAX_DIVISIONS 6

  6. #define TRACK_COUNT 4

  7. #define MAX_STEPS 18

  8. 

  9. #define sMIN(a,b) (((a)>(b))?(b):(a))

  10. #define sMAX(a,b) (((a)>(b))?(a):(b))

  11. 

  12. namespace rack_plugin_FrozenWasteland {

  13. 

  14. struct QuadEuclideanRhythm : Module {

  15. 	enum ParamIds {

  16. 		STEPS_1_PARAM,

  17. 		DIVISIONS_1_PARAM,

  18. 		OFFSET_1_PARAM,

  19. 		PAD_1_PARAM,

  20. 		ACCENTS_1_PARAM,

  21. 		ACCENT_ROTATE_1_PARAM,

  22. 		STEPS_2_PARAM,

  23. 		DIVISIONS_2_PARAM,

  24. 		OFFSET_2_PARAM,

  25. 		PAD_2_PARAM,

  26. 		ACCENTS_2_PARAM,

  27. 		ACCENT_ROTATE_2_PARAM,

  28. 		STEPS_3_PARAM,

  29. 		DIVISIONS_3_PARAM,

  30. 		OFFSET_3_PARAM,

  31. 		PAD_3_PARAM,

  32. 		ACCENTS_3_PARAM,

  33. 		ACCENT_ROTATE_3_PARAM,

  34. 		STEPS_4_PARAM,

  35. 		DIVISIONS_4_PARAM,

  36. 		OFFSET_4_PARAM,

  37. 		PAD_4_PARAM,

  38. 		ACCENTS_4_PARAM,

  39. 		ACCENT_ROTATE_4_PARAM,

  40. 		CHAIN_MODE_PARAM,	

  41. 		CONSTANT_TIME_MODE_PARAM,	

  42. 		NUM_PARAMS

  43. 	};

  44. 	enum InputIds {

  45. 		STEPS_1_INPUT,

  46. 		DIVISIONS_1_INPUT,

  47. 		OFFSET_1_INPUT,

  48. 		PAD_1_INPUT,

  49. 		ACCENTS_1_INPUT,

  50. 		ACCENT_ROTATE_1_INPUT,

  51. 		START_1_INPUT,

  52. 		STEPS_2_INPUT,

  53. 		DIVISIONS_2_INPUT,

  54. 		OFFSET_2_INPUT,

  55. 		PAD_2_INPUT,

  56. 		ACCENTS_2_INPUT,

  57. 		ACCENT_ROTATE_2_INPUT,

  58. 		START_2_INPUT,

  59. 		STEPS_3_INPUT,

  60. 		DIVISIONS_3_INPUT,

  61. 		OFFSET_3_INPUT,

  62. 		PAD_3_INPUT,

  63. 		ACCENTS_3_INPUT,

  64. 		ACCENT_ROTATE_3_INPUT,

  65. 		START_3_INPUT,

  66. 		STEPS_4_INPUT,

  67. 		DIVISIONS_4_INPUT,

  68. 		OFFSET_4_INPUT,

  69. 		PAD_4_INPUT,

  70. 		ACCENTS_4_INPUT,

  71. 		ACCENT_ROTATE_4_INPUT,

  72. 		START_4_INPUT,

  73. 		CLOCK_INPUT,

  74. 		RESET_INPUT,

  75. 		MUTE_INPUT,

  76. 		NUM_INPUTS

  77. 	};

  78. 	enum OutputIds {

  79. 		OUTPUT_1,

  80. 		ACCENT_OUTPUT_1,

  81. 		EOC_OUTPUT_1,

  82. 		OUTPUT_2,

  83. 		ACCENT_OUTPUT_2,

  84. 		EOC_OUTPUT_2,

  85. 		OUTPUT_3,

  86. 		ACCENT_OUTPUT_3,

  87. 		EOC_OUTPUT_3,

  88. 		OUTPUT_4,

  89. 		ACCENT_OUTPUT_4,

  90. 		EOC_OUTPUT_4,

  91. 		NUM_OUTPUTS

  92. 	};

  93. 	enum LightIds {

  94. 		CHAIN_MODE_NONE_LIGHT,

  95. 		CHAIN_MODE_BOSS_LIGHT,

  96. 		CHAIN_MODE_EMPLOYEE_LIGHT,

  97. 		MUTED_LIGHT,

  98. 		CONSTANT_TIME_LIGHT,

  99. 		NUM_LIGHTS

  100. 	};

  101. 	enum ChainModes {

  102. 		CHAIN_MODE_NONE,

  103. 		CHAIN_MODE_BOSS,

  104. 		CHAIN_MODE_EMPLOYEE

  105. 	};

  106. 

  107. 	bool beatMatrix[TRACK_COUNT][MAX_STEPS];

  108. 	bool accentMatrix[TRACK_COUNT][MAX_STEPS];

  109. 	int beatIndex[TRACK_COUNT];

  110. 	int stepsCount[TRACK_COUNT];

  111. 	float stepDuration[TRACK_COUNT];

  112. 	float lastStepTime[TRACK_COUNT];

  113. 	float maxStepCount;

  114. 

  115. 	bool running[TRACK_COUNT];

  116. 	int chainMode;

  117. 	bool initialized = false;

  118. 	bool muted = false;

  119. 	bool constantTime = false;

  120. 

  121. 	float time = 0.0;

  122. 	float duration = 0.0;

  123. 	bool secondClockReceived = false;

  124. 

  125. 	SchmittTrigger clockTrigger,resetTrigger,chainModeTrigger,constantTimeTrigger,muteTrigger,startTrigger[TRACK_COUNT];

  126. 	PulseGenerator beatPulse[TRACK_COUNT],accentPulse[TRACK_COUNT],eocPulse[TRACK_COUNT];

  127. 

  128. 

  129. 

  130. 	QuadEuclideanRhythm() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS,NUM_LIGHTS) {

  131. 		for(unsigned i = 0; i < TRACK_COUNT; i++) {

  132. 			beatIndex[i] = 0;

  133. 			stepsCount[i] = MAX_STEPS;

  134. 			lastStepTime[i] = 0.0;

  135. 			stepDuration[i] = 0.0;

  136. 			running[i] = true;

  137. 			for(unsigned j = 0; j < MAX_STEPS; j++) {

  138. 				beatMatrix[i][j] = false;

  139. 				accentMatrix[i][j] = false;

  140. 			}

  141. 		}		

  142. 	}

  143. 	void step() override;

  144. 

  145. 

  146. 	json_t *toJson() override {

  147. 		json_t *rootJ = json_object();

  148. 		json_object_set_new(rootJ, "constantTime", json_integer((bool) constantTime));

  149. 		json_object_set_new(rootJ, "chainMode", json_integer((int) chainMode));

  150. 		json_object_set_new(rootJ, "muted", json_integer((bool) muted));

  151. 		return rootJ;

  152. 	}

  153. 

  154. 	void fromJson(json_t *rootJ) override {

  155. 		json_t *ctJ = json_object_get(rootJ, "constantTime");

  156. 		if (ctJ)

  157. 			constantTime = json_integer_value(ctJ);

  158. 

  159. 		json_t *cmJ = json_object_get(rootJ, "chainMode");

  160. 		if (cmJ)

  161. 			chainMode = json_integer_value(cmJ);

  162. 

  163. 		json_t *mutedJ = json_object_get(rootJ, "muted");

  164. 		if (mutedJ)

  165. 			muted = json_integer_value(mutedJ);

  166. 	}

  167. 

  168. 	void setRunningState() {

  169. 		for(int trackNumber=0;trackNumber<4;trackNumber++)

  170. 		{

  171. 			if(chainMode == CHAIN_MODE_EMPLOYEE && inputs[(trackNumber * 7) + 6].active) { //START Input needs to be active

  172. 				running[trackNumber] = false;

  173. 			}

  174. 			else {

  175. 				running[trackNumber] = true;

  176. 			}

  177. 		}

  178. 	}

  179. 

  180. 	void advanceBeat(int trackNumber) {

  181. 		beatIndex[trackNumber]++;

  182. 		lastStepTime[trackNumber] = 0.0;					

  183. 					

  184. 		//End of Cycle

  185. 		if(beatIndex[trackNumber] >= stepsCount[trackNumber]) {

  186. 			beatIndex[trackNumber] = 0;

  187. 			eocPulse[trackNumber].trigger(1e-3);

  188. 			//If in a chain mode, stop running until start trigger received

  189. 			if(chainMode != CHAIN_MODE_NONE && inputs[(trackNumber * 7) + 6].active) { //START Input needs to be active

  190. 				running[trackNumber] = false;

  191. 			}

  192. 		}

  193. 	}

  194. 	// For more advanced Module features, read Rack's engine.hpp header file

  195. 	// - onSampleRateChange: event triggered by a change of sample rate

  196. 	// - onReset, onRandomize, onCreate, onDelete: implements special behavior when user clicks these from the context menu

  197. };

  198. 

  199. 

  200. 

  201. 

  202. 

  203. void QuadEuclideanRhythm::step() {

  204. 

  205. 	int levelArray[16];

  206. 	int accentLevelArray[16];

  207. 	int beatLocation[16];

  208. 

  209. 	//Set startup state

  210. 	if(!initialized) {

  211. 		setRunningState();

  212. 		initialized = true;

  213. 	}

  214. 

  215. 	// Modes

  216. 	if (constantTimeTrigger.process(params[CONSTANT_TIME_MODE_PARAM].value)) {

  217. 		constantTime = !constantTime;

  218. 		for(int trackNumber=0;trackNumber<4;trackNumber++) {

  219. 			beatIndex[trackNumber] = 0;

  220. 		}

  221. 		setRunningState();

  222. 	}

  223. 	lights[CONSTANT_TIME_LIGHT].value = constantTime;

  224. 

  225. 	if (chainModeTrigger.process(params[CHAIN_MODE_PARAM].value)) {

  226. 		chainMode = (chainMode + 1) % 3;

  227. 		setRunningState();

  228. 	}

  229. 	lights[CHAIN_MODE_NONE_LIGHT].value = chainMode == CHAIN_MODE_NONE ? 1.0 : 0.0;

  230. 	lights[CHAIN_MODE_BOSS_LIGHT].value = chainMode == CHAIN_MODE_BOSS ? 1.0 : 0.0;

  231. 	lights[CHAIN_MODE_EMPLOYEE_LIGHT].value = chainMode == CHAIN_MODE_EMPLOYEE ? 1.0 : 0.0;

  232. 

  233. 	lights[MUTED_LIGHT].value = muted ? 1.0 : 0.0;

  234. 

  235. 	maxStepCount = 0;

  236. 

  237. 	for(int trackNumber=0;trackNumber<4;trackNumber++) {

  238. 		//clear out the matrix and levels

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

  240. 		{

  241. 			beatMatrix[trackNumber][j] = false; 

  242. 			accentMatrix[trackNumber][j] = false;

  243. 			levelArray[j] = 0;		

  244. 			accentLevelArray[j] = 0;	

  245. 			beatLocation[j] = 0;

  246. 		}

  247. 

  248. 		float stepsCountf = params[trackNumber * 6].value;

  249. 		if(inputs[trackNumber * 7].active) {

  250. 			stepsCountf += inputs[trackNumber * 7].value;

  251. 		}

  252. 		stepsCountf = clamp(stepsCountf,0.0f,16.0f);	

  253. 

  254. 		float divisionf = params[(trackNumber * 6) + 1].value;

  255. 		if(inputs[(trackNumber * 7) + 1].active) {

  256. 			divisionf += inputs[(trackNumber * 7) + 1].value;

  257. 		}		

  258. 		divisionf = clamp(divisionf,0.0f,stepsCountf);

  259. 

  260. 		float offsetf = params[(trackNumber * 6) + 2].value;

  261. 		if(inputs[(trackNumber * 7) + 2].active) {

  262. 			offsetf += inputs[(trackNumber * 7) + 2].value;

  263. 		}	

  264. 		offsetf = clamp(offsetf,0.0f,15.0f);

  265. 

  266. 		float padf = params[trackNumber * 6 + 3].value;

  267. 		if(inputs[trackNumber * 7 + 3].active) {

  268. 			padf += inputs[trackNumber * 7 + 3].value;

  269. 		}

  270. 		padf = clamp(padf,0.0f,stepsCountf - divisionf);

  271. 

  272. 

  273. 		//Use this to reduce range of accent params/inputs so the range of motion of knob/modulation is more useful.

  274. 		float divisionScale = 1;

  275. 		if(stepsCountf > 0) {

  276. 			divisionScale = divisionf / stepsCountf;

  277. 		}		

  278. 

  279. 		float accentDivisionf = params[(trackNumber * 6) + 4].value * divisionScale;

  280. 		if(inputs[(trackNumber * 7) + 4].active) {

  281. 			accentDivisionf += inputs[(trackNumber * 7) + 4].value * divisionScale;

  282. 		}

  283. 		accentDivisionf = clamp(accentDivisionf,0.0f,divisionf);

  284. 

  285. 		float accentRotationf = params[(trackNumber * 6) + 5].value * divisionScale;

  286. 		if(inputs[(trackNumber * 7) + 5].active) {

  287. 			accentRotationf += inputs[(trackNumber * 7) + 5].value * divisionScale;

  288. 		}

  289. 		if(divisionf > 0) {

  290. 			accentRotationf = clamp(accentRotationf,0.0f,divisionf-1);			

  291. 		} else {

  292. 			accentRotationf = 0;

  293. 		}

  294. 

  295. 		if(stepsCountf > maxStepCount)

  296. 			maxStepCount = stepsCountf;

  297. 

  298. 

  299. 		stepsCount[trackNumber] = int(stepsCountf);

  300. 

  301. 		int division = int(divisionf);

  302. 		int offset = int(offsetf);		

  303. 		int pad = int(padf);

  304. 		int accentDivision = int(accentDivisionf);

  305. 		int accentRotation = int(accentRotationf);

  306. 

  307. 

  308. 		if(stepsCount[trackNumber] > 0) {

  309. 			//Calculate Beats

  310. 			int level = 0;

  311. 			int restsLeft = sMAX(0,stepsCount[trackNumber]-division-pad); // just make sure no negatives

  312. 			do {

  313. 				levelArray[level] = sMIN(restsLeft,division); 

  314. 				restsLeft = restsLeft - division;

  315. 				level += 1;

  316. 			} while (restsLeft > 0 && level < 16);

  317. 

  318. 			int tempIndex =pad;

  319. 			int beatIndex = 0;

  320. 			for (int j = 0; j < division; j++) {

  321. 	            beatMatrix[trackNumber][(tempIndex + offset) % stepsCount[trackNumber]] = true;

  322. 	            beatLocation[beatIndex] = (tempIndex + offset) % stepsCount[trackNumber];

  323. 	            tempIndex++;

  324. 	            beatIndex++;

  325. 	            for (int k = 0; k < 16; k++) {

  326. 	                if (levelArray[k] > j) {

  327. 	                    tempIndex++;

  328. 	                }

  329. 	            }

  330. 	        }	

  331. 

  332. 	        //Calculate Accents

  333. 	        level = 0;

  334. 	        restsLeft = sMAX(0,division-accentDivision); // just make sure no negatives

  335. 	        do {

  336. 				accentLevelArray[level] = sMIN(restsLeft,accentDivision);

  337. 				restsLeft = restsLeft - accentDivision;

  338. 				level += 1;

  339. 			} while (restsLeft > 0 && level < 16);

  340. 

  341. 			tempIndex =0;

  342. 			for (int j = 0; j < accentDivision; j++) {

  343. 	            accentMatrix[trackNumber][beatLocation[(tempIndex + accentRotation) % division]] = true;

  344. 	            tempIndex++;

  345. 	            for (int k = 0; k < 16; k++) {

  346. 	                if (accentLevelArray[k] > j) {

  347. 	                    tempIndex++;

  348. 	                }

  349. 	            }

  350. 	        }	

  351.         }	

  352. 	}

  353. 

  354. 	if(inputs[RESET_INPUT].active) {

  355. 		if(resetTrigger.process(inputs[RESET_INPUT].value)) {

  356. 			for(int trackNumber=0;trackNumber<4;trackNumber++)

  357. 			{

  358. 				beatIndex[trackNumber] = 0;

  359. 			}

  360. 			setRunningState();

  361. 		}

  362. 	}

  363. 

  364. 	if(inputs[MUTE_INPUT].active) {

  365. 		if(muteTrigger.process(inputs[MUTE_INPUT].value)) {

  366. 			muted = !muted;

  367. 		}

  368. 	}

  369. 

  370. 	//See if need to start up

  371. 	for(int trackNumber=0;trackNumber < 4;trackNumber++) {

  372. 		if(chainMode != CHAIN_MODE_NONE && inputs[(trackNumber * 7) + 6].active && !running[trackNumber]) {

  373. 			if(startTrigger[trackNumber].process(inputs[(trackNumber * 7) + 6].value)) {

  374. 				running[trackNumber] = true;

  375. 			}

  376. 		}

  377. 	}

  378. 

  379. 	//Advance beat on trigger if not in constant time mode

  380. 	float timeAdvance =1.0 / engineGetSampleRate();

  381.     time += timeAdvance;

  382. 	if(inputs[CLOCK_INPUT].active) {

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

  384. 			if(secondClockReceived) {

  385. 				duration = time;

  386. 			}

  387. 			time = 0;

  388. 			secondClockReceived = true;			

  389. 

  390. 			for(int trackNumber=0;trackNumber < TRACK_COUNT;trackNumber++)

  391. 			{

  392. 				if(running[trackNumber]) {

  393. 					if(!constantTime) {

  394. 						advanceBeat(trackNumber);

  395. 					}					

  396. 				}

  397. 			}

  398. 		}

  399. 

  400. 		bool resyncAll = false;

  401. 		//For constant time, don't rely on clock trigger to advance beat, use time

  402. 		for(int trackNumber=0;trackNumber < TRACK_COUNT;trackNumber++) {

  403. 			if(stepsCount[trackNumber] > 0)

  404. 				stepDuration[trackNumber] = duration * maxStepCount / (float)stepsCount[trackNumber];

  405. 

  406. 			if(running[trackNumber]) {

  407. 				lastStepTime[trackNumber] +=timeAdvance;

  408. 				if(constantTime && stepDuration[trackNumber] > 0.0 && lastStepTime[trackNumber] >= stepDuration[trackNumber]) {

  409. 					advanceBeat(trackNumber);

  410. 					if(stepsCount[trackNumber] >= (int)maxStepCount && beatIndex[trackNumber] == 0) {

  411. 						resyncAll = true;

  412. 					}

  413. 				}					

  414. 			}

  415. 		}

  416. 		if(resyncAll) {

  417. 			for(int trackNumber=0;trackNumber < TRACK_COUNT;trackNumber++) {

  418. 				lastStepTime[trackNumber] = 0;

  419. 				beatIndex[trackNumber] = 0;

  420. 			}

  421. 		}

  422. 	}

  423. 

  424. 

  425. 	// Set output to current state

  426. 	for(int trackNumber=0;trackNumber<TRACK_COUNT;trackNumber++) {

  427. 		float outputValue = (lastStepTime[trackNumber] < stepDuration[trackNumber] / 2) ? 10.0 : 0.0;

  428. 		//Send out beat

  429. 		if(beatMatrix[trackNumber][beatIndex[trackNumber]] == true && running[trackNumber] && !muted) {

  430. 			outputs[trackNumber * 3].value = outputValue;

  431. 		} else {

  432. 			outputs[trackNumber * 3].value = 0.0;	

  433. 		}

  434. 		//send out accent

  435. 		if(accentMatrix[trackNumber][beatIndex[trackNumber]] == true && running[trackNumber] && !muted) {

  436. 			outputs[trackNumber * 3 + 1].value = outputValue;	

  437. 		} else {

  438. 			outputs[trackNumber * 3 + 1].value = 0.0;	

  439. 		}

  440. 		//Send out End of Cycle

  441. 		outputs[(trackNumber * 3) + 2].value = eocPulse[trackNumber].process(1.0 / engineGetSampleRate()) ? 10.0 : 0;	

  442. 	}

  443. }

  444. 

  445. struct QERBeatDisplay : TransparentWidget {

  446. 	QuadEuclideanRhythm *module;

  447. 	int frame = 0;

  448. 	std::shared_ptr<Font> font;

  449. 

  450. 	QERBeatDisplay() {

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

  452. 	}

  453. 

  454. 	void drawBox(NVGcontext *vg, float stepNumber, float trackNumber,bool isBeat,bool isAccent,bool isCurrent) {

  455. 		

  456. 		//nvgSave(vg);

  457. 		//Rect b = Rect(Vec(0, 0), box.size);

  458. 		//nvgScissor(vg, b.pos.x, b.pos.y, b.size.x, b.size.y);

  459. 		nvgBeginPath(vg);

  460. 		

  461. 		float boxX = stepNumber * 22.5;

  462. 		float boxY = trackNumber * 22.5;

  463. 

  464. 		float opacity = 0x80; // Testing using opacity for accents

  465. 

  466. 		if(isAccent) {

  467. 			opacity = 0xff;

  468. 		}

  469. 

  470. 

  471. 		NVGcolor strokeColor = nvgRGBA(0xef, 0xe0, 0, 0xff);

  472. 		NVGcolor fillColor = nvgRGBA(0xef,0xe0,0,opacity);

  473. 		if(isCurrent)

  474. 		{

  475. 			strokeColor = nvgRGBA(0x2f, 0xf0, 0, 0xff);

  476. 			fillColor = nvgRGBA(0x2f,0xf0,0,opacity);			

  477. 		}

  478. 

  479. 		nvgStrokeColor(vg, strokeColor);

  480. 		nvgStrokeWidth(vg, 1.0);

  481. 		nvgRect(vg,boxX,boxY,21,21.0);

  482. 		if(isBeat) {

  483. 			nvgFillColor(vg, fillColor);

  484. 			nvgFill(vg);

  485. 		}

  486. 		nvgStroke(vg);

  487. 	}

  488. 

  489. 	void draw(NVGcontext *vg) override {

  490. 

  491. 		for(int trackNumber = 0;trackNumber < 4;trackNumber++) {

  492. 			for(int stepNumber = 0;stepNumber < module->stepsCount[trackNumber];stepNumber++) {				

  493. 				bool isBeat = module->beatMatrix[trackNumber][stepNumber];

  494. 				bool isAccent = module->accentMatrix[trackNumber][stepNumber];

  495. 				bool isCurrent = module->beatIndex[trackNumber] == stepNumber && module->running[trackNumber];				

  496. 				drawBox(vg, float(stepNumber), float(trackNumber),isBeat,isAccent,isCurrent);

  497. 			}

  498. 

  499. 		}

  500. 	}

  501. };

  502. 

  503. 

  504. struct QuadEuclideanRhythmWidget : ModuleWidget {

  505. 	QuadEuclideanRhythmWidget(QuadEuclideanRhythm *module);

  506. };

  507. 

  508. QuadEuclideanRhythmWidget::QuadEuclideanRhythmWidget(QuadEuclideanRhythm *module) : ModuleWidget(module) {

  509. 	box.size = Vec(15*26, RACK_GRID_HEIGHT);

  510. 

  511. 	{

  512. 		SVGPanel *panel = new SVGPanel();

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

  514. 		panel->setBackground(SVG::load(assetPlugin(plugin, "res/QuadEuclideanRhythm.svg")));

  515. 		addChild(panel);

  516. 	}

  517. 

  518. 	addChild(Widget::create<ScrewSilver>(Vec(RACK_GRID_WIDTH - 12, 0)));

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

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

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

  522. 

  523. 

  524. 	{

  525. 		QERBeatDisplay *display = new QERBeatDisplay();

  526. 		display->module = module;

  527. 		display->box.pos = Vec(16, 34);

  528. 		display->box.size = Vec(box.size.x-30, 135);

  529. 		addChild(display);

  530. 	}

  531. 

  532. 

  533. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(22, 138), module, QuadEuclideanRhythm::STEPS_1_PARAM, 0.0, 16.2, 16.0));

  534. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(61, 138), module, QuadEuclideanRhythm::DIVISIONS_1_PARAM, 1.0, 16.2, 2.0));

  535. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(100, 138), module, QuadEuclideanRhythm::OFFSET_1_PARAM, 0.0, 15.2, 0.0));

  536. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(139, 138), module, QuadEuclideanRhythm::PAD_1_PARAM, 0.0, 15.2, 0.0));

  537. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(178, 138), module, QuadEuclideanRhythm::ACCENTS_1_PARAM, 0.0, 15.2, 0.0));

  538. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(217, 138), module, QuadEuclideanRhythm::ACCENT_ROTATE_1_PARAM, 0.0, 15.2, 0.0));

  539. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(22, 195), module, QuadEuclideanRhythm::STEPS_2_PARAM, 0.0, 16.0, 16.0));

  540. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(61, 195), module, QuadEuclideanRhythm::DIVISIONS_2_PARAM, 1.0, 16.2, 2.0));

  541. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(100, 195), module, QuadEuclideanRhythm::OFFSET_2_PARAM, 0.0, 15.2, 0.0));

  542. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(139, 195), module, QuadEuclideanRhythm::PAD_2_PARAM, 0.0, 15.2, 0.0));

  543. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(178, 195), module, QuadEuclideanRhythm::ACCENTS_2_PARAM, 0.0, 15.2, 0.0));

  544. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(217, 195), module, QuadEuclideanRhythm::ACCENT_ROTATE_2_PARAM, 0.0, 15.2, 0.0));

  545. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(22, 252), module, QuadEuclideanRhythm::STEPS_3_PARAM, 0.0, 16.2, 16.0));

  546. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(61, 252), module, QuadEuclideanRhythm::DIVISIONS_3_PARAM, 1.0, 16.2, 2.0));

  547. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(100, 252), module, QuadEuclideanRhythm::OFFSET_3_PARAM, 0.0, 15.2, 0.0));

  548. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(139, 252), module, QuadEuclideanRhythm::PAD_3_PARAM, 0.0, 15.2, 0.0));

  549. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(178, 252), module, QuadEuclideanRhythm::ACCENTS_3_PARAM, 0.0, 15.2, 0.0));

  550. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(217, 252), module, QuadEuclideanRhythm::ACCENT_ROTATE_3_PARAM, 0.0, 15.2, 0.0));

  551. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(22, 309), module, QuadEuclideanRhythm::STEPS_4_PARAM, 0.0, 16.2, 16.0));

  552. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(61, 309), module, QuadEuclideanRhythm::DIVISIONS_4_PARAM, 1.0, 16.2, 2.0));

  553. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(100, 309), module, QuadEuclideanRhythm::OFFSET_4_PARAM, 0.0, 15.2, 0.0));

  554. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(139, 309), module, QuadEuclideanRhythm::PAD_4_PARAM, 0.0, 15.2, 0.0));

  555. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(178, 309), module, QuadEuclideanRhythm::ACCENTS_4_PARAM, 0.0, 15.2, 0.0));

  556. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(217, 309), module, QuadEuclideanRhythm::ACCENT_ROTATE_4_PARAM, 0.0, 15.2, 0.0));

  557. 	addParam(ParamWidget::create<CKD6>(Vec(250, 285), module, QuadEuclideanRhythm::CHAIN_MODE_PARAM, 0.0, 1.0, 0.0));

  558. 	addParam(ParamWidget::create<CKD6>(Vec(335, 285), module, QuadEuclideanRhythm::CONSTANT_TIME_MODE_PARAM, 0.0, 1.0, 0.0));

  559. 

  560. 	addInput(Port::create<PJ301MPort>(Vec(23, 163), Port::INPUT, module, QuadEuclideanRhythm::STEPS_1_INPUT));

  561. 	addInput(Port::create<PJ301MPort>(Vec(62, 163), Port::INPUT, module, QuadEuclideanRhythm::DIVISIONS_1_INPUT));

  562. 	addInput(Port::create<PJ301MPort>(Vec(101, 163), Port::INPUT, module, QuadEuclideanRhythm::OFFSET_1_INPUT));

  563. 	addInput(Port::create<PJ301MPort>(Vec(140, 163), Port::INPUT, module, QuadEuclideanRhythm::PAD_1_INPUT));

  564. 	addInput(Port::create<PJ301MPort>(Vec(179, 163), Port::INPUT, module, QuadEuclideanRhythm::ACCENTS_1_INPUT));

  565. 	addInput(Port::create<PJ301MPort>(Vec(218, 163), Port::INPUT, module, QuadEuclideanRhythm::ACCENT_ROTATE_1_INPUT));

  566. 	addInput(Port::create<PJ301MPort>(Vec(23, 220), Port::INPUT, module, QuadEuclideanRhythm::STEPS_2_INPUT));

  567. 	addInput(Port::create<PJ301MPort>(Vec(62, 220), Port::INPUT, module, QuadEuclideanRhythm::DIVISIONS_2_INPUT));

  568. 	addInput(Port::create<PJ301MPort>(Vec(101, 220), Port::INPUT, module, QuadEuclideanRhythm::OFFSET_2_INPUT));

  569. 	addInput(Port::create<PJ301MPort>(Vec(140, 220), Port::INPUT, module, QuadEuclideanRhythm::PAD_2_INPUT));

  570. 	addInput(Port::create<PJ301MPort>(Vec(179, 220), Port::INPUT, module, QuadEuclideanRhythm::ACCENTS_2_INPUT));

  571. 	addInput(Port::create<PJ301MPort>(Vec(218, 220), Port::INPUT, module, QuadEuclideanRhythm::ACCENT_ROTATE_2_INPUT));

  572. 	addInput(Port::create<PJ301MPort>(Vec(23, 277), Port::INPUT, module, QuadEuclideanRhythm::STEPS_3_INPUT));

  573. 	addInput(Port::create<PJ301MPort>(Vec(62, 277), Port::INPUT, module, QuadEuclideanRhythm::DIVISIONS_3_INPUT));

  574. 	addInput(Port::create<PJ301MPort>(Vec(101, 277), Port::INPUT, module, QuadEuclideanRhythm::OFFSET_3_INPUT));

  575. 	addInput(Port::create<PJ301MPort>(Vec(140, 277), Port::INPUT, module, QuadEuclideanRhythm::PAD_3_INPUT));

  576. 	addInput(Port::create<PJ301MPort>(Vec(179, 277), Port::INPUT, module, QuadEuclideanRhythm::ACCENTS_3_INPUT));

  577. 	addInput(Port::create<PJ301MPort>(Vec(218, 277), Port::INPUT, module, QuadEuclideanRhythm::ACCENT_ROTATE_3_INPUT));

  578. 	addInput(Port::create<PJ301MPort>(Vec(23, 334), Port::INPUT, module, QuadEuclideanRhythm::STEPS_4_INPUT));

  579. 	addInput(Port::create<PJ301MPort>(Vec(62, 334), Port::INPUT, module, QuadEuclideanRhythm::DIVISIONS_4_INPUT));

  580. 	addInput(Port::create<PJ301MPort>(Vec(101, 334), Port::INPUT, module, QuadEuclideanRhythm::OFFSET_4_INPUT));

  581. 	addInput(Port::create<PJ301MPort>(Vec(140, 334), Port::INPUT, module, QuadEuclideanRhythm::PAD_4_INPUT));

  582. 	addInput(Port::create<PJ301MPort>(Vec(179, 334), Port::INPUT, module, QuadEuclideanRhythm::ACCENTS_4_INPUT));

  583. 	addInput(Port::create<PJ301MPort>(Vec(218, 334), Port::INPUT, module, QuadEuclideanRhythm::ACCENT_ROTATE_4_INPUT));

  584. 

  585. 	addInput(Port::create<PJ301MPort>(Vec(262, 343), Port::INPUT, module, QuadEuclideanRhythm::CLOCK_INPUT));

  586. 	addInput(Port::create<PJ301MPort>(Vec(302, 343), Port::INPUT, module, QuadEuclideanRhythm::RESET_INPUT));

  587. 	addInput(Port::create<PJ301MPort>(Vec(335, 343), Port::INPUT, module, QuadEuclideanRhythm::MUTE_INPUT));

  588. 

  589. 	addInput(Port::create<PJ301MPort>(Vec(322, 145), Port::INPUT, module, QuadEuclideanRhythm::START_1_INPUT));

  590. 	addInput(Port::create<PJ301MPort>(Vec(322, 175), Port::INPUT, module, QuadEuclideanRhythm::START_2_INPUT));

  591. 	addInput(Port::create<PJ301MPort>(Vec(322, 205), Port::INPUT, module, QuadEuclideanRhythm::START_3_INPUT));

  592. 	addInput(Port::create<PJ301MPort>(Vec(322, 235), Port::INPUT, module, QuadEuclideanRhythm::START_4_INPUT));

  593. 

  594. 

  595. 	addOutput(Port::create<PJ301MPort>(Vec(255, 145), Port::OUTPUT, module, QuadEuclideanRhythm::OUTPUT_1));

  596. 	addOutput(Port::create<PJ301MPort>(Vec(286, 145), Port::OUTPUT, module, QuadEuclideanRhythm::ACCENT_OUTPUT_1));

  597. 	addOutput(Port::create<PJ301MPort>(Vec(354, 145), Port::OUTPUT, module, QuadEuclideanRhythm::EOC_OUTPUT_1));

  598. 	addOutput(Port::create<PJ301MPort>(Vec(256, 175), Port::OUTPUT, module, QuadEuclideanRhythm::OUTPUT_2));

  599. 	addOutput(Port::create<PJ301MPort>(Vec(286, 175), Port::OUTPUT, module, QuadEuclideanRhythm::ACCENT_OUTPUT_2));

  600. 	addOutput(Port::create<PJ301MPort>(Vec(354, 175), Port::OUTPUT, module, QuadEuclideanRhythm::EOC_OUTPUT_2));

  601. 	addOutput(Port::create<PJ301MPort>(Vec(256, 205), Port::OUTPUT, module, QuadEuclideanRhythm::OUTPUT_3));

  602. 	addOutput(Port::create<PJ301MPort>(Vec(286, 205), Port::OUTPUT, module, QuadEuclideanRhythm::ACCENT_OUTPUT_3));

  603. 	addOutput(Port::create<PJ301MPort>(Vec(354, 205), Port::OUTPUT, module, QuadEuclideanRhythm::EOC_OUTPUT_3));

  604. 	addOutput(Port::create<PJ301MPort>(Vec(256, 235), Port::OUTPUT, module, QuadEuclideanRhythm::OUTPUT_4));

  605. 	addOutput(Port::create<PJ301MPort>(Vec(286, 235), Port::OUTPUT, module, QuadEuclideanRhythm::ACCENT_OUTPUT_4));

  606. 	addOutput(Port::create<PJ301MPort>(Vec(354, 235), Port::OUTPUT, module, QuadEuclideanRhythm::EOC_OUTPUT_4));

  607. 	

  608. 	addChild(ModuleLightWidget::create<SmallLight<BlueLight>>(Vec(282, 285), module, QuadEuclideanRhythm::CHAIN_MODE_NONE_LIGHT));

  609. 	addChild(ModuleLightWidget::create<SmallLight<GreenLight>>(Vec(282, 300), module, QuadEuclideanRhythm::CHAIN_MODE_BOSS_LIGHT));

  610. 	addChild(ModuleLightWidget::create<SmallLight<RedLight>>(Vec(282, 315), module, QuadEuclideanRhythm::CHAIN_MODE_EMPLOYEE_LIGHT));

  611. 

  612. 	addChild(ModuleLightWidget::create<LargeLight<RedLight>>(Vec(363, 347), module, QuadEuclideanRhythm::MUTED_LIGHT));

  613. 	addChild(ModuleLightWidget::create<SmallLight<BlueLight>>(Vec(370, 295), module, QuadEuclideanRhythm::CONSTANT_TIME_LIGHT));

  614. 	

  615. }

  616. 

  617. } // namespace rack_plugin_FrozenWasteland

  618. 

  619. using namespace rack_plugin_FrozenWasteland;

  620. 

  621. RACK_PLUGIN_MODEL_INIT(FrozenWasteland, QuadEuclideanRhythm) {

  622.    Model *modelQuadEuclideanRhythm = Model::create<QuadEuclideanRhythm, QuadEuclideanRhythmWidget>("Frozen Wasteland", "QuadEuclideanRhythm", "Quad Euclidean Rhythm", SEQUENCER_TAG);

  623.    return modelQuadEuclideanRhythm;

  624. }