VCVRack
/
AudibleInstruments
mirror of https://github.com/VCVRack/AudibleInstruments.git
1
0
Fork 0
Code Issues 0 Releases 8 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.
193 Commits
4 Branches
8.5MB
Tree: cb2bc9d779
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'cb2bc9d779'
${ noResults }
AudibleInstruments/src/Marbles.cpp

776 lines
26KB
Raw Blame History 

  1. #include "plugin.hpp"

  2. #include "marbles/random/random_generator.h"

  3. #include "marbles/random/random_stream.h"

  4. #include "marbles/random/t_generator.h"

  5. #include "marbles/random/x_y_generator.h"

  6. #include "marbles/note_filter.h"

  7. 

  8. 

  9. static const int BLOCK_SIZE = 5;

  10. 

  11. 

  12. static const marbles::Scale preset_scales[6] = {

  13. 	// C major

  14. 	{

  15. 		1.0f,

  16. 		12,

  17. 		{

  18. 			{ 0.0000f, 255 },  // C

  19. 			{ 0.0833f, 16 },   // C#

  20. 			{ 0.1667f, 96 },   // D

  21. 			{ 0.2500f, 24 },   // D#

  22. 			{ 0.3333f, 128 },  // E

  23. 			{ 0.4167f, 64 },   // F

  24. 			{ 0.5000f, 8 },    // F#

  25. 			{ 0.5833f, 192 },  // G

  26. 			{ 0.6667f, 16 },   // G#

  27. 			{ 0.7500f, 96 },   // A

  28. 			{ 0.8333f, 24 },   // A#

  29. 			{ 0.9167f, 128 },  // B

  30. 		}

  31. 	},

  32. 

  33. 	// C minor

  34. 	{

  35. 		1.0f,

  36. 		12,

  37. 		{

  38. 			{ 0.0000f, 255 },  // C

  39. 			{ 0.0833f, 16 },   // C#

  40. 			{ 0.1667f, 96 },   // D

  41. 			{ 0.2500f, 128 },  // Eb

  42. 			{ 0.3333f, 8 },    // E

  43. 			{ 0.4167f, 64 },   // F

  44. 			{ 0.5000f, 4 },    // F#

  45. 			{ 0.5833f, 192 },  // G

  46. 			{ 0.6667f, 16 },   // G#

  47. 			{ 0.7500f, 96 },   // A

  48. 			{ 0.8333f, 128 },  // Bb

  49. 			{ 0.9167f, 16 },   // B

  50. 		}

  51. 	},

  52. 

  53. 	// Pentatonic

  54. 	{

  55. 		1.0f,

  56. 		12,

  57. 		{

  58. 			{ 0.0000f, 255 },  // C

  59. 			{ 0.0833f, 4 },    // C#

  60. 			{ 0.1667f, 96 },   // D

  61. 			{ 0.2500f, 4 },    // Eb

  62. 			{ 0.3333f, 4 },    // E

  63. 			{ 0.4167f, 140 },  // F

  64. 			{ 0.5000f, 4 },    // F#

  65. 			{ 0.5833f, 192 },  // G

  66. 			{ 0.6667f, 4 },    // G#

  67. 			{ 0.7500f, 96 },   // A

  68. 			{ 0.8333f, 4 },    // Bb

  69. 			{ 0.9167f, 4 },    // B

  70. 		}

  71. 	},

  72. 

  73. 	// Pelog

  74. 	{

  75. 		1.0f,

  76. 		7,

  77. 		{

  78. 			{ 0.0000f, 255 },  // C

  79. 			{ 0.1275f, 128 },  // Db+

  80. 			{ 0.2625f, 32 },  // Eb-

  81. 			{ 0.4600f, 8 },    // F#-

  82. 			{ 0.5883f, 192 },  // G

  83. 			{ 0.7067f, 64 },  // Ab

  84. 			{ 0.8817f, 16 },    // Bb+

  85. 		}

  86. 	},

  87. 

  88. 	// Raag Bhairav That

  89. 	{

  90. 		1.0f,

  91. 		12,

  92. 		{

  93. 			{ 0.0000f, 255 }, // ** Sa

  94. 			{ 0.0752f, 128 }, // ** Komal Re

  95. 			{ 0.1699f, 4 },   //    Re

  96. 			{ 0.2630f, 4 },   //    Komal Ga

  97. 			{ 0.3219f, 128 }, // ** Ga

  98. 			{ 0.4150f, 64 },  // ** Ma

  99. 			{ 0.4918f, 4 },   //    Tivre Ma

  100. 			{ 0.5850f, 192 }, // ** Pa

  101. 			{ 0.6601f, 64 },  // ** Komal Dha

  102. 			{ 0.7549f, 4 },   //    Dha

  103. 			{ 0.8479f, 4 },   //    Komal Ni

  104. 			{ 0.9069f, 64 },  // ** Ni

  105. 		}

  106. 	},

  107. 

  108. 	// Raag Shri

  109. 	{

  110. 		1.0f,

  111. 		12,

  112. 		{

  113. 			{ 0.0000f, 255 }, // ** Sa

  114. 			{ 0.0752f, 4 },   //    Komal Re

  115. 			{ 0.1699f, 128 }, // ** Re

  116. 			{ 0.2630f, 64 },  // ** Komal Ga

  117. 			{ 0.3219f, 4 },   //    Ga

  118. 			{ 0.4150f, 128 }, // ** Ma

  119. 			{ 0.4918f, 4 },   //    Tivre Ma

  120. 			{ 0.5850f, 192 }, // ** Pa

  121. 			{ 0.6601f, 4 },   //    Komal Dha

  122. 			{ 0.7549f, 64 },  // ** Dha

  123. 			{ 0.8479f, 128 }, // ** Komal Ni

  124. 			{ 0.9069f, 4 },   //    Ni

  125. 		}

  126. 	},

  127. };

  128. 

  129. static const marbles::Ratio y_divider_ratios[] = {

  130. 	{ 1, 64 },

  131. 	{ 1, 48 },

  132. 	{ 1, 32 },

  133. 	{ 1, 24 },

  134. 	{ 1, 16 },

  135. 	{ 1, 12 },

  136. 	{ 1, 8 },

  137. 	{ 1, 6 },

  138. 	{ 1, 4 },

  139. 	{ 1, 3 },

  140. 	{ 1, 2 },

  141. 	{ 1, 1 },

  142. };

  143. 

  144. struct Marbles : Module {

  145. 	enum ParamIds {

  146. 		T_DEJA_VU_PARAM,

  147. 		X_DEJA_VU_PARAM,

  148. 		DEJA_VU_PARAM,

  149. 		T_RATE_PARAM,

  150. 		X_SPREAD_PARAM,

  151. 		T_MODE_PARAM,

  152. 		X_MODE_PARAM,

  153. 		DEJA_VU_LENGTH_PARAM,

  154. 		T_BIAS_PARAM,

  155. 		X_BIAS_PARAM,

  156. 		T_RANGE_PARAM,

  157. 		X_RANGE_PARAM,

  158. 		EXTERNAL_PARAM,

  159. 		T_JITTER_PARAM,

  160. 		X_STEPS_PARAM,

  161. 		Y_RATE_PARAM,

  162. 		Y_SPREAD_PARAM,

  163. 		Y_BIAS_PARAM,

  164. 		Y_STEPS_PARAM,

  165. 		GATE_BIAS_PARAM,

  166. 		GATE_JITTER_PARAM,

  167. 		NUM_PARAMS

  168. 	};

  169. 	enum InputIds {

  170. 		T_BIAS_INPUT,

  171. 		X_BIAS_INPUT,

  172. 		T_CLOCK_INPUT,

  173. 		T_RATE_INPUT,

  174. 		T_JITTER_INPUT,

  175. 		DEJA_VU_INPUT,

  176. 		X_STEPS_INPUT,

  177. 		X_SPREAD_INPUT,

  178. 		X_CLOCK_INPUT,

  179. 		NUM_INPUTS

  180. 	};

  181. 	enum OutputIds {

  182. 		T1_OUTPUT,

  183. 		T2_OUTPUT,

  184. 		T3_OUTPUT,

  185. 		Y_OUTPUT,

  186. 		X1_OUTPUT,

  187. 		X2_OUTPUT,

  188. 		X3_OUTPUT,

  189. 		NUM_OUTPUTS

  190. 	};

  191. 	enum LightIds {

  192. 		T_DEJA_VU_LIGHT,

  193. 		X_DEJA_VU_LIGHT,

  194. 		ENUMS(T_MODE_LIGHTS, 2),

  195. 		ENUMS(X_MODE_LIGHTS, 2),

  196. 		ENUMS(T_RANGE_LIGHTS, 2),

  197. 		ENUMS(X_RANGE_LIGHTS, 2),

  198. 		EXTERNAL_LIGHT,

  199. 		T1_LIGHT,

  200. 		T2_LIGHT,

  201. 		T3_LIGHT,

  202. 		Y_LIGHT,

  203. 		X1_LIGHT,

  204. 		X2_LIGHT,

  205. 		X3_LIGHT,

  206. 		NUM_LIGHTS

  207. 	};

  208. 

  209. 	marbles::RandomGenerator random_generator;

  210. 	marbles::RandomStream random_stream;

  211. 	marbles::TGenerator t_generator;

  212. 	marbles::XYGenerator xy_generator;

  213. 	marbles::NoteFilter note_filter;

  214. 

  215. 	// State

  216. 	dsp::BooleanTrigger tDejaVuTrigger;

  217. 	dsp::BooleanTrigger xDejaVuTrigger;

  218. 	dsp::BooleanTrigger tModeTrigger;

  219. 	dsp::BooleanTrigger xModeTrigger;

  220. 	dsp::BooleanTrigger tRangeTrigger;

  221. 	dsp::BooleanTrigger xRangeTrigger;

  222. 	dsp::BooleanTrigger externalTrigger;

  223. 	bool t_deja_vu;

  224. 	bool x_deja_vu;

  225. 	int t_mode;

  226. 	int x_mode;

  227. 	int t_range;

  228. 	int x_range;

  229. 	bool external;

  230. 	int x_scale;

  231. 	int y_divider_index;

  232. 	int x_clock_source_internal;

  233. 	int edit_mode;

  234. 

  235. 	// Buffers

  236. 	stmlib::GateFlags t_clocks[BLOCK_SIZE] = {};

  237. 	stmlib::GateFlags last_t_clock = 0;

  238. 	stmlib::GateFlags xy_clocks[BLOCK_SIZE] = {};

  239. 	stmlib::GateFlags last_xy_clock = 0;

  240. 	float ramp_master[BLOCK_SIZE] = {};

  241. 	float ramp_external[BLOCK_SIZE] = {};

  242. 	float ramp_slave[2][BLOCK_SIZE] = {};

  243. 	bool gates[BLOCK_SIZE * 2] = {};

  244. 	float voltages[BLOCK_SIZE * 4] = {};

  245. 	int blockIndex = 0;

  246. 

  247. 	Marbles() {

  248. 		config(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS);

  249. 		configParam(T_DEJA_VU_PARAM, 0.0, 1.0, 0.0, "t deja vu");

  250. 		configParam(X_DEJA_VU_PARAM, 0.0, 1.0, 0.0, "X deja vu");

  251. 		configParam(DEJA_VU_PARAM, 0.0, 1.0, 0.5, "Deja vu probability");

  252. 		configParam(T_RATE_PARAM, -1.0, 1.0, 0.0, "Clock rate");

  253. 		configParam(X_SPREAD_PARAM, 0.0, 1.0, 0.5, "Probability distribution");

  254. 		configParam(T_MODE_PARAM, 0.0, 1.0, 0.0, "t mode");

  255. 		configParam(X_MODE_PARAM, 0.0, 1.0, 0.0, "X mode");

  256. 		configParam(DEJA_VU_LENGTH_PARAM, 0.0, 1.0, 0.0, "Loop length");

  257. 		configParam(T_BIAS_PARAM, 0.0, 1.0, 0.5, "Gate bias");

  258. 		configParam(X_BIAS_PARAM, 0.0, 1.0, 0.5, "Distribution bias");

  259. 		configParam(T_RANGE_PARAM, 0.0, 1.0, 0.0, "Clock range mode");

  260. 		configParam(X_RANGE_PARAM, 0.0, 1.0, 0.0, "Output voltage range mode");

  261. 		configParam(EXTERNAL_PARAM, 0.0, 1.0, 0.0, "External processing mode");

  262. 		configParam(T_JITTER_PARAM, 0.0, 1.0, 0.0, "Randomness amount");

  263. 		configParam(X_STEPS_PARAM, 0.0, 1.0, 0.5, "Smoothness");

  264. 

  265. 		configParam(Y_RATE_PARAM, 0.0, 1.0, 4.5 / LENGTHOF(y_divider_ratios), "Clock divide");

  266. 		configParam(Y_SPREAD_PARAM, 0.0, 1.0, 0.5, "Probability distribution");

  267. 		configParam(Y_BIAS_PARAM, 0.0, 1.0, 0.5, "Voltage offset");

  268. 		configParam(Y_STEPS_PARAM, 0.0, 1.0, 0.0, "Smoothness");

  269. 

  270. 		configParam(GATE_BIAS_PARAM, 0.0, 1.0, 0.5, "Gate length");

  271. 		configParam(GATE_JITTER_PARAM, 0.0, 1.0, 0.0, "Gate length randomness");

  272. 

  273. 		random_generator.Init(1);

  274. 		random_stream.Init(&random_generator);

  275. 		note_filter.Init();

  276. 		onSampleRateChange();

  277. 		onReset();

  278. 	}

  279. 

  280. 	void onReset() override {

  281. 		t_deja_vu = false;

  282. 		x_deja_vu = false;

  283. 		t_mode = 0;

  284. 		x_mode = 0;

  285. 		t_range = 1;

  286. 		x_range = 1;

  287. 		external = false;

  288. 		x_scale = 0;

  289. 		y_divider_index = 4;

  290. 		x_clock_source_internal = 0;

  291. 		edit_mode = 0;

  292. 	}

  293. 

  294. 	void onRandomize() override {

  295. 		t_mode = random::u32() % 3;

  296. 		x_mode = random::u32() % 3;

  297. 		t_range = random::u32() % 3;

  298. 		x_range = random::u32() % 3;

  299. 	}

  300. 

  301. 	void onSampleRateChange() override {

  302. 		float sampleRate = APP->engine->getSampleRate();

  303. 		t_generator.Init(&random_stream, sampleRate);

  304. 		xy_generator.Init(&random_stream, sampleRate);

  305. 

  306. 		// Set scales

  307. 		for (int i = 0; i < 6; i++) {

  308. 			xy_generator.LoadScale(i, preset_scales[i]);

  309. 		}

  310. 	}

  311. 

  312. 	json_t* dataToJson() override {

  313. 		json_t* rootJ = json_object();

  314. 

  315. 		json_object_set_new(rootJ, "t_deja_vu", json_boolean(t_deja_vu));

  316. 		json_object_set_new(rootJ, "x_deja_vu", json_boolean(x_deja_vu));

  317. 		json_object_set_new(rootJ, "t_mode", json_integer(t_mode));

  318. 		json_object_set_new(rootJ, "x_mode", json_integer(x_mode));

  319. 		json_object_set_new(rootJ, "t_range", json_integer(t_range));

  320. 		json_object_set_new(rootJ, "x_range", json_integer(x_range));

  321. 		json_object_set_new(rootJ, "external", json_boolean(external));

  322. 		json_object_set_new(rootJ, "x_scale", json_integer(x_scale));

  323. 		json_object_set_new(rootJ, "y_divider_index", json_integer(y_divider_index));

  324. 		json_object_set_new(rootJ, "x_clock_source_internal", json_integer(x_clock_source_internal));

  325. 		json_object_set_new(rootJ, "edit_mode", json_integer(edit_mode));

  326. 

  327. 		return rootJ;

  328. 	}

  329. 

  330. 	void dataFromJson(json_t* rootJ) override {

  331. 		json_t* t_deja_vuJ = json_object_get(rootJ, "t_deja_vu");

  332. 		if (t_deja_vuJ)

  333. 			t_deja_vu = json_boolean_value(t_deja_vuJ);

  334. 

  335. 		json_t* x_deja_vuJ = json_object_get(rootJ, "x_deja_vu");

  336. 		if (x_deja_vuJ)

  337. 			x_deja_vu = json_boolean_value(x_deja_vuJ);

  338. 

  339. 		json_t* t_modeJ = json_object_get(rootJ, "t_mode");

  340. 		if (t_modeJ)

  341. 			t_mode = json_integer_value(t_modeJ);

  342. 

  343. 		json_t* x_modeJ = json_object_get(rootJ, "x_mode");

  344. 		if (x_modeJ)

  345. 			x_mode = json_integer_value(x_modeJ);

  346. 

  347. 		json_t* t_rangeJ = json_object_get(rootJ, "t_range");

  348. 		if (t_rangeJ)

  349. 			t_range = json_integer_value(t_rangeJ);

  350. 

  351. 		json_t* x_rangeJ = json_object_get(rootJ, "x_range");

  352. 		if (x_rangeJ)

  353. 			x_range = json_integer_value(x_rangeJ);

  354. 

  355. 		json_t* externalJ = json_object_get(rootJ, "external");

  356. 		if (externalJ)

  357. 			external = json_boolean_value(externalJ);

  358. 

  359. 		json_t* x_scaleJ = json_object_get(rootJ, "x_scale");

  360. 		if (x_scaleJ)

  361. 			x_scale = json_integer_value(x_scaleJ);

  362. 

  363. 		json_t* y_divider_indexJ = json_object_get(rootJ, "y_divider_index");

  364. 		if (y_divider_indexJ)

  365. 			y_divider_index = json_integer_value(y_divider_indexJ);

  366. 

  367. 		json_t* x_clock_source_internalJ = json_object_get(rootJ, "x_clock_source_internal");

  368. 		if (x_clock_source_internalJ)

  369. 			x_clock_source_internal = json_integer_value(x_clock_source_internalJ);

  370. 

  371. 		json_t* edit_modeJ = json_object_get(rootJ, "edit_mode");

  372. 		if (edit_modeJ)

  373. 			edit_mode = json_boolean_value(edit_modeJ);

  374. 	}

  375. 

  376. 	void process(const ProcessArgs& args) override {

  377. 		// Buttons

  378. 		if (tDejaVuTrigger.process(params[T_DEJA_VU_PARAM].getValue() <= 0.f)) {

  379. 			t_deja_vu = !t_deja_vu;

  380. 		}

  381. 		if (xDejaVuTrigger.process(params[X_DEJA_VU_PARAM].getValue() <= 0.f)) {

  382. 			x_deja_vu = !x_deja_vu;

  383. 		}

  384. 		if (tModeTrigger.process(params[T_MODE_PARAM].getValue() <= 0.f)) {

  385. 			t_mode = (t_mode + 1) % 3;

  386. 		}

  387. 		if (xModeTrigger.process(params[X_MODE_PARAM].getValue() <= 0.f)) {

  388. 			x_mode = (x_mode + 1) % 3;

  389. 		}

  390. 		if (tRangeTrigger.process(params[T_RANGE_PARAM].getValue() <= 0.f)) {

  391. 			t_range = (t_range + 1) % 3;

  392. 		}

  393. 		if (xRangeTrigger.process(params[X_RANGE_PARAM].getValue() <= 0.f)) {

  394. 			x_range = (x_range + 1) % 3;

  395. 		}

  396. 		if (externalTrigger.process(params[EXTERNAL_PARAM].getValue() <= 0.f)) {

  397. 			external = !external;

  398. 		}

  399. 

  400. 		// Clocks

  401. 		bool t_gate = (inputs[T_CLOCK_INPUT].getVoltage() >= 1.7f);

  402. 		last_t_clock = stmlib::ExtractGateFlags(last_t_clock, t_gate);

  403. 		t_clocks[blockIndex] = last_t_clock;

  404. 

  405. 		bool x_gate = (inputs[X_CLOCK_INPUT].getVoltage() >= 1.7f);

  406. 		last_xy_clock = stmlib::ExtractGateFlags(last_xy_clock, x_gate);

  407. 		xy_clocks[blockIndex] = last_xy_clock;

  408. 

  409. 		// Process block

  410. 		if (++blockIndex >= BLOCK_SIZE) {

  411. 			blockIndex = 0;

  412. 			stepBlock();

  413. 		}

  414. 

  415. 		// Lights and outputs

  416. 

  417. 		lights[T_DEJA_VU_LIGHT].setBrightness(t_deja_vu);

  418. 		lights[X_DEJA_VU_LIGHT].setBrightness(x_deja_vu);

  419. 

  420. 		lights[T_MODE_LIGHTS + 0].setBrightness(t_mode == 0 || t_mode == 1);

  421. 		lights[T_MODE_LIGHTS + 1].setBrightness(t_mode == 1 || t_mode == 2);

  422. 

  423. 		lights[X_MODE_LIGHTS + 0].setBrightness(x_mode == 0 || x_mode == 1);

  424. 		lights[X_MODE_LIGHTS + 1].setBrightness(x_mode == 1 || x_mode == 2);

  425. 

  426. 		lights[T_RANGE_LIGHTS + 0].setBrightness(t_range == 0 || t_range == 1);

  427. 		lights[T_RANGE_LIGHTS + 1].setBrightness(t_range == 1 || t_range == 2);

  428. 

  429. 		lights[X_RANGE_LIGHTS + 0].setBrightness(x_range == 0 || x_range == 1);

  430. 		lights[X_RANGE_LIGHTS + 1].setBrightness(x_range == 1 || x_range == 2);

  431. 

  432. 		lights[EXTERNAL_LIGHT].setBrightness(external);

  433. 

  434. 		outputs[T1_OUTPUT].setVoltage(gates[blockIndex * 2 + 0] ? 10.f : 0.f);

  435. 		lights[T1_LIGHT].setSmoothBrightness(gates[blockIndex * 2 + 0], args.sampleTime);

  436. 		outputs[T2_OUTPUT].setVoltage((ramp_master[blockIndex] < 0.5f) ? 10.f : 0.f);

  437. 		lights[T2_LIGHT].setSmoothBrightness(ramp_master[blockIndex] < 0.5f, args.sampleTime);

  438. 		outputs[T3_OUTPUT].setVoltage(gates[blockIndex * 2 + 1] ? 10.f : 0.f);

  439. 		lights[T3_LIGHT].setSmoothBrightness(gates[blockIndex * 2 + 1], args.sampleTime);

  440. 

  441. 		outputs[X1_OUTPUT].setVoltage(voltages[blockIndex * 4 + 0]);

  442. 		lights[X1_LIGHT].setSmoothBrightness(voltages[blockIndex * 4 + 0], args.sampleTime);

  443. 		outputs[X2_OUTPUT].setVoltage(voltages[blockIndex * 4 + 1]);

  444. 		lights[X2_LIGHT].setSmoothBrightness(voltages[blockIndex * 4 + 1], args.sampleTime);

  445. 		outputs[X3_OUTPUT].setVoltage(voltages[blockIndex * 4 + 2]);

  446. 		lights[X3_LIGHT].setSmoothBrightness(voltages[blockIndex * 4 + 2], args.sampleTime);

  447. 		outputs[Y_OUTPUT].setVoltage(voltages[blockIndex * 4 + 3]);

  448. 		lights[Y_LIGHT].setSmoothBrightness(voltages[blockIndex * 4 + 3], args.sampleTime);

  449. 	}

  450. 

  451. 	void stepBlock() {

  452. 		// Ramps

  453. 

  454. 		marbles::Ramps ramps;

  455. 		ramps.master = ramp_master;

  456. 		ramps.external = ramp_external;

  457. 		ramps.slave[0] = ramp_slave[0];

  458. 		ramps.slave[1] = ramp_slave[1];

  459. 

  460. 		float deja_vu = clamp(params[DEJA_VU_PARAM].getValue() + inputs[DEJA_VU_INPUT].getVoltage() / 5.f, 0.f, 1.f);

  461. 		static const int loop_length[] = {

  462. 			1, 1, 1, 2, 2,

  463. 			2, 2, 2, 3, 3,

  464. 			3, 3, 4, 4, 4,

  465. 			4, 4, 5, 5, 6,

  466. 			6, 6, 7, 7, 8,

  467. 			8, 8, 10, 10, 12,

  468. 			12, 12, 14, 14, 16,

  469. 			16

  470. 		};

  471. 		float deja_vu_length_index = params[DEJA_VU_LENGTH_PARAM].getValue() * (LENGTHOF(loop_length) - 1);

  472. 		int deja_vu_length = loop_length[(int) roundf(deja_vu_length_index)];

  473. 

  474. 		// Set up TGenerator

  475. 

  476. 		bool t_external_clock = inputs[T_CLOCK_INPUT].isConnected();

  477. 

  478. 		t_generator.set_model((marbles::TGeneratorModel) t_mode);

  479. 		t_generator.set_range((marbles::TGeneratorRange) t_range);

  480. 		float t_rate = 60.f * (params[T_RATE_PARAM].getValue() + inputs[T_RATE_INPUT].getVoltage() / 5.f);

  481. 		t_generator.set_rate(t_rate);

  482. 		float t_bias = clamp(params[T_BIAS_PARAM].getValue() + inputs[T_BIAS_INPUT].getVoltage() / 5.f, 0.f, 1.f);

  483. 		t_generator.set_bias(t_bias);

  484. 		float t_jitter = clamp(params[T_JITTER_PARAM].getValue() + inputs[T_JITTER_INPUT].getVoltage() / 5.f, 0.f, 1.f);

  485. 		t_generator.set_jitter(t_jitter);

  486. 		t_generator.set_deja_vu(t_deja_vu ? deja_vu : 0.f);

  487. 		t_generator.set_length(deja_vu_length);

  488. 		t_generator.set_pulse_width_mean(params[GATE_BIAS_PARAM].getValue());

  489. 		t_generator.set_pulse_width_std(params[GATE_JITTER_PARAM].getValue());

  490. 

  491. 		t_generator.Process(t_external_clock, t_clocks, ramps, gates, BLOCK_SIZE);

  492. 

  493. 		// Set up XYGenerator

  494. 

  495. 		marbles::ClockSource x_clock_source = (marbles::ClockSource) x_clock_source_internal;

  496. 		if (inputs[X_CLOCK_INPUT].isConnected())

  497. 			x_clock_source = marbles::CLOCK_SOURCE_EXTERNAL;

  498. 

  499. 		marbles::GroupSettings x;

  500. 		x.control_mode = (marbles::ControlMode) x_mode;

  501. 		x.voltage_range = (marbles::VoltageRange) x_range;

  502. 		// TODO Fix the scaling

  503. 		float note_cv = 0.5f * (params[X_SPREAD_PARAM].getValue() + inputs[X_SPREAD_INPUT].getVoltage() / 5.f);

  504. 		float u = note_filter.Process(0.5f * (note_cv + 1.f));

  505. 		x.register_mode = external;

  506. 		x.register_value = u;

  507. 

  508. 		float x_spread = clamp(params[X_SPREAD_PARAM].getValue() + inputs[X_SPREAD_INPUT].getVoltage() / 5.f, 0.f, 1.f);

  509. 		x.spread = x_spread;

  510. 		float x_bias = clamp(params[X_BIAS_PARAM].getValue() + inputs[X_BIAS_INPUT].getVoltage() / 5.f, 0.f, 1.f);

  511. 		x.bias = x_bias;

  512. 		float x_steps = clamp(params[X_STEPS_PARAM].getValue() + inputs[X_STEPS_INPUT].getVoltage() / 5.f, 0.f, 1.f);

  513. 		x.steps = x_steps;

  514. 		x.deja_vu = x_deja_vu ? deja_vu : 0.f;

  515. 		x.length = deja_vu_length;

  516. 		x.ratio.p = 1;

  517. 		x.ratio.q = 1;

  518. 		x.scale_index = x_scale;

  519. 

  520. 		marbles::GroupSettings y;

  521. 		y.control_mode = marbles::CONTROL_MODE_IDENTICAL;

  522. 		y.voltage_range = marbles::VOLTAGE_RANGE_FULL;

  523. 		y.register_mode = false;

  524. 		y.register_value = 0.0f;

  525. 		y.spread = params[Y_SPREAD_PARAM].getValue();

  526. 		y.bias = params[Y_BIAS_PARAM].getValue();

  527. 		y.steps = params[Y_STEPS_PARAM].getValue();

  528. 		y.deja_vu = 0.0f;

  529. 		y.length = 1;

  530. 

  531. 		uint index = (uint) (params[Y_RATE_PARAM].getValue() * LENGTHOF(y_divider_ratios));

  532. 		if (index < LENGTHOF(y_divider_ratios))

  533. 			y_divider_index = index;

  534. 		y.ratio = y_divider_ratios[y_divider_index];

  535. 		y.scale_index = x_scale;

  536. 

  537. 		xy_generator.Process(x_clock_source, x, y, xy_clocks, ramps, voltages, BLOCK_SIZE);

  538. 	}

  539. };

  540. 

  541. 

  542. template <typename BASE>

  543. struct CKD6Light : BASE {

  544. 	CKD6Light() {

  545. 		this->box.size = Vec(22, 22);

  546. 	}

  547. };

  548. 

  549. 

  550. struct MarblesWidget : ModuleWidget {

  551. 	ParamWidget* yRateParam;

  552. 	ParamWidget* ySpreadParam;

  553. 	ParamWidget* yBiasParam;

  554. 	ParamWidget* yStepsParam;

  555. 

  556. 	ParamWidget* gateBiasParam;

  557. 	ParamWidget* gateJitterParam;

  558. 

  559. 	MarblesWidget(Marbles* module) {

  560. 		setModule(module);

  561. 		setPanel(APP->window->loadSvg(asset::plugin(pluginInstance, "res/Marbles.svg")));

  562. 

  563. 		addChild(createWidget<ScrewSilver>(Vec(RACK_GRID_WIDTH, 0)));

  564. 		addChild(createWidget<ScrewSilver>(Vec(box.size.x - 2 * RACK_GRID_WIDTH, 0)));

  565. 		addChild(createWidget<ScrewSilver>(Vec(RACK_GRID_WIDTH, RACK_GRID_HEIGHT - RACK_GRID_WIDTH)));

  566. 		addChild(createWidget<ScrewSilver>(Vec(box.size.x - 2 * RACK_GRID_WIDTH, RACK_GRID_HEIGHT - RACK_GRID_WIDTH)));

  567. 

  568. 		addParam(createParamCentered<CKD6>(mm2px(Vec(16.545, 17.794)), module, Marbles::T_DEJA_VU_PARAM));

  569. 		addParam(createParamCentered<CKD6>(mm2px(Vec(74.845, 17.794)), module, Marbles::X_DEJA_VU_PARAM));

  570. 		addParam(createParamCentered<Rogan2PSWhite>(mm2px(Vec(45.695, 22.244)), module, Marbles::DEJA_VU_PARAM));

  571. 		addParam(createParamCentered<Rogan3PSWhite>(mm2px(Vec(23.467, 35.264)), module, Marbles::T_RATE_PARAM));

  572. 		addParam(createParamCentered<Rogan3PSWhite>(mm2px(Vec(67.945, 35.243)), module, Marbles::X_SPREAD_PARAM));

  573. 		addParam(createParamCentered<TL1105>(mm2px(Vec(6.945, 38.794)), module, Marbles::T_MODE_PARAM));

  574. 		addParam(createParamCentered<TL1105>(mm2px(Vec(84.445, 38.793)), module, Marbles::X_MODE_PARAM));

  575. 		addParam(createParamCentered<Rogan2PSWhite>(mm2px(Vec(45.695, 51.144)), module, Marbles::DEJA_VU_LENGTH_PARAM));

  576. 		addParam(createParamCentered<Rogan2PSWhite>(mm2px(Vec(9.545, 58.394)), module, Marbles::T_BIAS_PARAM));

  577. 		addParam(createParamCentered<Rogan2PSWhite>(mm2px(Vec(81.844, 58.394)), module, Marbles::X_BIAS_PARAM));

  578. 		addParam(createParamCentered<TL1105>(mm2px(Vec(26.644, 59.694)), module, Marbles::T_RANGE_PARAM));

  579. 		addParam(createParamCentered<TL1105>(mm2px(Vec(64.744, 59.694)), module, Marbles::X_RANGE_PARAM));

  580. 		addParam(createParamCentered<TL1105>(mm2px(Vec(45.694, 67.294)), module, Marbles::EXTERNAL_PARAM));

  581. 		addParam(createParamCentered<Rogan2PSWhite>(mm2px(Vec(31.544, 73.694)), module, Marbles::T_JITTER_PARAM));

  582. 		addParam(createParamCentered<Rogan2PSWhite>(mm2px(Vec(59.845, 73.694)), module, Marbles::X_STEPS_PARAM));

  583. 

  584. 		// Knobs for Y generator edit mode

  585. 		yRateParam = createParamCentered<Rogan3PSGreen>(mm2px(Vec(23.467, 35.264)), module, Marbles::Y_RATE_PARAM);

  586. 		addParam(yRateParam);

  587. 		ySpreadParam = createParamCentered<Rogan3PSGreen>(mm2px(Vec(67.945, 35.243)), module, Marbles::Y_SPREAD_PARAM);

  588. 		addParam(ySpreadParam);

  589. 		yBiasParam = createParamCentered<Rogan2PSGreen>(mm2px(Vec(81.844, 58.394)), module, Marbles::Y_BIAS_PARAM);

  590. 		addParam(yBiasParam);

  591. 		yStepsParam = createParamCentered<Rogan2PSGreen>(mm2px(Vec(59.845, 73.694)), module, Marbles::Y_STEPS_PARAM);

  592. 		addParam(yStepsParam);

  593. 

  594. 		// Make colored knobs not visible in module browser

  595. 		yRateParam->visible = false;

  596. 		ySpreadParam->visible = false;

  597. 		yBiasParam->visible = false;

  598. 		yStepsParam->visible = false;

  599. 

  600. 		// Knobs for gate edit mode

  601. 		gateBiasParam = createParamCentered<Rogan2PSRed>(mm2px(Vec(9.545, 58.394)), module, Marbles::GATE_BIAS_PARAM);

  602. 		addParam(gateBiasParam);

  603. 		gateJitterParam = createParamCentered<Rogan2PSRed>(mm2px(Vec(31.544, 73.694)), module, Marbles::GATE_JITTER_PARAM);

  604. 		addParam(gateJitterParam);

  605. 

  606. 		// Make colored knobs not visible in module browser

  607. 		gateBiasParam->visible = false;

  608. 		gateJitterParam->visible = false;

  609. 

  610. 		addInput(createInputCentered<PJ301MPort>(mm2px(Vec(9.545, 81.944)), module, Marbles::T_BIAS_INPUT));

  611. 		addInput(createInputCentered<PJ301MPort>(mm2px(Vec(81.844, 81.944)), module, Marbles::X_BIAS_INPUT));

  612. 		addInput(createInputCentered<PJ301MPort>(mm2px(Vec(9.545, 96.544)), module, Marbles::T_CLOCK_INPUT));

  613. 		addInput(createInputCentered<PJ301MPort>(mm2px(Vec(21.595, 96.544)), module, Marbles::T_RATE_INPUT));

  614. 		addInput(createInputCentered<PJ301MPort>(mm2px(Vec(33.644, 96.544)), module, Marbles::T_JITTER_INPUT));

  615. 		addInput(createInputCentered<PJ301MPort>(mm2px(Vec(45.695, 96.544)), module, Marbles::DEJA_VU_INPUT));

  616. 		addInput(createInputCentered<PJ301MPort>(mm2px(Vec(57.745, 96.544)), module, Marbles::X_STEPS_INPUT));

  617. 		addInput(createInputCentered<PJ301MPort>(mm2px(Vec(69.795, 96.544)), module, Marbles::X_SPREAD_INPUT));

  618. 		addInput(createInputCentered<PJ301MPort>(mm2px(Vec(81.844, 96.544)), module, Marbles::X_CLOCK_INPUT));

  619. 

  620. 		addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(9.545, 111.144)), module, Marbles::T1_OUTPUT));

  621. 		addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(21.595, 111.144)), module, Marbles::T2_OUTPUT));

  622. 		addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(33.644, 111.144)), module, Marbles::T3_OUTPUT));

  623. 		addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(45.695, 111.144)), module, Marbles::Y_OUTPUT));

  624. 		addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(57.745, 111.144)), module, Marbles::X1_OUTPUT));

  625. 		addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(69.795, 111.144)), module, Marbles::X2_OUTPUT));

  626. 		addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(81.844, 111.144)), module, Marbles::X3_OUTPUT));

  627. 

  628. 		addChild(createLightCentered<CKD6Light<GreenLight>>(mm2px(Vec(16.545, 17.794)), module, Marbles::T_DEJA_VU_LIGHT));

  629. 		addChild(createLightCentered<CKD6Light<GreenLight>>(mm2px(Vec(74.845, 17.794)), module, Marbles::X_DEJA_VU_LIGHT));

  630. 		addChild(createLightCentered<MediumLight<GreenRedLight>>(mm2px(Vec(6.944, 29.894)), module, Marbles::T_MODE_LIGHTS));

  631. 		addChild(createLightCentered<MediumLight<GreenRedLight>>(mm2px(Vec(84.444, 29.894)), module, Marbles::X_MODE_LIGHTS));

  632. 		addChild(createLightCentered<MediumLight<GreenRedLight>>(mm2px(Vec(26.644, 53.994)), module, Marbles::T_RANGE_LIGHTS));

  633. 		addChild(createLightCentered<MediumLight<GreenRedLight>>(mm2px(Vec(64.744, 53.994)), module, Marbles::X_RANGE_LIGHTS));

  634. 		addChild(createLightCentered<MediumLight<GreenLight>>(mm2px(Vec(45.695, 76.194)), module, Marbles::EXTERNAL_LIGHT));

  635. 		addChild(createLightCentered<MediumLight<GreenLight>>(mm2px(Vec(6.044, 104.794)), module, Marbles::T1_LIGHT));

  636. 		addChild(createLightCentered<MediumLight<GreenLight>>(mm2px(Vec(18.094, 104.794)), module, Marbles::T2_LIGHT));

  637. 		addChild(createLightCentered<MediumLight<GreenLight>>(mm2px(Vec(30.145, 104.794)), module, Marbles::T3_LIGHT));

  638. 		addChild(createLightCentered<MediumLight<GreenLight>>(mm2px(Vec(42.194, 104.794)), module, Marbles::Y_LIGHT));

  639. 		addChild(createLightCentered<MediumLight<GreenLight>>(mm2px(Vec(54.244, 104.794)), module, Marbles::X1_LIGHT));

  640. 		addChild(createLightCentered<MediumLight<GreenLight>>(mm2px(Vec(66.294, 104.794)), module, Marbles::X2_LIGHT));

  641. 		addChild(createLightCentered<MediumLight<GreenLight>>(mm2px(Vec(78.344, 104.794)), module, Marbles::X3_LIGHT));

  642. 	}

  643. 

  644. 	void step() override {

  645. 		Marbles *module = dynamic_cast<Marbles *>(this->module);

  646. 

  647. 		if (module) {

  648. 			yRateParam->visible = (module->edit_mode == 1);

  649. 			ySpreadParam->visible = (module->edit_mode == 1);

  650. 			yBiasParam->visible = (module->edit_mode == 1);

  651. 			yStepsParam->visible = (module->edit_mode == 1);

  652. 

  653. 			gateBiasParam->visible = (module->edit_mode == 2);

  654. 			gateJitterParam->visible = (module->edit_mode == 2);

  655. 		}

  656. 

  657. 		ModuleWidget::step();

  658. 	}

  659. 

  660. 	void appendContextMenu(Menu* menu) override {

  661. 		Marbles* module = dynamic_cast<Marbles*>(this->module);

  662. 

  663. 		struct ScaleItem : MenuItem {

  664. 			Marbles* module;

  665. 			int scale;

  666. 			void onAction(const event::Action& e) override {

  667. 				module->x_scale = scale;

  668. 			}

  669. 		};

  670. 

  671. 		menu->addChild(new MenuSeparator);

  672. 		menu->addChild(createMenuLabel("Scales"));

  673. 		const std::string scaleLabels[] = {

  674. 			"Major",

  675. 			"Minor",

  676. 			"Pentatonic",

  677. 			"Pelog",

  678. 			"Raag Bhairav That",

  679. 			"Raag Shri",

  680. 		};

  681. 		for (int i = 0; i < (int) LENGTHOF(scaleLabels); i++) {

  682. 			ScaleItem* item = createMenuItem<ScaleItem>(scaleLabels[i], CHECKMARK(module->x_scale == i));

  683. 			item->module = module;

  684. 			item->scale = i;

  685. 			menu->addChild(item);

  686. 		}

  687. 

  688. 		struct XClockSourceInternal : MenuItem {

  689. 			Marbles* module;

  690. 			int source;

  691. 			void onAction(const event::Action& e) override {

  692. 				module->x_clock_source_internal = source;

  693. 			}

  694. 		};

  695. 

  696. 		menu->addChild(new MenuSeparator);

  697. 		menu->addChild(createMenuLabel("Internal X clock source"));

  698. 		const std::string sourceLabels[] = {

  699. 			"T₁ → X₁, T₂ → X₂, T₃ → X₃",

  700. 			"T₁ → X₁, X₂, X₃",

  701. 			"T₂ → X₁, X₂, X₃",

  702. 			"T₃ → X₁, X₂, X₃",

  703. 		};

  704. 		for (int i = 0; i < (int) LENGTHOF(sourceLabels); i++) {

  705. 			XClockSourceInternal* item = createMenuItem<XClockSourceInternal>(sourceLabels[i], CHECKMARK(module->x_clock_source_internal == i));

  706. 			item->module = module;

  707. 			item->source = i;

  708. 			menu->addChild(item);

  709. 		}

  710. 

  711. 		struct YDividerIndexItem : MenuItem {

  712. 			Marbles* module;

  713. 			int index;

  714. 			void onAction(const event::Action& e) override {

  715. 				module->y_divider_index = index;

  716. 				module->params[module->Y_RATE_PARAM].setValue(index / LENGTHOF(y_divider_ratios));

  717. 			}

  718. 		};

  719. 

  720. 		struct YDividerItem : MenuItem {

  721. 			Marbles* module;

  722. 			Menu* createChildMenu() override {

  723. 				Menu* menu = new Menu();

  724. 				const std::string yDividerRatioLabels[] = {

  725. 					"1/64",

  726. 					"1/48",

  727. 					"1/32",

  728. 					"1/24",

  729. 					"1/16",

  730. 					"1/12",

  731. 					"1/8",

  732. 					"1/6",

  733. 					"1/4",

  734. 					"1/3",

  735. 					"1/2",

  736. 					"1",

  737. 				};

  738. 				for (int i = 0; i < (int) LENGTHOF(yDividerRatioLabels); i++) {

  739. 					YDividerIndexItem* item = createMenuItem<YDividerIndexItem>(yDividerRatioLabels[i], CHECKMARK(module->y_divider_index == i));

  740. 					item->module = module;

  741. 					item->index = i;

  742. 					menu->addChild(item);

  743. 				}

  744. 				return menu;

  745. 			}

  746. 		};

  747. 

  748. 		menu->addChild(new MenuSeparator);

  749. 		YDividerItem* yDividerItem = createMenuItem<YDividerItem>("Y divider ratio");

  750. 		yDividerItem->module = module;

  751. 		menu->addChild(yDividerItem);

  752. 

  753. 		struct MarblesEditModeItem : MenuItem {

  754. 			Marbles *module;

  755. 			int editMode;

  756. 			void onAction(const event::Action& e) override {

  757. 				module->edit_mode = editMode;

  758. 			}

  759. 			void step() override {

  760. 				rightText = (module->edit_mode == editMode) ? "✔" : "";

  761. 				MenuItem::step();

  762. 			}

  763. 		};

  764. 

  765. 		menu->addChild(new MenuSeparator);

  766. 		menu->addChild(construct<MenuLabel>(&MenuLabel::text, "Edit Mode"));

  767. 

  768. 		menu->addChild(construct<MarblesEditModeItem>(&MenuItem::text, "Default", &MarblesEditModeItem::module, module, &MarblesEditModeItem::editMode, 0));

  769. 		menu->addChild(construct<MarblesEditModeItem>(&MenuItem::text, "Y generator", &MarblesEditModeItem::module, module, &MarblesEditModeItem::editMode, 1));

  770. 		menu->addChild(construct<MarblesEditModeItem>(&MenuItem::text, "Gate", &MarblesEditModeItem::module, module, &MarblesEditModeItem::editMode, 2));

  771. 	}

  772. };

  773. 

  774. 

  775. Model* modelMarbles = createModel<Marbles, MarblesWidget>("Marbles");