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.
193 Commits
6 Branches
3.1MB
Tree: abb87f0ec4
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'abb87f0ec4'
${ noResults }
Fundamental/src/VCO.cpp

450 lines
14KB
Raw Blame History 

  1. #include "plugin.hpp"

  2. 

  3. 

  4. using simd::float_4;

  5. 

  6. 

  7. BINARY(src_sawTable_bin);

  8. BINARY(src_triTable_bin);

  9. 

  10. 

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

  12. template <typename T>

  13. T sin2pi_pade_05_7_6(T x) {

  14. 	x -= 0.5f;

  15. 	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))

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

  17. }

  18. 

  19. template <typename T>

  20. T sin2pi_pade_05_5_4(T x) {

  21. 	x -= 0.5f;

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

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

  24. }

  25. 

  26. 

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

  28. struct VoltageControlledOscillator {

  29. 	bool analog = false;

  30. 	bool soft = false;

  31. 	T lastSyncValue = 0.f;

  32. 	T phase = 0.f;

  33. 	T freq;

  34. 	T pw = 0.5f;

  35. 	bool syncEnabled = false;

  36. 	T syncDirection = T::zero();

  37. 

  38. 	dsp::Decimator<OVERSAMPLE, QUALITY, T> sinDecimator;

  39. 	dsp::Decimator<OVERSAMPLE, QUALITY, T> triDecimator;

  40. 	dsp::Decimator<OVERSAMPLE, QUALITY, T> sawDecimator;

  41. 	dsp::Decimator<OVERSAMPLE, QUALITY, T> sqrDecimator;

  42. 	dsp::TRCFilter<T> sqrFilter;

  43. 

  44. 	// For analog detuning effect

  45. 	T pitchSlew = 0.f;

  46. 	int pitchSlewIndex = 0;

  47. 

  48. 	T sinBuffer[OVERSAMPLE];

  49. 	T triBuffer[OVERSAMPLE];

  50. 	T sawBuffer[OVERSAMPLE];

  51. 	T sqrBuffer[OVERSAMPLE];

  52. 

  53. 	void setPitch(T pitchKnob, T pitchCv) {

  54. 		// Compute frequency

  55. 		T pitch = pitchKnob + pitchCv;

  56. 		if (analog) {

  57. 			// Apply pitch slew

  58. 			const float pitchSlewAmount = 3.f;

  59. 			pitch += pitchSlew * pitchSlewAmount;

  60. 		}

  61. 		freq = dsp::FREQ_C4 * simd::pow(2.f, pitch / 12.f);

  62. 	}

  63. 	void setPulseWidth(T pulseWidth) {

  64. 		const float pwMin = 0.01f;

  65. 		pw = simd::clamp(pulseWidth, pwMin, 1.f - pwMin);

  66. 	}

  67. 

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

  69. 		if (analog) {

  70. 			// Adjust pitch slew

  71. 			if (++pitchSlewIndex > 32) {

  72. 				const float pitchSlewTau = 100.f; // Time constant for leaky integrator in seconds

  73. 				T r;

  74. 				for (int i = 0; i < T::size; i++) {

  75. 					r.s[i] = random::uniform();

  76. 				}

  77. 				pitchSlew += ((2.f * r - 1.f) - pitchSlew / pitchSlewTau) * deltaTime;

  78. 				pitchSlewIndex = 0;

  79. 			}

  80. 		}

  81. 

  82. 		// Advance phase

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

  84. 		if (!soft) {

  85. 			syncDirection = T::zero();

  86. 		}

  87. 

  88. 		// Detect sync

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

  90. 		T syncCrossing = lastSyncValue / (lastSyncValue - syncValue);

  91. 		lastSyncValue = syncValue;

  92. 

  93. 

  94. 		for (int i = 0; i < OVERSAMPLE; i++) {

  95. 			// Reset if synced in this time interval

  96. 			T reset = (T(i) / OVERSAMPLE <= syncCrossing) & (syncCrossing < T(i + 1) / OVERSAMPLE);

  97. 			if (simd::movemask(reset)) {

  98. 				if (soft) {

  99. 					syncDirection = simd::ifelse(reset, ~syncDirection, syncDirection);

  100. 				}

  101. 				else {

  102. 					phase = simd::ifelse(reset, (syncCrossing - T(i) / OVERSAMPLE) * deltaPhase, phase);

  103. 					// This also works as a good approximation.

  104. 					// phase = 0.f;

  105. 				}

  106. 			}

  107. 

  108. 			// Sin

  109. 			if (analog) {

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

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

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

  113. 				sinBuffer[i] = 1.f - 16.f * simd::pow(x, 2);

  114. 				sinBuffer[i] *= simd::ifelse(halfPhase, 1.f, -1.f);

  115. 				// sinBuffer[i] *= 1.08f;

  116. 			}

  117. 			else {

  118. 				sinBuffer[i] = sin2pi_pade_05_5_4(phase);

  119. 				// sinBuffer[i] = sin2pi_pade_05_7_6(phase);

  120. 				// sinBuffer[i] = simd::sin(2 * T(M_PI) * phase);

  121. 			}

  122. 

  123. 			// Tri

  124. 			if (analog) {

  125. 				const float *triTable = (const float*) BINARY_START(src_triTable_bin);

  126. 				T p = phase * (BINARY_SIZE(src_triTable_bin) / sizeof(float) - 1);

  127. 				simd::Vector<int32_t, T::size> index = p;

  128. 				p -= index;

  129. 

  130. 				T v0, v1;

  131. 				for (int i = 0; i < T::size; i++) {

  132. 					v0.s[i] = triTable[index.s[i]];

  133. 					v1.s[i] = triTable[index.s[i] + 1];

  134. 				}

  135. 				triBuffer[i] = 1.129f * simd::crossfade(v0, v1, p);

  136. 			}

  137. 			else {

  138. 				triBuffer[i] = 1 - 4 * simd::fmin(simd::fabs(phase - 0.25f), simd::fabs(phase - 1.25f));

  139. 			}

  140. 

  141. 			// Saw

  142. 			if (analog) {

  143. 				const float *sawTable = (const float*) BINARY_START(src_sawTable_bin);

  144. 				T p = phase * (BINARY_SIZE(src_sawTable_bin) / sizeof(float) - 1);

  145. 				simd::Vector<int32_t, T::size> index = p;

  146. 				p -= index;

  147. 

  148. 				T v0, v1;

  149. 				for (int i = 0; i < T::size; i++) {

  150. 					v0.s[i] = sawTable[index.s[i]];

  151. 					v1.s[i] = sawTable[index.s[i] + 1];

  152. 				}

  153. 				sawBuffer[i] = 1.376f * simd::crossfade(v0, v1, p);

  154. 			}

  155. 			else {

  156. 				sawBuffer[i] = simd::ifelse(phase < 0.5f, 0.f, -2.f) + 2.f * phase;

  157. 			}

  158. 

  159. 			// Sqr

  160. 			sqrBuffer[i] = simd::ifelse(phase < pw, 1.f, -1.f);

  161. 			if (analog) {

  162. 				// Add a highpass filter here

  163. 				sqrFilter.setCutoff(10.f * deltaTime);

  164. 				sqrFilter.process(sqrBuffer[i]);

  165. 				sqrBuffer[i] = 0.771f * sqrFilter.highpass();

  166. 			}

  167. 

  168. 			// Advance phase

  169. 			phase += simd::ifelse(syncDirection, -1.f, 1.f) * deltaPhase / OVERSAMPLE;

  170. 			// Wrap phase to [0, 1)

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

  172. 		}

  173. 	}

  174. 

  175. 	T sin() {

  176. 		return sinDecimator.process(sinBuffer);

  177. 		// sinBuffer[0];

  178. 	}

  179. 	T tri() {

  180. 		return triDecimator.process(triBuffer);

  181. 		// triBuffer[0];

  182. 	}

  183. 	T saw() {

  184. 		return sawDecimator.process(sawBuffer);

  185. 		// sawBuffer[0];

  186. 	}

  187. 	T sqr() {

  188. 		return sqrDecimator.process(sqrBuffer);

  189. 		// sqrBuffer[0];

  190. 	}

  191. 	T light() {

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

  193. 	}

  194. };

  195. 

  196. 

  197. struct VCO : Module {

  198. 	enum ParamIds {

  199. 		MODE_PARAM,

  200. 		SYNC_PARAM,

  201. 		FREQ_PARAM,

  202. 		FINE_PARAM,

  203. 		FM_PARAM,

  204. 		PW_PARAM,

  205. 		PWM_PARAM,

  206. 		NUM_PARAMS

  207. 	};

  208. 	enum InputIds {

  209. 		PITCH_INPUT,

  210. 		FM_INPUT,

  211. 		SYNC_INPUT,

  212. 		PW_INPUT,

  213. 		NUM_INPUTS

  214. 	};

  215. 	enum OutputIds {

  216. 		SIN_OUTPUT,

  217. 		TRI_OUTPUT,

  218. 		SAW_OUTPUT,

  219. 		SQR_OUTPUT,

  220. 		NUM_OUTPUTS

  221. 	};

  222. 	enum LightIds {

  223. 		ENUMS(PHASE_LIGHT, 3),

  224. 		NUM_LIGHTS

  225. 	};

  226. 

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

  228. 	dsp::ClockDivider lightDivider;

  229. 

  230. 	VCO() {

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

  232. 		configParam(MODE_PARAM, 0.f, 1.f, 1.f, "Analog mode");

  233. 		configParam(SYNC_PARAM, 0.f, 1.f, 1.f, "Hard sync");

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

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

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

  237. 		configParam(PW_PARAM, 0.f, 1.f, 0.5f, "Pulse width", "%", 0.f, 100.f);

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

  239. 		lightDivider.setDivision(16);

  240. 	}

  241. 

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

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

  244. 

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

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

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

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

  249. 

  250. 			float pitchFine = 3.f * dsp::quadraticBipolar(params[FINE_PARAM].getValue());

  251. 			float_4 pitchCv = 12.f * inputs[PITCH_INPUT].getVoltageSimd<float_4>(c);

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

  253. 				pitchCv += dsp::quadraticBipolar(params[FM_PARAM].getValue()) * 12.f * inputs[FM_INPUT].getPolyVoltageSimd<float_4>(c);

  254. 			}

  255. 			oscillator->setPitch(params[FREQ_PARAM].getValue(), pitchFine + pitchCv);

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

  257. 

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

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

  260. 

  261. 			// Set output

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

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

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

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

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

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

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

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

  270. 		}

  271. 

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

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

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

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

  276. 

  277. 		// Light

  278. 		if (lightDivider.process()) {

  279. 			if (channels == 1) {

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

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

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

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

  284. 			}

  285. 			else {

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

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

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

  289. 			}

  290. 		}

  291. 	}

  292. };

  293. 

  294. 

  295. struct VCOWidget : ModuleWidget {

  296. 	VCOWidget(VCO *module) {

  297. 		setModule(module);

  298. 		setPanel(APP->window->loadSvg(asset::plugin(pluginInstance, "res/VCO-1.svg")));

  299. 

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

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

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

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

  304. 

  305. 		addParam(createParam<CKSS>(Vec(15, 77), module, VCO::MODE_PARAM));

  306. 		addParam(createParam<CKSS>(Vec(119, 77), module, VCO::SYNC_PARAM));

  307. 

  308. 		addParam(createParam<RoundHugeBlackKnob>(Vec(47, 61), module, VCO::FREQ_PARAM));

  309. 		addParam(createParam<RoundLargeBlackKnob>(Vec(23, 143), module, VCO::FINE_PARAM));

  310. 		addParam(createParam<RoundLargeBlackKnob>(Vec(91, 143), module, VCO::PW_PARAM));

  311. 		addParam(createParam<RoundLargeBlackKnob>(Vec(23, 208), module, VCO::FM_PARAM));

  312. 		addParam(createParam<RoundLargeBlackKnob>(Vec(91, 208), module, VCO::PWM_PARAM));

  313. 

  314. 		addInput(createInput<PJ301MPort>(Vec(11, 276), module, VCO::PITCH_INPUT));

  315. 		addInput(createInput<PJ301MPort>(Vec(45, 276), module, VCO::FM_INPUT));

  316. 		addInput(createInput<PJ301MPort>(Vec(80, 276), module, VCO::SYNC_INPUT));

  317. 		addInput(createInput<PJ301MPort>(Vec(114, 276), module, VCO::PW_INPUT));

  318. 

  319. 		addOutput(createOutput<PJ301MPort>(Vec(11, 320), module, VCO::SIN_OUTPUT));

  320. 		addOutput(createOutput<PJ301MPort>(Vec(45, 320), module, VCO::TRI_OUTPUT));

  321. 		addOutput(createOutput<PJ301MPort>(Vec(80, 320), module, VCO::SAW_OUTPUT));

  322. 		addOutput(createOutput<PJ301MPort>(Vec(114, 320), module, VCO::SQR_OUTPUT));

  323. 

  324. 		addChild(createLight<SmallLight<RedGreenBlueLight>>(Vec(99, 42.5f), module, VCO::PHASE_LIGHT));

  325. 	}

  326. };

  327. 

  328. 

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

  330. 

  331. 

  332. struct VCO2 : Module {

  333. 	enum ParamIds {

  334. 		MODE_PARAM,

  335. 		SYNC_PARAM,

  336. 		FREQ_PARAM,

  337. 		WAVE_PARAM,

  338. 		FM_PARAM,

  339. 		NUM_PARAMS

  340. 	};

  341. 	enum InputIds {

  342. 		FM_INPUT,

  343. 		SYNC_INPUT,

  344. 		WAVE_INPUT,

  345. 		NUM_INPUTS

  346. 	};

  347. 	enum OutputIds {

  348. 		OUT_OUTPUT,

  349. 		NUM_OUTPUTS

  350. 	};

  351. 	enum LightIds {

  352. 		ENUMS(PHASE_LIGHT, 3),

  353. 		NUM_LIGHTS

  354. 	};

  355. 

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

  357. 	dsp::ClockDivider lightDivider;

  358. 

  359. 	VCO2() {

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

  361. 		configParam(MODE_PARAM, 0.f, 1.f, 1.f, "Analog mode");

  362. 		configParam(SYNC_PARAM, 0.f, 1.f, 1.f, "Hard sync");

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

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

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

  366. 		lightDivider.setDivision(16);

  367. 	}

  368. 

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

  370. 		float freqParam = params[FREQ_PARAM].getValue();

  371. 		float fmParam = params[FM_PARAM].getValue();

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

  373. 

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

  375. 

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

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

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

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

  380. 

  381. 			float_4 pitch = freqParam + dsp::quadraticBipolar(fmParam) * 12.f * inputs[FM_INPUT].getVoltageSimd<float_4>(c);

  382. 			oscillator->setPitch(0.f, pitch);

  383. 

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

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

  386. 

  387. 			// Outputs

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

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

  390. 				float_4 v = 0.f;

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

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

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

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

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

  396. 			}

  397. 		}

  398. 

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

  400. 

  401. 		// Light

  402. 		if (lightDivider.process()) {

  403. 			if (channels == 1) {

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

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

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

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

  408. 			}

  409. 			else {

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

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

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

  413. 			}

  414. 		}

  415. 	}

  416. };

  417. 

  418. 

  419. 

  420. 

  421. struct VCO2Widget : ModuleWidget {

  422. 	VCO2Widget(VCO2 *module) {

  423. 		setModule(module);

  424. 		setPanel(APP->window->loadSvg(asset::plugin(pluginInstance, "res/VCO-2.svg")));

  425. 

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

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

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

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

  430. 

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

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

  433. 

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

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

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

  437. 

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

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

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

  441. 

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

  443. 

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

  445. 	}

  446. };

  447. 

  448. 

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