draw()

void fl::Chasing_Spirals_Q31_SIMD::draw ( Context & ctx )

overridevirtual

Implements fl::IAnimartrix2Viz.

Definition at line 417 of file chasing_spirals.cpp.hpp.

                                                             {
    auto setup = setupChasingSpiralFrame(ctx, mState);
    const int   total_pixels  = setup.total_pixels;
    const i32  *base_angle    = setup.base_angle;
    const i32  *dist_scaled   = setup.dist_scaled;
    const i32  *rf3_arr       = setup.rf3;
    const i32  *rf_half_arr   = setup.rf_half;
    const i32  *rf_qtr_arr    = setup.rf_quarter;
    const u16  *pixel_idx     = setup.pixel_idx;
    const i32  *fade_lut      = setup.fade_lut;
    const u8   *perm          = setup.perm;
    const i32   cx_raw        = setup.cx_raw;
    const i32   cy_raw        = setup.cy_raw;
    const i32   lin0_raw      = setup.lin0_raw;
    const i32   lin1_raw      = setup.lin1_raw;
    const i32   lin2_raw      = setup.lin2_raw;
    const i32   rad0_raw      = setup.rad0_raw;
    const i32   rad1_raw      = setup.rad1_raw;
    const i32   rad2_raw      = setup.rad2_raw;
    fl::span<CRGB> leds       = setup.leds;
 
    // SIMD pixel pipeline: process 4 pixels per iteration
    int i = 0;
    for (; i + 3 < total_pixels; i += 4) {
        // Aligned SoA loads (arrays are FL_ALIGNAS(16), stride is 4)
        auto base_vec    = loadAligned(base_angle,  i);
        auto dist_vec    = loadAligned(dist_scaled, i);
        auto rf3_vec     = loadAligned(rf3_arr,     i);
        auto rf_half_vec = loadAligned(rf_half_arr, i);
        auto rf_qtr_vec  = loadAligned(rf_qtr_arr,  i);
 
        auto r_vec = simd4_processChannel(
            base_vec, dist_vec, rad0_raw, lin0_raw, fade_lut, perm, cx_raw, cy_raw, rf3_vec);
        auto g_vec = simd4_processChannel(
            base_vec, dist_vec, rad1_raw, lin1_raw, fade_lut, perm, cx_raw, cy_raw, rf_half_vec);
        auto b_vec = simd4_processChannel(
            base_vec, dist_vec, rad2_raw, lin2_raw, fade_lut, perm, cx_raw, cy_raw, rf_qtr_vec);
 
        // Scatter to LED array (pixel_idx holds arbitrary xyMap-remapped indices)
        scatterPixel(leds, pixel_idx[i+0], r_vec, g_vec, b_vec, 0);
        scatterPixel(leds, pixel_idx[i+1], r_vec, g_vec, b_vec, 1);
        scatterPixel(leds, pixel_idx[i+2], r_vec, g_vec, b_vec, 2);
        scatterPixel(leds, pixel_idx[i+3], r_vec, g_vec, b_vec, 3);
    }
 
    // Scalar fallback for remaining pixels (when total_pixels % 4 != 0)
    for (; i < total_pixels; i++) {
        const i32 base_raw = base_angle[i];
        const i32 dist_raw = dist_scaled[i];
 
        auto noise_ch = [&](i32 rad_raw, i32 lin_raw) -> i32 {
            u32 a24 = radiansToA24(base_raw, rad_raw);
            SinCos32 sc = sincos32(a24);
            i32 nx = perlinCoord(sc.cos_val, dist_raw, lin_raw + cx_raw);
            i32 ny = perlinCoord(sc.sin_val, dist_raw, cy_raw);
            i32 raw = Perlin::pnoise2d_raw(nx, ny, fade_lut, perm);
            return clampAndScale255(raw);
        };
 
        i32 s0 = noise_ch(rad0_raw, lin0_raw);
        i32 s1 = noise_ch(rad1_raw, lin1_raw);
        i32 s2 = noise_ch(rad2_raw, lin2_raw);
 
        i32 r = applyRadialFilter(s0, rf3_arr[i]);
        i32 g = applyRadialFilter(s1, rf_half_arr[i]);
        i32 b = applyRadialFilter(s2, rf_qtr_arr[i]);
 
        leds[pixel_idx[i]] = CRGB(static_cast<u8>(r), static_cast<u8>(g), static_cast<u8>(b));
    }
}

References fl::SinCos32::cos_val, fl::FL_NO_EXCEPT, fl::g, leds, mState, setup(), fl::SinCos32::sin_val, and fl::sincos32().

Here is the call graph for this function: