BogaudioModules

commit e683255d304140ee39cb1e2d19ef7ee2d93a865b
parent 025794301165f10286395b58d361fbed80db624a
Author: Matt Demanett <matt@demanett.net>
Date:   Fri, 13 Sep 2019 21:50:20 -0400

Poly: PAN, XFADE.

Diffstat:
M
src/Pan.cpp
 | 
36
++++++++++++++++++++++--------------
M
src/Pan.hpp
 | 
12
+++++++-----
M
src/XFade.cpp
 | 
37
++++++++++++++++++++++++-------------
M
src/XFade.hpp
 | 
16
+++++++++++-----

4 files changed, 64 insertions(+), 37 deletions(-)
diff --git a/src/Pan.cpp b/src/Pan.cpp
@@ -3,33 +3,41 @@
 #include "mixer.hpp"
 
 void Pan::sampleRateChange() {
-	_slew1.setParams(APP->engine->getSampleRate(), MixerChannel::panSlewTimeMS, 2.0f);
-	_slew2.setParams(APP->engine->getSampleRate(), MixerChannel::panSlewTimeMS, 2.0f);
+	for (int c = 0; c < maxChannels; ++c) {
+		_slew1[c].setParams(APP->engine->getSampleRate(), MixerChannel::panSlewTimeMS, 2.0f);
+		_slew2[c].setParams(APP->engine->getSampleRate(), MixerChannel::panSlewTimeMS, 2.0f);
+	}
 }
 
-void Pan::processChannel(const ProcessArgs& args, int _c) {
-	if (!((inputs[IN1_INPUT].isConnected() || inputs[IN2_INPUT].isConnected()) && (outputs[L_OUTPUT].isConnected() || outputs[R_OUTPUT].isConnected()))) {
-		return;
-	}
+bool Pan::active() {
+	return (inputs[IN1_INPUT].isConnected() || inputs[IN2_INPUT].isConnected()) && (outputs[L_OUTPUT].isConnected() || outputs[R_OUTPUT].isConnected());
+}
+
+int Pan::channels() {
+	return std::max(inputs[IN1_INPUT].getChannels(), inputs[IN2_INPUT].getChannels());
+}
 
+void Pan::processChannel(const ProcessArgs& args, int c) {
 	float pan = params[PAN1_PARAM].getValue();
 	if (inputs[CV1_INPUT].isConnected()) {
-		pan *= clamp(inputs[CV1_INPUT].getVoltage() / 5.0f, -1.0f, 1.0f);
+		pan *= clamp(inputs[CV1_INPUT].getPolyVoltage(c) / 5.0f, -1.0f, 1.0f);
 	}
-	_panner1.setPan(_slew1.next(pan));
+	_panner1[c].setPan(_slew1[c].next(pan));
 
 	pan = params[PAN2_PARAM].getValue();
 	if (inputs[CV2_INPUT].isConnected()) {
-		pan *= clamp(inputs[CV2_INPUT].getVoltage() / 5.0f, -1.0f, 1.0f);
+		pan *= clamp(inputs[CV2_INPUT].getPolyVoltage(c) / 5.0f, -1.0f, 1.0f);
 	}
-	_panner2.setPan(_slew2.next(pan));
+	_panner2[c].setPan(_slew2[c].next(pan));
 
 	float l1 = 0.0f, r1 = 0.0f;
-	_panner1.next(inputs[IN1_INPUT].getVoltageSum(), l1, r1);
+	_panner1[c].next(inputs[IN1_INPUT].getPolyVoltage(c), l1, r1);
 	float l2 = 0.0f, r2 = 0.0f;
-	_panner2.next(inputs[IN2_INPUT].getVoltageSum(), l2, r2);
-	outputs[L_OUTPUT].setVoltage(_saturatorLeft.next(l1 + l2));
-	outputs[R_OUTPUT].setVoltage(_saturatorRight.next(r1 + r2));
+	_panner2[c].next(inputs[IN2_INPUT].getPolyVoltage(c), l2, r2);
+	outputs[L_OUTPUT].setChannels(_channels);
+	outputs[L_OUTPUT].setVoltage(_saturatorLeft.next(l1 + l2), c);
+	outputs[R_OUTPUT].setChannels(_channels);
+	outputs[R_OUTPUT].setVoltage(_saturatorRight.next(r1 + r2), c);
 }
 
 struct PanWidget : ModuleWidget {
diff --git a/src/Pan.hpp b/src/Pan.hpp
@@ -34,10 +34,10 @@ struct Pan : BGModule {
 		NUM_LIGHTS
 	};
 
-	Panner _panner1;
-	Panner _panner2;
-	bogaudio::dsp::SlewLimiter _slew1;
-	bogaudio::dsp::SlewLimiter _slew2;
+	Panner _panner1[maxChannels];
+	Panner _panner2[maxChannels];
+	bogaudio::dsp::SlewLimiter _slew1[maxChannels];
+	bogaudio::dsp::SlewLimiter _slew2[maxChannels];
 	Saturator _saturatorLeft;
 	Saturator _saturatorRight;
 
@@ -49,8 +49,10 @@ struct Pan : BGModule {
 		sampleRateChange();
 	}
 
+	bool active() override;
+	int channels() override;
 	void sampleRateChange() override;
-	void processChannel(const ProcessArgs& args, int _c) override;
+	void processChannel(const ProcessArgs& args, int c) override;
 };
 
 } // namespace bogaudio
diff --git a/src/XFade.cpp b/src/XFade.cpp
@@ -2,38 +2,49 @@
 #include "XFade.hpp"
 
 void XFade::sampleRateChange() {
-	_mixSL.setParams(APP->engine->getSampleRate(), 10.0f, 2.0f);
+	for (int c = 0; c < maxChannels; ++c) {
+		_mixSL[c].setParams(APP->engine->getSampleRate(), 10.0f, 2.0f);
+	}
+}
+
+bool XFade::active() {
+	return outputs[OUT_OUTPUT].isConnected();
+}
+
+int XFade::channels() {
+	return std::max(inputs[A_INPUT].getChannels(), inputs[B_INPUT].getChannels());
+}
+
+void XFade::always(const ProcessArgs& args) {
+	lights[LINEAR_LIGHT].value = params[LINEAR_PARAM].getValue() > 0.5f;
 }
 
-void XFade::processChannel(const ProcessArgs& args, int _c) {
+void XFade::processChannel(const ProcessArgs& args, int c) {
 	bool linear = params[LINEAR_PARAM].getValue() > 0.5f;
-	lights[LINEAR_LIGHT].value = linear;
-	if (!outputs[OUT_OUTPUT].isConnected()) {
-		return;
-	}
 
 	float mix = params[MIX_PARAM].getValue();
 	if (inputs[MIX_INPUT].isConnected()) {
-		mix *= clamp(inputs[MIX_INPUT].getVoltage() / 5.0f, -1.0f, 1.0f);
+		mix *= clamp(inputs[MIX_INPUT].getPolyVoltage(c) / 5.0f, -1.0f, 1.0f);
 	}
-	mix = _mixSL.next(mix);
+	mix = _mixSL[c].next(mix);
 
 	float curveIn = params[CURVE_PARAM].getValue();
 
-	if (_linear != linear || _mix != mix || _curveIn != curveIn) {
+	if (_linear != linear || _mix[c] != mix || _curveIn[c] != curveIn) {
 		_linear = linear;
-		_mix = mix;
-		_curveIn = curveIn;
+		_mix[c] = mix;
+		_curveIn[c] = curveIn;
 		if (!linear) {
 			curveIn = powf(params[CURVE_PARAM].getValue(), 0.082f);
 		}
 		curveIn *= 2.0f;
 		curveIn -= 1.0f;
 
-		_mixer.setParams(mix, curveIn, linear);
+		_mixer[c].setParams(mix, curveIn, linear);
 	}
 
-	outputs[OUT_OUTPUT].setVoltage(_mixer.next(inputs[A_INPUT].getVoltageSum(), inputs[B_INPUT].getVoltageSum()));
+	outputs[OUT_OUTPUT].setChannels(_channels);
+	outputs[OUT_OUTPUT].setVoltage(_mixer[c].next(inputs[A_INPUT].getVoltage(c), inputs[B_INPUT].getVoltage(c)), c);
 }
 
 struct XFadeWidget : ModuleWidget {
diff --git a/src/XFade.hpp b/src/XFade.hpp
@@ -35,10 +35,10 @@ struct XFade : BGModule {
 	};
 
 	bool _linear = false;
-	float _mix = 0.0f;
-	float _curveIn = -1.0f;
-	bogaudio::dsp::SlewLimiter _mixSL;
-	CrossFader _mixer;
+	float _mix[maxChannels] {};
+	float _curveIn[maxChannels];
+	bogaudio::dsp::SlewLimiter _mixSL[maxChannels];
+	CrossFader _mixer[maxChannels];
 
 	XFade() {
 		config(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS);
@@ -47,10 +47,16 @@ struct XFade : BGModule {
 		configParam(LINEAR_PARAM, 0.0f, 1.0f, 0.0f, "Linear");
 
 		sampleRateChange();
+		for (int c = 0; c < maxChannels; ++c) {
+			_curveIn[c] = -1.0f;
+		}
 	}
 
 	void sampleRateChange() override;
-	void processChannel(const ProcessArgs& args, int _c) override;
+	bool active() override;
+	int channels() override;
+	void always(const ProcessArgs& args) override;
+	void processChannel(const ProcessArgs& args, int c) override;
 };
 
 } // namespace bogaudio