VCVRack
/
Befaco
mirror of https://github.com/VCVRack/Befaco.git
1
0
Fork 0
Code Issues 0 Releases 17 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.
159 Commits
7 Branches
13MB
Tree: 0cff3b0281
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0cff3b0281'
${ noResults }
Befaco/src/EvenVCO.cpp

248 lines
8.4KB
Raw Blame History 

  1. #include "plugin.hpp"

  2. 

  3. using simd::float_4;

  4. 

  5. struct EvenVCO : Module {

  6. 	enum ParamIds {

  7. 		OCTAVE_PARAM,

  8. 		TUNE_PARAM,

  9. 		PWM_PARAM,

  10. 		NUM_PARAMS

  11. 	};

  12. 	enum InputIds {

  13. 		PITCH1_INPUT,

  14. 		PITCH2_INPUT,

  15. 		FM_INPUT,

  16. 		SYNC_INPUT,

  17. 		PWM_INPUT,

  18. 		NUM_INPUTS

  19. 	};

  20. 	enum OutputIds {

  21. 		TRI_OUTPUT,

  22. 		SINE_OUTPUT,

  23. 		EVEN_OUTPUT,

  24. 		SAW_OUTPUT,

  25. 		SQUARE_OUTPUT,

  26. 		NUM_OUTPUTS

  27. 	};

  28. 

  29. 	float_4 phase[4] = {};

  30. 	float_4 tri[4] = {};

  31. 

  32. 	/** The value of the last sync input */

  33. 	float sync = 0.0;

  34. 	/** The outputs */

  35. 	/** Whether we are past the pulse width already */

  36. 	bool halfPhase[PORT_MAX_CHANNELS] = {};

  37. 

  38. 	dsp::MinBlepGenerator<16, 32> triSquareMinBlep[PORT_MAX_CHANNELS];

  39. 	dsp::MinBlepGenerator<16, 32> triMinBlep[PORT_MAX_CHANNELS];

  40. 	dsp::MinBlepGenerator<16, 32> sineMinBlep[PORT_MAX_CHANNELS];

  41. 	dsp::MinBlepGenerator<16, 32> doubleSawMinBlep[PORT_MAX_CHANNELS];

  42. 	dsp::MinBlepGenerator<16, 32> sawMinBlep[PORT_MAX_CHANNELS];

  43. 	dsp::MinBlepGenerator<16, 32> squareMinBlep[PORT_MAX_CHANNELS];

  44. 

  45. 	EvenVCO() {

  46. 		config(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS);

  47. 		configParam(OCTAVE_PARAM, -5.0, 4.0, 0.0, "Octave", "'", 0.5);

  48. 		getParamQuantity(OCTAVE_PARAM)->snapEnabled = true;

  49. 		configParam(TUNE_PARAM, -7.0, 7.0, 0.0, "Tune", " semitones");

  50. 		configParam(PWM_PARAM, -1.0, 1.0, 0.0, "Pulse width");

  51. 

  52. 		configInput(PITCH1_INPUT, "Pitch 1");

  53. 		configInput(PITCH2_INPUT, "Pitch 2");

  54. 		configInput(FM_INPUT, "FM");

  55. 		configInput(SYNC_INPUT, "Sync (not implemented)");

  56. 		configInput(PWM_INPUT, "Pulse Width Modulation");

  57. 

  58. 		configOutput(TRI_OUTPUT, "Triangle");

  59. 		configOutput(SINE_OUTPUT, "Sine");

  60. 		configOutput(EVEN_OUTPUT, "Even");

  61. 		configOutput(SAW_OUTPUT, "Sawtooth");

  62. 		configOutput(SQUARE_OUTPUT, "Square");

  63. 	}

  64. 

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

  66. 

  67. 		int channels_pitch1 = inputs[PITCH1_INPUT].getChannels();

  68. 		int channels_pitch2 = inputs[PITCH2_INPUT].getChannels();

  69. 

  70. 		int channels = 1;

  71. 		channels = std::max(channels, channels_pitch1);

  72. 		channels = std::max(channels, channels_pitch2);

  73. 

  74. 		float pitch_0 = 1.f + std::round(params[OCTAVE_PARAM].getValue()) + params[TUNE_PARAM].getValue() / 12.f;

  75. 

  76. 		// Compute frequency, pitch is 1V/oct

  77. 		float_4 pitch[4] = {};

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

  79. 			pitch[c / 4] = pitch_0;

  80. 

  81. 		if (inputs[PITCH1_INPUT].isConnected()) {

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

  83. 				pitch[c / 4] += inputs[PITCH1_INPUT].getPolyVoltageSimd<float_4>(c);

  84. 		}

  85. 

  86. 		if (inputs[PITCH2_INPUT].isConnected()) {

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

  88. 				pitch[c / 4] += inputs[PITCH2_INPUT].getPolyVoltageSimd<float_4>(c);

  89. 		}

  90. 

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

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

  93. 				pitch[c / 4] += inputs[FM_INPUT].getPolyVoltageSimd<float_4>(c) / 4.f;

  94. 		}

  95. 

  96. 		float_4 freq[4] = {};

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

  98. 			freq[c / 4] = dsp::FREQ_C4 * simd::pow(2.f, pitch[c / 4]);

  99. 			freq[c / 4] = clamp(freq[c / 4], 0.f, 20000.f);

  100. 		}

  101. 

  102. 		// Pulse width

  103. 		float_4 pw[4] = {};

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

  105. 			pw[c / 4] = params[PWM_PARAM].getValue();

  106. 

  107. 		if (inputs[PWM_INPUT].isConnected()) {

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

  109. 				pw[c / 4] += inputs[PWM_INPUT].getPolyVoltageSimd<float_4>(c) / 5.f;

  110. 		}

  111. 

  112. 		float_4 deltaPhase[4] = {};

  113. 		float_4 oldPhase[4] = {};

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

  115. 			pw[c / 4] = rescale(clamp(pw[c / 4], -1.0f, 1.0f), -1.0f, 1.0f, 0.05f, 1.0f - 0.05f);

  116. 

  117. 			// Advance phase

  118. 			deltaPhase[c / 4] = clamp(freq[c / 4] * args.sampleTime, 1e-6f, 0.5f);

  119. 			oldPhase[c / 4] = phase[c / 4];

  120. 			phase[c / 4] += deltaPhase[c / 4];

  121. 		}

  122. 

  123. 		// the next block can't be done with SIMD instructions, but should at least be completed with

  124. 		// blocks of 4 (otherwise popping artfifacts are generated from invalid phase/oldPhase/deltaPhase)

  125. 		const int channelsRoundedUpNearestFour = (1 + (channels - 1) / 4) * 4;

  126. 		for (int c = 0; c < channelsRoundedUpNearestFour; c++) {

  127. 

  128. 			if (oldPhase[c / 4].s[c % 4] < 0.5 && phase[c / 4].s[c % 4] >= 0.5) {

  129. 				float crossing = -(phase[c / 4].s[c % 4] - 0.5) / deltaPhase[c / 4].s[c % 4];

  130. 				triSquareMinBlep[c].insertDiscontinuity(crossing, 2.f);

  131. 				doubleSawMinBlep[c].insertDiscontinuity(crossing, -2.f);

  132. 			}

  133. 

  134. 			if (!halfPhase[c] && phase[c / 4].s[c % 4] >= pw[c / 4].s[c % 4]) {

  135. 				float crossing  = -(phase[c / 4].s[c % 4] - pw[c / 4].s[c % 4]) / deltaPhase[c / 4].s[c % 4];

  136. 				squareMinBlep[c].insertDiscontinuity(crossing, 2.f);

  137. 				halfPhase[c] = true;

  138. 			}

  139. 

  140. 			// Reset phase if at end of cycle

  141. 			if (phase[c / 4].s[c % 4] >= 1.f) {

  142. 				phase[c / 4].s[c % 4] -= 1.f;

  143. 				float crossing = -phase[c / 4].s[c % 4] / deltaPhase[c / 4].s[c % 4];

  144. 				triSquareMinBlep[c].insertDiscontinuity(crossing, -2.f);

  145. 				doubleSawMinBlep[c].insertDiscontinuity(crossing, -2.f);

  146. 				squareMinBlep[c].insertDiscontinuity(crossing, -2.f);

  147. 				sawMinBlep[c].insertDiscontinuity(crossing, -2.f);

  148. 				halfPhase[c] = false;

  149. 			}

  150. 		}

  151. 

  152. 		float_4 triSquareMinBlepOut[4] = {};

  153. 		float_4 doubleSawMinBlepOut[4] = {};

  154. 		float_4 sawMinBlepOut[4] = {};

  155. 		float_4 squareMinBlepOut[4] = {};

  156. 

  157. 		float_4 triSquare[4] = {};

  158. 		float_4 sine[4] = {};

  159. 		float_4 doubleSaw[4] = {};

  160. 

  161. 		float_4 even[4] = {};

  162. 		float_4 saw[4] = {};

  163. 		float_4 square[4] = {};

  164. 		float_4 triOut[4] = {};

  165. 

  166. 		for (int c = 0; c < channelsRoundedUpNearestFour; c++) {

  167. 			triSquareMinBlepOut[c / 4].s[c % 4] = triSquareMinBlep[c].process();

  168. 			doubleSawMinBlepOut[c / 4].s[c % 4] = doubleSawMinBlep[c].process();

  169. 			sawMinBlepOut[c / 4].s[c % 4] = sawMinBlep[c].process();

  170. 			squareMinBlepOut[c / 4].s[c % 4] = squareMinBlep[c].process();

  171. 		}

  172. 

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

  174. 

  175. 			triSquare[c / 4] = simd::ifelse((phase[c / 4] < 0.5f), -1.f, +1.f);

  176. 			triSquare[c / 4] += triSquareMinBlepOut[c / 4];

  177. 

  178. 			// Integrate square for triangle

  179. 

  180. 			tri[c / 4] += (4.f * triSquare[c / 4]) * (freq[c / 4] * args.sampleTime);

  181. 			tri[c / 4] *= (1.f - 40.f * args.sampleTime);

  182. 			triOut[c / 4] = 5.f * tri[c / 4];

  183. 

  184. 			sine[c / 4] = 5.f * simd::cos(2 * M_PI * phase[c / 4]);

  185. 

  186. 			doubleSaw[c / 4] = simd::ifelse((phase[c / 4] < 0.5), (-1.f + 4.f * phase[c / 4]), (-1.f + 4.f * (phase[c / 4] - 0.5f)));

  187. 			doubleSaw[c / 4] += doubleSawMinBlepOut[c / 4];

  188. 			doubleSaw[c / 4] *= 5.f;

  189. 

  190. 			even[c / 4] = 0.55 * (doubleSaw[c / 4] + 1.27 * sine[c / 4]);

  191. 			saw[c / 4] = -1.f + 2.f * phase[c / 4];

  192. 			saw[c / 4] += sawMinBlepOut[c / 4];

  193. 			saw[c / 4] *= 5.f;

  194. 

  195. 			square[c / 4] = simd::ifelse((phase[c / 4] < pw[c / 4]),  -1.f, +1.f);

  196. 			square[c / 4] += squareMinBlepOut[c / 4];

  197. 			square[c / 4] *= 5.f;

  198. 

  199. 			// Set outputs

  200. 			outputs[TRI_OUTPUT].setVoltageSimd(triOut[c / 4], c);

  201. 			outputs[SINE_OUTPUT].setVoltageSimd(sine[c / 4], c);

  202. 			outputs[EVEN_OUTPUT].setVoltageSimd(even[c / 4], c);

  203. 			outputs[SAW_OUTPUT].setVoltageSimd(saw[c / 4], c);

  204. 			outputs[SQUARE_OUTPUT].setVoltageSimd(square[c / 4], c);

  205. 		}

  206. 

  207. 		// Outputs

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

  209. 		outputs[SINE_OUTPUT].setChannels(channels);

  210. 		outputs[EVEN_OUTPUT].setChannels(channels);

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

  212. 		outputs[SQUARE_OUTPUT].setChannels(channels);

  213. 	}

  214. };

  215. 

  216. 

  217. struct EvenVCOWidget : ModuleWidget {

  218. 	EvenVCOWidget(EvenVCO* module) {

  219. 		setModule(module);

  220. 		setPanel(APP->window->loadSvg(asset::plugin(pluginInstance, "res/panels/EvenVCO.svg")));

  221. 

  222. 		addChild(createWidget<Knurlie>(Vec(15, 0)));

  223. 		addChild(createWidget<Knurlie>(Vec(15, 365)));

  224. 		addChild(createWidget<Knurlie>(Vec(15 * 6, 0)));

  225. 		addChild(createWidget<Knurlie>(Vec(15 * 6, 365)));

  226. 

  227. 		addParam(createParam<BefacoBigKnob>(Vec(22, 32), module, EvenVCO::OCTAVE_PARAM));

  228. 		addParam(createParam<BefacoTinyKnob>(Vec(73, 131), module, EvenVCO::TUNE_PARAM));

  229. 		addParam(createParam<Davies1900hRedKnob>(Vec(16, 230), module, EvenVCO::PWM_PARAM));

  230. 

  231. 		addInput(createInput<BefacoInputPort>(Vec(8, 120), module, EvenVCO::PITCH1_INPUT));

  232. 		addInput(createInput<BefacoInputPort>(Vec(19, 157), module, EvenVCO::PITCH2_INPUT));

  233. 		addInput(createInput<BefacoInputPort>(Vec(48, 183), module, EvenVCO::FM_INPUT));

  234. 		addInput(createInput<BefacoInputPort>(Vec(86, 189), module, EvenVCO::SYNC_INPUT));

  235. 

  236. 		addInput(createInput<BefacoInputPort>(Vec(72, 236), module, EvenVCO::PWM_INPUT));

  237. 

  238. 		addOutput(createOutput<BefacoOutputPort>(Vec(10, 283), module, EvenVCO::TRI_OUTPUT));

  239. 		addOutput(createOutput<BefacoOutputPort>(Vec(87, 283), module, EvenVCO::SINE_OUTPUT));

  240. 		addOutput(createOutput<BefacoOutputPort>(Vec(48, 306), module, EvenVCO::EVEN_OUTPUT));

  241. 		addOutput(createOutput<BefacoOutputPort>(Vec(10, 327), module, EvenVCO::SAW_OUTPUT));

  242. 		addOutput(createOutput<BefacoOutputPort>(Vec(87, 327), module, EvenVCO::SQUARE_OUTPUT));

  243. 	}

  244. };

  245. 

  246. 

  247. Model* modelEvenVCO = createModel<EvenVCO, EvenVCOWidget>("EvenVCO");