drawAALine()

void fl::FlowFieldFP::drawAALine ( s16x16 x0, s16x16 y0, s16x16 x1, s16x16 y1, s16x16 t, s16x16 colorShift )

private

Definition at line 615 of file flowfield.cpp.hpp.

                                                            {
    int w = mState.width;
    int h = mState.height;
    s16x16 dx = x1 - x0;
    s16x16 dy = y1 - y0;
    s16x16 max_delta = fl::max(s16x16::abs(dx), s16x16::abs(dy));
    int steps = fl::max(1, (max_delta * s16x16(3)).to_int());
    s16x16 invSteps = s16x16(1) / s16x16(steps);
 
    i32 *__restrict__ rp = mState.r.data();
    i32 *__restrict__ gp = mState.g.data();
    i32 *__restrict__ bp = mState.b.data();
 
    // Precompute step increments (was recomputing from scratch each iteration)
    s16x16 dx_step = dx * invSteps;
    s16x16 dy_step = dy * invSteps;
    s16x16 u = s16x16();
    s16x16 px = x0;
    s16x16 py = y0;
 
    for (int i = 0; i <= steps; i++, u = u + invSteps, px = px + dx_step, py = py + dy_step) {
        CRGB c = rainbow(t, colorShift, u);
 
        int ix = s16x16::floor(px).to_int();
        int iy = s16x16::floor(py).to_int();
        s16x16 fx = s16x16::fract(px);
        s16x16 fy = s16x16::fract(py);
        constexpr s16x16 one(1.0f);
        s16x16 inv_fx = one - fx;
        s16x16 inv_fy = one - fy;
 
        i32 weights[4] = {
            (inv_fx * inv_fy).raw(),
            (fx * inv_fy).raw(),
            (inv_fx * fy).raw(),
            (fx * fy).raw(),
        };
 
        // Pre-shift color values once per step
        i32 cr_raw = static_cast<i32>(c.r) << 16;
        i32 cg_raw = static_cast<i32>(c.g) << 16;
        i32 cb_raw = static_cast<i32>(c.b) << 16;
 
        int offX[4] = {0, 1, 0, 1};
        int offY[4] = {0, 0, 1, 1};
 
        for (int j = 0; j < 4; j++) {
            int cx = ix + offX[j];
            int cy = iy + offY[j];
            if (cx < 0 || cx >= w || cy < 0 || cy >= h)
                continue;
            i32 wt_q16 = weights[j];
            if (wt_q16 <= 0) continue;
            int gi = cy * w + cx;
            // Lerp: old + (new - old) * wt — 1 i64 mul per channel instead of 2
            rp[gi] += static_cast<i32>((static_cast<i64>(cr_raw - rp[gi]) * wt_q16) >> 16);
            gp[gi] += static_cast<i32>((static_cast<i64>(cg_raw - gp[gi]) * wt_q16) >> 16);
            bp[gi] += static_cast<i32>((static_cast<i64>(cb_raw - bp[gi]) * wt_q16) >> 16);
        }
    }
}

References fl::s16x16::abs(), colorShift, fl::s16x16::floor(), fl::s16x16::fract(), fl::max(), mState, rainbow(), steps(), fl::t, and fl::s16x16::to_int().

Referenced by emitLissajousLine().

Here is the call graph for this function:

Here is the caller graph for this function: