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

327 lines
11KB
Raw Blame History 

  1. #include "plugin.hpp"

  2. #include "Wavetable.hpp"

  3. 

  4. 

  5. using simd::float_4;

  6. 

  7. 

  8. struct WTVCO : Module {

  9. 	enum ParamIds {

  10. 		MODE_PARAM, // removed

  11. 		SOFT_PARAM,

  12. 		FREQ_PARAM,

  13. 		POS_PARAM,

  14. 		FM_PARAM,

  15. 		// added in 2.0

  16. 		POS_CV_PARAM,

  17. 		LINEAR_PARAM,

  18. 		NUM_PARAMS

  19. 	};

  20. 	enum InputIds {

  21. 		FM_INPUT,

  22. 		SYNC_INPUT,

  23. 		POS_INPUT,

  24. 		// added in 2.0

  25. 		PITCH_INPUT,

  26. 		NUM_INPUTS

  27. 	};

  28. 	enum OutputIds {

  29. 		WAVE_OUTPUT,

  30. 		NUM_OUTPUTS

  31. 	};

  32. 	enum LightIds {

  33. 		ENUMS(PHASE_LIGHT, 3),

  34. 		SOFT_LIGHT,

  35. 		LINEAR_LIGHT,

  36. 		NUM_LIGHTS

  37. 	};

  38. 

  39. 	Wavetable wavetable;

  40. 	float_4 phases[4] = {};

  41. 	float lastPos = 0.f;

  42. 	dsp::MinBlepGenerator<16, 16, float_4> syncMinBleps[4];

  43. 	float_4 lastSyncValues[4] = {};

  44. 	float_4 syncDirections[4] = {};

  45. 

  46. 	dsp::ClockDivider lightDivider;

  47. 	dsp::BooleanTrigger softTrigger;

  48. 	dsp::BooleanTrigger linearTrigger;

  49. 

  50. 	WTVCO() {

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

  52. 

  53. 		configSwitch(SOFT_PARAM, 0.f, 1.f, 0.f, "Sync", {"Hard", "Soft"});

  54. 		configSwitch(LINEAR_PARAM, 0.f, 1.f, 0.f, "FM mode", {"1V/octave", "Through-zero linear"});

  55. 

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

  57. 		configParam(POS_PARAM, 0.f, 1.f, 0.f, "Wavetable position", "%", 0.f, 100.f);

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

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

  60. 		configParam(POS_CV_PARAM, -1.f, 1.f, 0.f, "Wavetable position CV", "%", 0.f, 100.f);

  61. 		getParamQuantity(POS_CV_PARAM)->randomizeEnabled = false;

  62. 

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

  64. 		configInput(SYNC_INPUT, "Sync");

  65. 		configInput(POS_INPUT, "Wavetable position");

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

  67. 

  68. 		configOutput(WAVE_OUTPUT, "Wavetable");

  69. 

  70. 		configLight(PHASE_LIGHT, "Phase");

  71. 

  72. 		wavetable.setQuality(8);

  73. 

  74. 		lightDivider.setDivision(16);

  75. 

  76. 		onReset();

  77. 	}

  78. 

  79. 	void onReset() override {

  80. 		wavetable.reset();

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

  82. 			syncDirections[i] = 1.f;

  83. 		}

  84. 	}

  85. 

  86. 	void onAdd(const AddEvent& e) override {

  87. 		std::string path = system::join(getPatchStorageDirectory(), "wavetable.wav");

  88. 		// Silently fails

  89. 		wavetable.load(path);

  90. 	}

  91. 

  92. 	void onSave(const SaveEvent& e) override {

  93. 		if (!wavetable.samples.empty()) {

  94. 			std::string path = system::join(createPatchStorageDirectory(), "wavetable.wav");

  95. 			wavetable.save(path);

  96. 		}

  97. 	}

  98. 

  99. 	void clearOutput() {

  100. 		outputs[WAVE_OUTPUT].setVoltage(0.f);

  101. 		outputs[WAVE_OUTPUT].setChannels(1);

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

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

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

  105. 	}

  106. 

  107. 	float getWave(float index, float pos, float octave) {

  108. 		// Get wave indexes

  109. 		float indexF = index - std::trunc(index);

  110. 		size_t index0 = std::trunc(index);

  111. 		size_t index1 = (index0 + 1) % (wavetable.waveLen * wavetable.quality);

  112. 		// Get position indexes

  113. 		float posF = pos - std::trunc(pos);

  114. 		size_t pos0 = std::trunc(pos);

  115. 		size_t pos1 = pos0 + 1;

  116. 		// Get octave index

  117. 		// float octaveF = octave - std::trunc(octave);

  118. 		size_t octave0 = std::trunc(octave);

  119. 		octave0 = std::min(octave0, wavetable.octaves - 1);

  120. 		// size_t octave1 = octave0 + 1;

  121. 

  122. 		// Linearly interpolate wave index

  123. 		float out = crossfade(wavetable.interpolatedAt(octave0, pos0, index0), wavetable.interpolatedAt(octave0, pos0, index1), indexF);

  124. 		// Interpolate octave

  125. 		// if (octaveF > 0.f && octave1 < wavetable.octaves) {

  126. 		// 	float out1 = crossfade(wavetable.interpolatedAt(octave1, pos0, index0), wavetable.interpolatedAt(octave1, pos0, index1), indexF);

  127. 		// 	out = crossfade(out, out1, octaveF);

  128. 		// }

  129. 		// Linearly interpolate position if needed

  130. 		if (posF > 0.f) {

  131. 			float out1 = crossfade(wavetable.interpolatedAt(octave0, pos1, index0), wavetable.interpolatedAt(octave0, pos1, index1), indexF);

  132. 			// Interpolate octave

  133. 			// if (octaveF > 0.f && octave1 < wavetable.octaves) {

  134. 			// 	float out2 = crossfade(wavetable.interpolatedAt(octave1, pos1, index0), wavetable.interpolatedAt(octave1, pos1, index1), indexF);

  135. 			// 	out1 = crossfade(out1, out2, octaveF);

  136. 			// }

  137. 			out = crossfade(out, out1, posF);

  138. 		}

  139. 		return out;

  140. 	}

  141. 

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

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

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

  145. 		float posParam = params[POS_PARAM].getValue();

  146. 		float posCvParam = params[POS_CV_PARAM].getValue();

  147. 		bool soft = params[SOFT_PARAM].getValue() > 0.f;

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

  149. 		bool syncEnabled = inputs[SYNC_INPUT].isConnected();

  150. 

  151. 		int channels = std::max({1, inputs[PITCH_INPUT].getChannels(), inputs[FM_INPUT].getChannels()});

  152. 

  153. 		int waveCount = wavetable.getWaveCount();

  154. 		if (wavetable.waveLen >= 2 && waveCount >= 1) {

  155. 			// Iterate channels

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

  157. 				// Calculate frequency in Hz

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

  159. 				float_4 freq;

  160. 				if (!linear) {

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

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

  163. 				}

  164. 				else {

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

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

  167. 				}

  168. 

  169. 				// Limit to Nyquist frequency

  170. 				freq = simd::fmin(freq, args.sampleRate / 2);

  171. 				float_4 octave = simd::log2(args.sampleRate / 2 / freq);

  172. 

  173. 				// Accumulate phase

  174. 				float_4 phase = phases[c / 4];

  175. 				if (!soft) {

  176. 					syncDirections[c / 4] = 1.f;

  177. 				}

  178. 				// Delta phase can be negative

  179. 				float_4 deltaPhase = freq * args.sampleTime * syncDirections[c / 4];

  180. 				phase += deltaPhase;

  181. 				// Wrap phase

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

  183. 				phases[c / 4] = phase;

  184. 				float_4 index = phase * wavetable.waveLen * wavetable.quality;

  185. 

  186. 				// Get wavetable position, scaled from 0 to (waveCount - 1)

  187. 				float_4 pos = posParam + inputs[POS_INPUT].getPolyVoltageSimd<float_4>(c) * posCvParam / 10.f;

  188. 				pos = simd::clamp(pos);

  189. 				pos *= (waveCount - 1);

  190. 

  191. 				if (c == 0)

  192. 					lastPos = pos[0];

  193. 

  194. 				// Get wave output serially

  195. 				int ccs = std::min(4, channels - c);

  196. 				float_4 out = 0.f;

  197. 				for (int cc = 0; cc < ccs; cc++) {

  198. 					out[cc] = getWave(index[cc], pos[cc], octave[cc]);

  199. 				}

  200. 

  201. 				// Sync

  202. 				if (syncEnabled) {

  203. 					float_4 syncValue = inputs[SYNC_INPUT].getPolyVoltageSimd<float_4>(c);

  204. 					float_4 deltaSync = syncValue - lastSyncValues[c / 4];

  205. 					float_4 syncCrossing = -lastSyncValues[c / 4] / deltaSync;

  206. 					lastSyncValues[c / 4] = syncValue;

  207. 					float_4 sync = (0.f < syncCrossing) & (syncCrossing <= 1.f) & (syncValue >= 0.f);

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

  209. 					if (syncMask) {

  210. 						if (soft) {

  211. 							syncDirections[c / 4] = simd::ifelse(sync, -syncDirections[c / 4], syncDirections[c / 4]);

  212. 						}

  213. 						else {

  214. 							phases[c / 4] = simd::ifelse(sync, (1.f - syncCrossing) * deltaPhase, phases[c / 4]);

  215. 							// Insert minBLEP for sync serially

  216. 							for (int cc = 0; cc < ccs; cc++) {

  217. 								if (syncMask & (1 << cc)) {

  218. 									float_4 mask = simd::movemaskInverse<float_4>(1 << cc);

  219. 									float p = syncCrossing[cc] - 1.f;

  220. 									float index = phases[c / 4][cc] * wavetable.waveLen * wavetable.quality;

  221. 									float out1 = getWave(index, pos[cc], octave[cc]);

  222. 									float_4 x = mask & (out1 - out[cc]);

  223. 									syncMinBleps[c / 4].insertDiscontinuity(p, x);

  224. 								}

  225. 							}

  226. 						}

  227. 					}

  228. 				}

  229. 				out += syncMinBleps[c / 4].process();

  230. 

  231. 				outputs[WAVE_OUTPUT].setVoltageSimd(out * 5.f, c);

  232. 			}

  233. 		}

  234. 		else {

  235. 			// Wavetable is invalid, so set 0V

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

  237. 				outputs[WAVE_OUTPUT].setVoltageSimd(float_4(0.f), c);

  238. 			}

  239. 		}

  240. 

  241. 		outputs[WAVE_OUTPUT].setChannels(channels);

  242. 

  243. 		// Light

  244. 		if (lightDivider.process()) {

  245. 			if (channels == 1) {

  246. 				float b = 1.f - phases[0][0];

  247. 				lights[PHASE_LIGHT + 0].setSmoothBrightness(b, args.sampleTime * lightDivider.getDivision());

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

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

  250. 			}

  251. 			else {

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

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

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

  255. 			}

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

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

  258. 		}

  259. 	}

  260. 

  261. 	void paramsFromJson(json_t* rootJ) override {

  262. 		// In <2.0, there were no attenuverters, so set them to 1.0 in case they are not overwritten.

  263. 		params[POS_CV_PARAM].setValue(1.f);

  264. 		Module::paramsFromJson(rootJ);

  265. 	}

  266. 

  267. 	json_t* dataToJson() override {

  268. 		json_t* rootJ = json_object();

  269. 		// Merge wavetable

  270. 		json_t* wavetableJ = wavetable.toJson();

  271. 		json_object_update(rootJ, wavetableJ);

  272. 		json_decref(wavetableJ);

  273. 		return rootJ;

  274. 	}

  275. 

  276. 	void dataFromJson(json_t* rootJ) override {

  277. 		// wavetable

  278. 		wavetable.fromJson(rootJ);

  279. 	}

  280. };

  281. 

  282. 

  283. struct WTVCOWidget : ModuleWidget {

  284. 	WTVCOWidget(WTVCO* module) {

  285. 		setModule(module);

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

  287. 

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

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

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

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

  292. 

  293. 		addParam(createParamCentered<RoundLargeBlackKnob>(mm2px(Vec(8.915, 56.388)), module, WTVCO::FREQ_PARAM));

  294. 		addParam(createParamCentered<RoundLargeBlackKnob>(mm2px(Vec(26.645, 56.388)), module, WTVCO::POS_PARAM));

  295. 		addParam(createParamCentered<Trimpot>(mm2px(Vec(6.897, 80.603)), module, WTVCO::FM_PARAM));

  296. 		addParam(createLightParamCentered<VCVLightLatch<MediumSimpleLight<WhiteLight>>>(mm2px(Vec(17.734, 80.603)), module, WTVCO::LINEAR_PARAM, WTVCO::LINEAR_LIGHT));

  297. 		addParam(createParamCentered<Trimpot>(mm2px(Vec(28.571, 80.603)), module, WTVCO::POS_CV_PARAM));

  298. 		addParam(createLightParamCentered<VCVLightLatch<MediumSimpleLight<WhiteLight>>>(mm2px(Vec(17.734, 96.859)), module, WTVCO::SOFT_PARAM, WTVCO::SOFT_LIGHT));

  299. 

  300. 		addInput(createInputCentered<PJ301MPort>(mm2px(Vec(6.897, 96.813)), module, WTVCO::FM_INPUT));

  301. 		addInput(createInputCentered<PJ301MPort>(mm2px(Vec(28.571, 96.859)), module, WTVCO::POS_INPUT));

  302. 		addInput(createInputCentered<PJ301MPort>(mm2px(Vec(6.897, 113.115)), module, WTVCO::PITCH_INPUT));

  303. 		addInput(createInputCentered<PJ301MPort>(mm2px(Vec(17.734, 113.115)), module, WTVCO::SYNC_INPUT));

  304. 

  305. 		addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(28.571, 113.115)), module, WTVCO::WAVE_OUTPUT));

  306. 

  307. 		addChild(createLightCentered<SmallLight<RedGreenBlueLight>>(mm2px(Vec(17.733, 49.409)), module, WTVCO::PHASE_LIGHT));

  308. 

  309. 		WTDisplay<WTVCO>* display = createWidget<WTDisplay<WTVCO>>(mm2px(Vec(0.004, 13.04)));

  310. 		display->box.size = mm2px(Vec(35.56, 29.224));

  311. 		display->module = module;

  312. 		addChild(display);

  313. 	}

  314. 

  315. 	void appendContextMenu(Menu* menu) override {

  316. 		WTVCO* module = dynamic_cast<WTVCO*>(this->module);

  317. 		assert(module);

  318. 

  319. 		menu->addChild(new MenuSeparator);

  320. 

  321. 		module->wavetable.appendContextMenu(menu);

  322. 	}

  323. };

  324. 

  325. 

  326. Model* modelVCO2 = createModel<WTVCO, WTVCOWidget>("VCO2");