Method processTopSection

src/NoisePlethora.cpp:326–375

exactly the same for A and B

	// exactly the same for A and B
	void processTopSection(Section SECTION, ParamIds X_PARAM, ParamIds Y_PARAM, ParamIds FILTER_TYPE_PARAM,
	                       ParamIds CUTOFF_PARAM, ParamIds CUTOFF_CV_PARAM, ParamIds RES_PARAM,
	                       InputIds PROG_INPUT, InputIds X_INPUT, InputIds Y_INPUT, InputIds CUTOFF_INPUT, OutputIds OUTPUT,
	                       const ProcessArgs& args, bool updateParams) {

		// periodically work out how CV should modify the current sections algorithm
		if (updateParams) {
			processCVOffsets(SECTION, PROG_INPUT);
		}

		float out = 0.f;
		if (algorithm[SECTION] && outputs[OUTPUT].isConnected()) {
			float cvX = params[X_PARAM].getValue() + rescale(inputs[X_INPUT].getVoltage(), -10.f, +10.f, -1.f, 1.f);
			float cvY = params[Y_PARAM].getValue() + rescale(inputs[Y_INPUT].getVoltage(), -10.f, +10.f, -1.f, 1.f);

			// update parameters of the algorithm
			if (updateParams) {
				algorithm[SECTION]->process(clamp(cvX, 0.f, 1.f), clamp(cvY, 0.f, 1.f));
			}
			// process the audio graph
			out = algorithm[SECTION]->processGraph();
			// each algorithm has a specific gain factor
			out = out * programSelectorWithCV.getSection(SECTION).getCurrentProgramGain();

			// if filters are active
			if (!bypassFilters) {

				// set parameters
				const float freqCV = std::pow(params[CUTOFF_CV_PARAM].getValue(), 2) * inputs[CUTOFF_INPUT].getVoltage();
				const float pitch = rescale(params[CUTOFF_PARAM].getValue(), 0, 1, -5.5, +5.5) + freqCV;
				const float cutoff = clamp(dsp::FREQ_C4 * std::pow(2.f, pitch), 1.f, 20000.);
				const float cutoffNormalised = clamp(cutoff / args.sampleRate, 0.f, 0.49f);
				const float q = M_SQRT1_2 + std::pow(params[RES_PARAM].getValue(), 2) * 10.f;
				const FilterMode mode = typeMappingSVF[(int) params[FILTER_TYPE_PARAM].getValue()];
				svfFilter[SECTION].setParameters(cutoffNormalised, q);

				// apply filter
				svfFilter[SECTION].process(out);
				// and retrieve relevant output
				out = svfFilter[SECTION].output(mode);
			}

			if (blockDC) {
				// cascaded Biquad (4th order highpass at ~20Hz)
				out = blockDCFilter[SECTION].process(out);
			}
		}

		outputs[OUTPUT].setVoltage(Saturator<float>::process(out) * 5.f);
	}

	// process section C
	void processBottomSection(const ProcessArgs& args) {