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.
1248 Commits
4 Branches
544MB
Tree: 54ed9c8aa2
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '54ed9c8aa2'
${ noResults }
Rack/plugins/community/repos/SubmarineFree/src/PO12.cpp

510 lines
19KB
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. 	if (outputs[OUTPUT_1].active || outputs[OUTPUT_9].active)

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

  130. 	if (outputs[OUTPUT_2].active || outputs[OUTPUT_10].active)

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

  132. 	if (outputs[OUTPUT_3].active || outputs[OUTPUT_11].active)

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

  134. 	if (outputs[OUTPUT_4].active || outputs[OUTPUT_12].active)

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

  136. 	if (outputs[OUTPUT_5].active || outputs[OUTPUT_13].active)

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

  138. 	if (outputs[OUTPUT_6].active || outputs[OUTPUT_14].active)

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

  140. 	if (outputs[OUTPUT_7].active || outputs[OUTPUT_15].active)

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

  142. 	if (outputs[OUTPUT_8].active || outputs[OUTPUT_16].active)

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

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

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

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

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

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

  149. 			offset *= 2 * M_PI;

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

  151. 		}	

  152. 	}

  153. }

  154. 

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

  156. 	if (outputs[OUTPUT_1].active || outputs[OUTPUT_9].active)

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

  158. 	if (outputs[OUTPUT_2].active || outputs[OUTPUT_10].active)

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

  160. 	if (outputs[OUTPUT_3].active || outputs[OUTPUT_11].active)

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

  162. 	if (outputs[OUTPUT_4].active || outputs[OUTPUT_12].active)

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

  164. 	if (outputs[OUTPUT_5].active || outputs[OUTPUT_13].active)

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

  166. 	if (outputs[OUTPUT_6].active || outputs[OUTPUT_14].active)

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

  168. 	if (outputs[OUTPUT_7].active || outputs[OUTPUT_15].active)

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

  170. 	if (outputs[OUTPUT_8].active || outputs[OUTPUT_16].active)

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

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

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

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

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

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

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

  178. 		}	

  179. 	}

  180. }

  181. 

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

  183. 	if (outputs[OUTPUT_1].active)

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

  185. 	if (outputs[OUTPUT_2].active)

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

  187. 	if (outputs[OUTPUT_3].active)

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

  189. 	if (outputs[OUTPUT_4].active)

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

  191. 	if (outputs[OUTPUT_5].active)

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

  193. 	if (outputs[OUTPUT_6].active)

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

  195. 	if (outputs[OUTPUT_7].active)

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

  197. 	if (outputs[OUTPUT_8].active)

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

  199. 	if (outputs[OUTPUT_9].active)

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

  201. 	if (outputs[OUTPUT_10].active)

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

  203. 	if (outputs[OUTPUT_11].active)

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

  205. 	if (outputs[OUTPUT_12].active)

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

  207. 	if (outputs[OUTPUT_13].active)

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

  209. 	if (outputs[OUTPUT_14].active)

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

  211. 	if (outputs[OUTPUT_15].active)

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

  213. 	if (outputs[OUTPUT_16].active)

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

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

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

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

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

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

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

  221. 		}	

  222. 	}

  223. }

  224. 

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

  226. 	if (outputs[OUTPUT_1].active || outputs[OUTPUT_9].active)

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

  228. 	if (outputs[OUTPUT_2].active || outputs[OUTPUT_10].active)

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

  230. 	if (outputs[OUTPUT_3].active || outputs[OUTPUT_11].active)

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

  232. 	if (outputs[OUTPUT_4].active || outputs[OUTPUT_12].active)

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

  234. 	if (outputs[OUTPUT_5].active || outputs[OUTPUT_13].active)

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

  236. 	if (outputs[OUTPUT_6].active || outputs[OUTPUT_14].active)

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

  238. 	if (outputs[OUTPUT_7].active || outputs[OUTPUT_15].active)

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

  240. 	if (outputs[OUTPUT_8].active || outputs[OUTPUT_16].active)

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

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

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

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

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

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

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

  248. 		}	

  249. 	}

  250. }

  251. 	

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

  253. 	phase *= (2 * M_PI);

  254. 	if (outputs[OUTPUT_1].active || outputs[OUTPUT_9].active)

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

  256. 	if (outputs[OUTPUT_2].active || outputs[OUTPUT_10].active)

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

  258. 	if (outputs[OUTPUT_3].active || outputs[OUTPUT_11].active)

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

  260. 	if (outputs[OUTPUT_4].active || outputs[OUTPUT_12].active)

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

  262. 	if (outputs[OUTPUT_5].active || outputs[OUTPUT_13].active)

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

  264. 	if (outputs[OUTPUT_6].active || outputs[OUTPUT_14].active)

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

  266. 	if (outputs[OUTPUT_7].active || outputs[OUTPUT_15].active)

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

  268. 	if (outputs[OUTPUT_8].active || outputs[OUTPUT_16].active)

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

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

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

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

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

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

  275. 			offset *= 2 * M_PI;

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

  277. 		}	

  278. 	}

  279. }

  280. 

  281. void PO_101::step() {

  282. 	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));

  283. 	float deltaTime = freq / engineGetSampleRate();

  284. 	phase += deltaTime;

  285. 	double intPart;

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

  287. 	

  288. 	{

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

  290. 		if (waveShape < 0.5f)

  291. 			sin(phase);

  292. 		else if (waveShape < 1.5f)

  293. 			tri(phase);

  294. 		else if (waveShape < 2.5f)

  295. 			saw(phase);

  296. 		else if (waveShape < 3.5f)

  297. 			sqr(phase);

  298. 		else

  299. 			rsn(phase);

  300. 	}

  301. 

  302. }

  303. 

  304. struct PO_204 : Module, PO_Util {

  305. 	

  306. 	enum ParamIds {

  307. 		PARAM_TUNE,

  308. 		PARAM_FINE,

  309. 		PARAM_WAVE_1,

  310. 		PARAM_WAVE_2,

  311. 		PARAM_WAVE_3,

  312. 		PARAM_WAVE_4,

  313. 		PARAM_PHASE_1,

  314. 		PARAM_PHASE_2,

  315. 		PARAM_PHASE_3,

  316. 		PARAM_PHASE_4,

  317. 		PARAM_MULT_1,

  318. 		PARAM_MULT_2,

  319. 		PARAM_MULT_3,

  320. 		PARAM_MULT_4,

  321. 		NUM_PARAMS

  322. 	};

  323. 	enum InputIds {

  324. 		INPUT_TUNE,

  325. 		INPUT_WAVE_1,

  326. 		INPUT_WAVE_2,

  327. 		INPUT_WAVE_3,

  328. 		INPUT_WAVE_4,

  329. 		INPUT_PHASE_1,

  330. 		INPUT_PHASE_2,

  331. 		INPUT_PHASE_3,

  332. 		INPUT_PHASE_4,

  333. 		INPUT_MULT_1,

  334. 		INPUT_MULT_2,

  335. 		INPUT_MULT_3,

  336. 		INPUT_MULT_4,

  337. 		NUM_INPUTS

  338. 	};

  339. 	enum OutputIds {

  340. 		OUTPUT_1,

  341. 		OUTPUT_2,

  342. 		OUTPUT_3,

  343. 		OUTPUT_4,

  344. 		NUM_OUTPUTS

  345. 	};

  346. 	enum LightIds {

  347. 		NUM_LIGHTS

  348. 	};

  349. 

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

  351. 	void step() override;

  352. 	float phase = 0.0f;

  353. 	float baseFreq = 261.626f;

  354. };

  355. 

  356. void PO_204::step() {

  357. 	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));

  358. 	float deltaTime = freq / engineGetSampleRate();

  359. 	phase += deltaTime;

  360. 	double intPart;

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

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

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

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

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

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

  367. 			offset *= floor(clamp(params[PARAM_MULT_1 + i].value + (inputs[INPUT_MULT_1 + i].active?inputs[INPUT_MULT_1 + i].value:0.0f) * 16.0f / 10.0f, 1.0f, 16.5f));

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

  369. 			double waveSection;

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

  371. 			float w1 = 0.0f;

  372. 			float w2 = 0.0f;

  373. 			switch ((int)waveSection) {

  374. 				case 0:

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

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

  377. 					break;

  378. 				case 1:

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

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

  381. 					break;

  382. 				case 2:

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

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

  385. 					break;

  386. 				case 3:

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

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

  389. 					break;

  390. 				case 4:

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

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

  393. 					break;

  394. 				case 5:

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

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

  397. 					break;

  398. 				case 6:

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

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

  401. 					break;

  402. 				case 7:

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

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

  405. 					break;

  406. 				case 8:

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

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

  409. 					break;

  410. 				case 9:

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

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

  413. 					break;

  414. 				default:

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

  416. 					break;

  417. 			}

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

  419. 		}	

  420. 	}

  421. }

  422. 

  423. struct PO_Layout : ModuleWidget {

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

  425. 	void Layout() {

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

  427. 		addParam(ParamWidget::create<NarrowKnob<SnapKnob<MedKnob<LightKnob>>>>(Vec(121, 39), module, PO_101::PARAM_WAVE, 0.0f, +4.0f, 0.0f));

  428. 

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

  430. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  447. 

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

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

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

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

  452. 		}

  453. 	}

  454. };

  455. 

  456. struct PO101 : PO_Layout {

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

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

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

  460. 		Layout();

  461. 	}

  462. };

  463. 

  464. struct PO102 : PO_Layout {

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

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

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

  468. 		module->baseFreq = 1.0f;

  469. 		Layout();

  470. 	}

  471. };

  472. 

  473. struct PO204 : ModuleWidget {

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

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

  476. 		addParam(ParamWidget::create<MedKnob<LightKnob>>(Vec(60, 19), module, PO_204::PARAM_TUNE, -90.0f, +54.0f, 0.0f));

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

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

  479. 

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

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

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

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

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

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

  486. 			addInput(Port::create<SilverPort>(Vec(84.5, 125 + 70 * i), Port::INPUT, module, PO_204::INPUT_MULT_1 + i));

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

  488. 		}

  489. 	}

  490. };

  491. 

  492. } // namespace rack_plugin_SubmarineFree

  493. 

  494. using namespace rack_plugin_SubmarineFree;

  495. 

  496. RACK_PLUGIN_MODEL_INIT(SubmarineFree, PO101) {

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

  498.    return modelPO101;

  499. }

  500. 

  501. RACK_PLUGIN_MODEL_INIT(SubmarineFree, PO102) {

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

  503.    return modelPO102;

  504. }

  505. 

  506. RACK_PLUGIN_MODEL_INIT(SubmarineFree, PO204) {

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

  508.    return modelPO204;

  509. }