VCVRack
/
Fundamental
mirror of https://github.com/VCVRack/Fundamental.git
1
0
Fork 0
Code Issues 0 Releases 28 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.
334 Commits
6 Branches
3.1MB
Tree: 3f64bc6c60
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '3f64bc6c60'
${ noResults }
Fundamental/src/VCO.cpp

521 lines
16KB
Raw Blame History 

  1. #include "plugin.hpp"

  2. 

  3. 

  4. using simd::float_4;

  5. 

  6. 

  7. // Accurate only on [0, 1]

  8. template <typename T>

  9. T sin2pi_pade_05_7_6(T x) {

  10. 	x -= 0.5f;

  11. 	return (T(-6.28319) * x + T(35.353) * simd::pow(x, 3) - T(44.9043) * simd::pow(x, 5) + T(16.0951) * simd::pow(x, 7))

  12. 	       / (1 + T(0.953136) * simd::pow(x, 2) + T(0.430238) * simd::pow(x, 4) + T(0.0981408) * simd::pow(x, 6));

  13. }

  14. 

  15. template <typename T>

  16. T sin2pi_pade_05_5_4(T x) {

  17. 	x -= 0.5f;

  18. 	return (T(-6.283185307) * x + T(33.19863968) * simd::pow(x, 3) - T(32.44191367) * simd::pow(x, 5))

  19. 	       / (1 + T(1.296008659) * simd::pow(x, 2) + T(0.7028072946) * simd::pow(x, 4));

  20. }

  21. 

  22. template <typename T>

  23. T expCurve(T x) {

  24. 	return (3 + x * (-13 + 5 * x)) / (3 + 2 * x);

  25. }

  26. 

  27. 

  28. template <int OVERSAMPLE, int QUALITY, typename T>

  29. struct VoltageControlledOscillator {

  30. 	bool analog = false;

  31. 	bool soft = false;

  32. 	bool syncEnabled = false;

  33. 	// For optimizing in serial code

  34. 	int channels = 0;

  35. 

  36. 	T lastSyncValue = 0.f;

  37. 	T phase = 0.f;

  38. 	T freq;

  39. 	T pulseWidth = 0.5f;

  40. 	T syncDirection = 1.f;

  41. 

  42. 	dsp::TRCFilter<T> sqrFilter;

  43. 

  44. 	dsp::MinBlepGenerator<QUALITY, OVERSAMPLE, T> sqrMinBlep;

  45. 	dsp::MinBlepGenerator<QUALITY, OVERSAMPLE, T> sawMinBlep;

  46. 	dsp::MinBlepGenerator<QUALITY, OVERSAMPLE, T> triMinBlep;

  47. 	dsp::MinBlepGenerator<QUALITY, OVERSAMPLE, T> sinMinBlep;

  48. 

  49. 	T sqrValue = 0.f;

  50. 	T sawValue = 0.f;

  51. 	T triValue = 0.f;

  52. 	T sinValue = 0.f;

  53. 

  54. 	void setPitch(T pitch) {

  55. 		freq = dsp::FREQ_C4 * dsp::approxExp2_taylor5(pitch + 30.f) / std::pow(2.f, 30.f);

  56. 	}

  57. 

  58. 	void setPulseWidth(T pulseWidth) {

  59. 		const float pwMin = 0.01f;

  60. 		this->pulseWidth = simd::clamp(pulseWidth, pwMin, 1.f - pwMin);

  61. 	}

  62. 

  63. 	void process(float deltaTime, T syncValue) {

  64. 		// Advance phase

  65. 		T deltaPhase = simd::clamp(freq * deltaTime, 1e-6f, 0.35f);

  66. 		if (soft) {

  67. 			// Reverse direction

  68. 			deltaPhase *= syncDirection;

  69. 		}

  70. 		else {

  71. 			// Reset back to forward

  72. 			syncDirection = 1.f;

  73. 		}

  74. 		phase += deltaPhase;

  75. 		// Wrap phase

  76. 		phase -= simd::floor(phase);

  77. 

  78. 		// Jump sqr when crossing 0, or 1 if backwards

  79. 		T wrapPhase = (syncDirection == -1.f) & 1.f;

  80. 		T wrapCrossing = (wrapPhase - (phase - deltaPhase)) / deltaPhase;

  81. 		int wrapMask = simd::movemask((0 < wrapCrossing) & (wrapCrossing <= 1.f));

  82. 		if (wrapMask) {

  83. 			for (int i = 0; i < channels; i++) {

  84. 				if (wrapMask & (1 << i)) {

  85. 					T mask = simd::movemaskInverse<T>(1 << i);

  86. 					float p = wrapCrossing[i] - 1.f;

  87. 					T x = mask & (2.f * syncDirection);

  88. 					sqrMinBlep.insertDiscontinuity(p, x);

  89. 				}

  90. 			}

  91. 		}

  92. 

  93. 		// Jump sqr when crossing `pulseWidth`

  94. 		T pulseCrossing = (pulseWidth - (phase - deltaPhase)) / deltaPhase;

  95. 		int pulseMask = simd::movemask((0 < pulseCrossing) & (pulseCrossing <= 1.f));

  96. 		if (pulseMask) {

  97. 			for (int i = 0; i < channels; i++) {

  98. 				if (pulseMask & (1 << i)) {

  99. 					T mask = simd::movemaskInverse<T>(1 << i);

  100. 					float p = pulseCrossing[i] - 1.f;

  101. 					T x = mask & (-2.f * syncDirection);

  102. 					sqrMinBlep.insertDiscontinuity(p, x);

  103. 				}

  104. 			}

  105. 		}

  106. 

  107. 		// Jump saw when crossing 0.5

  108. 		T halfCrossing = (0.5f - (phase - deltaPhase)) / deltaPhase;

  109. 		int halfMask = simd::movemask((0 < halfCrossing) & (halfCrossing <= 1.f));

  110. 		if (halfMask) {

  111. 			for (int i = 0; i < channels; i++) {

  112. 				if (halfMask & (1 << i)) {

  113. 					T mask = simd::movemaskInverse<T>(1 << i);

  114. 					float p = halfCrossing[i] - 1.f;

  115. 					T x = mask & (-2.f * syncDirection);

  116. 					sawMinBlep.insertDiscontinuity(p, x);

  117. 				}

  118. 			}

  119. 		}

  120. 

  121. 		// Detect sync

  122. 		// Might be NAN or outside of [0, 1) range

  123. 		if (syncEnabled) {

  124. 			T deltaSync = syncValue - lastSyncValue;

  125. 			T syncCrossing = -lastSyncValue / deltaSync;

  126. 			lastSyncValue = syncValue;

  127. 			T sync = (0.f < syncCrossing) & (syncCrossing <= 1.f) & (syncValue >= 0.f);

  128. 			int syncMask = simd::movemask(sync);

  129. 			if (syncMask) {

  130. 				if (soft) {

  131. 					syncDirection = simd::ifelse(sync, -syncDirection, syncDirection);

  132. 				}

  133. 				else {

  134. 					T newPhase = simd::ifelse(sync, (1.f - syncCrossing) * deltaPhase, phase);

  135. 					// Insert minBLEP for sync

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

  137. 						if (syncMask & (1 << i)) {

  138. 							T mask = simd::movemaskInverse<T>(1 << i);

  139. 							float p = syncCrossing[i] - 1.f;

  140. 							T x;

  141. 							x = mask & (sqr(newPhase) - sqr(phase));

  142. 							sqrMinBlep.insertDiscontinuity(p, x);

  143. 							x = mask & (saw(newPhase) - saw(phase));

  144. 							sawMinBlep.insertDiscontinuity(p, x);

  145. 							x = mask & (tri(newPhase) - tri(phase));

  146. 							triMinBlep.insertDiscontinuity(p, x);

  147. 							x = mask & (sin(newPhase) - sin(phase));

  148. 							sinMinBlep.insertDiscontinuity(p, x);

  149. 						}

  150. 					}

  151. 					phase = newPhase;

  152. 				}

  153. 			}

  154. 		}

  155. 

  156. 		// Square

  157. 		sqrValue = sqr(phase);

  158. 		sqrValue += sqrMinBlep.process();

  159. 

  160. 		if (analog) {

  161. 			sqrFilter.setCutoffFreq(20.f * deltaTime);

  162. 			sqrFilter.process(sqrValue);

  163. 			sqrValue = sqrFilter.highpass() * 0.95f;

  164. 		}

  165. 

  166. 		// Saw

  167. 		sawValue = saw(phase);

  168. 		sawValue += sawMinBlep.process();

  169. 

  170. 		// Tri

  171. 		triValue = tri(phase);

  172. 		triValue += triMinBlep.process();

  173. 

  174. 		// Sin

  175. 		sinValue = sin(phase);

  176. 		sinValue += sinMinBlep.process();

  177. 	}

  178. 

  179. 	T sin(T phase) {

  180. 		T v;

  181. 		if (analog) {

  182. 			// Quadratic approximation of sine, slightly richer harmonics

  183. 			T halfPhase = (phase < 0.5f);

  184. 			T x = phase - simd::ifelse(halfPhase, 0.25f, 0.75f);

  185. 			v = 1.f - 16.f * simd::pow(x, 2);

  186. 			v *= simd::ifelse(halfPhase, 1.f, -1.f);

  187. 		}

  188. 		else {

  189. 			v = sin2pi_pade_05_5_4(phase);

  190. 			// v = sin2pi_pade_05_7_6(phase);

  191. 			// v = simd::sin(2 * T(M_PI) * phase);

  192. 		}

  193. 		return v;

  194. 	}

  195. 	T sin() {

  196. 		return sinValue;

  197. 	}

  198. 

  199. 	T tri(T phase) {

  200. 		T v;

  201. 		if (analog) {

  202. 			T x = phase + 0.25f;

  203. 			x -= simd::trunc(x);

  204. 			T halfX = (x >= 0.5f);

  205. 			x *= 2;

  206. 			x -= simd::trunc(x);

  207. 			v = expCurve(x) * simd::ifelse(halfX, 1.f, -1.f);

  208. 		}

  209. 		else {

  210. 			v = 1 - 4 * simd::fmin(simd::fabs(phase - 0.25f), simd::fabs(phase - 1.25f));

  211. 		}

  212. 		return v;

  213. 	}

  214. 	T tri() {

  215. 		return triValue;

  216. 	}

  217. 

  218. 	T saw(T phase) {

  219. 		T v;

  220. 		T x = phase + 0.5f;

  221. 		x -= simd::trunc(x);

  222. 		if (analog) {

  223. 			v = -expCurve(x);

  224. 		}

  225. 		else {

  226. 			v = 2 * x - 1;

  227. 		}

  228. 		return v;

  229. 	}

  230. 	T saw() {

  231. 		return sawValue;

  232. 	}

  233. 

  234. 	T sqr(T phase) {

  235. 		T v = simd::ifelse(phase < pulseWidth, 1.f, -1.f);

  236. 		return v;

  237. 	}

  238. 	T sqr() {

  239. 		return sqrValue;

  240. 	}

  241. 

  242. 	T light() {

  243. 		return simd::sin(2 * T(M_PI) * phase);

  244. 	}

  245. };

  246. 

  247. 

  248. struct VCO : Module {

  249. 	enum ParamIds {

  250. 		MODE_PARAM,

  251. 		SYNC_PARAM,

  252. 		FREQ_PARAM,

  253. 		FINE_PARAM, // removed

  254. 		FM_PARAM,

  255. 		PW_PARAM,

  256. 		PWM_PARAM,

  257. 		LINEAR_PARAM,

  258. 		NUM_PARAMS

  259. 	};

  260. 	enum InputIds {

  261. 		PITCH_INPUT,

  262. 		FM_INPUT,

  263. 		SYNC_INPUT,

  264. 		PW_INPUT,

  265. 		NUM_INPUTS

  266. 	};

  267. 	enum OutputIds {

  268. 		SIN_OUTPUT,

  269. 		TRI_OUTPUT,

  270. 		SAW_OUTPUT,

  271. 		SQR_OUTPUT,

  272. 		NUM_OUTPUTS

  273. 	};

  274. 	enum LightIds {

  275. 		ENUMS(PHASE_LIGHT, 3),

  276. 		NUM_LIGHTS

  277. 	};

  278. 

  279. 	VoltageControlledOscillator<16, 16, float_4> oscillators[4];

  280. 	dsp::ClockDivider lightDivider;

  281. 

  282. 	VCO() {

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

  284. 		configSwitch(MODE_PARAM, 0.f, 1.f, 1.f, "Engine mode", {"Digital", "Analog"});

  285. 		configSwitch(SYNC_PARAM, 0.f, 1.f, 1.f, "Sync mode", {"Soft", "Hard"});

  286. 		configParam(FREQ_PARAM, -54.f, 54.f, 0.f, "Frequency", " Hz", dsp::FREQ_SEMITONE, dsp::FREQ_C4);

  287. 		configParam(FINE_PARAM, -1.f, 1.f, 0.f, "Fine frequency");

  288. 		configParam(FM_PARAM, 0.f, 1.f, 0.f, "Frequency modulation", "%", 0.f, 100.f);

  289. 		configParam(PW_PARAM, 0.01f, 0.99f, 0.5f, "Pulse width", "%", 0.f, 100.f);

  290. 		configParam(PWM_PARAM, 0.f, 1.f, 0.f, "Pulse width modulation", "%", 0.f, 100.f);

  291. 		configInput(PITCH_INPUT, "1V/octave pitch");

  292. 		configInput(FM_INPUT, "Frequency modulation");

  293. 		configInput(SYNC_INPUT, "Sync");

  294. 		configInput(PW_INPUT, "Pulse width modulation");

  295. 		configOutput(SIN_OUTPUT, "Sine");

  296. 		configOutput(TRI_OUTPUT, "Triangle");

  297. 		configOutput(SAW_OUTPUT, "Sawtooth");

  298. 		configOutput(SQR_OUTPUT, "Square");

  299. 

  300. 		lightDivider.setDivision(16);

  301. 	}

  302. 

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

  304. 		float freqParam = params[FREQ_PARAM].getValue() / 12.f;

  305. 		freqParam += dsp::quadraticBipolar(params[FINE_PARAM].getValue()) * 3.f / 12.f;

  306. 		float fmParam = dsp::quadraticBipolar(params[FM_PARAM].getValue());

  307. 

  308. 		int channels = std::max(inputs[PITCH_INPUT].getChannels(), 1);

  309. 

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

  311. 			auto* oscillator = &oscillators[c / 4];

  312. 			oscillator->channels = std::min(channels - c, 4);

  313. 			oscillator->analog = params[MODE_PARAM].getValue() > 0.f;

  314. 			oscillator->soft = params[SYNC_PARAM].getValue() <= 0.f;

  315. 

  316. 			float_4 pitch = freqParam;

  317. 			pitch += inputs[PITCH_INPUT].getVoltageSimd<float_4>(c);

  318. 			if (inputs[FM_INPUT].isConnected()) {

  319. 				pitch += fmParam * inputs[FM_INPUT].getPolyVoltageSimd<float_4>(c);

  320. 			}

  321. 			oscillator->setPitch(pitch);

  322. 			oscillator->setPulseWidth(params[PW_PARAM].getValue() + params[PWM_PARAM].getValue() * inputs[PW_INPUT].getPolyVoltageSimd<float_4>(c) / 10.f);

  323. 

  324. 			oscillator->syncEnabled = inputs[SYNC_INPUT].isConnected();

  325. 			oscillator->process(args.sampleTime, inputs[SYNC_INPUT].getPolyVoltageSimd<float_4>(c));

  326. 

  327. 			// Set output

  328. 			if (outputs[SIN_OUTPUT].isConnected())

  329. 				outputs[SIN_OUTPUT].setVoltageSimd(5.f * oscillator->sin(), c);

  330. 			if (outputs[TRI_OUTPUT].isConnected())

  331. 				outputs[TRI_OUTPUT].setVoltageSimd(5.f * oscillator->tri(), c);

  332. 			if (outputs[SAW_OUTPUT].isConnected())

  333. 				outputs[SAW_OUTPUT].setVoltageSimd(5.f * oscillator->saw(), c);

  334. 			if (outputs[SQR_OUTPUT].isConnected())

  335. 				outputs[SQR_OUTPUT].setVoltageSimd(5.f * oscillator->sqr(), c);

  336. 		}

  337. 

  338. 		outputs[SIN_OUTPUT].setChannels(channels);

  339. 		outputs[TRI_OUTPUT].setChannels(channels);

  340. 		outputs[SAW_OUTPUT].setChannels(channels);

  341. 		outputs[SQR_OUTPUT].setChannels(channels);

  342. 

  343. 		// Light

  344. 		if (lightDivider.process()) {

  345. 			if (channels == 1) {

  346. 				float lightValue = oscillators[0].light()[0];

  347. 				lights[PHASE_LIGHT + 0].setSmoothBrightness(-lightValue, args.sampleTime * lightDivider.getDivision());

  348. 				lights[PHASE_LIGHT + 1].setSmoothBrightness(lightValue, args.sampleTime * lightDivider.getDivision());

  349. 				lights[PHASE_LIGHT + 2].setBrightness(0.f);

  350. 			}

  351. 			else {

  352. 				lights[PHASE_LIGHT + 0].setBrightness(0.f);

  353. 				lights[PHASE_LIGHT + 1].setBrightness(0.f);

  354. 				lights[PHASE_LIGHT + 2].setBrightness(1.f);

  355. 			}

  356. 		}

  357. 	}

  358. };

  359. 

  360. 

  361. struct VCOWidget : ModuleWidget {

  362. 	VCOWidget(VCO* module) {

  363. 		setModule(module);

  364. 		setPanel(createPanel(asset::plugin(pluginInstance, "res/VCO.svg")));

  365. 

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

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

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

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

  370. 

  371. 		addParam(createParamCentered<RoundHugeBlackKnob>(mm2px(Vec(22.905, 29.808)), module, VCO::FREQ_PARAM));

  372. 		addParam(createParamCentered<RoundLargeBlackKnob>(mm2px(Vec(22.862, 56.388)), module, VCO::PW_PARAM));

  373. 		addParam(createParamCentered<Trimpot>(mm2px(Vec(6.607, 80.603)), module, VCO::FM_PARAM));

  374. 		addParam(createParamCentered<VCVLatch>(mm2px(Vec(17.444, 80.603)), module, VCO::LINEAR_PARAM));

  375. 		addParam(createParamCentered<VCVLatch>(mm2px(Vec(28.282, 80.603)), module, VCO::SYNC_PARAM));

  376. 		addParam(createParamCentered<Trimpot>(mm2px(Vec(39.118, 80.603)), module, VCO::PWM_PARAM));

  377. 

  378. 		addInput(createInputCentered<PJ301MPort>(mm2px(Vec(6.607, 96.859)), module, VCO::FM_INPUT));

  379. 		addInput(createInputCentered<PJ301MPort>(mm2px(Vec(17.444, 96.859)), module, VCO::PITCH_INPUT));

  380. 		addInput(createInputCentered<PJ301MPort>(mm2px(Vec(28.282, 96.859)), module, VCO::SYNC_INPUT));

  381. 		addInput(createInputCentered<PJ301MPort>(mm2px(Vec(39.15, 96.859)), module, VCO::PW_INPUT));

  382. 

  383. 		addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(6.607, 113.115)), module, VCO::SIN_OUTPUT));

  384. 		addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(17.444, 113.115)), module, VCO::TRI_OUTPUT));

  385. 		addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(28.282, 113.115)), module, VCO::SAW_OUTPUT));

  386. 		addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(39.119, 113.115)), module, VCO::SQR_OUTPUT));

  387. 

  388. 		addChild(createLightCentered<SmallLight<RedLight>>(mm2px(Vec(31.089, 16.428)), module, VCO::PHASE_LIGHT));

  389. 	}

  390. };

  391. 

  392. 

  393. Model* modelVCO = createModel<VCO, VCOWidget>("VCO");

  394. 

  395. #if 0

  396. struct VCO2 : Module {

  397. 	enum ParamIds {

  398. 		MODE_PARAM,

  399. 		SYNC_PARAM,

  400. 		FREQ_PARAM,

  401. 		WAVE_PARAM,

  402. 		FM_PARAM,

  403. 		NUM_PARAMS

  404. 	};

  405. 	enum InputIds {

  406. 		FM_INPUT,

  407. 		SYNC_INPUT,

  408. 		WAVE_INPUT,

  409. 		NUM_INPUTS

  410. 	};

  411. 	enum OutputIds {

  412. 		OUT_OUTPUT,

  413. 		NUM_OUTPUTS

  414. 	};

  415. 	enum LightIds {

  416. 		ENUMS(PHASE_LIGHT, 3),

  417. 		NUM_LIGHTS

  418. 	};

  419. 

  420. 	VoltageControlledOscillator<8, 8, float_4> oscillators[4];

  421. 	dsp::ClockDivider lightDivider;

  422. 

  423. 	VCO2() {

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

  425. 		configSwitch(MODE_PARAM, 0.f, 1.f, 1.f, "Engine mode", {"Digital", "Analog"});

  426. 		configSwitch(SYNC_PARAM, 0.f, 1.f, 1.f, "Sync mode", {"Soft", "Hard"});

  427. 		configParam(FREQ_PARAM, -54.f, 54.f, 0.f, "Frequency", " Hz", dsp::FREQ_SEMITONE, dsp::FREQ_C4);

  428. 		configParam(WAVE_PARAM, 0.f, 3.f, 1.5f, "Wave");

  429. 		configParam(FM_PARAM, 0.f, 1.f, 1.f, "Frequency modulation", "%", 0.f, 100.f);

  430. 		configInput(FM_INPUT, "Frequency modulation");

  431. 		configInput(SYNC_INPUT, "Sync");

  432. 		configInput(WAVE_INPUT, "Wave type");

  433. 		configOutput(OUT_OUTPUT, "Audio");

  434. 

  435. 		lightDivider.setDivision(16);

  436. 	}

  437. 

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

  439. 		float freqParam = params[FREQ_PARAM].getValue() / 12.f;

  440. 		float fmParam = dsp::quadraticBipolar(params[FM_PARAM].getValue());

  441. 		float waveParam = params[WAVE_PARAM].getValue();

  442. 

  443. 		int channels = std::max(inputs[FM_INPUT].getChannels(), 1);

  444. 

  445. 		for (int c = 0; c < channels; c += 4) {

  446. 			auto* oscillator = &oscillators[c / 4];

  447. 			oscillator->channels = std::min(channels - c, 4);

  448. 			oscillator->analog = (params[MODE_PARAM].getValue() > 0.f);

  449. 			oscillator->soft = (params[SYNC_PARAM].getValue() <= 0.f);

  450. 

  451. 			float_4 pitch = freqParam;

  452. 			pitch += fmParam * inputs[FM_INPUT].getVoltageSimd<float_4>(c);

  453. 			oscillator->setPitch(pitch);

  454. 

  455. 			oscillator->syncEnabled = inputs[SYNC_INPUT].isConnected();

  456. 			oscillator->process(args.sampleTime, inputs[SYNC_INPUT].getPolyVoltageSimd<float_4>(c));

  457. 

  458. 			// Outputs

  459. 			if (outputs[OUT_OUTPUT].isConnected()) {

  460. 				float_4 wave = simd::clamp(waveParam + inputs[WAVE_INPUT].getPolyVoltageSimd<float_4>(c) / 10.f * 3.f, 0.f, 3.f);

  461. 				float_4 v = 0.f;

  462. 				v += oscillator->sin() * simd::fmax(0.f, 1.f - simd::fabs(wave - 0.f));

  463. 				v += oscillator->tri() * simd::fmax(0.f, 1.f - simd::fabs(wave - 1.f));

  464. 				v += oscillator->saw() * simd::fmax(0.f, 1.f - simd::fabs(wave - 2.f));

  465. 				v += oscillator->sqr() * simd::fmax(0.f, 1.f - simd::fabs(wave - 3.f));

  466. 				outputs[OUT_OUTPUT].setVoltageSimd(5.f * v, c);

  467. 			}

  468. 		}

  469. 

  470. 		outputs[OUT_OUTPUT].setChannels(channels);

  471. 

  472. 		// Light

  473. 		if (lightDivider.process()) {

  474. 			if (channels == 1) {

  475. 				float lightValue = oscillators[0].light()[0];

  476. 				lights[PHASE_LIGHT + 0].setSmoothBrightness(-lightValue, args.sampleTime * lightDivider.getDivision());

  477. 				lights[PHASE_LIGHT + 1].setSmoothBrightness(lightValue, args.sampleTime * lightDivider.getDivision());

  478. 				lights[PHASE_LIGHT + 2].setBrightness(0.f);

  479. 			}

  480. 			else {

  481. 				lights[PHASE_LIGHT + 0].setBrightness(0.f);

  482. 				lights[PHASE_LIGHT + 1].setBrightness(0.f);

  483. 				lights[PHASE_LIGHT + 2].setBrightness(1.f);

  484. 			}

  485. 		}

  486. 	}

  487. };

  488. 

  489. 

  490. 

  491. 

  492. struct VCO2Widget : ModuleWidget {

  493. 	VCO2Widget(VCO2* module) {

  494. 		setModule(module);

  495. 		setPanel(createPanel(asset::plugin(pluginInstance, "res/WTVCO.svg")));

  496. 

  497. 		addChild(createWidget<ScrewSilver>(Vec(15, 0)));

  498. 		addChild(createWidget<ScrewSilver>(Vec(box.size.x - 30, 0)));

  499. 		addChild(createWidget<ScrewSilver>(Vec(15, 365)));

  500. 		addChild(createWidget<ScrewSilver>(Vec(box.size.x - 30, 365)));

  501. 

  502. 		addParam(createParam<CKSS>(Vec(62, 150), module, VCO2::MODE_PARAM));

  503. 		addParam(createParam<CKSS>(Vec(62, 215), module, VCO2::SYNC_PARAM));

  504. 

  505. 		addParam(createParam<RoundHugeBlackKnob>(Vec(17, 60), module, VCO2::FREQ_PARAM));

  506. 		addParam(createParam<RoundLargeBlackKnob>(Vec(12, 143), module, VCO2::WAVE_PARAM));

  507. 		addParam(createParam<RoundLargeBlackKnob>(Vec(12, 208), module, VCO2::FM_PARAM));

  508. 

  509. 		addInput(createInput<PJ301MPort>(Vec(11, 276), module, VCO2::FM_INPUT));

  510. 		addInput(createInput<PJ301MPort>(Vec(54, 276), module, VCO2::SYNC_INPUT));

  511. 		addInput(createInput<PJ301MPort>(Vec(11, 320), module, VCO2::WAVE_INPUT));

  512. 

  513. 		addOutput(createOutput<PJ301MPort>(Vec(54, 320), module, VCO2::OUT_OUTPUT));

  514. 

  515. 		addChild(createLight<SmallLight<RedGreenBlueLight>>(Vec(68, 42.5f), module, VCO2::PHASE_LIGHT));

  516. 	}

  517. };

  518. 

  519. 

  520. Model* modelVCO2 = createModel<VCO2, VCO2Widget>("VCO2");

  521. #endif