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.
1346 Commits
4 Branches
540MB
Tree: 0cf549b2f7
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0cf549b2f7'
${ noResults }
Rack/plugins/community/repos/SubmarineFree/src/PO.cpp

457 lines
16KB
Raw Blame History 

  1. #include "SubmarineFree.hpp"

  2. #include "dsp/functions.hpp"

  3. 

  4. namespace rack_plugin_SubmarineFree {

  5. 

  6. struct PO_Util {

  7. 	static constexpr float deg0   = 0.0f;

  8. 	static constexpr float deg30  =         M_PI / 6.0f;

  9. 	static constexpr float deg45  =         M_PI / 4.0f;

  10. 	static constexpr float deg60  =         M_PI / 3.0f;

  11. 	static constexpr float deg90  =         M_PI / 2.0f;

  12. 	static constexpr float deg120 = 2.0f  * M_PI / 3.0f;

  13. 	static constexpr float deg135 = 3.0f  * M_PI / 4.0f;

  14. 	static constexpr float deg150 = 5.0f  * M_PI / 6.0f;

  15. 	static constexpr float ph0 = 0.0f;

  16. 	static constexpr float ph30 = 1.0f / 12.0f;

  17. 	static constexpr float ph45 = 0.125f;

  18. 	static constexpr float ph60 = 1.0f / 6.0f;

  19. 	static constexpr float ph90 = 0.25f;

  20. 	static constexpr float ph120 = 1.0f / 3.0f;

  21. 	static constexpr float ph135 = 0.375f;

  22. 	static constexpr float ph150 = 5.0f / 12.0f;

  23. 	static constexpr float ph180 = 0.5f;

  24. 	static constexpr float ph210 = 7.0f / 12.0f;

  25. 	static constexpr float ph225 = 0.625;

  26. 	static constexpr float ph240 = 2.0f / 3.0f;

  27. 	static constexpr float ph270 = 0.75f;

  28. 	static constexpr float ph300 = 5.0f / 6.0f;

  29. 	static constexpr float ph315 = 0.875f;

  30. 	static constexpr float ph330 = 11.0f / 12.0f;

  31. 

  32. 	float sin(float phase);

  33. 	float tri(float phase);

  34. 	float saw(float phase);

  35. 	float sqr(float phase);

  36. 	float rsn(float phase);

  37. };

  38. 

  39. float PO_Util::sin(float phase) {

  40. 	return 5.0f * sinf(phase);

  41. }

  42. 

  43. float PO_Util::tri(float phase) {

  44. 	phase -= floor(phase);

  45. 	if (phase < 0.25f)

  46. 		return 20.0f * phase;

  47. 	if (phase < 0.75f)

  48. 		return 20.0f * (0.5f - phase);

  49. 	return 20.0f * (phase - 1.0f);

  50. }

  51. 

  52. float PO_Util::saw(float phase) {

  53. 	phase -= floor(phase);

  54. 	if (phase < 0.5f)

  55. 		return 10.0f * phase;

  56. 	return 10.0f * (phase - 1.0f);

  57. }

  58. 

  59. float PO_Util::sqr(float phase) {

  60. 	phase -= floor(phase);

  61. 	return (phase < 0.5f)?5.0f:-5.0f;

  62. }

  63. 

  64. float PO_Util::rsn(float phase) {

  65. 	return 10.0f * fabs(sinf(phase)) - 5.0f; 

  66. }

  67. 

  68. struct PO_101 : Module, PO_Util {

  69. 	

  70. 	enum ParamIds {

  71. 		PARAM_TUNE,

  72. 		PARAM_FINE,

  73. 		PARAM_WAVE,

  74. 		PARAM_PHASE_1,

  75. 		PARAM_PHASE_2,

  76. 		PARAM_PHASE_3,

  77. 		PARAM_PHASE_4,

  78. 		NUM_PARAMS

  79. 	};

  80. 	enum InputIds {

  81. 		INPUT_NOTE_CV,

  82. 		INPUT_PHASE_1,

  83. 		INPUT_PHASE_2,

  84. 		INPUT_PHASE_3,

  85. 		INPUT_PHASE_4,

  86. 		NUM_INPUTS

  87. 	};

  88. 	enum OutputIds {

  89. 		OUTPUT_1,

  90. 		OUTPUT_2,

  91. 		OUTPUT_3,

  92. 		OUTPUT_4,

  93. 		OUTPUT_5,

  94. 		OUTPUT_6,

  95. 		OUTPUT_7,

  96. 		OUTPUT_8,

  97. 		OUTPUT_9,

  98. 		OUTPUT_10,

  99. 		OUTPUT_11,

  100. 		OUTPUT_12,

  101. 		OUTPUT_13,

  102. 		OUTPUT_14,

  103. 		OUTPUT_15,

  104. 		OUTPUT_16,

  105. 		OUTPUT_17,

  106. 		OUTPUT_18,

  107. 		OUTPUT_19,

  108. 		OUTPUT_20,

  109. 		NUM_OUTPUTS

  110. 	};

  111. 	enum LightIds {

  112. 		NUM_LIGHTS

  113. 	};

  114. 

  115. 	PO_101() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {}

  116. 	void step() override;

  117. 	void sin(float phase);

  118. 	void tri(float phase);

  119. 	void saw(float phase);

  120. 	void sqr(float phase);

  121. 	void rsn(float phase);

  122. 	float phase = 0.0f;

  123. 	float baseFreq = 261.626f;

  124. };

  125. 

  126. void PO_101::sin(float phase) {

  127. 	phase *= (2 * M_PI);

  128. 	outputs[OUTPUT_9].value = -(outputs[OUTPUT_1].value = PO_Util::sin(phase + deg0));

  129. 	outputs[OUTPUT_10].value = -(outputs[OUTPUT_2].value = PO_Util::sin(phase + deg30)); 

  130. 	outputs[OUTPUT_11].value = -(outputs[OUTPUT_3].value = PO_Util::sin(phase + deg45)); 

  131. 	outputs[OUTPUT_12].value = -(outputs[OUTPUT_4].value = PO_Util::sin(phase + deg60)); 

  132. 	outputs[OUTPUT_13].value = -(outputs[OUTPUT_5].value = PO_Util::sin(phase + deg90)); 

  133. 	outputs[OUTPUT_14].value = -(outputs[OUTPUT_6].value = PO_Util::sin(phase + deg120)); 

  134. 	outputs[OUTPUT_15].value = -(outputs[OUTPUT_7].value = PO_Util::sin(phase + deg135)); 

  135. 	outputs[OUTPUT_16].value = -(outputs[OUTPUT_8].value = PO_Util::sin(phase + deg150)); 

  136. 	for (int i = 0; i < 4; i++) {

  137. 		if (outputs[OUTPUT_17 + i].active) {

  138. 			float offset = params[PARAM_PHASE_1 + i].value;

  139. 			if (inputs[INPUT_PHASE_1 + i].active)

  140. 				offset += inputs[INPUT_PHASE_1 + i].value * 0.4f;

  141. 			offset *= 2 * M_PI;

  142. 			outputs[OUTPUT_17 + i].value = PO_Util::sin(phase + offset);

  143. 		}	

  144. 	}

  145. }

  146. 

  147. void PO_101::tri(float phase) {

  148. 	outputs[OUTPUT_9].value = -(outputs[OUTPUT_1].value = PO_Util::tri(phase + ph0));

  149. 	outputs[OUTPUT_10].value = -(outputs[OUTPUT_2].value = PO_Util::tri(phase + ph30)); 

  150. 	outputs[OUTPUT_11].value = -(outputs[OUTPUT_3].value = PO_Util::tri(phase + ph45)); 

  151. 	outputs[OUTPUT_12].value = -(outputs[OUTPUT_4].value = PO_Util::tri(phase + ph60)); 

  152. 	outputs[OUTPUT_13].value = -(outputs[OUTPUT_5].value = PO_Util::tri(phase + ph90)); 

  153. 	outputs[OUTPUT_14].value = -(outputs[OUTPUT_6].value = PO_Util::tri(phase + ph120)); 

  154. 	outputs[OUTPUT_15].value = -(outputs[OUTPUT_7].value = PO_Util::tri(phase + ph135)); 

  155. 	outputs[OUTPUT_16].value = -(outputs[OUTPUT_8].value = PO_Util::tri(phase + ph150)); 

  156. 	for (int i = 0; i < 4; i++) {

  157. 		if (outputs[OUTPUT_17 + i].active) {

  158. 			float offset = params[PARAM_PHASE_1 + i].value;

  159. 			if (inputs[INPUT_PHASE_1 + i].active)

  160. 				offset += inputs[INPUT_PHASE_1 + i].value * 0.4f;

  161. 			outputs[OUTPUT_17 + i].value = PO_Util::tri(phase + offset);

  162. 		}	

  163. 	}

  164. }

  165. 

  166. void PO_101::saw(float phase) {

  167. 	outputs[OUTPUT_1].value = PO_Util::saw(phase + ph0);

  168. 	outputs[OUTPUT_2].value = PO_Util::saw(phase + ph30); 

  169. 	outputs[OUTPUT_3].value = PO_Util::saw(phase + ph45); 

  170. 	outputs[OUTPUT_4].value = PO_Util::saw(phase + ph60); 

  171. 	outputs[OUTPUT_5].value = PO_Util::saw(phase + ph90); 

  172. 	outputs[OUTPUT_6].value = PO_Util::saw(phase + ph120); 

  173. 	outputs[OUTPUT_7].value = PO_Util::saw(phase + ph135); 

  174. 	outputs[OUTPUT_8].value = PO_Util::saw(phase + ph150); 

  175. 	outputs[OUTPUT_9].value = PO_Util::saw(phase + ph180);

  176. 	outputs[OUTPUT_10].value = PO_Util::saw(phase + ph210); 

  177. 	outputs[OUTPUT_11].value = PO_Util::saw(phase + ph225); 

  178. 	outputs[OUTPUT_12].value = PO_Util::saw(phase + ph240); 

  179. 	outputs[OUTPUT_13].value = PO_Util::saw(phase + ph270); 

  180. 	outputs[OUTPUT_14].value = PO_Util::saw(phase + ph300); 

  181. 	outputs[OUTPUT_15].value = PO_Util::saw(phase + ph315); 

  182. 	outputs[OUTPUT_16].value = PO_Util::saw(phase + ph330); 

  183. 	for (int i = 0; i < 4; i++) {

  184. 		if (outputs[OUTPUT_17 + i].active) {

  185. 			float offset = params[PARAM_PHASE_1 + i].value;

  186. 			if (inputs[INPUT_PHASE_1 + i].active)

  187. 				offset += inputs[INPUT_PHASE_1 + i].value * 0.4f;

  188. 			outputs[OUTPUT_17 + i].value = PO_Util::saw(phase + offset);

  189. 		}	

  190. 	}

  191. }

  192. 

  193. void PO_101::sqr(float phase) {

  194. 	outputs[OUTPUT_9].value = -(outputs[OUTPUT_1].value = PO_Util::sqr(phase + ph0));

  195. 	outputs[OUTPUT_10].value = -(outputs[OUTPUT_2].value = PO_Util::sqr(phase + ph30)); 

  196. 	outputs[OUTPUT_11].value = -(outputs[OUTPUT_3].value = PO_Util::sqr(phase + ph45)); 

  197. 	outputs[OUTPUT_12].value = -(outputs[OUTPUT_4].value = PO_Util::sqr(phase + ph60)); 

  198. 	outputs[OUTPUT_13].value = -(outputs[OUTPUT_5].value = PO_Util::sqr(phase + ph90)); 

  199. 	outputs[OUTPUT_14].value = -(outputs[OUTPUT_6].value = PO_Util::sqr(phase + ph120)); 

  200. 	outputs[OUTPUT_15].value = -(outputs[OUTPUT_7].value = PO_Util::sqr(phase + ph135)); 

  201. 	outputs[OUTPUT_16].value = -(outputs[OUTPUT_8].value = PO_Util::sqr(phase + ph150)); 

  202. 	for (int i = 0; i < 4; i++) {

  203. 		if (outputs[OUTPUT_17 + i].active) {

  204. 			float offset = params[PARAM_PHASE_1 + i].value;

  205. 			if (inputs[INPUT_PHASE_1 + i].active)

  206. 				offset += inputs[INPUT_PHASE_1 + i].value * 0.4f;

  207. 			outputs[OUTPUT_17 + i].value = PO_Util::sqr(phase + offset);

  208. 		}	

  209. 	}

  210. }

  211. 	

  212. void PO_101::rsn(float phase) {

  213. 	phase *= (2 * M_PI);

  214. 	outputs[OUTPUT_9].value = (outputs[OUTPUT_1].value = PO_Util::rsn(phase + deg0));

  215. 	outputs[OUTPUT_10].value = (outputs[OUTPUT_2].value = PO_Util::rsn(phase + deg30)); 

  216. 	outputs[OUTPUT_11].value = (outputs[OUTPUT_3].value = PO_Util::rsn(phase + deg45)); 

  217. 	outputs[OUTPUT_12].value = (outputs[OUTPUT_4].value = PO_Util::rsn(phase + deg60)); 

  218. 	outputs[OUTPUT_13].value = (outputs[OUTPUT_5].value = PO_Util::rsn(phase + deg90)); 

  219. 	outputs[OUTPUT_14].value = (outputs[OUTPUT_6].value = PO_Util::rsn(phase + deg120)); 

  220. 	outputs[OUTPUT_15].value = (outputs[OUTPUT_7].value = PO_Util::rsn(phase + deg135)); 

  221. 	outputs[OUTPUT_16].value = (outputs[OUTPUT_8].value = PO_Util::rsn(phase + deg150)); 

  222. 	for (int i = 0; i < 4; i++) {

  223. 		if (outputs[OUTPUT_17 + i].active) {

  224. 			float offset = params[PARAM_PHASE_1 + i].value;

  225. 			if (inputs[INPUT_PHASE_1 + i].active)

  226. 				offset += inputs[INPUT_PHASE_1 + i].value * 0.4f;

  227. 			offset *= 2 * M_PI;

  228. 			outputs[OUTPUT_17 + i].value = PO_Util::rsn(phase + offset);

  229. 		}	

  230. 	}

  231. }

  232. 

  233. void PO_101::step() {

  234. 	float freq = baseFreq * powf(2.0f, (params[PARAM_TUNE].value + 3.0f * quadraticBipolar(params[PARAM_FINE].value)) / 12.0f + (inputs[INPUT_NOTE_CV].active?inputs[INPUT_NOTE_CV].value:0.0f));

  235. 	float deltaTime = freq / engineGetSampleRate();

  236. 	phase += deltaTime;

  237. 	double intPart;

  238. 	phase = modf(phase, &intPart); 

  239. 	

  240. 	{

  241. 		float waveShape = clamp(params[PARAM_WAVE].value, 0.0f, 4.0f);

  242. 		if (waveShape < 0.5f)

  243. 			sin(phase);

  244. 		else if (waveShape < 1.5f)

  245. 			tri(phase);

  246. 		else if (waveShape < 2.5f)

  247. 			saw(phase);

  248. 		else if (waveShape < 3.5f)

  249. 			sqr(phase);

  250. 		else

  251. 			rsn(phase);

  252. 	}

  253. 

  254. }

  255. 

  256. struct PO_204 : Module, PO_Util {

  257. 	

  258. 	enum ParamIds {

  259. 		PARAM_TUNE,

  260. 		PARAM_FINE,

  261. 		PARAM_WAVE_1,

  262. 		PARAM_WAVE_2,

  263. 		PARAM_WAVE_3,

  264. 		PARAM_WAVE_4,

  265. 		PARAM_PHASE_1,

  266. 		PARAM_PHASE_2,

  267. 		PARAM_PHASE_3,

  268. 		PARAM_PHASE_4,

  269. 		PARAM_MULT_1,

  270. 		PARAM_MULT_2,

  271. 		PARAM_MULT_3,

  272. 		PARAM_MULT_4,

  273. 		NUM_PARAMS

  274. 	};

  275. 	enum InputIds {

  276. 		INPUT_TUNE,

  277. 		INPUT_WAVE_1,

  278. 		INPUT_WAVE_2,

  279. 		INPUT_WAVE_3,

  280. 		INPUT_WAVE_4,

  281. 		INPUT_PHASE_1,

  282. 		INPUT_PHASE_2,

  283. 		INPUT_PHASE_3,

  284. 		INPUT_PHASE_4,

  285. 		NUM_INPUTS

  286. 	};

  287. 	enum OutputIds {

  288. 		OUTPUT_1,

  289. 		OUTPUT_2,

  290. 		OUTPUT_3,

  291. 		OUTPUT_4,

  292. 		NUM_OUTPUTS

  293. 	};

  294. 	enum LightIds {

  295. 		NUM_LIGHTS

  296. 	};

  297. 

  298. 	PO_204() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {}

  299. 	void step() override;

  300. 	float phase = 0.0f;

  301. 	float baseFreq = 261.626f;

  302. };

  303. 

  304. void PO_204::step() {

  305. 	float freq = baseFreq * powf(2.0f, (params[PARAM_TUNE].value + 3.0f * quadraticBipolar(params[PARAM_FINE].value)) / 12.0f + (inputs[INPUT_TUNE].active?inputs[INPUT_TUNE].value:0.0f));

  306. 	float deltaTime = freq / engineGetSampleRate();

  307. 	phase += deltaTime;

  308. 	double intPart;

  309. 	phase = modf(phase, &intPart); 

  310. 	for (int i = 0; i < 4; i++) {

  311. 		if (outputs[OUTPUT_1 + i].active) {

  312. 			float offset = phase + params[PARAM_PHASE_1 + i].value;

  313. 			if (inputs[INPUT_PHASE_1 + i].active)

  314. 				offset += inputs[INPUT_PHASE_1 + i].value * 0.4f;

  315. 			offset *= params[PARAM_MULT_1 + i].value;

  316. 			float wave = params[PARAM_WAVE_1 + i].value + (inputs[INPUT_WAVE_1 + i].active?inputs[INPUT_WAVE_1 + i].value:0.0f);

  317. 			double waveSection;

  318. 			wave = modf(clamp(wave, 0.0f, 10.0f), &waveSection);		

  319. 			float w1 = 0.0f;

  320. 			float w2 = 0.0f;

  321. 			switch ((int)waveSection) {

  322. 				case 0:

  323. 					w1 = PO_Util::sin(offset * 2 * M_PI);

  324. 					w2 = PO_Util::saw(offset);

  325. 					break;

  326. 				case 1:

  327. 					w1 = PO_Util::saw(offset);

  328. 					w2 = PO_Util::rsn(offset * 2 * M_PI);

  329. 					break;

  330. 				case 2:

  331. 					w1 = PO_Util::rsn(offset * 2 * M_PI);

  332. 					w2 = PO_Util::tri(offset);

  333. 					break;

  334. 				case 3:

  335. 					w1 = PO_Util::tri(offset);

  336. 					w2 = PO_Util::sqr(offset);

  337. 					break;

  338. 				case 4:

  339. 					w1 = PO_Util::sqr(offset);

  340. 					w2 = PO_Util::sin(offset * 2 * M_PI);

  341. 					break;

  342. 				case 5:

  343. 					w1 = PO_Util::sin(offset * 2 * M_PI);

  344. 					w2 = PO_Util::tri(offset);

  345. 					break;

  346. 				case 6:

  347. 					w1 = PO_Util::tri(offset);

  348. 					w2 = PO_Util::saw(offset);

  349. 					break;

  350. 				case 7:

  351. 					w1 = PO_Util::saw(offset);

  352. 					w2 = PO_Util::sqr(offset);

  353. 					break;

  354. 				case 8:

  355. 					w1 = PO_Util::sqr(offset);

  356. 					w2 = PO_Util::rsn(offset * 2 * M_PI);

  357. 					break;

  358. 				case 9:

  359. 					w1 = PO_Util::rsn(offset * 2 * M_PI);

  360. 					w2 = PO_Util::sin(offset * 2 * M_PI);

  361. 					break;

  362. 				default:

  363. 					w2 = w1 = PO_Util::sin(offset * 2 * M_PI);

  364. 					break;

  365. 			}

  366. 			outputs[OUTPUT_1 + i].value = w1 * (1.0f - wave) + w2 * wave;

  367. 		}	

  368. 	}

  369. }

  370. 

  371. struct PO_Layout : ModuleWidget {

  372. 	PO_Layout(PO_101 *module) : ModuleWidget(module) {}

  373. 	void Layout() {

  374. 		addParam(ParamWidget::create<sub_knob_med>(Vec(66, 39), module, PO_101::PARAM_FINE, -1.0f, +1.0f, 0.0f));

  375. 		addParam(ParamWidget::create<sub_knob_med_snap_narrow>(Vec(121, 39), module, PO_101::PARAM_WAVE, 0.0f, +4.0f, 0.0f));

  376. 

  377. 		addInput(Port::create<sub_port>(Vec(45,19), Port::INPUT, module, PO_101::INPUT_NOTE_CV));

  378. 

  379. 		addOutput(Port::create<sub_port>(Vec(77.5,100), Port::OUTPUT, module, PO_101::OUTPUT_1));

  380. 		addOutput(Port::create<sub_port>(Vec(110,109), Port::OUTPUT, module, PO_101::OUTPUT_2));

  381. 		addOutput(Port::create<sub_port>(Vec(142.5,100), Port::OUTPUT, module, PO_101::OUTPUT_3));

  382. 		addOutput(Port::create<sub_port>(Vec(133.5,132.5), Port::OUTPUT, module, PO_101::OUTPUT_4));

  383. 		addOutput(Port::create<sub_port>(Vec(142.5,165), Port::OUTPUT, module, PO_101::OUTPUT_5));

  384. 		addOutput(Port::create<sub_port>(Vec(133.5,197.5), Port::OUTPUT, module, PO_101::OUTPUT_6));

  385. 		addOutput(Port::create<sub_port>(Vec(142.5,230), Port::OUTPUT, module, PO_101::OUTPUT_7));

  386. 		addOutput(Port::create<sub_port>(Vec(110,221), Port::OUTPUT, module, PO_101::OUTPUT_8));

  387. 		addOutput(Port::create<sub_port>(Vec(77.5,230), Port::OUTPUT, module, PO_101::OUTPUT_9));

  388. 		addOutput(Port::create<sub_port>(Vec(45,221), Port::OUTPUT, module, PO_101::OUTPUT_10));

  389. 		addOutput(Port::create<sub_port>(Vec(12.5,230), Port::OUTPUT, module, PO_101::OUTPUT_11));

  390. 		addOutput(Port::create<sub_port>(Vec(21.5,197.5), Port::OUTPUT, module, PO_101::OUTPUT_12));

  391. 		addOutput(Port::create<sub_port>(Vec(12.5,165), Port::OUTPUT, module, PO_101::OUTPUT_13));

  392. 		addOutput(Port::create<sub_port>(Vec(21.5,132.5), Port::OUTPUT, module, PO_101::OUTPUT_14));

  393. 		addOutput(Port::create<sub_port>(Vec(12.5,100), Port::OUTPUT, module, PO_101::OUTPUT_15));

  394. 		addOutput(Port::create<sub_port>(Vec(45,109), Port::OUTPUT, module, PO_101::OUTPUT_16));

  395. 

  396. 		for (int i = 0; i < 4; i++) {

  397. 			addInput(Port::create<sub_port>(Vec(10 + 45 * i,260), Port::INPUT, module, PO_101::INPUT_PHASE_1 + i));

  398. 			addParam(ParamWidget::create<sub_knob_med>(Vec(3.5 + 45 * i, 290), module, PO_101::PARAM_PHASE_1 + i, -1.0f, +1.0f, 0.0f));

  399. 			addOutput(Port::create<sub_port>(Vec(10 + 45 * i,333), Port::OUTPUT, module, PO_101::OUTPUT_17 + i));

  400. 		}

  401. 	}

  402. };

  403. 

  404. struct PO101 : PO_Layout {

  405. 	PO101(PO_101 *module) : PO_Layout(module) {

  406. 		setPanel(SVG::load(assetPlugin(plugin, "res/PO-101.svg")));

  407. 		addParam(ParamWidget::create<sub_knob_med>(Vec(11, 39), module, PO_101::PARAM_TUNE, -54.0f, +54.0f, 0.0f));

  408. 		Layout();

  409. 	}

  410. };

  411. 

  412. struct PO102 : PO_Layout {

  413. 	PO102(PO_101 *module) : PO_Layout(module) {

  414. 		setPanel(SVG::load(assetPlugin(plugin, "res/PO-102.svg")));

  415. 		addParam(ParamWidget::create<sub_knob_med>(Vec(11, 39), module, PO_101::PARAM_TUNE, -96.0f, 72.0f, -12.0f));

  416. 		module->baseFreq = 1.0f;

  417. 		Layout();

  418. 	}

  419. };

  420. 

  421. struct PO204 : ModuleWidget {

  422. 	PO204(PO_204 *module) : ModuleWidget(module) {

  423. 		setPanel(SVG::load(assetPlugin(plugin, "res/PO-204.svg")));

  424. 		addParam(ParamWidget::create<sub_knob_med>(Vec(60, 19), module, PO_204::PARAM_TUNE, -54.0f, +54.0f, 0.0f));

  425. 		addParam(ParamWidget::create<sub_knob_med>(Vec(105, 19), module, PO_204::PARAM_FINE, -1.0f, +1.0f, 0.0f));

  426. 		addInput(Port::create<sub_port>(Vec(17.5, 25.5), Port::INPUT, module, PO_204::INPUT_TUNE));

  427. 

  428. 		for (int i = 0; i < 4; i++) {

  429. 			addParam(ParamWidget::create<sub_knob_small>(Vec(5, 89 + 70 * i), module, PO_204::PARAM_WAVE_1 + i, 0.0f, 10.0f, 5.0f));

  430. 			addParam(ParamWidget::create<sub_knob_small>(Vec(45, 89 + 70 * i), module, PO_204::PARAM_PHASE_1 + i, -1.0f, +1.0f, 0.0f));

  431. 			addParam(ParamWidget::create<sub_knob_small_snap>(Vec(85, 89 + 70 * i), module, PO_204::PARAM_MULT_1 + i, 1.0f, 16.0f, 1.0f));

  432. 			addInput(Port::create<sub_port>(Vec(4.5, 125 + 70 * i), Port::INPUT, module, PO_204::INPUT_WAVE_1 + i));

  433. 			addInput(Port::create<sub_port>(Vec(44.5, 125 + 70 * i), Port::INPUT, module, PO_204::INPUT_PHASE_1 + i));

  434. 			addOutput(Port::create<sub_port>(Vec(120.5, 125 + 70 * i), Port::OUTPUT, module, PO_204::OUTPUT_1 + i));

  435. 		}

  436. 	}

  437. };

  438. 

  439. } // namespace rack_plugin_SubmarineFree

  440. 

  441. using namespace rack_plugin_SubmarineFree;

  442. 

  443. RACK_PLUGIN_MODEL_INIT(SubmarineFree, PO101) {

  444.    Model *modelPO101 = Model::create<PO_101, PO101>("SubmarineFree", "PO-101", "PO-101 Phased VCO", OSCILLATOR_TAG, MULTIPLE_TAG, DIGITAL_TAG);

  445.    return modelPO101;

  446. }

  447. 

  448. RACK_PLUGIN_MODEL_INIT(SubmarineFree, PO102) {

  449.    Model *modelPO102 = Model::create<PO_101, PO102>("SubmarineFree", "PO-102", "PO-102 Phased LFO", OSCILLATOR_TAG, MULTIPLE_TAG, DIGITAL_TAG);

  450.    return modelPO102;

  451. }

  452. 

  453. RACK_PLUGIN_MODEL_INIT(SubmarineFree, PO204) {

  454.    Model *modelPO204 = Model::create<PO_204, PO204>("SubmarineFree", "PO-204", "PO-204 Phase Modulation Engine", OSCILLATOR_TAG, QUAD_TAG, DIGITAL_TAG);

  455.    return modelPO204;

  456. }