setupChasingSpiralFrame()

FrameSetup fl::anonymous_namespace{chasing_spirals.cpp.hpp}::setupChasingSpiralFrame	(	Context &	ctx,
		ChasingSpiralState &	state )

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

                                                                            {
    auto *e = ctx.mEngine.get();
    e->get_ready();
 
    // Timing (once per frame, float is fine here)
    e->timings.master_speed = 0.01;
    e->timings.ratio[0] = 0.1;
    e->timings.ratio[1] = 0.13;
    e->timings.ratio[2] = 0.16;
    e->timings.offset[1] = 10;
    e->timings.offset[2] = 20;
    e->timings.offset[3] = 30;
    e->calculate_oscillators(e->timings);
 
    const int num_x = e->num_x;
    const int num_y = e->num_y;
    const int total_pixels = num_x * num_y;
 
    // Per-frame constants (float->FP boundary conversions)
    constexpr FP scale(0.1f);
    const FP radius_fp(e->radial_filter_radius);
    const FP center_x_scaled = FP(e->animation.center_x * 0.1f);
    const FP center_y_scaled = FP(e->animation.center_y * 0.1f);
 
    const FP radial0(e->move.radial[0]);
    const FP radial1(e->move.radial[1]);
    const FP radial2(e->move.radial[2]);
 
    // Reduce linear offsets modulo the Perlin noise period before converting
    // to s16x16. Two reasons:
    //   1. Prevents s16x16 overflow (range ±32767 in integer part).
    //   2. Float32 precision fix: matches the same reduction applied in
    //      Chasing_Spirals_Float (animartrix v1 and v2 float paths) so both
    //      paths compute identical Perlin coordinates at all time values.
    //      Without this reduction, float32 loses per-pixel coordinate precision
    //      when move.linear grows large (ULP at 200,000 ≈ 0.024 > pixel step 0.1).
    // Perlin noise is exactly periodic with period 256 at integer coordinates,
    // so with scale_x=0.1 the effective period for offset_x is 256/0.1 = 2560.
    // See: tests/fl/fx/2d/animartrix2.cpp "period reduction" test cases.
    constexpr float perlin_period = 2560.0f; // 256.0f / scale_x(0.1f)
    constexpr float scale_f = 0.1f;
    const FP linear0_scaled = FP(fmodf(e->move.linear[0], perlin_period) * scale_f);
    const FP linear1_scaled = FP(fmodf(e->move.linear[1], perlin_period) * scale_f);
    const FP linear2_scaled = FP(fmodf(e->move.linear[2], perlin_period) * scale_f);
 
    constexpr FP three_fp(3.0f);
    constexpr FP one(1.0f);
 
    // Build per-pixel SoA geometry (once when grid size changes)
    if (state.count != total_pixels) {
        const int padded = (total_pixels + 3) & ~3;  // multiple of 4 for SIMD safety
        state.base_angle.resize(padded, 0);
        state.dist_scaled.resize(padded, 0);
        state.rf3.resize(padded, 0);
        state.rf_half.resize(padded, 0);
        state.rf_quarter.resize(padded, 0);
        state.pixel_idx.resize(padded, 0);
 
        const FP inv_radius = one / radius_fp;
        const FP one_third = one / three_fp;
        int idx = 0;
        for (int x = 0; x < num_x; x++) {
            for (int y = 0; y < num_y; y++) {
                const FP theta(e->polar_theta[x][y]);
                const FP dist(e->distance[x][y]);
                const FP rf = (radius_fp - dist) * inv_radius;
                state.base_angle[idx]  = (three_fp * theta - dist * one_third).raw();
                state.dist_scaled[idx] = (dist * scale).raw();
                state.rf3[idx]         = (three_fp * rf).raw();
                state.rf_half[idx]     = (rf >> 1).raw();
                state.rf_quarter[idx]  = (rf >> 2).raw();
                state.pixel_idx[idx]   = e->mCtx->xyMapFn(x, y, e->mCtx->xyMapUserData);
                idx++;
            }
        }
        state.count = total_pixels;
    }
 
    // Initialize Perlin fade LUT once per state lifetime
    if (!state.fade_lut_initialized) {
        Perlin::init_fade_lut(state.fade_lut);
        state.fade_lut_initialized = true;
    }
 
    const i32 cx_raw   = center_x_scaled.raw();
    const i32 cy_raw   = center_y_scaled.raw();
    const i32 lin0_raw = linear0_scaled.raw();
    const i32 lin1_raw = linear1_scaled.raw();
    const i32 lin2_raw = linear2_scaled.raw();
    const i32 rad0_raw = radial0.raw();
    const i32 rad1_raw = radial1.raw();
    const i32 rad2_raw = radial2.raw();
 
    // Stamp alignment on SoA pointers at the source so every downstream
    // consumer (Q31 scalar loop, SIMD 4-wide loop, loadAligned helper)
    // inherits the hint without needing per-site annotations.
    //
    // Why this matters for performance:
    //   1. The SIMD path calls loadAligned() which feeds load_u32_4_aligned().
    //      With the alignment hint the compiler emits movdqa/movaps (aligned
    //      128-bit loads) instead of movdqu/movups (unaligned). On older x86
    //      (pre-Nehalem) unaligned loads are significantly slower; on modern
    //      cores they still cost an extra micro-op when the address crosses a
    //      cache-line boundary.
    //   2. The Q31 scalar path benefits too: the compiler can widen scalar
    //      i32 loads into SIMD gathers or auto-vectorize more aggressively
    //      when it knows the base pointer is 16-byte aligned.
    //   3. fade_lut (256-entry i32 Perlin fade table) is accessed in every
    //      Perlin noise evaluation; the alignment hint lets the compiler
    //      assume cache-line-friendly access patterns.
    //
    // The underlying SoA arrays are allocated with FL_ALIGNAS(16) in
    // ChasingSpiralState, so this is a promise (not a request).
    // pixel_idx is u16 (2 bytes) and not SIMD-loaded, so no hint needed.
    return FrameSetup{
        total_pixels,
        fl::assume_aligned<16>(state.base_angle.data()),
        fl::assume_aligned<16>(state.dist_scaled.data()),
        fl::assume_aligned<16>(state.rf3.data()),
        fl::assume_aligned<16>(state.rf_half.data()),
        fl::assume_aligned<16>(state.rf_quarter.data()),
        state.pixel_idx.data(),
        fl::assume_aligned<16>(state.fade_lut),
        PERLIN_NOISE,
        cx_raw,
        cy_raw,
        lin0_raw,
        lin1_raw,
        lin2_raw,
        rad0_raw,
        rad1_raw,
        rad2_raw,
        e->mCtx->leds
    };
}

References fl::fl::assume_aligned(), fl::fmodf(), fl::perlin_s16x16::init_fade_lut(), fl::Context::mEngine, fl::s16x16::raw(), scale, setupChasingSpiralFrame(), state, fl::x, and fl::y.

Referenced by setupChasingSpiralFrame().

Here is the call graph for this function:

Here is the caller graph for this function: