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.
1298 Commits
4 Branches
540MB
Tree: 28f39da891
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '28f39da891'
${ noResults }
Rack/plugins/community/repos/Bogaudio/src/EightFO.cpp

291 lines
12KB
Raw Blame History 

  1. 

  2. #include "EightFO.hpp"

  3. #include "dsp/pitch.hpp"

  4. 

  5. void EightFO::onReset() {

  6. 	_resetTrigger.reset();

  7. 	_modulationStep = modulationSteps;

  8. 	_sampleStep = _phasor._sampleRate;

  9. }

  10. 

  11. void EightFO::onSampleRateChange() {

  12. 	_phasor.setSampleRate(engineGetSampleRate());

  13. 	_modulationStep = modulationSteps;

  14. 	_sampleStep = _phasor._sampleRate;

  15. }

  16. 

  17. void EightFO::step() {

  18. 	lights[SLOW_LIGHT].value = _slowMode = params[SLOW_PARAM].value > 0.5f;

  19. 	if (!(

  20. 		outputs[PHASE7_OUTPUT].active ||

  21. 		outputs[PHASE6_OUTPUT].active ||

  22. 		outputs[PHASE5_OUTPUT].active ||

  23. 		outputs[PHASE4_OUTPUT].active ||

  24. 		outputs[PHASE3_OUTPUT].active ||

  25. 		outputs[PHASE2_OUTPUT].active ||

  26. 		outputs[PHASE1_OUTPUT].active ||

  27. 		outputs[PHASE0_OUTPUT].active

  28. 	)) {

  29. 		return;

  30. 	}

  31. 

  32. 	++_modulationStep;

  33. 	if (_modulationStep >= modulationSteps) {

  34. 		_modulationStep = 0;

  35. 

  36. 		float frequency = params[FREQUENCY_PARAM].value;

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

  38. 			frequency += inputs[PITCH_INPUT].value;

  39. 		}

  40. 		if (_slowMode) {

  41. 			frequency -= 8.0f;

  42. 		}

  43. 		else {

  44. 			frequency -= 4.0f;

  45. 		}

  46. 		frequency = cvToFrequency(frequency);

  47. 		if (frequency > 2000.0f) {

  48. 			frequency = 2000.0f;

  49. 		}

  50. 		_phasor.setFrequency(frequency);

  51. 

  52. 		_wave = (Wave)int(params[WAVE_PARAM].value);

  53. 		if (_wave == SQUARE_WAVE) {

  54. 			float pw = params[SAMPLE_PWM_PARAM].value;

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

  56. 				pw *= clamp(inputs[SAMPLE_PWM_INPUT].value / 5.0f, -1.0f, 1.0f);

  57. 			}

  58. 			pw *= 1.0f - 2.0f * _square.minPulseWidth;

  59. 			pw *= 0.5f;

  60. 			pw += 0.5f;

  61. 			_square.setPulseWidth(pw);

  62. 			_sampleSteps = 1;

  63. 		}

  64. 		else {

  65. 			float sample = fabsf(params[SAMPLE_PWM_PARAM].value);

  66. 			if (inputs[SAMPLE_PWM_INPUT].active) {

  67. 				sample *= clamp(fabsf(inputs[SAMPLE_PWM_INPUT].value) / 5.0f, 0.0f, 1.0f);

  68. 			}

  69. 			float maxSampleSteps = (_phasor._sampleRate / _phasor._frequency) / 4.0f;

  70. 			_sampleSteps = clamp((int)(sample * maxSampleSteps), 1, (int)maxSampleSteps);

  71. 			_square.setPulseWidth(SquareOscillator::defaultPulseWidth);

  72. 		}

  73. 

  74. 		_offset = params[OFFSET_PARAM].value;

  75. 		if (inputs[OFFSET_INPUT].active) {

  76. 			_offset *= clamp(inputs[OFFSET_INPUT].value / 5.0f, -1.0f, 1.0f);

  77. 		}

  78. 		_offset *= 5.0f;

  79. 		_scale = params[SCALE_PARAM].value;

  80. 		if (inputs[SCALE_INPUT].active) {

  81. 			_scale *= clamp(inputs[SCALE_INPUT].value / 10.0f, 0.0f, 1.0f);

  82. 		}

  83. 

  84. 		_phase7Offset = phaseOffset(params[PHASE7_PARAM], inputs[PHASE7_INPUT], basePhase7Offset);

  85. 		_phase6Offset = phaseOffset(params[PHASE6_PARAM], inputs[PHASE6_INPUT], basePhase6Offset);

  86. 		_phase5Offset = phaseOffset(params[PHASE5_PARAM], inputs[PHASE5_INPUT], basePhase5Offset);

  87. 		_phase4Offset = phaseOffset(params[PHASE4_PARAM], inputs[PHASE4_INPUT], basePhase4Offset);

  88. 		_phase3Offset = phaseOffset(params[PHASE3_PARAM], inputs[PHASE3_INPUT], basePhase3Offset);

  89. 		_phase2Offset = phaseOffset(params[PHASE2_PARAM], inputs[PHASE2_INPUT], basePhase2Offset);

  90. 		_phase1Offset = phaseOffset(params[PHASE1_PARAM], inputs[PHASE1_INPUT], basePhase1Offset);

  91. 		_phase0Offset = phaseOffset(params[PHASE0_PARAM], inputs[PHASE0_INPUT], basePhase0Offset);

  92. 	}

  93. 

  94. 	if (_resetTrigger.next(inputs[RESET_INPUT].value)) {

  95. 		_phasor.resetPhase();

  96. 	}

  97. 

  98. 	_phasor.advancePhase();

  99. 	bool useSample = false;

  100. 	if (_sampleSteps > 1) {

  101. 		++_sampleStep;

  102. 		if (_sampleStep >= _sampleSteps) {

  103. 			_sampleStep = 0;

  104. 		}

  105. 		else {

  106. 			useSample = true;

  107. 		}

  108. 	}

  109. 	updateOutput(useSample, outputs[PHASE7_OUTPUT], _phase7Offset, _phase7Sample, _phase7Active);

  110. 	updateOutput(useSample, outputs[PHASE6_OUTPUT], _phase6Offset, _phase6Sample, _phase6Active);

  111. 	updateOutput(useSample, outputs[PHASE5_OUTPUT], _phase5Offset, _phase5Sample, _phase5Active);

  112. 	updateOutput(useSample, outputs[PHASE4_OUTPUT], _phase4Offset, _phase4Sample, _phase4Active);

  113. 	updateOutput(useSample, outputs[PHASE3_OUTPUT], _phase3Offset, _phase3Sample, _phase3Active);

  114. 	updateOutput(useSample, outputs[PHASE2_OUTPUT], _phase2Offset, _phase2Sample, _phase2Active);

  115. 	updateOutput(useSample, outputs[PHASE1_OUTPUT], _phase1Offset, _phase1Sample, _phase1Active);

  116. 	updateOutput(useSample, outputs[PHASE0_OUTPUT], _phase0Offset, _phase0Sample, _phase0Active);

  117. }

  118. 

  119. Phasor::phase_delta_t EightFO::phaseOffset(Param& p, Input& i, Phasor::phase_delta_t baseOffset) {

  120. 	float o = p.value * Phasor::maxPhase / 2.0f;

  121. 	if (i.active) {

  122. 		o *= clamp(i.value / 5.0f, -1.0f, 1.0f);

  123. 	}

  124. 	return baseOffset - o;

  125. }

  126. 

  127. void EightFO::updateOutput(bool useSample, Output& output, Phasor::phase_delta_t& offset, float& sample, bool& active) {

  128. 	if (output.active) {

  129. 		if (useSample && active) {

  130. 			output.value = sample;

  131. 		}

  132. 		else {

  133. 			float v = 0.0f;

  134. 			switch (_wave) {

  135. 				case NO_WAVE: {

  136. 					assert(false);

  137. 				}

  138. 				case SINE_WAVE: {

  139. 					v = _sine.nextFromPhasor(_phasor, offset);

  140. 					break;

  141. 				}

  142. 				case TRIANGLE_WAVE: {

  143. 					v = _triangle.nextFromPhasor(_phasor, offset);

  144. 					break;

  145. 				}

  146. 				case RAMP_UP_WAVE: {

  147. 					v = _ramp.nextFromPhasor(_phasor, offset);

  148. 					break;

  149. 				}

  150. 				case RAMP_DOWN_WAVE: {

  151. 					v = -_ramp.nextFromPhasor(_phasor, offset);

  152. 					break;

  153. 				}

  154. 				case SQUARE_WAVE: {

  155. 					v = _square.nextFromPhasor(_phasor, offset);

  156. 					break;

  157. 				}

  158. 			}

  159. 			output.value = sample = amplitude * _scale * v + _offset;

  160. 		}

  161. 		active = true;

  162. 	}

  163. 	else {

  164. 		active = false;

  165. 	}

  166. }

  167. 

  168. struct EightFOWidget : ModuleWidget {

  169. 	static constexpr int hp = 17;

  170. 

  171. 	EightFOWidget(EightFO* module) : ModuleWidget(module) {

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

  173. 

  174. 		{

  175. 			SVGPanel *panel = new SVGPanel();

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

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

  178. 			addChild(panel);

  179. 		}

  180. 

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

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

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

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

  185. 

  186. 		// generated by svg_widgets.rb

  187. 		auto frequencyParamPosition = Vec(40.0, 45.0);

  188. 		auto slowParamPosition = Vec(126.0, 333.7);

  189. 		auto waveParamPosition = Vec(20.0, 168.0);

  190. 		auto samplePwmParamPosition = Vec(100.0, 163.0);

  191. 		auto offsetParamPosition = Vec(40.0, 226.0);

  192. 		auto scaleParamPosition = Vec(100.0, 226.0);

  193. 		auto phase7ParamPosition = Vec(144.0, 40.0);

  194. 		auto phase6ParamPosition = Vec(144.0, 80.0);

  195. 		auto phase5ParamPosition = Vec(144.0, 120.0);

  196. 		auto phase4ParamPosition = Vec(144.0, 160.0);

  197. 		auto phase3ParamPosition = Vec(144.0, 200.0);

  198. 		auto phase2ParamPosition = Vec(144.0, 240.0);

  199. 		auto phase1ParamPosition = Vec(144.0, 280.0);

  200. 		auto phase0ParamPosition = Vec(144.0, 320.0);

  201. 

  202. 		auto phase7InputPosition = Vec(179.0, 36.0);

  203. 		auto phase6InputPosition = Vec(179.0, 76.0);

  204. 		auto phase5InputPosition = Vec(179.0, 116.0);

  205. 		auto phase4InputPosition = Vec(179.0, 156.0);

  206. 		auto phase3InputPosition = Vec(179.0, 196.0);

  207. 		auto phase2InputPosition = Vec(179.0, 236.0);

  208. 		auto phase1InputPosition = Vec(179.0, 276.0);

  209. 		auto phase0InputPosition = Vec(179.0, 316.0);

  210. 		auto samplePwmInputPosition = Vec(14.0, 277.0);

  211. 		auto offsetInputPosition = Vec(52.0, 277.0);

  212. 		auto scaleInputPosition = Vec(90.0, 277.0);

  213. 		auto pitchInputPosition = Vec(14.0, 318.0);

  214. 		auto resetInputPosition = Vec(52.0, 318.0);

  215. 

  216. 		auto phase7OutputPosition = Vec(218.0, 36.0);

  217. 		auto phase6OutputPosition = Vec(218.0, 76.0);

  218. 		auto phase5OutputPosition = Vec(218.0, 116.0);

  219. 		auto phase4OutputPosition = Vec(218.0, 156.0);

  220. 		auto phase3OutputPosition = Vec(218.0, 196.0);

  221. 		auto phase2OutputPosition = Vec(218.0, 236.0);

  222. 		auto phase1OutputPosition = Vec(218.0, 276.0);

  223. 		auto phase0OutputPosition = Vec(218.0, 316.0);

  224. 

  225. 		auto slowLightPosition = Vec(86.0, 335.0);

  226. 		// end generated by svg_widgets.rb

  227. 

  228. 		addParam(ParamWidget::create<Knob68>(frequencyParamPosition, module, EightFO::FREQUENCY_PARAM, -8.0, 5.0, 0.0));

  229. 		{

  230. 			auto w = ParamWidget::create<Knob16>(waveParamPosition, module, EightFO::WAVE_PARAM, 1.0, 5.0, 3.0);

  231. 			auto k = dynamic_cast<SVGKnob*>(w);

  232. 			k->snap = true;

  233. 			k->minAngle = 0.0;

  234. 			k->maxAngle = M_PI;

  235. 			k->speed = 3.0;

  236. 			addParam(w);

  237. 		}

  238. 		addParam(ParamWidget::create<StatefulButton9>(slowParamPosition, module, EightFO::SLOW_PARAM, 0.0, 1.0, 0.0));

  239. 		addParam(ParamWidget::create<Knob26>(samplePwmParamPosition, module, EightFO::SAMPLE_PWM_PARAM, -1.0, 1.0, 0.0));

  240. 		addParam(ParamWidget::create<Knob26>(offsetParamPosition, module, EightFO::OFFSET_PARAM, -1.0, 1.0, 0.0));

  241. 		addParam(ParamWidget::create<Knob26>(scaleParamPosition, module, EightFO::SCALE_PARAM, 0.0, 1.0, 1.0));

  242. 

  243. 		addPhaseParam(phase7ParamPosition, module, EightFO::PHASE7_PARAM, Phasor::phaseToRadians(module->basePhase7Offset));

  244. 		addPhaseParam(phase6ParamPosition, module, EightFO::PHASE6_PARAM, Phasor::phaseToRadians(module->basePhase6Offset));

  245. 		addPhaseParam(phase5ParamPosition, module, EightFO::PHASE5_PARAM, Phasor::phaseToRadians(module->basePhase5Offset));

  246. 		addPhaseParam(phase4ParamPosition, module, EightFO::PHASE4_PARAM, Phasor::phaseToRadians(module->basePhase4Offset));

  247. 		addPhaseParam(phase3ParamPosition, module, EightFO::PHASE3_PARAM, Phasor::phaseToRadians(module->basePhase3Offset));

  248. 		addPhaseParam(phase2ParamPosition, module, EightFO::PHASE2_PARAM, Phasor::phaseToRadians(module->basePhase2Offset));

  249. 		addPhaseParam(phase1ParamPosition, module, EightFO::PHASE1_PARAM, Phasor::phaseToRadians(module->basePhase1Offset));

  250. 		addPhaseParam(phase0ParamPosition, module, EightFO::PHASE0_PARAM, Phasor::phaseToRadians(module->basePhase0Offset));

  251. 

  252. 		addInput(Port::create<Port24>(samplePwmInputPosition, Port::INPUT, module, EightFO::SAMPLE_PWM_INPUT));

  253. 		addInput(Port::create<Port24>(offsetInputPosition, Port::INPUT, module, EightFO::OFFSET_INPUT));

  254. 		addInput(Port::create<Port24>(scaleInputPosition, Port::INPUT, module, EightFO::SCALE_INPUT));

  255. 		addInput(Port::create<Port24>(phase7InputPosition, Port::INPUT, module, EightFO::PHASE7_INPUT));

  256. 		addInput(Port::create<Port24>(phase6InputPosition, Port::INPUT, module, EightFO::PHASE6_INPUT));

  257. 		addInput(Port::create<Port24>(phase5InputPosition, Port::INPUT, module, EightFO::PHASE5_INPUT));

  258. 		addInput(Port::create<Port24>(phase4InputPosition, Port::INPUT, module, EightFO::PHASE4_INPUT));

  259. 		addInput(Port::create<Port24>(phase3InputPosition, Port::INPUT, module, EightFO::PHASE3_INPUT));

  260. 		addInput(Port::create<Port24>(phase2InputPosition, Port::INPUT, module, EightFO::PHASE2_INPUT));

  261. 		addInput(Port::create<Port24>(phase1InputPosition, Port::INPUT, module, EightFO::PHASE1_INPUT));

  262. 		addInput(Port::create<Port24>(phase0InputPosition, Port::INPUT, module, EightFO::PHASE0_INPUT));

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

  264. 		addInput(Port::create<Port24>(resetInputPosition, Port::INPUT, module, EightFO::RESET_INPUT));

  265. 

  266. 		addOutput(Port::create<Port24>(phase7OutputPosition, Port::OUTPUT, module, EightFO::PHASE7_OUTPUT));

  267. 		addOutput(Port::create<Port24>(phase6OutputPosition, Port::OUTPUT, module, EightFO::PHASE6_OUTPUT));

  268. 		addOutput(Port::create<Port24>(phase5OutputPosition, Port::OUTPUT, module, EightFO::PHASE5_OUTPUT));

  269. 		addOutput(Port::create<Port24>(phase4OutputPosition, Port::OUTPUT, module, EightFO::PHASE4_OUTPUT));

  270. 		addOutput(Port::create<Port24>(phase3OutputPosition, Port::OUTPUT, module, EightFO::PHASE3_OUTPUT));

  271. 		addOutput(Port::create<Port24>(phase2OutputPosition, Port::OUTPUT, module, EightFO::PHASE2_OUTPUT));

  272. 		addOutput(Port::create<Port24>(phase1OutputPosition, Port::OUTPUT, module, EightFO::PHASE1_OUTPUT));

  273. 		addOutput(Port::create<Port24>(phase0OutputPosition, Port::OUTPUT, module, EightFO::PHASE0_OUTPUT));

  274. 

  275. 		addChild(ModuleLightWidget::create<SmallLight<GreenLight>>(slowLightPosition, module, EightFO::SLOW_LIGHT));

  276. 	}

  277. 

  278. 	void addPhaseParam(const Vec& position, Module* module, EightFO::ParamsIds paramId, float rotation) {

  279. 		auto w = ParamWidget::create<Knob16>(position, module, paramId, -1.0, 1.0, 0.0);

  280. 		auto k = dynamic_cast<SVGKnob*>(w);

  281. 		k->minAngle += 0.5 * M_PI - rotation;

  282. 		k->maxAngle += 0.5 * M_PI - rotation;

  283. 		addParam(w);

  284. 	}

  285. };

  286. 

  287. RACK_PLUGIN_MODEL_INIT(Bogaudio, EightFO) {

  288.    Model *modelEightFO = createModel<EightFO, EightFOWidget>("Bogaudio-EightFO", "8FO",  "LFO with 8 phased outputs", LFO_TAG);

  289.    return modelEightFO;

  290. }