Method updateShape

Source/DSP/LfoEngine.cpp:31–125

}

void LfoEngine::updateShape(const LfoData& shapeData)
{
    const auto& points = shapeData.points;
    const auto& curvatures = shapeData.curvatures;

    if (points.size() < 2 || curvatures.size() < (points.size() - 1))
    {
        jassertfalse;
        return;
    }

    const auto numPointsInTable = wavetable.getNumPoints();

    // Step 1: Create a temporary, mutable array to build the waveform.
    juce::Array<float> tempTable;
    tempTable.resize(numPointsInTable);

    // Step 2: Generate the raw, unsmoothed shape into the temporary array.
    for (int i = 0; i < numPointsInTable; ++i)
    {
        const float phase = (float) i / (float) (numPointsInTable > 1 ? numPointsInTable - 1 : 1);

        float sampleValue = 0.5f; // Default to middle value

        if (points.size() >= 2)
        {
            // Find the correct segment for the current phase
            for (size_t p = 0; p < points.size() - 1; ++p)
            {
                const auto& p1 = points[p];
                const auto& p2 = points[p + 1];

                if (phase >= p1.x && phase <= p2.x)
                {
                    const float segmentWidth = p2.x - p1.x;

                    // Fallback to linear interpolation if curvatures data is missing or segment is zero-width
                    if (p >= curvatures.size() || std::abs(segmentWidth) < 1e-9f)
                    {
                        sampleValue = (std::abs(segmentWidth) < 1e-9f)
                                          ? p1.y
                                          : p1.y + (p2.y - p1.y) * ((phase - p1.x) / segmentWidth);
                    }
                    else // Apply curvature
                    {
                        const float curvature = curvatures[p];
                        const float tx = (phase - p1.x) / segmentWidth;
                        const float absExp = std::pow(4.0f, std::abs(curvature));
                        float ty;

                        if (curvature >= 0.0f)
                            ty = std::pow(tx, absExp);
                        else
                            ty = 1.0f - std::pow(juce::jmax(0.0f, 1.0f - tx), absExp);

                        sampleValue = p1.y + (p2.y - p1.y) * ty;
                    }
                    break; // Exit segment search once found