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

413 lines
12KB
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 = 0.f;

  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 setPulseWidth(T pulseWidth) {

  55. 		const float pwMin = 0.01f;

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

  57. 	}

  58. 

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

  60. 		// Advance phase

  61. 		T deltaPhase = simd::clamp(freq * deltaTime, 0.f, 0.35f);

  62. 		if (soft) {

  63. 			// Reverse direction

  64. 			deltaPhase *= syncDirection;

  65. 		}

  66. 		else {

  67. 			// Reset back to forward

  68. 			syncDirection = 1.f;

  69. 		}

  70. 		phase += deltaPhase;

  71. 		// Wrap phase

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

  73. 

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

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

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

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

  78. 		if (wrapMask) {

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

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

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

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

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

  84. 					sqrMinBlep.insertDiscontinuity(p, x);

  85. 				}

  86. 			}

  87. 		}

  88. 

  89. 		// Jump sqr when crossing `pulseWidth`

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

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

  92. 		if (pulseMask) {

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

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

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

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

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

  98. 					sqrMinBlep.insertDiscontinuity(p, x);

  99. 				}

  100. 			}

  101. 		}

  102. 

  103. 		// Jump saw when crossing 0.5

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

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

  106. 		if (halfMask) {

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

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

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

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

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

  112. 					sawMinBlep.insertDiscontinuity(p, x);

  113. 				}

  114. 			}

  115. 		}

  116. 

  117. 		// Detect sync

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

  119. 		if (syncEnabled) {

  120. 			T deltaSync = syncValue - lastSyncValue;

  121. 			T syncCrossing = -lastSyncValue / deltaSync;

  122. 			lastSyncValue = syncValue;

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

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

  125. 			if (syncMask) {

  126. 				if (soft) {

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

  128. 				}

  129. 				else {

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

  131. 					// Insert minBLEP for sync

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

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

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

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

  136. 							T x;

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

  138. 							sqrMinBlep.insertDiscontinuity(p, x);

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

  140. 							sawMinBlep.insertDiscontinuity(p, x);

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

  142. 							triMinBlep.insertDiscontinuity(p, x);

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

  144. 							sinMinBlep.insertDiscontinuity(p, x);

  145. 						}

  146. 					}

  147. 					phase = newPhase;

  148. 				}

  149. 			}

  150. 		}

  151. 

  152. 		// Square

  153. 		sqrValue = sqr(phase);

  154. 		sqrValue += sqrMinBlep.process();

  155. 

  156. 		if (analog) {

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

  158. 			sqrFilter.process(sqrValue);

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

  160. 		}

  161. 

  162. 		// Saw

  163. 		sawValue = saw(phase);

  164. 		sawValue += sawMinBlep.process();

  165. 

  166. 		// Tri

  167. 		triValue = tri(phase);

  168. 		triValue += triMinBlep.process();

  169. 

  170. 		// Sin

  171. 		sinValue = sin(phase);

  172. 		sinValue += sinMinBlep.process();

  173. 	}

  174. 

  175. 	T sin(T phase) {

  176. 		T v;

  177. 		if (analog) {

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

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

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

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

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

  183. 		}

  184. 		else {

  185. 			v = sin2pi_pade_05_5_4(phase);

  186. 			// v = sin2pi_pade_05_7_6(phase);

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

  188. 		}

  189. 		return v;

  190. 	}

  191. 	T sin() {

  192. 		return sinValue;

  193. 	}

  194. 

  195. 	T tri(T phase) {

  196. 		T v;

  197. 		if (analog) {

  198. 			T x = phase + 0.25f;

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

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

  201. 			x *= 2;

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

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

  204. 		}

  205. 		else {

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

  207. 		}

  208. 		return v;

  209. 	}

  210. 	T tri() {

  211. 		return triValue;

  212. 	}

  213. 

  214. 	T saw(T phase) {

  215. 		T v;

  216. 		T x = phase + 0.5f;

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

  218. 		if (analog) {

  219. 			v = -expCurve(x);

  220. 		}

  221. 		else {

  222. 			v = 2 * x - 1;

  223. 		}

  224. 		return v;

  225. 	}

  226. 	T saw() {

  227. 		return sawValue;

  228. 	}

  229. 

  230. 	T sqr(T phase) {

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

  232. 		return v;

  233. 	}

  234. 	T sqr() {

  235. 		return sqrValue;

  236. 	}

  237. 

  238. 	T light() {

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

  240. 	}

  241. };

  242. 

  243. 

  244. struct VCO : Module {

  245. 	enum ParamIds {

  246. 		MODE_PARAM, // removed

  247. 		SYNC_PARAM,

  248. 		FREQ_PARAM,

  249. 		FINE_PARAM, // removed

  250. 		FM_PARAM,

  251. 		PW_PARAM,

  252. 		PW_CV_PARAM,

  253. 		// new in 2.0

  254. 		LINEAR_PARAM,

  255. 		NUM_PARAMS

  256. 	};

  257. 	enum InputIds {

  258. 		PITCH_INPUT,

  259. 		FM_INPUT,

  260. 		SYNC_INPUT,

  261. 		PW_INPUT,

  262. 		NUM_INPUTS

  263. 	};

  264. 	enum OutputIds {

  265. 		SIN_OUTPUT,

  266. 		TRI_OUTPUT,

  267. 		SAW_OUTPUT,

  268. 		SQR_OUTPUT,

  269. 		NUM_OUTPUTS

  270. 	};

  271. 	enum LightIds {

  272. 		ENUMS(PHASE_LIGHT, 3),

  273. 		LINEAR_LIGHT,

  274. 		SOFT_LIGHT,

  275. 		NUM_LIGHTS

  276. 	};

  277. 

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

  279. 	dsp::ClockDivider lightDivider;

  280. 

  281. 	VCO() {

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

  283. 		configSwitch(LINEAR_PARAM, 0.f, 1.f, 0.f, "FM mode", {"1V/octave", "Linear"});

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

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

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

  287. 		getParamQuantity(FM_PARAM)->randomizeEnabled = false;

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

  289. 		configParam(PW_CV_PARAM, -1.f, 1.f, 0.f, "Pulse width modulation", "%", 0.f, 100.f);

  290. 		getParamQuantity(PW_CV_PARAM)->randomizeEnabled = false;

  291. 

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

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

  294. 		configInput(SYNC_INPUT, "Sync");

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

  296. 

  297. 		configOutput(SIN_OUTPUT, "Sine");

  298. 		configOutput(TRI_OUTPUT, "Triangle");

  299. 		configOutput(SAW_OUTPUT, "Sawtooth");

  300. 		configOutput(SQR_OUTPUT, "Square");

  301. 

  302. 		lightDivider.setDivision(16);

  303. 	}

  304. 

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

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

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

  308. 		float pwParam = params[PW_PARAM].getValue();

  309. 		float pwCvParam = params[PW_CV_PARAM].getValue();

  310. 		bool linear = params[LINEAR_PARAM].getValue() > 0.f;

  311. 		bool soft = params[SYNC_PARAM].getValue() <= 0.f;

  312. 

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

  314. 

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

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

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

  318. 			// removed

  319. 			oscillator.analog = true;

  320. 			oscillator.soft = soft;

  321. 

  322. 			// Get frequency

  323. 			float_4 pitch = freqParam + inputs[PITCH_INPUT].getPolyVoltageSimd<float_4>(c);

  324. 			float_4 freq;

  325. 			if (!linear) {

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

  327. 				freq = dsp::FREQ_C4 * dsp::exp2_taylor5(pitch);

  328. 			}

  329. 			else {

  330. 				freq = dsp::FREQ_C4 * dsp::exp2_taylor5(pitch);

  331. 				freq += dsp::FREQ_C4 * inputs[FM_INPUT].getPolyVoltageSimd<float_4>(c) * fmParam;

  332. 			}

  333. 			freq = clamp(freq, 0.f, args.sampleRate / 2.f);

  334. 			oscillator.freq = freq;

  335. 

  336. 			// Get pulse width

  337. 			float_4 pw = pwParam + inputs[PW_INPUT].getPolyVoltageSimd<float_4>(c) / 10.f * pwCvParam;

  338. 			oscillator.setPulseWidth(pw);

  339. 

  340. 			oscillator.syncEnabled = inputs[SYNC_INPUT].isConnected();

  341. 			float_4 sync = inputs[SYNC_INPUT].getPolyVoltageSimd<float_4>(c);

  342. 			oscillator.process(args.sampleTime, sync);

  343. 

  344. 			// Set output

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

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

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

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

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

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

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

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

  353. 		}

  354. 

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

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

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

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

  359. 

  360. 		// Light

  361. 		if (lightDivider.process()) {

  362. 			if (channels == 1) {

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

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

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

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

  367. 			}

  368. 			else {

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

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

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

  372. 			}

  373. 			lights[LINEAR_LIGHT].setBrightness(linear);

  374. 			lights[SOFT_LIGHT].setBrightness(soft);

  375. 		}

  376. 	}

  377. };

  378. 

  379. 

  380. struct VCOWidget : ModuleWidget {

  381. 	VCOWidget(VCO* module) {

  382. 		setModule(module);

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

  384. 

  385. 		addChild(createWidget<ThemedScrew>(Vec(RACK_GRID_WIDTH, 0)));

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

  387. 		addChild(createWidget<ThemedScrew>(Vec(RACK_GRID_WIDTH, RACK_GRID_HEIGHT - RACK_GRID_WIDTH)));

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

  389. 

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

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

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

  393. 		addParam(createLightParamCentered<VCVLightLatch<MediumSimpleLight<WhiteLight>>>(mm2px(Vec(17.444, 80.603)), module, VCO::LINEAR_PARAM, VCO::LINEAR_LIGHT));

  394. 		addParam(createLightParamCentered<VCVLightLatch<MediumSimpleLight<WhiteLight>>>(mm2px(Vec(28.282, 80.603)), module, VCO::SYNC_PARAM, VCO::SOFT_LIGHT));

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

  396. 

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

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

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

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

  401. 

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

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

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

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

  406. 

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

  408. 	}

  409. };

  410. 

  411. 

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