Method processBlock

Source/DSP/LfoManager.cpp:77–145

// =============================================================================

void LfoManager::processBlock(juce::AudioBuffer<float>& outputBuffer, float sampleRate, juce::AudioPlayHead* playHead, int numSamples)
{
    const juce::ScopedLock sl(dataAccessLock);
    // 1. Generate all raw LFO signals for the current block.
    // This fills the internal 'lfoOutputBuffer'.
    generateLfoOutput(sampleRate, playHead, numSamples);

    // 2. Copy the generated LFO signals to the output buffer.
    jassert(outputBuffer.getNumSamples() == lfoOutputBuffer.getNumSamples());
    jassert(outputBuffer.getNumChannels() >= lfoOutputBuffer.getNumChannels());

    for (int channel = 0; channel < lfoOutputBuffer.getNumChannels(); ++channel)
    {
        outputBuffer.copyFrom(channel, 0, lfoOutputBuffer, channel, 0, numSamples);
    }

    // 3. Clear the map of calculated values from the previous block.
    // We now store normalized values.
    modulatedValues.clear();

    // 4. Iterate through all modulation routings to calculate final parameter values.
    for (const auto& routing : modulationRoutings)
    {
        // Skip invalid or unassigned routings
        if (routing.isBypassed || routing.targetParameterID.isEmpty())
            continue;

        // Use the first sample of the LFO output as the representative value for the whole block.
        float lfoValue = lfoOutputBuffer.getSample(routing.sourceLfoIndex, 0);

        // Get the RangedAudioParameter for conversions
        auto* parameter = treeState.getParameter(routing.targetParameterID);
        if (parameter == nullptr)
            continue;

        // Get the parameter's original NORMALIZED value (from the GUI knob)
        const float normalizedBaseValue = parameter->getValue();

        // For bipolar mode, the effective modulation depth should be halved to match
        // the perceived range of unipolar mode.
        float effectiveDepth = routing.depth;

        // Apply bipolar (-1 to 1) or unipolar (0 to 1) mapping to the LFO signal.
        if (routing.isBipolar)
        {
            lfoValue = lfoValue * 2.0f - 1.0f; // Map LFO from [0, 1] to [-1, 1]
            effectiveDepth *= 0.5f; // Halve the depth for bipolar
        }

        // The modulation amount is now a simple multiplication in the normalized space.
        // The depth parameter scales the LFO output directly.
        const float normalizedModulationAmount = lfoValue * effectiveDepth;

        // If this parameter hasn't been touched yet in this block, initialize it with its base normalized value.
        if (modulatedValues.find(routing.targetParameterID) == modulatedValues.end())
        {
            modulatedValues[routing.targetParameterID] = normalizedBaseValue;
        }