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.
135 Commits
4 Branches
40MB
Tree: b83a55df06
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b83a55df06'
${ noResults }
AudibleInstruments/src/Elements.cpp

317 lines
12KB
Raw Blame History 

  1. #include "AudibleInstruments.hpp"

  2. #include "elements/dsp/part.h"

  3. 

  4. 

  5. struct Elements : Module {

  6. 	enum ParamIds {

  7. 		CONTOUR_PARAM,

  8. 		BOW_PARAM,

  9. 		BLOW_PARAM,

  10. 		STRIKE_PARAM,

  11. 		COARSE_PARAM,

  12. 		FINE_PARAM,

  13. 		FM_PARAM,

  14. 

  15. 		FLOW_PARAM,

  16. 		MALLET_PARAM,

  17. 		GEOMETRY_PARAM,

  18. 		BRIGHTNESS_PARAM,

  19. 

  20. 		BOW_TIMBRE_PARAM,

  21. 		BLOW_TIMBRE_PARAM,

  22. 		STRIKE_TIMBRE_PARAM,

  23. 		DAMPING_PARAM,

  24. 		POSITION_PARAM,

  25. 		SPACE_PARAM,

  26. 

  27. 		BOW_TIMBRE_MOD_PARAM,

  28. 		FLOW_MOD_PARAM,

  29. 		BLOW_TIMBRE_MOD_PARAM,

  30. 		MALLET_MOD_PARAM,

  31. 		STRIKE_TIMBRE_MOD_PARAM,

  32. 		DAMPING_MOD_PARAM,

  33. 		GEOMETRY_MOD_PARAM,

  34. 		POSITION_MOD_PARAM,

  35. 		BRIGHTNESS_MOD_PARAM,

  36. 		SPACE_MOD_PARAM,

  37. 

  38. 		PLAY_PARAM,

  39. 		NUM_PARAMS

  40. 	};

  41. 	enum InputIds {

  42. 		NOTE_INPUT,

  43. 		FM_INPUT,

  44. 		GATE_INPUT,

  45. 		STRENGTH_INPUT,

  46. 		BLOW_INPUT,

  47. 		STRIKE_INPUT,

  48. 

  49. 		BOW_TIMBRE_MOD_INPUT,

  50. 		FLOW_MOD_INPUT,

  51. 		BLOW_TIMBRE_MOD_INPUT,

  52. 		MALLET_MOD_INPUT,

  53. 		STRIKE_TIMBRE_MOD_INPUT,

  54. 		DAMPING_MOD_INPUT,

  55. 		GEOMETRY_MOD_INPUT,

  56. 		POSITION_MOD_INPUT,

  57. 		BRIGHTNESS_MOD_INPUT,

  58. 		SPACE_MOD_INPUT,

  59. 		NUM_INPUTS

  60. 	};

  61. 	enum OutputIds {

  62. 		AUX_OUTPUT,

  63. 		MAIN_OUTPUT,

  64. 		NUM_OUTPUTS

  65. 	};

  66. 	enum LightIds {

  67. 		GATE_LIGHT,

  68. 		EXCITER_LIGHT,

  69. 		RESONATOR_LIGHT,

  70. 		NUM_LIGHTS

  71. 	};

  72. 

  73. 	SampleRateConverter<2> inputSrc;

  74. 	SampleRateConverter<2> outputSrc;

  75. 	DoubleRingBuffer<Frame<2>, 256> inputBuffer;

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

  77. 

  78. 	uint16_t reverb_buffer[32768] = {};

  79. 	elements::Part *part;

  80. 

  81. 	Elements();

  82. 	~Elements();

  83. 	void step() override;

  84. 

  85. 	json_t *dataToJson() override {

  86. 		json_t *rootJ = json_object();

  87. 		json_object_set_new(rootJ, "model", json_integer(getModel()));

  88. 		return rootJ;

  89. 	}

  90. 

  91. 	void dataFromJson(json_t *rootJ) override {

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

  93. 		if (modelJ) {

  94. 			setModel(json_integer_value(modelJ));

  95. 		}

  96. 	}

  97. 

  98. 	int getModel() {

  99. 		return (int)part->resonator_model();

  100. 	}

  101. 

  102. 	void setModel(int model) {

  103. 		part->set_resonator_model((elements::ResonatorModel)model);

  104. 	}

  105. };

  106. 

  107. 

  108. Elements::Elements() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {

  109. 	part = new elements::Part();

  110. 	// In the Mutable Instruments code, Part doesn't initialize itself, so zero it here.

  111. 	memset(part, 0, sizeof(*part));

  112. 	part->Init(reverb_buffer);

  113. 	// Just some random numbers

  114. 	uint32_t seed[3] = {1, 2, 3};

  115. 	part->Seed(seed, 3);

  116. }

  117. 

  118. Elements::~Elements() {

  119. 	delete part;

  120. }

  121. 

  122. void Elements::step() {

  123. 	// Get input

  124. 	if (!inputBuffer.full()) {

  125. 		Frame<2> inputFrame;

  126. 		inputFrame.samples[0] = inputs[BLOW_INPUT].value / 5.0;

  127. 		inputFrame.samples[1] = inputs[STRIKE_INPUT].value / 5.0;

  128. 		inputBuffer.push(inputFrame);

  129. 	}

  130. 

  131. 	// Render frames

  132. 	if (outputBuffer.empty()) {

  133. 		float blow[16] = {};

  134. 		float strike[16] = {};

  135. 		float main[16];

  136. 		float aux[16];

  137. 

  138. 		// Convert input buffer

  139. 		{

  140. 			inputSrc.setRates(engineGetSampleRate(), 32000);

  141. 			Frame<2> inputFrames[16];

  142. 			int inLen = inputBuffer.size();

  143. 			int outLen = 16;

  144. 			inputSrc.process(inputBuffer.startData(), &inLen, inputFrames, &outLen);

  145. 			inputBuffer.startIncr(inLen);

  146. 

  147. 			for (int i = 0; i < outLen; i++) {

  148. 				blow[i] = inputFrames[i].samples[0];

  149. 				strike[i] = inputFrames[i].samples[1];

  150. 			}

  151. 		}

  152. 

  153. 		// Set patch from parameters

  154. 		elements::Patch* p = part->mutable_patch();

  155. 		p->exciter_envelope_shape = params[CONTOUR_PARAM].value;

  156. 		p->exciter_bow_level = params[BOW_PARAM].value;

  157. 		p->exciter_blow_level = params[BLOW_PARAM].value;

  158. 		p->exciter_strike_level = params[STRIKE_PARAM].value;

  159. 

  160. #define BIND(_p, _m, _i) clamp(params[_p].value + 3.3f*quadraticBipolar(params[_m].value)*inputs[_i].value/5.0f, 0.0f, 0.9995f)

  161. 

  162. 		p->exciter_bow_timbre = BIND(BOW_TIMBRE_PARAM, BOW_TIMBRE_MOD_PARAM, BOW_TIMBRE_MOD_INPUT);

  163. 		p->exciter_blow_meta = BIND(FLOW_PARAM, FLOW_MOD_PARAM, FLOW_MOD_INPUT);

  164. 		p->exciter_blow_timbre = BIND(BLOW_TIMBRE_PARAM, BLOW_TIMBRE_MOD_PARAM, BLOW_TIMBRE_MOD_INPUT);

  165. 		p->exciter_strike_meta = BIND(MALLET_PARAM, MALLET_MOD_PARAM, MALLET_MOD_INPUT);

  166. 		p->exciter_strike_timbre = BIND(STRIKE_TIMBRE_PARAM, STRIKE_TIMBRE_MOD_PARAM, STRIKE_TIMBRE_MOD_INPUT);

  167. 		p->resonator_geometry = BIND(GEOMETRY_PARAM, GEOMETRY_MOD_PARAM, GEOMETRY_MOD_INPUT);

  168. 		p->resonator_brightness = BIND(BRIGHTNESS_PARAM, BRIGHTNESS_MOD_PARAM, BRIGHTNESS_MOD_INPUT);

  169. 		p->resonator_damping = BIND(DAMPING_PARAM, DAMPING_MOD_PARAM, DAMPING_MOD_INPUT);

  170. 		p->resonator_position = BIND(POSITION_PARAM, POSITION_MOD_PARAM, POSITION_MOD_INPUT);

  171. 		p->space = clamp(params[SPACE_PARAM].value + params[SPACE_MOD_PARAM].value*inputs[SPACE_MOD_INPUT].value/5.0f, 0.0f, 2.0f);

  172. 

  173. 		// Get performance inputs

  174. 		elements::PerformanceState performance;

  175. 		performance.note = 12.0*inputs[NOTE_INPUT].value + roundf(params[COARSE_PARAM].value) + params[FINE_PARAM].value + 69.0;

  176. 		performance.modulation = 3.3*quarticBipolar(params[FM_PARAM].value) * 49.5 * inputs[FM_INPUT].value/5.0;

  177. 		performance.gate = params[PLAY_PARAM].value >= 1.0 || inputs[GATE_INPUT].value >= 1.0;

  178. 		performance.strength = clamp(1.0 - inputs[STRENGTH_INPUT].value/5.0f, 0.0f, 1.0f);

  179. 

  180. 		// Generate audio

  181. 		part->Process(performance, blow, strike, main, aux, 16);

  182. 

  183. 		// Convert output buffer

  184. 		{

  185. 			Frame<2> outputFrames[16];

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

  187. 				outputFrames[i].samples[0] = main[i];

  188. 				outputFrames[i].samples[1] = aux[i];

  189. 			}

  190. 

  191. 			outputSrc.setRates(32000, engineGetSampleRate());

  192. 			int inLen = 16;

  193. 			int outLen = outputBuffer.capacity();

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

  195. 			outputBuffer.endIncr(outLen);

  196. 		}

  197. 

  198. 		// Set lights

  199. 		lights[GATE_LIGHT].setBrightness(performance.gate ? 0.75 : 0.0);

  200. 		lights[EXCITER_LIGHT].setBrightness(part->exciter_level());

  201. 		lights[RESONATOR_LIGHT].setBrightness(part->resonator_level());

  202. 	}

  203. 

  204. 	// Set output

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

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

  207. 		outputs[AUX_OUTPUT].value = 5.0 * outputFrame.samples[0];

  208. 		outputs[MAIN_OUTPUT].value = 5.0 * outputFrame.samples[1];

  209. 	}

  210. }

  211. 

  212. 

  213. struct ElementsModalItem : MenuItem {

  214. 	Elements *elements;

  215. 	int model;

  216. 	void onAction(const event::Action &e) override {

  217. 		elements->setModel(model);

  218. 	}

  219. 	void step() override {

  220. 		rightText = CHECKMARK(elements->getModel() == model);

  221. 		MenuItem::step();

  222. 	}

  223. };

  224. 

  225. 

  226. struct ElementsWidget : ModuleWidget {

  227. 	ElementsWidget(Elements *module) : ModuleWidget(module) {

  228. 		setPanel(SVG::load(assetPlugin(pluginInstance, "res/Elements.svg")));

  229. 

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

  231. 		addChild(createWidget<ScrewSilver>(Vec(480, 0)));

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

  233. 		addChild(createWidget<ScrewSilver>(Vec(480, 365)));

  234. 

  235. 		addParam(createParam<Rogan1PSWhite>(Vec(28, 42), module, Elements::CONTOUR_PARAM, 0.0, 1.0, 1.0));

  236. 		addParam(createParam<Rogan1PSWhite>(Vec(99, 42), module, Elements::BOW_PARAM, 0.0, 1.0, 0.0));

  237. 		addParam(createParam<Rogan1PSRed>(Vec(169, 42), module, Elements::BLOW_PARAM, 0.0, 1.0, 0.0));

  238. 		addParam(createParam<Rogan1PSGreen>(Vec(239, 42), module, Elements::STRIKE_PARAM, 0.0, 1.0, 0.5));

  239. 		addParam(createParam<Rogan1PSWhite>(Vec(310, 42), module, Elements::COARSE_PARAM, -30.0, 30.0, 0.0));

  240. 		addParam(createParam<Rogan1PSWhite>(Vec(381, 42), module, Elements::FINE_PARAM, -2.0, 2.0, 0.0));

  241. 		addParam(createParam<Rogan1PSWhite>(Vec(451, 42), module, Elements::FM_PARAM, -1.0, 1.0, 0.0));

  242. 

  243. 		addParam(createParam<Rogan3PSRed>(Vec(115, 116), module, Elements::FLOW_PARAM, 0.0, 1.0, 0.5));

  244. 		addParam(createParam<Rogan3PSGreen>(Vec(212, 116), module, Elements::MALLET_PARAM, 0.0, 1.0, 0.5));

  245. 		addParam(createParam<Rogan3PSWhite>(Vec(326, 116), module, Elements::GEOMETRY_PARAM, 0.0, 1.0, 0.5));

  246. 		addParam(createParam<Rogan3PSWhite>(Vec(423, 116), module, Elements::BRIGHTNESS_PARAM, 0.0, 1.0, 0.5));

  247. 

  248. 		addParam(createParam<Rogan1PSWhite>(Vec(99, 202), module, Elements::BOW_TIMBRE_PARAM, 0.0, 1.0, 0.5));

  249. 		addParam(createParam<Rogan1PSRed>(Vec(170, 202), module, Elements::BLOW_TIMBRE_PARAM, 0.0, 1.0, 0.5));

  250. 		addParam(createParam<Rogan1PSGreen>(Vec(239, 202), module, Elements::STRIKE_TIMBRE_PARAM, 0.0, 1.0, 0.5));

  251. 		addParam(createParam<Rogan1PSWhite>(Vec(310, 202), module, Elements::DAMPING_PARAM, 0.0, 1.0, 0.5));

  252. 		addParam(createParam<Rogan1PSWhite>(Vec(380, 202), module, Elements::POSITION_PARAM, 0.0, 1.0, 0.5));

  253. 		addParam(createParam<Rogan1PSWhite>(Vec(451, 202), module, Elements::SPACE_PARAM, 0.0, 2.0, 0.0));

  254. 

  255. 		addParam(createParam<Trimpot>(Vec(104.5, 273), module, Elements::BOW_TIMBRE_MOD_PARAM, -1.0, 1.0, 0.0));

  256. 		addParam(createParam<Trimpot>(Vec(142.5, 273), module, Elements::FLOW_MOD_PARAM, -1.0, 1.0, 0.0));

  257. 		addParam(createParam<Trimpot>(Vec(181.5, 273), module, Elements::BLOW_TIMBRE_MOD_PARAM, -1.0, 1.0, 0.0));

  258. 		addParam(createParam<Trimpot>(Vec(219.5, 273), module, Elements::MALLET_MOD_PARAM, -1.0, 1.0, 0.0));

  259. 		addParam(createParam<Trimpot>(Vec(257.5, 273), module, Elements::STRIKE_TIMBRE_MOD_PARAM, -1.0, 1.0, 0.0));

  260. 		addParam(createParam<Trimpot>(Vec(315.5, 273), module, Elements::DAMPING_MOD_PARAM, -1.0, 1.0, 0.0));

  261. 		addParam(createParam<Trimpot>(Vec(354.5, 273), module, Elements::GEOMETRY_MOD_PARAM, -1.0, 1.0, 0.0));

  262. 		addParam(createParam<Trimpot>(Vec(392.5, 273), module, Elements::POSITION_MOD_PARAM, -1.0, 1.0, 0.0));

  263. 		addParam(createParam<Trimpot>(Vec(430.5, 273), module, Elements::BRIGHTNESS_MOD_PARAM, -1.0, 1.0, 0.0));

  264. 		addParam(createParam<Trimpot>(Vec(469.5, 273), module, Elements::SPACE_MOD_PARAM, -2.0, 2.0, 0.0));

  265. 

  266. 		addInput(createPort<PJ301MPort>(Vec(20, 178), PortWidget::INPUT, module, Elements::NOTE_INPUT));

  267. 		addInput(createPort<PJ301MPort>(Vec(55, 178), PortWidget::INPUT, module, Elements::FM_INPUT));

  268. 

  269. 		addInput(createPort<PJ301MPort>(Vec(20, 224), PortWidget::INPUT, module, Elements::GATE_INPUT));

  270. 		addInput(createPort<PJ301MPort>(Vec(55, 224), PortWidget::INPUT, module, Elements::STRENGTH_INPUT));

  271. 

  272. 		addInput(createPort<PJ301MPort>(Vec(20, 270), PortWidget::INPUT, module, Elements::BLOW_INPUT));

  273. 		addInput(createPort<PJ301MPort>(Vec(55, 270), PortWidget::INPUT, module, Elements::STRIKE_INPUT));

  274. 

  275. 		addOutput(createPort<PJ301MPort>(Vec(20, 316), PortWidget::OUTPUT, module, Elements::AUX_OUTPUT));

  276. 		addOutput(createPort<PJ301MPort>(Vec(55, 316), PortWidget::OUTPUT, module, Elements::MAIN_OUTPUT));

  277. 

  278. 		addInput(createPort<PJ301MPort>(Vec(101, 316), PortWidget::INPUT, module, Elements::BOW_TIMBRE_MOD_INPUT));

  279. 		addInput(createPort<PJ301MPort>(Vec(139, 316), PortWidget::INPUT, module, Elements::FLOW_MOD_INPUT));

  280. 		addInput(createPort<PJ301MPort>(Vec(178, 316), PortWidget::INPUT, module, Elements::BLOW_TIMBRE_MOD_INPUT));

  281. 		addInput(createPort<PJ301MPort>(Vec(216, 316), PortWidget::INPUT, module, Elements::MALLET_MOD_INPUT));

  282. 		addInput(createPort<PJ301MPort>(Vec(254, 316), PortWidget::INPUT, module, Elements::STRIKE_TIMBRE_MOD_INPUT));

  283. 		addInput(createPort<PJ301MPort>(Vec(312, 316), PortWidget::INPUT, module, Elements::DAMPING_MOD_INPUT));

  284. 		addInput(createPort<PJ301MPort>(Vec(350, 316), PortWidget::INPUT, module, Elements::GEOMETRY_MOD_INPUT));

  285. 		addInput(createPort<PJ301MPort>(Vec(389, 316), PortWidget::INPUT, module, Elements::POSITION_MOD_INPUT));

  286. 		addInput(createPort<PJ301MPort>(Vec(427, 316), PortWidget::INPUT, module, Elements::BRIGHTNESS_MOD_INPUT));

  287. 		addInput(createPort<PJ301MPort>(Vec(466, 316), PortWidget::INPUT, module, Elements::SPACE_MOD_INPUT));

  288. 

  289. 		addParam(createParam<CKD6>(Vec(36, 116), module, Elements::PLAY_PARAM, 0.0, 1.0, 0.0));

  290. 

  291. 		struct GateLight : YellowLight {

  292. 			GateLight() {

  293. 				box.size = Vec(28-6, 28-6);

  294. 				bgColor = COLOR_BLACK_TRANSPARENT;

  295. 			}

  296. 		};

  297. 

  298. 		addChild(createLight<GateLight>(Vec(36+3, 116+3), module, Elements::GATE_LIGHT));

  299. 		addChild(createLight<MediumLight<GreenLight>>(Vec(184, 165), module, Elements::EXCITER_LIGHT));

  300. 		addChild(createLight<MediumLight<RedLight>>(Vec(395, 165), module, Elements::RESONATOR_LIGHT));

  301. 	}

  302. 

  303. 	void appendContextMenu(Menu *menu) override {

  304. 		Elements *elements = dynamic_cast<Elements*>(module);

  305. 		assert(elements);

  306. 

  307. 		menu->addChild(construct<MenuLabel>());

  308. 		menu->addChild(construct<MenuLabel>(&MenuLabel::text, "Alternative models"));

  309. 		menu->addChild(construct<ElementsModalItem>(&MenuItem::text, "Original", &ElementsModalItem::elements, elements, &ElementsModalItem::model, 0));

  310. 		menu->addChild(construct<ElementsModalItem>(&MenuItem::text, "Non-linear string", &ElementsModalItem::elements, elements, &ElementsModalItem::model, 1));

  311. 		menu->addChild(construct<ElementsModalItem>(&MenuItem::text, "Chords", &ElementsModalItem::elements, elements, &ElementsModalItem::model, 2));

  312. 	}

  313. };

  314. 

  315. 

  316. Model *modelElements = createModel<Elements, ElementsWidget>("Elements");