Method process

src/Bypass.cpp:86–170

	}

	void process(const ProcessArgs& args) override {

		// slew time in secs (so take inverse for lambda)
		clickFilter.rise = clickFilter.fall = 1.0 / params[SLEW_TIME_PARAM].getValue();

		const int maxInputChannels = std::max({1, inputs[IN_L_INPUT].getChannels(), inputs[IN_R_INPUT].getChannels()});
		const int maxFxReturnChannels = std::max({1, inputs[FROM_FX_L_INPUT].getChannels(), inputs[FROM_FX_R_INPUT].getChannels()});

		const LatchMode latchMode = (LatchMode) params[LAUNCH_MODE_PARAM].getValue();
		const ReturnMode returnMode = (ReturnMode) params[MODE_PARAM].getValue();


		const bool launchCvTriggered = launchCvTrigger.process(inputs[LAUNCH_INPUT].getVoltage());
		const bool launchButtonPressed = launchButtonTrigger.process(launchButtonHeld);

		// logical or (high if either high)
		const float launchValue = std::max(launchCvTrigger.isHigh(), launchButtonTrigger.isHigh());
		if (latchMode == LatchMode::TOGGLE_MODE) {
			const bool risingEdge = launchCvTriggered || launchButtonPressed;

			if (risingEdge) {
				active = !active;
			}
		}

		// FX send section
		const float sendActive = clickFilter.process(args.sampleTime, (latchMode == LatchMode::TOGGLE_MODE) ? active : launchValue);
		for (int c = 0; c < maxInputChannels; c += 4) {
			const float_4 inL = inputs[IN_L_INPUT].getPolyVoltageSimd<float_4>(c);
			const float_4 inR = inputs[IN_R_INPUT].getNormalPolyVoltageSimd<float_4>(inL, c);

			// we start be assuming that FXs can be polyphonic, but recognise that often they are not
			outputs[TO_FX_L_OUTPUT].setVoltageSimd<float_4>(inL * sendActive, c);
			outputs[TO_FX_R_OUTPUT].setVoltageSimd<float_4>(inR * sendActive, c);
		}
		// fx send polyphony is set by input polyphony
		outputs[TO_FX_L_OUTPUT].setChannels(maxInputChannels);
		outputs[TO_FX_R_OUTPUT].setChannels(maxInputChannels);


		// FX return section
		const float gainTaper = params[FX_GAIN_PARAM].getValue() < 0.f ? 30 * params[FX_GAIN_PARAM].getValue() : params[FX_GAIN_PARAM].getValue() * 12;
		const float fxReturnGain = std::pow(10, gainTaper / 20.0f);
		float_4 dryLeft, dryRight, outL, outR;
		for (int c = 0; c < maxFxReturnChannels; c += 4) {

			const bool fxMonophonic = (maxInputChannels == 1);
			if (fxMonophonic) {
				// if the return fx is monophonic, mix down dry inputs to monophonic also
				dryLeft = inputs[IN_L_INPUT].getVoltageSum();
				dryRight = inputs[IN_R_INPUT].isConnected() ? inputs[IN_R_INPUT].getVoltageSum() : inputs[IN_L_INPUT].getVoltageSum();
			}
			else {
				// if the return fx is polyphonic, then we don't need to do anything special
				dryLeft = inputs[IN_L_INPUT].getPolyVoltageSimd<float_4>(c);
				dryRight = inputs[IN_R_INPUT].getNormalPolyVoltageSimd<float_4>(dryLeft, c);
			}