Method process

src/Octaves.cpp:113–206

	void process(const ProcessArgs& args) override {

		const int numActivePolyphonyEngines = getNumActivePolyphonyEngines();

		// work out active outputs
		const int highestOutput = getMaxConnectedOutput();
		if (highestOutput == -1) {
			return;
		}

		for (int c = 0; c < numActivePolyphonyEngines; c += 4) {

			const int rangeIndex = params[RANGE_PARAM].getValue();
			float_4 pitch = ranges[rangeIndex] * params[TUNE_PARAM].getValue() + inputs[VOCT1_INPUT].getPolyVoltageSimd<float_4>(c) + inputs[VOCT2_INPUT].getPolyVoltageSimd<float_4>(c);
			pitch += params[OCTAVE_PARAM].getValue() - 3;
			const float_4 freq = dsp::FREQ_C4 * dsp::exp2_taylor5(pitch);
			// -1 to +1
			const float_4 pwmCV = params[PWM_CV_PARAM].getValue() * clamp(inputs[PWM_INPUT].getPolyVoltageSimd<float_4>(c) / 10.f, -1.f, 1.f);
			const float_4 pulseWidthLimit = limitPW ? 0.05f : 0.0f;

			// pwm in [-0.25 : +0.25]
			const float_4 pwm = 2 * clamp(0.5 - params[PWM_PARAM].getValue() + 0.5 * pwmCV, -0.5f + pulseWidthLimit, 0.5f - pulseWidthLimit);

			const int oversamplingRatio = oversampler[0][0].getOversamplingRatio();

			const float_4 deltaPhase = freq * args.sampleTime / oversamplingRatio;

			//  process sync
			float_4 sync = syncTrigger[c / 4].process(inputs[SYNC_INPUT].getPolyVoltageSimd<float_4>(c));
			phase[c / 4] = simd::ifelse(sync, 0.5f, phase[c / 4]);


			for (int i = 0; i < oversamplingRatio; i++) {

				phase[c / 4] += deltaPhase;
				phase[c / 4] -= simd::floor(phase[c / 4]);

				float_4 sum = {};
				for (int oct = 0; oct <= highestOutput; oct++) {

					const float_4 gainCV = simd::clamp(inputs[GAIN_01F_INPUT + oct].getNormalPolyVoltageSimd<float_4>(10.f, c) / 10.f, 0.f, 1.0f);
					const float_4 gain = params[GAIN_01F_PARAM + oct].getValue() * gainCV;

					// don't bother processing if gain is zero and no output is connected
					const bool isGainZero = simd::movemask(gain != 0.f) == 0; 
					if (isGainZero && !outputs[OUT_01F_OUTPUT + oct].isConnected()) {
						continue;
					}

					// derive phases for higher octaves from base phase (this keeps things in sync!)
					const float_4 n = (float)(1 << oct);
					// this is on [0, 1]
					const float_4 effectivePhase = n * simd::fmod(phase[c / 4], 1 / n);
					const float_4 waveTri = 1.0 - 2.0 * simd::abs(2.f * effectivePhase - 1.0);
					// build square from triangle + comparator
					const float_4 waveSquare = simd::ifelse(waveTri > pwm, +1.f, -1.f);

					sum += (useTriangleCore ? waveTri : waveSquare) * gain;