Method process

src/Bandit.cpp:142–207

	void process(const ProcessArgs& args) override {

		const int maxPolyphony = std::max({1, inputs[ALL_INPUT].getChannels(), inputs[LOW_INPUT].getChannels(),
		                                   inputs[LOW_MID_INPUT].getChannels(), inputs[HIGH_MID_INPUT].getChannels(),
		                                   inputs[HIGH_INPUT].getChannels()});

		const bool allReturnsActiveAndMonophonic = inputs[LOW_RETURN_INPUT].isMonophonic() && inputs[LOW_MID_RETURN_INPUT].isMonophonic() &&
		  inputs[HIGH_MID_RETURN_INPUT].isMonophonic() && inputs[HIGH_RETURN_INPUT].isMonophonic();

		float_4 mixOutput[4] = {};
		for (int c = 0; c < maxPolyphony; c += 4) {

			const float_4 inLow = inputs[LOW_INPUT].getPolyVoltageSimd<float_4>(c);
			const float_4 inLowMid = inputs[LOW_MID_INPUT].getPolyVoltageSimd<float_4>(c);
			const float_4 inHighMid = inputs[HIGH_MID_INPUT].getPolyVoltageSimd<float_4>(c);
			const float_4 inHigh = inputs[HIGH_INPUT].getPolyVoltageSimd<float_4>(c);
			const float_4 inAll = inputs[ALL_INPUT].getPolyVoltageSimd<float_4>(c);

			const float_4 lowGain = params[LOW_GAIN_PARAM].getValue() * clamp(inputs[LOW_CV_INPUT].getNormalPolyVoltageSimd<float_4>(10.f, c) / 10.f, 0.f, 1.f);
			const float_4 outLow = 0.7 * 2 * filterLow[c / 4][1].process(filterLow[c / 4][0].process((inLow + inAll) * lowGain));
			outputs[LOW_OUTPUT].setVoltageSimd<float_4>(outLow, c);

			const float_4 lowMidGain = params[LOW_MID_GAIN_PARAM].getValue() * clamp(inputs[LOW_MID_CV_INPUT].getNormalPolyVoltageSimd<float_4>(10.f, c) / 10.f, 0.f, 1.f);
			const float_4 outLowMid = 2 * filterLowMid[c / 4][1].process(filterLowMid[c / 4][0].process((inLowMid + inAll) * lowMidGain));
			outputs[LOW_MID_OUTPUT].setVoltageSimd<float_4>(outLowMid, c);

			const float_4 highMidGain = params[HIGH_MID_GAIN_PARAM].getValue() * clamp(inputs[HIGH_MID_CV_INPUT].getNormalPolyVoltageSimd<float_4>(10.f, c) / 10.f, 0.f, 1.f);
			const float_4 outHighMid = 2 * filterHighMid[c / 4][1].process(filterHighMid[c / 4][0].process((inHighMid + inAll) * highMidGain));
			outputs[HIGH_MID_OUTPUT].setVoltageSimd<float_4>(outHighMid, c);

			const float_4 highGain = params[HIGH_GAIN_PARAM].getValue() * clamp(inputs[HIGH_CV_INPUT].getNormalPolyVoltageSimd<float_4>(10.f, c) / 10.f, 0.f, 1.f);
			const float_4 outHigh = 0.7 * 2 * filterHigh[c / 4][1].process(filterHigh[c / 4][0].process((inHigh + inAll) * highGain));
			outputs[HIGH_OUTPUT].setVoltageSimd<float_4>(outHigh, c);

			// the fx return input is normalled to the fx send output
			mixOutput[c / 4]  = inputs[LOW_RETURN_INPUT].getNormalPolyVoltageSimd<float_4>(outLow * !outputs[LOW_OUTPUT].isConnected(), c);
			mixOutput[c / 4] += inputs[LOW_MID_RETURN_INPUT].getNormalPolyVoltageSimd<float_4>(outLowMid * !outputs[LOW_MID_OUTPUT].isConnected(), c);
			mixOutput[c / 4] += inputs[HIGH_MID_RETURN_INPUT].getNormalPolyVoltageSimd<float_4>(outHighMid * !outputs[HIGH_MID_OUTPUT].isConnected(), c);
			mixOutput[c / 4] += inputs[HIGH_RETURN_INPUT].getNormalPolyVoltageSimd<float_4>(outHigh * !outputs[HIGH_OUTPUT].isConnected(), c);
			mixOutput[c / 4] = mixOutput[c / 4] * clamp(inputs[ALL_CV_INPUT].getNormalPolyVoltageSimd<float_4>(10.f, c) / 10.f, 0.f, 1.f);

			if (applySaturation) {
				mixOutput[c / 4] = Saturator<float_4>::process(mixOutput[c / 4] / 10.f) * 10.f;
			}

			outputs[MIX_OUTPUT].setVoltageSimd<float_4>(mixOutput[c / 4], c);
		}

		outputs[LOW_OUTPUT].setChannels(maxPolyphony);
		outputs[LOW_MID_OUTPUT].setChannels(maxPolyphony);
		outputs[HIGH_MID_OUTPUT].setChannels(maxPolyphony);
		outputs[HIGH_OUTPUT].setChannels(maxPolyphony);

		if (allReturnsActiveAndMonophonic) {
			// special case: if all return paths are connected and monophonic, then output mix should be monophonic
			outputs[MIX_OUTPUT].setChannels(1);
		}
		else {