VCVRack
/
AudibleInstruments
mirror of https://github.com/VCVRack/AudibleInstruments.git
1
0
Fork 0
Code Issues 0 Releases 8 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.
112 Commits
4 Branches
8.5MB
Tree: 5af180a099
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '5af180a099'
${ noResults }
AudibleInstruments/src/Plaits.cpp

321 lines
11KB
Raw Blame History 

  1. #include "AudibleInstruments.hpp"

  2. #include "dsp/samplerate.hpp"

  3. #include "dsp/ringbuffer.hpp"

  4. #include "dsp/functions.hpp"

  5. #include "dsp/digital.hpp"

  6. #include "plaits/dsp/voice.h"

  7. 

  8. 

  9. struct Plaits : Module {

  10. 	enum ParamIds {

  11. 		MODEL1_PARAM,

  12. 		MODEL2_PARAM,

  13. 		FREQ_PARAM,

  14. 		HARMONICS_PARAM,

  15. 		TIMBRE_PARAM,

  16. 		MORPH_PARAM,

  17. 		TIMBRE_CV_PARAM,

  18. 		FREQ_CV_PARAM,

  19. 		MORPH_CV_PARAM,

  20. 		NUM_PARAMS

  21. 	};

  22. 	enum InputIds {

  23. 		ENGINE_INPUT,

  24. 		TIMBRE_INPUT,

  25. 		FREQ_INPUT,

  26. 		MORPH_INPUT,

  27. 		HARMONICS_INPUT,

  28. 		TRIGGER_INPUT,

  29. 		LEVEL_INPUT,

  30. 		NOTE_INPUT,

  31. 		NUM_INPUTS

  32. 	};

  33. 	enum OutputIds {

  34. 		OUT_OUTPUT,

  35. 		AUX_OUTPUT,

  36. 		NUM_OUTPUTS

  37. 	};

  38. 	enum LightIds {

  39. 		ENUMS(MODEL_LIGHT, 8 * 2),

  40. 		NUM_LIGHTS

  41. 	};

  42. 

  43. 	plaits::Voice voice;

  44. 	plaits::Patch patch;

  45. 	plaits::Modulations modulations;

  46. 	char shared_buffer[16384];

  47. 	float triPhase = 0.f;

  48. 

  49. 	SampleRateConverter<2> outputSrc;

  50. 	DoubleRingBuffer<Frame<2>, 256> outputBuffer;

  51. 	bool lowCpu = false;

  52. 	bool lpg = false;

  53. 

  54. 	SchmittTrigger model1Trigger;

  55. 	SchmittTrigger model2Trigger;

  56. 

  57. 	Plaits() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {

  58. 		memset(shared_buffer, 0, sizeof(shared_buffer));

  59. 		stmlib::BufferAllocator allocator(shared_buffer, sizeof(shared_buffer));

  60. 		voice.Init(&allocator);

  61. 

  62. 		memset(&patch, 0, sizeof(patch));

  63. 		memset(&modulations, 0, sizeof(modulations));

  64. 		onReset();

  65. 	}

  66. 

  67. 	void onReset() override {

  68. 		patch.engine = 0;

  69. 		patch.lpg_colour = 0.5f;

  70. 		patch.decay = 0.5f;

  71. 	}

  72. 

  73. 	void onRandomize() override {

  74. 		patch.engine = randomu32() % 16;

  75. 	}

  76. 

  77. 	json_t *toJson() override {

  78. 		json_t *rootJ = json_object();

  79. 

  80. 		json_object_set_new(rootJ, "lowCpu", json_boolean(lowCpu));

  81. 		json_object_set_new(rootJ, "model", json_integer(patch.engine));

  82. 		json_object_set_new(rootJ, "lpgColor", json_real(patch.lpg_colour));

  83. 		json_object_set_new(rootJ, "decay", json_real(patch.decay));

  84. 

  85. 		return rootJ;

  86. 	}

  87. 

  88. 	void fromJson(json_t *rootJ) override {

  89. 		json_t *lowCpuJ = json_object_get(rootJ, "lowCpu");

  90. 		if (lowCpuJ)

  91. 			lowCpu = json_boolean_value(lowCpuJ);

  92. 

  93. 		json_t *modelJ = json_object_get(rootJ, "model");

  94. 		if (modelJ)

  95. 			patch.engine = json_integer_value(modelJ);

  96. 

  97. 		json_t *lpgColorJ = json_object_get(rootJ, "lpgColor");

  98. 		if (lpgColorJ)

  99. 			patch.lpg_colour = json_number_value(lpgColorJ);

  100. 

  101. 		json_t *decayJ = json_object_get(rootJ, "decay");

  102. 		if (decayJ)

  103. 			patch.decay = json_number_value(decayJ);

  104. 	}

  105. 

  106. 	void step() override {

  107. 		if (outputBuffer.empty()) {

  108. 			const int blockSize = 12;

  109. 

  110. 			// Model buttons

  111. 			if (model1Trigger.process(params[MODEL1_PARAM].value)) {

  112. 				if (patch.engine >= 8) {

  113. 					patch.engine -= 8;

  114. 				}

  115. 				else {

  116. 					patch.engine = (patch.engine + 1) % 8;

  117. 				}

  118. 			}

  119. 			if (model2Trigger.process(params[MODEL2_PARAM].value)) {

  120. 				if (patch.engine < 8) {

  121. 					patch.engine += 8;

  122. 				}

  123. 				else {

  124. 					patch.engine = (patch.engine + 1) % 8 + 8;

  125. 				}

  126. 			}

  127. 

  128. 			// Model lights

  129. 			int activeEngine = voice.active_engine();

  130. 			triPhase += 2.f * engineGetSampleTime() * blockSize;

  131. 			if (triPhase >= 1.f)

  132. 				triPhase -= 1.f;

  133. 			float tri = (triPhase < 0.5f) ? triPhase * 2.f : (1.f - triPhase) * 2.f;

  134. 

  135. 			for (int i = 0; i < 8; i++) {

  136. 				lights[MODEL_LIGHT + 2*i + 0].setBrightness((activeEngine == i) ? 1.f : (patch.engine == i) ? tri : 0.f);

  137. 				lights[MODEL_LIGHT + 2*i + 1].setBrightness((activeEngine == i + 8) ? 1.f : (patch.engine == i + 8) ? tri : 0.f);

  138. 			}

  139. 

  140. 			// Calculate pitch for lowCpu mode if needed

  141. 			float pitch = params[FREQ_PARAM].value;

  142. 			if (lowCpu)

  143. 				pitch += log2f(48000.f * engineGetSampleTime());

  144. 			// Update patch

  145. 			patch.note = 60.f + pitch * 12.f;

  146. 			patch.harmonics = params[HARMONICS_PARAM].value;

  147. 			if (!lpg) {

  148. 				patch.timbre = params[TIMBRE_PARAM].value;

  149. 				patch.morph = params[MORPH_PARAM].value;

  150. 			}

  151. 			else {

  152. 				patch.lpg_colour = params[TIMBRE_PARAM].value;

  153. 				patch.decay = params[MORPH_PARAM].value;

  154. 			}

  155. 			patch.frequency_modulation_amount = params[FREQ_CV_PARAM].value;

  156. 			patch.timbre_modulation_amount = params[TIMBRE_CV_PARAM].value;

  157. 			patch.morph_modulation_amount = params[MORPH_CV_PARAM].value;

  158. 

  159. 			// Update modulations

  160. 			modulations.engine = inputs[ENGINE_INPUT].value / 5.f;

  161. 			modulations.note = inputs[NOTE_INPUT].value * 12.f;

  162. 			modulations.frequency = inputs[FREQ_INPUT].value * 6.f;

  163. 			modulations.harmonics = inputs[HARMONICS_INPUT].value / 5.f;

  164. 			modulations.timbre = inputs[TIMBRE_INPUT].value / 8.f;

  165. 			modulations.morph = inputs[MORPH_INPUT].value / 8.f;

  166. 			// Triggers at around 0.7 V

  167. 			modulations.trigger = inputs[TRIGGER_INPUT].value / 3.f;

  168. 			modulations.level = inputs[LEVEL_INPUT].value / 8.f;

  169. 

  170. 			modulations.frequency_patched = inputs[FREQ_INPUT].active;

  171. 			modulations.timbre_patched = inputs[TIMBRE_INPUT].active;

  172. 			modulations.morph_patched = inputs[MORPH_INPUT].active;

  173. 			modulations.trigger_patched = inputs[TRIGGER_INPUT].active;

  174. 			modulations.level_patched = inputs[LEVEL_INPUT].active;

  175. 

  176. 			// Render frames

  177. 			plaits::Voice::Frame output[blockSize];

  178. 			voice.Render(patch, modulations, output, blockSize);

  179. 

  180. 			// Convert output to frames

  181. 			Frame<2> outputFrames[blockSize];

  182. 			for (int i = 0; i < blockSize; i++) {

  183. 				outputFrames[i].samples[0] = output[i].out / 32768.f;

  184. 				outputFrames[i].samples[1] = output[i].aux / 32768.f;

  185. 			}

  186. 

  187. 			// Convert output

  188. 			if (lowCpu) {

  189. 				int len = min(outputBuffer.capacity(), blockSize);

  190. 				memcpy(outputBuffer.endData(), outputFrames, len * sizeof(Frame<2>));

  191. 				outputBuffer.endIncr(len);

  192. 			}

  193. 			else {

  194. 				outputSrc.setRates(48000, engineGetSampleRate());

  195. 				int inLen = blockSize;

  196. 				int outLen = outputBuffer.capacity();

  197. 				outputSrc.process(outputFrames, &inLen, outputBuffer.endData(), &outLen);

  198. 				outputBuffer.endIncr(outLen);

  199. 			}

  200. 		}

  201. 

  202. 		// Set output

  203. 		if (!outputBuffer.empty()) {

  204. 			Frame<2> outputFrame = outputBuffer.shift();

  205. 			// Inverting op-amp on outputs

  206. 			outputs[OUT_OUTPUT].value = -outputFrame.samples[0] * 5.f;

  207. 			outputs[AUX_OUTPUT].value = -outputFrame.samples[1] * 5.f;

  208. 		}

  209. 	}

  210. };

  211. 

  212. 

  213. static const std::string modelLabels[16] = {

  214. 	"Pair of classic waveforms",

  215. 	"Waveshaping oscillator",

  216. 	"Two operator FM",

  217. 	"Granular formant oscillator",

  218. 	"Harmonic oscillator",

  219. 	"Wavetable oscillator",

  220. 	"Chords",

  221. 	"Vowel and speech synthesis",

  222. 	"Granular cloud",

  223. 	"Filtered noise",

  224. 	"Particle noise",

  225. 	"Inharmonic string modeling",

  226. 	"Modal resonator",

  227. 	"Analog bass drum",

  228. 	"Analog snare drum",

  229. 	"Analog hi-hat",

  230. };

  231. 

  232. 

  233. struct PlaitsWidget : ModuleWidget {

  234. 	PlaitsWidget(Plaits *module) : ModuleWidget(module) {

  235. 		setPanel(SVG::load(assetPlugin(plugin, "res/Plaits.svg")));

  236. 

  237. 		addChild(Widget::create<ScrewSilver>(Vec(RACK_GRID_WIDTH, 0)));

  238. 		addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 2 * RACK_GRID_WIDTH, 0)));

  239. 		addChild(Widget::create<ScrewSilver>(Vec(RACK_GRID_WIDTH, RACK_GRID_HEIGHT - RACK_GRID_WIDTH)));

  240. 		addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 2 * RACK_GRID_WIDTH, RACK_GRID_HEIGHT - RACK_GRID_WIDTH)));

  241. 

  242. 		addParam(ParamWidget::create<TL1105>(mm2px(Vec(23.32685, 14.6539)), module, Plaits::MODEL1_PARAM, 0.0, 1.0, 0.0));

  243. 		addParam(ParamWidget::create<TL1105>(mm2px(Vec(32.22764, 14.6539)), module, Plaits::MODEL2_PARAM, 0.0, 1.0, 0.0));

  244. 		addParam(ParamWidget::create<Rogan3PSWhite>(mm2px(Vec(3.1577, 20.21088)), module, Plaits::FREQ_PARAM, -4.0, 4.0, 0.0));

  245. 		addParam(ParamWidget::create<Rogan3PSWhite>(mm2px(Vec(39.3327, 20.21088)), module, Plaits::HARMONICS_PARAM, 0.0, 1.0, 0.5));

  246. 		addParam(ParamWidget::create<Rogan1PSWhite>(mm2px(Vec(4.04171, 49.6562)), module, Plaits::TIMBRE_PARAM, 0.0, 1.0, 0.5));

  247. 		addParam(ParamWidget::create<Rogan1PSWhite>(mm2px(Vec(42.71716, 49.6562)), module, Plaits::MORPH_PARAM, 0.0, 1.0, 0.5));

  248. 		addParam(ParamWidget::create<Trimpot>(mm2px(Vec(7.88712, 77.60705)), module, Plaits::TIMBRE_CV_PARAM, -1.0, 1.0, 0.0));

  249. 		addParam(ParamWidget::create<Trimpot>(mm2px(Vec(27.2245, 77.60705)), module, Plaits::FREQ_CV_PARAM, -1.0, 1.0, 0.0));

  250. 		addParam(ParamWidget::create<Trimpot>(mm2px(Vec(46.56189, 77.60705)), module, Plaits::MORPH_CV_PARAM, -1.0, 1.0, 0.0));

  251. 

  252. 		addInput(Port::create<PJ301MPort>(mm2px(Vec(3.31381, 92.48067)), Port::INPUT, module, Plaits::ENGINE_INPUT));

  253. 		addInput(Port::create<PJ301MPort>(mm2px(Vec(14.75983, 92.48067)), Port::INPUT, module, Plaits::TIMBRE_INPUT));

  254. 		addInput(Port::create<PJ301MPort>(mm2px(Vec(26.20655, 92.48067)), Port::INPUT, module, Plaits::FREQ_INPUT));

  255. 		addInput(Port::create<PJ301MPort>(mm2px(Vec(37.65257, 92.48067)), Port::INPUT, module, Plaits::MORPH_INPUT));

  256. 		addInput(Port::create<PJ301MPort>(mm2px(Vec(49.0986, 92.48067)), Port::INPUT, module, Plaits::HARMONICS_INPUT));

  257. 		addInput(Port::create<PJ301MPort>(mm2px(Vec(3.31381, 107.08103)), Port::INPUT, module, Plaits::TRIGGER_INPUT));

  258. 		addInput(Port::create<PJ301MPort>(mm2px(Vec(14.75983, 107.08103)), Port::INPUT, module, Plaits::LEVEL_INPUT));

  259. 		addInput(Port::create<PJ301MPort>(mm2px(Vec(26.20655, 107.08103)), Port::INPUT, module, Plaits::NOTE_INPUT));

  260. 

  261. 		addOutput(Port::create<PJ301MPort>(mm2px(Vec(37.65257, 107.08103)), Port::OUTPUT, module, Plaits::OUT_OUTPUT));

  262. 		addOutput(Port::create<PJ301MPort>(mm2px(Vec(49.0986, 107.08103)), Port::OUTPUT, module, Plaits::AUX_OUTPUT));

  263. 

  264. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(mm2px(Vec(28.79498, 23.31649)), module, Plaits::MODEL_LIGHT + 0 * 2));

  265. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(mm2px(Vec(28.79498, 28.71704)), module, Plaits::MODEL_LIGHT + 1 * 2));

  266. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(mm2px(Vec(28.79498, 34.1162)), module, Plaits::MODEL_LIGHT + 2 * 2));

  267. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(mm2px(Vec(28.79498, 39.51675)), module, Plaits::MODEL_LIGHT + 3 * 2));

  268. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(mm2px(Vec(28.79498, 44.91731)), module, Plaits::MODEL_LIGHT + 4 * 2));

  269. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(mm2px(Vec(28.79498, 50.31785)), module, Plaits::MODEL_LIGHT + 5 * 2));

  270. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(mm2px(Vec(28.79498, 55.71771)), module, Plaits::MODEL_LIGHT + 6 * 2));

  271. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(mm2px(Vec(28.79498, 61.11827)), module, Plaits::MODEL_LIGHT + 7 * 2));

  272. 	}

  273. 

  274. 	void appendContextMenu(Menu *menu) override {

  275. 		Plaits *module = dynamic_cast<Plaits*>(this->module);

  276. 

  277. 		struct PlaitsLowCpuItem : MenuItem {

  278. 			Plaits *module;

  279. 			void onAction(EventAction &e) override {

  280. 				module->lowCpu ^= true;

  281. 			}

  282. 		};

  283. 

  284. 		struct PlaitsLPGItem : MenuItem {

  285. 			Plaits *module;

  286. 			void onAction(EventAction &e) override {

  287. 				module->lpg ^= true;

  288. 			}

  289. 		};

  290. 

  291. 		struct PlaitsModelItem : MenuItem {

  292. 			Plaits *module;

  293. 			int model;

  294. 			void onAction(EventAction &e) override {

  295. 				module->patch.engine = model;

  296. 			}

  297. 		};

  298. 

  299. 		menu->addChild(MenuEntry::create());

  300. 		PlaitsLowCpuItem *lowCpuItem = MenuItem::create<PlaitsLowCpuItem>("Low CPU", CHECKMARK(module->lowCpu));

  301. 		lowCpuItem->module = module;

  302. 		menu->addChild(lowCpuItem);

  303. 		PlaitsLPGItem *lpgItem = MenuItem::create<PlaitsLPGItem>("Edit LPG response/decay", CHECKMARK(module->lpg));

  304. 		lpgItem->module = module;

  305. 		menu->addChild(lpgItem);

  306. 

  307. 		menu->addChild(new MenuEntry());

  308. 		menu->addChild(MenuLabel::create("Models"));

  309. 		for (int i = 0; i < 16; i++) {

  310. 			PlaitsModelItem *modelItem = MenuItem::create<PlaitsModelItem>(modelLabels[i], CHECKMARK(module->patch.engine == i));

  311. 			modelItem->module = module;

  312. 			modelItem->model = i;

  313. 			menu->addChild(modelItem);

  314. 		}

  315. 	}

  316. };

  317. 

  318. 

  319. Model *modelPlaits = Model::create<Plaits, PlaitsWidget>("Audible Instruments", "Plaits", "Macro Oscillator 2", OSCILLATOR_TAG, WAVESHAPER_TAG);