VCVRack
/
Rack
mirror of https://github.com/VCVRack/Rack.git
1
0
Fork 0
Code Issues 0 Releases 43 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.
1245 Commits
4 Branches
544MB
Tree: ffab729529
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ffab729529'
${ noResults }
Rack/plugins/community/repos/Bogaudio/src/FMOp.cpp

296 lines
10.0KB
Raw Blame History 

  1. 

  2. #include "FMOp.hpp"

  3. #include "dsp/pitch.hpp"

  4. 

  5. #define LINEAR_LEVEL "linearLevel"

  6. 

  7. void FMOp::onReset() {

  8. 	_steps = modulationSteps;

  9. 	_envelope.reset();

  10. 	_gateTrigger.reset();

  11. }

  12. 

  13. void FMOp::onSampleRateChange() {

  14. 	_steps = modulationSteps;

  15. 	float sampleRate = engineGetSampleRate();

  16. 	_envelope.setSampleRate(sampleRate);

  17. 	_phasor.setSampleRate(sampleRate);

  18. 	_decimator.setParams(sampleRate, oversample);

  19. 	_maxFrequency = 0.475f * sampleRate;

  20. 	_feedbackSL.setParams(sampleRate, 5.0f, 1.0f);

  21. 	_depthSL.setParams(sampleRate, 5.0f, 1.0f);

  22. 	_levelSL.setParams(sampleRate, 10.0f, 1.0f);

  23. 	_sustainSL.setParams(sampleRate, 1.0f, 1.0f);

  24. }

  25. 

  26. json_t* FMOp::toJson() {

  27. 	json_t* root = json_object();

  28. 	json_object_set_new(root, LINEAR_LEVEL, json_boolean(_linearLevel));

  29. 	return root;

  30. }

  31. 

  32. void FMOp::fromJson(json_t* root) {

  33. 	json_t* ll = json_object_get(root, LINEAR_LEVEL);

  34. 	if (ll) {

  35. 		_linearLevel = json_is_true(ll);

  36. 	}

  37. }

  38. 

  39. void FMOp::step() {

  40. 	if (!outputs[AUDIO_OUTPUT].active) {

  41. 		lights[ENV_TO_LEVEL_LIGHT].value = params[ENV_TO_LEVEL_PARAM].value > 0.5f;

  42. 		lights[ENV_TO_FEEDBACK_LIGHT].value = params[ENV_TO_FEEDBACK_PARAM].value > 0.5f;

  43. 		lights[ENV_TO_DEPTH_LIGHT].value = params[ENV_TO_DEPTH_PARAM].value > 0.5f;

  44. 		return;

  45. 	}

  46. 	lights[ENV_TO_LEVEL_LIGHT].value = _levelEnvelopeOn;

  47. 	lights[ENV_TO_FEEDBACK_LIGHT].value = _feedbackEnvelopeOn;

  48. 	lights[ENV_TO_DEPTH_LIGHT].value = _depthEnvelopeOn;

  49. 

  50. 	float pitchIn = 0.0f;

  51. 	if (inputs[PITCH_INPUT].active) {

  52. 		pitchIn = inputs[PITCH_INPUT].value;

  53. 	}

  54. 	float gateIn = 0.0f;

  55. 	if (inputs[GATE_INPUT].active) {

  56. 		gateIn = inputs[GATE_INPUT].value;

  57. 	}

  58. 

  59. 	++_steps;

  60. 	if (_steps >= modulationSteps) {

  61. 		_steps = 0;

  62. 

  63. 		float ratio = params[RATIO_PARAM].value;

  64. 		if (ratio < 0.0f) {

  65. 			ratio = std::max(1.0f + ratio, 0.01f);

  66. 		}

  67. 		else {

  68. 			ratio *= 9.0f;

  69. 			ratio += 1.0f;

  70. 		}

  71. 		float frequency = pitchIn;

  72. 		frequency += params[FINE_PARAM].value / 12.0f;

  73. 		frequency = cvToFrequency(frequency);

  74. 		frequency *= ratio;

  75. 		frequency = clamp(frequency, -_maxFrequency, _maxFrequency);

  76. 		_phasor.setFrequency(frequency / (float)oversample);

  77. 

  78. 		bool levelEnvelopeOn = params[ENV_TO_LEVEL_PARAM].value > 0.5f;

  79. 		bool feedbackEnvelopeOn = params[ENV_TO_FEEDBACK_PARAM].value > 0.5f;

  80. 		bool depthEnvelopeOn = params[ENV_TO_DEPTH_PARAM].value > 0.5f;

  81. 		if (_levelEnvelopeOn != levelEnvelopeOn || _feedbackEnvelopeOn != feedbackEnvelopeOn || _depthEnvelopeOn != depthEnvelopeOn) {

  82. 			_levelEnvelopeOn = levelEnvelopeOn;

  83. 			_feedbackEnvelopeOn = feedbackEnvelopeOn;

  84. 			_depthEnvelopeOn = depthEnvelopeOn;

  85. 			bool envelopeOn = _levelEnvelopeOn || _feedbackEnvelopeOn || _depthEnvelopeOn;

  86. 			if (envelopeOn && !_envelopeOn) {

  87. 				_envelope.reset();

  88. 			}

  89. 			_envelopeOn = envelopeOn;

  90. 		}

  91. 		if (_envelopeOn) {

  92. 			float sustain = params[SUSTAIN_PARAM].value;

  93. 			if (inputs[SUSTAIN_INPUT].active) {

  94. 				sustain *= clamp(inputs[SUSTAIN_INPUT].value / 10.0f, 0.0f, 1.0f);

  95. 			}

  96. 			_envelope.setAttack(powf(params[ATTACK_PARAM].value, 2.0f) * 10.f);

  97. 			_envelope.setDecay(powf(params[DECAY_PARAM].value, 2.0f) * 10.f);

  98. 			_envelope.setSustain(_sustainSL.next(sustain));

  99. 			_envelope.setRelease(powf(params[RELEASE_PARAM].value, 2.0f) * 10.f);

  100. 		}

  101. 

  102. 		_feedback = params[FEEDBACK_PARAM].value;

  103. 		if (inputs[FEEDBACK_INPUT].active) {

  104. 			_feedback *= clamp(inputs[FEEDBACK_INPUT].value / 10.0f, 0.0f, 1.0f);

  105. 		}

  106. 

  107. 		_depth = params[DEPTH_PARAM].value;

  108. 		if (inputs[DEPTH_INPUT].active) {

  109. 			_depth *= clamp(inputs[DEPTH_INPUT].value / 10.0f, 0.0f, 1.0f);

  110. 		}

  111. 

  112. 		_level = params[LEVEL_PARAM].value;

  113. 		if (inputs[LEVEL_INPUT].active) {

  114. 			_level *= clamp(inputs[LEVEL_INPUT].value / 10.0f, 0.0f, 1.0f);

  115. 		}

  116. 	}

  117. 

  118. 	float envelope = 0.0f;

  119. 	if (_envelopeOn) {

  120. 		_gateTrigger.process(gateIn);

  121. 		_envelope.setGate(_gateTrigger.isHigh());

  122. 		envelope = _envelope.next();

  123. 	}

  124. 

  125. 	float feedback = _feedbackSL.next(_feedback);

  126. 	if (_feedbackEnvelopeOn) {

  127. 		feedback *= envelope;

  128. 	}

  129. 	bool feedbackOn = feedback > 0.001f;

  130. 

  131. 	float out = _levelSL.next(_level);

  132. 	if (_levelEnvelopeOn) {

  133. 		out *= envelope;

  134. 	}

  135. 

  136. 	float offset = 0.0f;

  137. 	if (feedbackOn) {

  138. 		offset = feedback * _feedbackDelayedSample;

  139. 	}

  140. 

  141. 	if (inputs[FM_INPUT].active) {

  142. 		float depth = _depthSL.next(_depth);

  143. 		if (_depthEnvelopeOn) {

  144. 			depth *= envelope;

  145. 		}

  146. 		offset += inputs[FM_INPUT].value * depth * 2.0f;

  147. 	}

  148. 

  149. 	float sample = 0.0f;

  150. 	if (out > 0.0001f) {

  151. 		Phasor::phase_delta_t o = Phasor::radiansToPhase(offset);

  152. 		if (feedbackOn) {

  153. 			if (_oversampleMix < 1.0f) {

  154. 				_oversampleMix += oversampleMixIncrement;

  155. 			}

  156. 		}

  157. 		else if (_oversampleMix > 0.0f) {

  158. 			_oversampleMix -= oversampleMixIncrement;

  159. 		}

  160. 

  161. 		if (_oversampleMix > 0.0f) {

  162. 			for (int i = 0; i < oversample; ++i) {

  163. 				_phasor.advancePhase();

  164. 				_buffer[i] = _sineTable.nextFromPhasor(_phasor, o);

  165. 			}

  166. 			sample = _oversampleMix * _decimator.next(_buffer);

  167. 		}

  168. 		else {

  169. 			_phasor.advancePhase(oversample);

  170. 		}

  171. 		if (_oversampleMix < 1.0f) {

  172. 			sample += (1.0f - _oversampleMix) * _sineTable.nextFromPhasor(_phasor, o);

  173. 		}

  174. 

  175. 		if (_linearLevel) {

  176. 			sample *= out;

  177. 		}

  178. 		else {

  179. 			out = (1.0f - out) * Amplifier::minDecibels;

  180. 			_amplifier.setLevel(out);

  181. 			sample = _amplifier.next(sample);

  182. 		}

  183. 	}

  184. 	else {

  185. 		_phasor.advancePhase(oversample);

  186. 	}

  187. 

  188. 	outputs[AUDIO_OUTPUT].value = _feedbackDelayedSample = amplitude * sample;

  189. }

  190. 

  191. struct LinearLevelMenuItem : MenuItem {

  192. 	FMOp* _module;

  193. 

  194. 	LinearLevelMenuItem(FMOp* module, const char* label)

  195. 	: _module(module)

  196. 	{

  197. 		this->text = label;

  198. 	}

  199. 

  200. 	void onAction(EventAction &e) override {

  201. 		_module->_linearLevel = !_module->_linearLevel;

  202. 	}

  203. 

  204. 	void step() override {

  205. 		rightText = _module->_linearLevel ? "✔" : "";

  206. 	}

  207. };

  208. 

  209. struct FMOpWidget : ModuleWidget {

  210. 	static constexpr int hp = 10;

  211. 

  212. 	FMOpWidget(FMOp* module) : ModuleWidget(module) {

  213. 		box.size = Vec(RACK_GRID_WIDTH * hp, RACK_GRID_HEIGHT);

  214. 

  215. 		{

  216. 			SVGPanel *panel = new SVGPanel();

  217. 			panel->box.size = box.size;

  218. 			panel->setBackground(SVG::load(assetPlugin(plugin, "res/FMOp.svg")));

  219. 			addChild(panel);

  220. 		}

  221. 

  222. 		addChild(Widget::create<ScrewSilver>(Vec(15, 0)));

  223. 		addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 30, 0)));

  224. 		addChild(Widget::create<ScrewSilver>(Vec(15, 365)));

  225. 		addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 30, 365)));

  226. 

  227. 		// generated by svg_widgets.rb

  228. 		auto ratioParamPosition = Vec(30.0, 45.0);

  229. 		auto fineParamPosition = Vec(112.0, 57.0);

  230. 		auto attackParamPosition = Vec(107.0, 94.0);

  231. 		auto decayParamPosition = Vec(107.0, 139.0);

  232. 		auto sustainParamPosition = Vec(107.0, 184.0);

  233. 		auto releaseParamPosition = Vec(107.0, 229.0);

  234. 		auto depthParamPosition = Vec(36.0, 106.0);

  235. 		auto envToDepthParamPosition = Vec(59.0, 139.7);

  236. 		auto feedbackParamPosition = Vec(36.0, 162.0);

  237. 		auto envToFeedbackParamPosition = Vec(59.0, 195.7);

  238. 		auto levelParamPosition = Vec(36.0, 218.0);

  239. 		auto envToLevelParamPosition = Vec(59.0, 251.7);

  240. 

  241. 		auto depthInputPosition = Vec(15.0, 274.0);

  242. 		auto feedbackInputPosition = Vec(47.0, 274.0);

  243. 		auto levelInputPosition = Vec(79.0, 274.0);

  244. 		auto sustainInputPosition = Vec(111.0, 274.0);

  245. 		auto pitchInputPosition = Vec(15.0, 318.0);

  246. 		auto fmInputPosition = Vec(47.0, 318.0);

  247. 		auto gateInputPosition = Vec(79.0, 318.0);

  248. 

  249. 		auto audioOutputPosition = Vec(111.0, 318.0);

  250. 

  251. 		auto envToDepthLightPosition = Vec(30.0, 141.0);

  252. 		auto envToFeedbackLightPosition = Vec(30.0, 197.0);

  253. 		auto envToLevelLightPosition = Vec(30.0, 253.0);

  254. 		// end generated by svg_widgets.rb

  255. 

  256. 		addParam(ParamWidget::create<Knob38>(ratioParamPosition, module, FMOp::RATIO_PARAM, -1.0, 1.0, 0.0));

  257. 		addParam(ParamWidget::create<Knob16>(fineParamPosition, module, FMOp::FINE_PARAM, -1.0, 1.0, 0.0));

  258. 		addParam(ParamWidget::create<Knob26>(attackParamPosition, module, FMOp::ATTACK_PARAM, 0.0, 1.0, 0.12));

  259. 		addParam(ParamWidget::create<Knob26>(decayParamPosition, module, FMOp::DECAY_PARAM, 0.0, 1.0, 0.31623));

  260. 		addParam(ParamWidget::create<Knob26>(sustainParamPosition, module, FMOp::SUSTAIN_PARAM, 0.0, 1.0, 1.0));

  261. 		addParam(ParamWidget::create<Knob26>(releaseParamPosition, module, FMOp::RELEASE_PARAM, 0.0, 1.0, 0.31623));

  262. 		addParam(ParamWidget::create<Knob26>(depthParamPosition, module, FMOp::DEPTH_PARAM, 0.0, 1.0, 0.0));

  263. 		addParam(ParamWidget::create<Knob26>(feedbackParamPosition, module, FMOp::FEEDBACK_PARAM, 0.0, 1.0, 0.0));

  264. 		addParam(ParamWidget::create<Knob26>(levelParamPosition, module, FMOp::LEVEL_PARAM, 0.0, 1.0, 1.0));

  265. 		addParam(ParamWidget::create<StatefulButton9>(envToLevelParamPosition, module, FMOp::ENV_TO_LEVEL_PARAM, 0.0, 1.0, 0.0));

  266. 		addParam(ParamWidget::create<StatefulButton9>(envToFeedbackParamPosition, module, FMOp::ENV_TO_FEEDBACK_PARAM, 0.0, 1.0, 0.0));

  267. 		addParam(ParamWidget::create<StatefulButton9>(envToDepthParamPosition, module, FMOp::ENV_TO_DEPTH_PARAM, 0.0, 1.0, 0.0));

  268. 

  269. 		addInput(Port::create<Port24>(sustainInputPosition, Port::INPUT, module, FMOp::SUSTAIN_INPUT));

  270. 		addInput(Port::create<Port24>(depthInputPosition, Port::INPUT, module, FMOp::DEPTH_INPUT));

  271. 		addInput(Port::create<Port24>(feedbackInputPosition, Port::INPUT, module, FMOp::FEEDBACK_INPUT));

  272. 		addInput(Port::create<Port24>(levelInputPosition, Port::INPUT, module, FMOp::LEVEL_INPUT));

  273. 		addInput(Port::create<Port24>(pitchInputPosition, Port::INPUT, module, FMOp::PITCH_INPUT));

  274. 		addInput(Port::create<Port24>(gateInputPosition, Port::INPUT, module, FMOp::GATE_INPUT));

  275. 		addInput(Port::create<Port24>(fmInputPosition, Port::INPUT, module, FMOp::FM_INPUT));

  276. 

  277. 		addOutput(Port::create<Port24>(audioOutputPosition, Port::OUTPUT, module, FMOp::AUDIO_OUTPUT));

  278. 

  279. 		addChild(ModuleLightWidget::create<SmallLight<GreenLight>>(envToLevelLightPosition, module, FMOp::ENV_TO_LEVEL_LIGHT));

  280. 		addChild(ModuleLightWidget::create<SmallLight<GreenLight>>(envToFeedbackLightPosition, module, FMOp::ENV_TO_FEEDBACK_LIGHT));

  281. 		addChild(ModuleLightWidget::create<SmallLight<GreenLight>>(envToDepthLightPosition, module, FMOp::ENV_TO_DEPTH_LIGHT));

  282. 	}

  283. 

  284. 	void appendContextMenu(Menu* menu) override {

  285. 	  FMOp* fmop = dynamic_cast<FMOp*>(module);

  286. 		assert(fmop);

  287. 		menu->addChild(new MenuLabel());

  288. 		menu->addChild(new LinearLevelMenuItem(fmop, "Linear level response"));

  289. 	}

  290. };

  291. 

  292. RACK_PLUGIN_MODEL_INIT(Bogaudio, FMOp) {

  293.    Model *modelFMOp = createModel<FMOp, FMOpWidget>("Bogaudio-FMOp", "FM-OP",  "FM oscillator", OSCILLATOR_TAG, SYNTH_VOICE_TAG);

  294.    return modelFMOp;

  295. }