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.
197 Commits
4 Branches
8.5MB
Branch: v1
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'v1'
${ noResults }
AudibleInstruments/src/Tides2.cpp

310 lines
12KB
Raw Permalink Blame History 

  1. #include "plugin.hpp"

  2. #include "stmlib/dsp/hysteresis_quantizer.h"

  3. #include "stmlib/dsp/units.h"

  4. #include "tides2/poly_slope_generator.h"

  5. #include "tides2/ramp_extractor.h"

  6. #include "tides2/io_buffer.h"

  7. 

  8. 

  9. static const float kRootScaled[3] = {

  10. 	0.125f,

  11. 	2.0f,

  12. 	130.81f

  13. };

  14. 

  15. static const tides2::Ratio kRatios[20] = {

  16. 	{ 0.0625f, 16 },

  17. 	{ 0.125f, 8 },

  18. 	{ 0.1666666f, 6 },

  19. 	{ 0.25f, 4 },

  20. 	{ 0.3333333f, 3 },

  21. 	{ 0.5f, 2 },

  22. 	{ 0.6666666f, 3 },

  23. 	{ 0.75f, 4 },

  24. 	{ 0.8f, 5 },

  25. 	{ 1, 1 },

  26. 	{ 1, 1 },

  27. 	{ 1.25f, 4 },

  28. 	{ 1.3333333f, 3 },

  29. 	{ 1.5f, 2 },

  30. 	{ 2.0f, 1 },

  31. 	{ 3.0f, 1 },

  32. 	{ 4.0f, 1 },

  33. 	{ 6.0f, 1 },

  34. 	{ 8.0f, 1 },

  35. 	{ 16.0f, 1 },

  36. };

  37. 

  38. 

  39. struct Tides2 : Module {

  40. 	enum ParamIds {

  41. 		RANGE_PARAM,

  42. 		MODE_PARAM,

  43. 		RAMP_PARAM,

  44. 		FREQUENCY_PARAM,

  45. 		SHAPE_PARAM,

  46. 		SMOOTHNESS_PARAM,

  47. 		SLOPE_PARAM,

  48. 		SHIFT_PARAM,

  49. 		SLOPE_CV_PARAM,

  50. 		FREQUENCY_CV_PARAM,

  51. 		SMOOTHNESS_CV_PARAM,

  52. 		SHAPE_CV_PARAM,

  53. 		SHIFT_CV_PARAM,

  54. 		NUM_PARAMS

  55. 	};

  56. 	enum InputIds {

  57. 		SLOPE_INPUT,

  58. 		FREQUENCY_INPUT,

  59. 		V_OCT_INPUT,

  60. 		SMOOTHNESS_INPUT,

  61. 		SHAPE_INPUT,

  62. 		SHIFT_INPUT,

  63. 		TRIG_INPUT,

  64. 		CLOCK_INPUT,

  65. 		NUM_INPUTS

  66. 	};

  67. 	enum OutputIds {

  68. 		ENUMS(OUT_OUTPUTS, 4),

  69. 		NUM_OUTPUTS

  70. 	};

  71. 	enum LightIds {

  72. 		ENUMS(RANGE_LIGHT, 2),

  73. 		ENUMS(OUTPUT_MODE_LIGHT, 2),

  74. 		ENUMS(RAMP_MODE_LIGHT, 2),

  75. 		ENUMS(OUTPUT_LIGHTS, 4),

  76. 		NUM_LIGHTS

  77. 	};

  78. 

  79. 	tides2::PolySlopeGenerator poly_slope_generator;

  80. 	tides2::RampExtractor ramp_extractor;

  81. 	stmlib::HysteresisQuantizer ratio_index_quantizer;

  82. 

  83. 	// State

  84. 	int range;

  85. 	tides2::OutputMode output_mode;

  86. 	tides2::RampMode ramp_mode;

  87. 	dsp::BooleanTrigger rangeTrigger;

  88. 	dsp::BooleanTrigger modeTrigger;

  89. 	dsp::BooleanTrigger rampTrigger;

  90. 

  91. 	// Buffers

  92. 	tides2::PolySlopeGenerator::OutputSample out[tides2::kBlockSize] = {};

  93. 	stmlib::GateFlags trig_flags[tides2::kBlockSize] = {};

  94. 	stmlib::GateFlags clock_flags[tides2::kBlockSize] = {};

  95. 	stmlib::GateFlags previous_trig_flag = stmlib::GATE_FLAG_LOW;

  96. 	stmlib::GateFlags previous_clock_flag = stmlib::GATE_FLAG_LOW;

  97. 

  98. 	bool must_reset_ramp_extractor = true;

  99. 	tides2::OutputMode previous_output_mode = tides2::OUTPUT_MODE_GATES;

  100. 	uint8_t frame = 0;

  101. 

  102. 	Tides2() {

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

  104. 		configParam(RANGE_PARAM, 0.0, 1.0, 0.0, "Frequency range");

  105. 		configParam(MODE_PARAM, 0.0, 1.0, 0.0, "Output mode");

  106. 		configParam(FREQUENCY_PARAM, -48, 48, 0.0, "Frequency");

  107. 		configParam(SHAPE_PARAM, 0.0, 1.0, 0.5, "Shape");

  108. 		configParam(RAMP_PARAM, 0.0, 1.0, 0.0, "Ramp mode");

  109. 		configParam(SMOOTHNESS_PARAM, 0.0, 1.0, 0.5, "Waveshape transformation");

  110. 		configParam(SLOPE_PARAM, 0.0, 1.0, 0.5, "Ascending/descending ratio");

  111. 		configParam(SHIFT_PARAM, 0.0, 1.0, 0.5, "Output polarization and shifting");

  112. 		configParam(SLOPE_CV_PARAM, -1.0, 1.0, 0.0, "Slope CV");

  113. 		configParam(FREQUENCY_CV_PARAM, -1.0, 1.0, 0.0, "Frequency CV");

  114. 		configParam(SMOOTHNESS_CV_PARAM, -1.0, 1.0, 0.0, "Smoothness CV");

  115. 		configParam(SHAPE_CV_PARAM, -1.0, 1.0, 0.0, "Shape CV");

  116. 		configParam(SHIFT_CV_PARAM, -1.0, 1.0, 0.0, "Shift CV");

  117. 

  118. 		poly_slope_generator.Init();

  119. 		ratio_index_quantizer.Init();

  120. 		onReset();

  121. 		onSampleRateChange();

  122. 	}

  123. 

  124. 	void onReset() override {

  125. 		range = 1;

  126. 		output_mode = tides2::OUTPUT_MODE_GATES;

  127. 		ramp_mode = tides2::RAMP_MODE_LOOPING;

  128. 	}

  129. 

  130. 	void onRandomize() override {

  131. 		range = random::u32() % 3;

  132. 		output_mode = (tides2::OutputMode)(random::u32() % 4);

  133. 		ramp_mode = (tides2::RampMode)(random::u32() % 3);

  134. 	}

  135. 

  136. 	void onSampleRateChange() override {

  137. 		ramp_extractor.Init(APP->engine->getSampleRate(), 40.f / APP->engine->getSampleRate());

  138. 	}

  139. 

  140. 	json_t* dataToJson() override {

  141. 		json_t* rootJ = json_object();

  142. 

  143. 		json_object_set_new(rootJ, "range", json_integer(range));

  144. 		json_object_set_new(rootJ, "output", json_integer(output_mode));

  145. 		json_object_set_new(rootJ, "ramp", json_integer(ramp_mode));

  146. 

  147. 		return rootJ;

  148. 	}

  149. 

  150. 	void dataFromJson(json_t* rootJ) override {

  151. 		json_t* rangeJ = json_object_get(rootJ, "range");

  152. 		if (rangeJ)

  153. 			range = json_integer_value(rangeJ);

  154. 

  155. 		json_t* outputJ = json_object_get(rootJ, "output");

  156. 		if (outputJ)

  157. 			output_mode = (tides2::OutputMode) json_integer_value(outputJ);

  158. 

  159. 		json_t* rampJ = json_object_get(rootJ, "ramp");

  160. 		if (rampJ)

  161. 			ramp_mode = (tides2::RampMode) json_integer_value(rampJ);

  162. 	}

  163. 

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

  165. 		// Switches

  166. 		if (rangeTrigger.process(params[RANGE_PARAM].getValue() > 0.f)) {

  167. 			range = (range + 1) % 3;

  168. 		}

  169. 		if (modeTrigger.process(params[MODE_PARAM].getValue() > 0.f)) {

  170. 			output_mode = (tides2::OutputMode)((output_mode + 1) % 4);

  171. 		}

  172. 		if (rampTrigger.process(params[RAMP_PARAM].getValue() > 0.f)) {

  173. 			ramp_mode = (tides2::RampMode)((ramp_mode + 1) % 3);

  174. 		}

  175. 

  176. 		// Input gates

  177. 		trig_flags[frame] = stmlib::ExtractGateFlags(previous_trig_flag, inputs[TRIG_INPUT].getVoltage() >= 1.7f);

  178. 		previous_trig_flag = trig_flags[frame];

  179. 

  180. 		clock_flags[frame] = stmlib::ExtractGateFlags(previous_clock_flag, inputs[CLOCK_INPUT].getVoltage() >= 1.7f);

  181. 		previous_clock_flag = clock_flags[frame];

  182. 

  183. 		// Process block

  184. 		if (++frame >= tides2::kBlockSize) {

  185. 			frame = 0;

  186. 

  187. 			tides2::Range range_mode = (range < 2) ? tides2::RANGE_CONTROL : tides2::RANGE_AUDIO;

  188. 			float note = clamp(params[FREQUENCY_PARAM].getValue() + 12.f * inputs[V_OCT_INPUT].getVoltage(), -96.f, 96.f);

  189. 			float fm = clamp(params[FREQUENCY_CV_PARAM].getValue() * inputs[FREQUENCY_INPUT].getVoltage() * 12.f, -96.f, 96.f);

  190. 			float transposition = note + fm;

  191. 

  192. 			float ramp[tides2::kBlockSize];

  193. 			float frequency;

  194. 

  195. 			if (inputs[CLOCK_INPUT].isConnected()) {

  196. 				if (must_reset_ramp_extractor) {

  197. 					ramp_extractor.Reset();

  198. 				}

  199. 

  200. 				tides2::Ratio r = ratio_index_quantizer.Lookup(kRatios, 0.5f + transposition * 0.0105f, 20);

  201. 				frequency = ramp_extractor.Process(

  202. 				              range_mode == tides2::RANGE_AUDIO,

  203. 				              range_mode == tides2::RANGE_AUDIO && ramp_mode == tides2::RAMP_MODE_AR,

  204. 				              r,

  205. 				              clock_flags,

  206. 				              ramp,

  207. 				              tides2::kBlockSize);

  208. 				must_reset_ramp_extractor = false;

  209. 			}

  210. 			else {

  211. 				frequency = kRootScaled[range] / args.sampleRate * stmlib::SemitonesToRatio(transposition);

  212. 				must_reset_ramp_extractor = true;

  213. 			}

  214. 

  215. 			// Get parameters

  216. 			float slope = clamp(params[SLOPE_PARAM].getValue() + dsp::cubic(params[SLOPE_CV_PARAM].getValue()) * inputs[SLOPE_INPUT].getVoltage() / 10.f, 0.f, 1.f);

  217. 			float shape = clamp(params[SHAPE_PARAM].getValue() + dsp::cubic(params[SHAPE_CV_PARAM].getValue()) * inputs[SHAPE_INPUT].getVoltage() / 10.f, 0.f, 1.f);

  218. 			float smoothness = clamp(params[SMOOTHNESS_PARAM].getValue() + dsp::cubic(params[SMOOTHNESS_CV_PARAM].getValue()) * inputs[SMOOTHNESS_INPUT].getVoltage() / 10.f, 0.f, 1.f);

  219. 			float shift = clamp(params[SHIFT_PARAM].getValue() + dsp::cubic(params[SHIFT_CV_PARAM].getValue()) * inputs[SHIFT_INPUT].getVoltage() / 10.f, 0.f, 1.f);

  220. 

  221. 			if (output_mode != previous_output_mode) {

  222. 				poly_slope_generator.Reset();

  223. 				previous_output_mode = output_mode;

  224. 			}

  225. 

  226. 			// Render generator

  227. 			poly_slope_generator.Render(

  228. 			  ramp_mode,

  229. 			  output_mode,

  230. 			  range_mode,

  231. 			  frequency,

  232. 			  slope,

  233. 			  shape,

  234. 			  smoothness,

  235. 			  shift,

  236. 			  trig_flags,

  237. 			  !inputs[TRIG_INPUT].isConnected() && inputs[CLOCK_INPUT].isConnected() ? ramp : NULL,

  238. 			  out,

  239. 			  tides2::kBlockSize);

  240. 

  241. 			// Set lights

  242. 			lights[RANGE_LIGHT + 0].value = (range == 0 || range == 1);

  243. 			lights[RANGE_LIGHT + 1].value = (range == 1 || range == 2);

  244. 			lights[OUTPUT_MODE_LIGHT + 0].value = (output_mode == tides2::OUTPUT_MODE_AMPLITUDE || output_mode == tides2::OUTPUT_MODE_SLOPE_PHASE);

  245. 			lights[OUTPUT_MODE_LIGHT + 1].value = (output_mode == tides2::OUTPUT_MODE_FREQUENCY || output_mode == tides2::OUTPUT_MODE_SLOPE_PHASE);

  246. 			lights[RAMP_MODE_LIGHT + 0].value = (ramp_mode == tides2::RAMP_MODE_AD || ramp_mode == tides2::RAMP_MODE_LOOPING);

  247. 			lights[RAMP_MODE_LIGHT + 1].value = (ramp_mode == tides2::RAMP_MODE_AR || ramp_mode == tides2::RAMP_MODE_LOOPING);

  248. 		}

  249. 

  250. 		// Outputs

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

  252. 			float value = out[frame].channel[i];

  253. 			outputs[OUT_OUTPUTS + i].setVoltage(value);

  254. 			lights[OUTPUT_LIGHTS + i].setSmoothBrightness(value, args.sampleTime);

  255. 		}

  256. 	}

  257. };

  258. 

  259. 

  260. struct Tides2Widget : ModuleWidget {

  261. 	Tides2Widget(Tides2* module) {

  262. 		setModule(module);

  263. 		setPanel(APP->window->loadSvg(asset::plugin(pluginInstance, "res/Tides2.svg")));

  264. 

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

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

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

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

  269. 

  270. 		addParam(createParamCentered<TL1105>(mm2px(Vec(7.425, 16.15)), module, Tides2::RANGE_PARAM));

  271. 		addParam(createParamCentered<TL1105>(mm2px(Vec(63.325, 16.15)), module, Tides2::MODE_PARAM));

  272. 		addParam(createParamCentered<Rogan3PSWhite>(mm2px(Vec(16.325, 33.449)), module, Tides2::FREQUENCY_PARAM));

  273. 		addParam(createParamCentered<Rogan3PSWhite>(mm2px(Vec(54.425, 33.449)), module, Tides2::SHAPE_PARAM));

  274. 		addParam(createParamCentered<TL1105>(mm2px(Vec(35.375, 38.699)), module, Tides2::RAMP_PARAM));

  275. 		addParam(createParamCentered<Rogan1PSWhite>(mm2px(Vec(35.375, 55.549)), module, Tides2::SMOOTHNESS_PARAM));

  276. 		addParam(createParamCentered<Rogan1PSWhite>(mm2px(Vec(11.575, 60.599)), module, Tides2::SLOPE_PARAM));

  277. 		addParam(createParamCentered<Rogan1PSWhite>(mm2px(Vec(59.175, 60.599)), module, Tides2::SHIFT_PARAM));

  278. 		addParam(createParamCentered<Trimpot>(mm2px(Vec(9.276, 80.599)), module, Tides2::SLOPE_CV_PARAM));

  279. 		addParam(createParamCentered<Trimpot>(mm2px(Vec(22.324, 80.599)), module, Tides2::FREQUENCY_CV_PARAM));

  280. 		addParam(createParamCentered<Trimpot>(mm2px(Vec(35.375, 80.599)), module, Tides2::SMOOTHNESS_CV_PARAM));

  281. 		addParam(createParamCentered<Trimpot>(mm2px(Vec(48.425, 80.599)), module, Tides2::SHAPE_CV_PARAM));

  282. 		addParam(createParamCentered<Trimpot>(mm2px(Vec(61.475, 80.599)), module, Tides2::SHIFT_CV_PARAM));

  283. 

  284. 		addInput(createInputCentered<PJ301MPort>(mm2px(Vec(6.775, 96.499)), module, Tides2::SLOPE_INPUT));

  285. 		addInput(createInputCentered<PJ301MPort>(mm2px(Vec(18.225, 96.499)), module, Tides2::FREQUENCY_INPUT));

  286. 		addInput(createInputCentered<PJ301MPort>(mm2px(Vec(29.675, 96.499)), module, Tides2::V_OCT_INPUT));

  287. 		addInput(createInputCentered<PJ301MPort>(mm2px(Vec(41.125, 96.499)), module, Tides2::SMOOTHNESS_INPUT));

  288. 		addInput(createInputCentered<PJ301MPort>(mm2px(Vec(52.575, 96.499)), module, Tides2::SHAPE_INPUT));

  289. 		addInput(createInputCentered<PJ301MPort>(mm2px(Vec(64.025, 96.499)), module, Tides2::SHIFT_INPUT));

  290. 		addInput(createInputCentered<PJ301MPort>(mm2px(Vec(6.775, 111.099)), module, Tides2::TRIG_INPUT));

  291. 		addInput(createInputCentered<PJ301MPort>(mm2px(Vec(18.225, 111.099)), module, Tides2::CLOCK_INPUT));

  292. 

  293. 		addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(29.675, 111.099)), module, Tides2::OUT_OUTPUTS + 0));

  294. 		addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(41.125, 111.099)), module, Tides2::OUT_OUTPUTS + 1));

  295. 		addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(52.575, 111.099)), module, Tides2::OUT_OUTPUTS + 2));

  296. 		addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(64.025, 111.099)), module, Tides2::OUT_OUTPUTS + 3));

  297. 

  298. 		addChild(createLightCentered<MediumLight<GreenRedLight>>(mm2px(Vec(13.776, 16.149)), module, Tides2::RANGE_LIGHT));

  299. 		addChild(createLightCentered<MediumLight<GreenRedLight>>(mm2px(Vec(56.975, 16.149)), module, Tides2::OUTPUT_MODE_LIGHT));

  300. 		addChild(createLightCentered<MediumLight<GreenRedLight>>(mm2px(Vec(35.375, 33.449)), module, Tides2::RAMP_MODE_LIGHT));

  301. 		addChild(createLightCentered<MediumLight<GreenLight>>(mm2px(Vec(26.174, 104.749)), module, Tides2::OUTPUT_LIGHTS + 0));

  302. 		addChild(createLightCentered<MediumLight<GreenLight>>(mm2px(Vec(37.625, 104.749)), module, Tides2::OUTPUT_LIGHTS + 1));

  303. 		addChild(createLightCentered<MediumLight<GreenLight>>(mm2px(Vec(49.075, 104.749)), module, Tides2::OUTPUT_LIGHTS + 2));

  304. 		addChild(createLightCentered<MediumLight<GreenLight>>(mm2px(Vec(60.525, 104.749)), module, Tides2::OUTPUT_LIGHTS + 3));

  305. 	}

  306. };

  307. 

  308. 

  309. Model* modelTides2 = createModel<Tides2, Tides2Widget>("Tides2");