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.
1310 Commits
4 Branches
565MB
Tree: b5ee038c72
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b5ee038c72'
${ noResults }
Rack/plugins/community/repos/FrozenWasteland/src/QuadGolombRulerRhythm.cpp

634 lines
24KB
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. struct QuadGolombRulerRhythm : Module {

  13. 	enum ParamIds {

  14. 		STEPS_1_PARAM,

  15. 		DIVISIONS_1_PARAM,

  16. 		OFFSET_1_PARAM,

  17. 		PAD_1_PARAM,

  18. 		ACCENTS_1_PARAM,

  19. 		ACCENT_ROTATE_1_PARAM,

  20. 		STEPS_2_PARAM,

  21. 		DIVISIONS_2_PARAM,

  22. 		OFFSET_2_PARAM,

  23. 		PAD_2_PARAM,

  24. 		ACCENTS_2_PARAM,

  25. 		ACCENT_ROTATE_2_PARAM,

  26. 		STEPS_3_PARAM,

  27. 		DIVISIONS_3_PARAM,

  28. 		OFFSET_3_PARAM,

  29. 		PAD_3_PARAM,

  30. 		ACCENTS_3_PARAM,

  31. 		ACCENT_ROTATE_3_PARAM,

  32. 		STEPS_4_PARAM,

  33. 		DIVISIONS_4_PARAM,

  34. 		OFFSET_4_PARAM,

  35. 		PAD_4_PARAM,

  36. 		ACCENTS_4_PARAM,

  37. 		ACCENT_ROTATE_4_PARAM,

  38. 		CHAIN_MODE_PARAM,	

  39. 		CONSTANT_TIME_MODE_PARAM,		

  40. 		NUM_PARAMS

  41. 	};

  42. 	enum InputIds {

  43. 		STEPS_1_INPUT,

  44. 		DIVISIONS_1_INPUT,

  45. 		OFFSET_1_INPUT,

  46. 		PAD_1_INPUT,

  47. 		ACCENTS_1_INPUT,

  48. 		ACCENT_ROTATE_1_INPUT,

  49. 		START_1_INPUT,

  50. 		STEPS_2_INPUT,

  51. 		DIVISIONS_2_INPUT,

  52. 		OFFSET_2_INPUT,

  53. 		PAD_2_INPUT,

  54. 		ACCENTS_2_INPUT,

  55. 		ACCENT_ROTATE_2_INPUT,

  56. 		START_2_INPUT,

  57. 		STEPS_3_INPUT,

  58. 		DIVISIONS_3_INPUT,

  59. 		OFFSET_3_INPUT,

  60. 		PAD_3_INPUT,

  61. 		ACCENTS_3_INPUT,

  62. 		ACCENT_ROTATE_3_INPUT,

  63. 		START_3_INPUT,

  64. 		STEPS_4_INPUT,

  65. 		DIVISIONS_4_INPUT,

  66. 		OFFSET_4_INPUT,

  67. 		PAD_4_INPUT,

  68. 		ACCENTS_4_INPUT,

  69. 		ACCENT_ROTATE_4_INPUT,

  70. 		START_4_INPUT,

  71. 		CLOCK_INPUT,

  72. 		RESET_INPUT,

  73. 		MUTE_INPUT,

  74. 		NUM_INPUTS

  75. 	};

  76. 	enum OutputIds {

  77. 		OUTPUT_1,

  78. 		ACCENT_OUTPUT_1,

  79. 		EOC_OUTPUT_1,

  80. 		OUTPUT_2,

  81. 		ACCENT_OUTPUT_2,

  82. 		EOC_OUTPUT_2,

  83. 		OUTPUT_3,

  84. 		ACCENT_OUTPUT_3,

  85. 		EOC_OUTPUT_3,

  86. 		OUTPUT_4,

  87. 		ACCENT_OUTPUT_4,

  88. 		EOC_OUTPUT_4,

  89. 		NUM_OUTPUTS

  90. 	};

  91. 	enum LightIds {

  92. 		CHAIN_MODE_NONE_LIGHT,

  93. 		CHAIN_MODE_BOSS_LIGHT,

  94. 		CHAIN_MODE_EMPLOYEE_LIGHT,

  95. 		MUTED_LIGHT,

  96. 		CONSTANT_TIME_LIGHT,

  97. 		NUM_LIGHTS

  98. 	};

  99. 	enum ChainModes {

  100. 		CHAIN_MODE_NONE,

  101. 		CHAIN_MODE_BOSS,

  102. 		CHAIN_MODE_EMPLOYEE

  103. 	};

  104. 

  105. 

  106. 	bool beatMatrix[TRACK_COUNT][MAX_STEPS];

  107. 	bool accentMatrix[TRACK_COUNT][MAX_STEPS];

  108. 	int beatIndex[TRACK_COUNT];

  109. 	int stepsCount[TRACK_COUNT];

  110. 	float stepDuration[TRACK_COUNT];

  111. 	float lastStepTime[TRACK_COUNT];

  112. 	float maxStepCount;

  113. 

  114. 

  115. 	const int rulerOrders[NUM_RULERS] = {1,2,3,4,5,5,6,6,6,6};

  116. 	const int rulerLengths[NUM_RULERS] = {0,1,3,6,11,11,17,17,17,17};

  117. 	const int rulers[NUM_RULERS][MAX_DIVISIONS] = {{0},

  118. 												   {0,1},

  119. 												   {0,1,3},

  120. 												   {0,1,4,6},

  121. 												   {0,1,4,9,11},

  122. 												   {0,2,7,8,11},

  123. 												   {0,1,4,10,12,17},

  124. 												   {0,1,4,10,15,17},

  125. 												   {0,1,8,11,13,17},

  126. 												   {0,1,8,12,14,17}};

  127. 

  128. 	bool running[TRACK_COUNT];

  129. 	int chainMode = 0;

  130. 	bool initialized = false;

  131. 	bool muted = false;

  132. 	bool constantTime = false;

  133. 

  134. 	float time = 0.0;

  135. 	float duration = 0.0;

  136. 	bool secondClockReceived = false;

  137. 

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

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

  140. 

  141. 

  142. 	QuadGolombRulerRhythm() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS,NUM_LIGHTS) {

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

  144. 			beatIndex[i] = 0;

  145. 			stepsCount[i] = MAX_STEPS;

  146. 			lastStepTime[i] = 0.0;

  147. 			stepDuration[i] = 0.0;

  148. 			running[i] = true;

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

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

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

  152. 			}

  153. 		}		

  154. 	}

  155. 	void step() override;

  156. 

  157. 

  158. 	json_t *toJson() override {

  159. 		json_t *rootJ = json_object();

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

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

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

  163. 		return rootJ;

  164. 	}

  165. 

  166. 	void fromJson(json_t *rootJ) override {

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

  168. 		if (ctJ)

  169. 			constantTime = json_integer_value(ctJ);

  170. 

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

  172. 		if (cmJ)

  173. 			chainMode = json_integer_value(cmJ);

  174. 

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

  176. 		if (mutedJ)

  177. 			muted = json_integer_value(mutedJ);

  178. 	}

  179. 

  180. 	void setRunningState() {

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

  182. 		{

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

  184. 				running[trackNumber] = false;

  185. 			}

  186. 			else {

  187. 				running[trackNumber] = true;

  188. 			}

  189. 		}

  190. 	}

  191. 

  192. 	void advanceBeat(int trackNumber) {

  193. 		beatIndex[trackNumber]++;

  194. 		lastStepTime[trackNumber] = 0.0;		

  195. 					

  196. 		//End of Cycle

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

  198. 			beatIndex[trackNumber] = 0;

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

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

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

  202. 				running[trackNumber] = false;

  203. 			}

  204. 		}

  205. 	}

  206. 

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

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

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

  210. };

  211. 

  212. 

  213. 

  214. void QuadGolombRulerRhythm::step() {

  215. 

  216. 	int accentLevelArray[MAX_STEPS];

  217. 	int beatLocation[MAX_STEPS];

  218. 

  219. 	//Set startup state

  220. 	if(!initialized) {

  221. 		setRunningState();

  222. 		initialized = true;

  223. 	}

  224. 

  225. 	// Modes

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

  227. 		constantTime = !constantTime;

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

  229. 			beatIndex[trackNumber] = 0;

  230. 		}

  231. 		setRunningState();

  232. 	}

  233. 	lights[CONSTANT_TIME_LIGHT].value = constantTime;

  234. 

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

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

  237. 		setRunningState();

  238. 	}

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

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

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

  242. 

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

  244. 

  245. 

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

  247. 		//clear out the matrix and levels

  248. 		for(int j=0;j<MAX_STEPS;j++)

  249. 		{

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

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

  252. 			accentLevelArray[j] = 0;	

  253. 			beatLocation[j] = 0;

  254. 		}

  255. 

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

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

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

  259. 		}

  260. 		stepsCountf = clamp(stepsCountf,0.0f,18.0f);

  261. 

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

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

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

  265. 		}		

  266. 		divisionf = clamp(divisionf,0.0f,(float)(NUM_RULERS-1));

  267. 

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

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

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

  271. 		}	

  272. 		offsetf = clamp(offsetf,0.0f,17.0f);

  273. 

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

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

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

  277. 		}

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

  279. 

  280. 

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

  282. 		float divisionScale = 1;

  283. 		if(stepsCountf > 0) {

  284. 			divisionScale = divisionf / stepsCountf;

  285. 		}		

  286. 

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

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

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

  290. 		}

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

  292. 

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

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

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

  296. 		}

  297. 		if(divisionf > 0) {

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

  299. 		} else {

  300. 			accentRotationf = 0;

  301. 		}

  302. 

  303. 		if(stepsCountf > maxStepCount)

  304. 			maxStepCount = stepsCountf;

  305. 

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

  307. 		int division = int(divisionf);

  308. 		int offset = int(offsetf);		

  309. 		int pad = int(padf);

  310. 		int accentDivision = int(accentDivisionf);

  311. 		int accentRotation = int(accentRotationf);

  312. 

  313. 

  314. 		//Calculate Beats if there are divisions to calcuate for	

  315. 		//Ruler Lengths and orders are 0 based, which is why I add 1 here. 	

  316. 		//Yes, I could add 1 to length in the constant array, but I want that to match wikipedia definition				

  317. 		if(stepsCount[trackNumber] > 0 && division > 0) {

  318. 			int rulerToUse = division - 1;

  319. 			int actualStepCount = stepsCount[trackNumber] - pad;

  320. 			while(rulerLengths[rulerToUse] + 1 > actualStepCount && rulerToUse >= 	0) {

  321. 				rulerToUse -=1;

  322. 			} 

  323. 			

  324. 			//Multiply beats so that low division beats fill out entire pattern

  325. 			int spaceMultiplier = (actualStepCount / (rulerLengths[rulerToUse] + 1)) + 1;

  326. 			if(actualStepCount % (rulerLengths[rulerToUse] + 1) == 0) {

  327. 				spaceMultiplier -=1;

  328. 			}			

  329. 

  330. 			

  331. 

  332. 			for (int j = 0; j < rulerOrders[rulerToUse];j++)

  333. 			{

  334. 				int divisionLocation = rulers[rulerToUse][j] * spaceMultiplier;

  335. 				divisionLocation +=pad;

  336. 				if(j > 0) {

  337. 					divisionLocation -=1;

  338. 				}

  339. 				beatMatrix[trackNumber][(divisionLocation + offset) % stepsCount[trackNumber]] = true;

  340. 	            beatLocation[j] = (divisionLocation + offset) % stepsCount[trackNumber];	            

  341. 			}

  342. 

  343. 		

  344. 

  345. 	        //Calculate Accents

  346. 	        int level = 0;

  347. 	        int restsLeft = sMAX(0,rulerOrders[rulerToUse]-accentDivision); // just make sure no negatives

  348. 	        do {

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

  350. 				restsLeft = restsLeft - accentDivision;

  351. 				level += 1;

  352. 			} while (restsLeft > 0 && level < MAX_STEPS);

  353. 

  354. 			int tempIndex =0;

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

  356. 	            accentMatrix[trackNumber][beatLocation[(tempIndex + accentRotation) % rulerOrders[rulerToUse]]] = true;

  357. 	            tempIndex++;

  358. 	            for (int k = 0; k < MAX_STEPS; k++) {

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

  360. 	                    tempIndex++;

  361. 	                }

  362. 	            }

  363. 	        }	

  364.         }	

  365. 	}

  366. 

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

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

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

  370. 			{

  371. 				beatIndex[trackNumber] = 0;

  372. 			}

  373. 			setRunningState();

  374. 		}

  375. 	}

  376. 

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

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

  379. 			muted = !muted;

  380. 		}

  381. 	}

  382. 

  383. 	//See if need to start up

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

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

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

  387. 				running[trackNumber] = true;

  388. 			}

  389. 		}

  390. 	}

  391. 

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

  393. 	float timeAdvance =1.0 / engineGetSampleRate();

  394.     time += timeAdvance;

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

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

  397. 			if(secondClockReceived) {

  398. 				duration = time;

  399. 			}

  400. 			time = 0;

  401. 			secondClockReceived = true;			

  402. 

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

  404. 			{

  405. 				if(running[trackNumber]) {

  406. 					if(!constantTime) {

  407. 						advanceBeat(trackNumber);

  408. 					}					

  409. 				}

  410. 			}

  411. 		}

  412. 

  413. 		bool resyncAll = false;

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

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

  416. 			if(stepsCount[trackNumber] > 0)

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

  418. 

  419. 			if(running[trackNumber]) {

  420. 				lastStepTime[trackNumber] +=timeAdvance;

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

  422. 					advanceBeat(trackNumber);

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

  424. 						resyncAll = true;

  425. 					}

  426. 				}					

  427. 			}

  428. 		}

  429. 		if(resyncAll) {

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

  431. 				lastStepTime[trackNumber] = 0;

  432. 				beatIndex[trackNumber] = 0;

  433. 			}

  434. 		}

  435. 	}

  436. 

  437. 	// Set output to current state		

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

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

  440. 		//Send out beat

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

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

  443. 		} else {

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

  445. 		}

  446. 		//send out accent

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

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

  449. 		} else {

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

  451. 		}

  452. 		//Send out End of Cycle

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

  454. 	}

  455. 

  456. }

  457. 

  458. struct QBRBeatDisplay : TransparentWidget {

  459. 	QuadGolombRulerRhythm *module;

  460. 	int frame = 0;

  461. 	std::shared_ptr<Font> font;

  462. 

  463. 	QBRBeatDisplay() {

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

  465. 	}

  466. 

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

  468. 		

  469. 		//nvgSave(vg);

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

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

  472. 		

  473. 		float boxX = stepNumber * 22.5;

  474. 		float boxY = trackNumber * 22.5;

  475. 

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

  477. 

  478. 		if(isAccent) {

  479. 			opacity = 0xff;

  480. 		}

  481. 

  482. 

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

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

  485. 		if(isCurrent)

  486. 		{

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

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

  489. 		}

  490. 

  491. 		nvgStrokeColor(vg, strokeColor);

  492. 		nvgStrokeWidth(vg, 1.0);

  493. 		nvgBeginPath(vg);

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

  495. 		nvgStroke(vg);

  496. 		nvgClosePath(vg);

  497. 		if(isBeat) {

  498. 			nvgFillColor(vg, fillColor);

  499. 			nvgFill(vg);

  500. 		}

  501. 	}

  502. 

  503. 	void draw(NVGcontext *vg) override {

  504. 

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

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

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

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

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

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

  511. 			}

  512. 

  513. 		}

  514. 	}

  515. };

  516. 

  517. 

  518. struct QuadGolombRulerRhythmWidget : ModuleWidget {

  519. 	QuadGolombRulerRhythmWidget(QuadGolombRulerRhythm *module);

  520. };

  521. 

  522. QuadGolombRulerRhythmWidget::QuadGolombRulerRhythmWidget(QuadGolombRulerRhythm *module) : ModuleWidget(module) {

  523. 	box.size = Vec(15*29, RACK_GRID_HEIGHT);

  524. 

  525. 	{

  526. 		SVGPanel *panel = new SVGPanel();

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

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

  529. 		addChild(panel);

  530. 	}

  531. 

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

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

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

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

  536. 

  537. 

  538. 	{

  539. 		QBRBeatDisplay *display = new QBRBeatDisplay();

  540. 		display->module = module;

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

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

  543. 		addChild(display);

  544. 	}

  545. 

  546. 

  547. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(22, 138), module, QuadGolombRulerRhythm::STEPS_1_PARAM, 0.0, 18.2, 18.0));

  548. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(61, 138), module, QuadGolombRulerRhythm::DIVISIONS_1_PARAM, 0.0, 10.2, 2.0));

  549. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(100, 138), module, QuadGolombRulerRhythm::OFFSET_1_PARAM, 0.0, 17.2, 0.0));

  550. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(139, 138), module, QuadGolombRulerRhythm::PAD_1_PARAM, 0.0, 17.2, 0.0));

  551. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(178, 138), module, QuadGolombRulerRhythm::ACCENTS_1_PARAM, 0.0, 17.2, 0.0));

  552. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(217, 138), module, QuadGolombRulerRhythm::ACCENT_ROTATE_1_PARAM, 0.0, 17.2, 0.0));

  553. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(22, 195), module, QuadGolombRulerRhythm::STEPS_2_PARAM, 0.0, 18.0, 18.0));

  554. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(61, 195), module, QuadGolombRulerRhythm::DIVISIONS_2_PARAM, 0.0, 10.2, 2.0));

  555. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(100, 195), module, QuadGolombRulerRhythm::OFFSET_2_PARAM, 0.0, 17.2, 0.0));

  556. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(139, 195), module, QuadGolombRulerRhythm::PAD_2_PARAM, 0.0, 17.2, 0.0));

  557. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(178, 195), module, QuadGolombRulerRhythm::ACCENTS_2_PARAM, 0.0, 17.2, 0.0));

  558. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(217, 195), module, QuadGolombRulerRhythm::ACCENT_ROTATE_2_PARAM, 0.0, 17.2, 0.0));

  559. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(22, 252), module, QuadGolombRulerRhythm::STEPS_3_PARAM, 0.0, 18.2, 18.0));

  560. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(61, 252), module, QuadGolombRulerRhythm::DIVISIONS_3_PARAM, 0.0, 10.2, 2.0));

  561. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(100, 252), module, QuadGolombRulerRhythm::OFFSET_3_PARAM, 0.0, 17.2, 0.0));

  562. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(139, 252), module, QuadGolombRulerRhythm::PAD_3_PARAM, 0.0, 17.2, 0.0));

  563. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(178, 252), module, QuadGolombRulerRhythm::ACCENTS_3_PARAM, 0.0, 17.2, 0.0));

  564. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(217, 252), module, QuadGolombRulerRhythm::ACCENT_ROTATE_3_PARAM, 0.0, 17.2, 0.0));

  565. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(22, 309), module, QuadGolombRulerRhythm::STEPS_4_PARAM, 0.0, 18.2, 18.0));

  566. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(61, 309), module, QuadGolombRulerRhythm::DIVISIONS_4_PARAM, 0.0, 10.2, 2.0));

  567. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(100, 309), module, QuadGolombRulerRhythm::OFFSET_4_PARAM, 0.0, 17.2, 0.0));

  568. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(139, 309), module, QuadGolombRulerRhythm::PAD_4_PARAM, 0.0, 17.2, 0.0));

  569. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(178, 309), module, QuadGolombRulerRhythm::ACCENTS_4_PARAM, 0.0, 17.2, 0.0));

  570. 	addParam(ParamWidget::create<RoundSmallBlackKnob>(Vec(217, 309), module, QuadGolombRulerRhythm::ACCENT_ROTATE_4_PARAM, 0.0, 17.2, 0.0));

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

  572. 	addParam(ParamWidget::create<CKD6>(Vec(360, 285), module, QuadGolombRulerRhythm::CONSTANT_TIME_MODE_PARAM, 0.0, 1.0, 0.0));

  573. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  598. 

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

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

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

  602. 

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

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

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

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

  607. 

  608. 

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

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

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

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

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

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

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

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

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

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

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

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

  621. 	

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

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

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

  625. 

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

  627. 	addChild(ModuleLightWidget::create<SmallLight<BlueLight>>(Vec(395, 295), module, QuadGolombRulerRhythm::CONSTANT_TIME_LIGHT));

  628. }

  629. 

  630. RACK_PLUGIN_MODEL_INIT(FrozenWasteland, QuadGolombRulerRhythm) {

  631.    Model *modelQuadGolombRulerRhythm = Model::create<QuadGolombRulerRhythm, QuadGolombRulerRhythmWidget>("Frozen Wasteland", "QuadGolombRulerRhythm", "Quad Golomb Ruler Rhythm", SEQUENCER_TAG);

  632.    return modelQuadGolombRulerRhythm;

  633. }