renderStrokeRow()

template<typename PixelT, bool Overwrite>

void fl::gfx::detail::renderStrokeRow ( PixelT * buf, int w, int py, fl::i32 cross_start, fl::i32 dot_start, const StrokeCtx< PixelT > & sc )

inline

Render one scanline of a stroke line using phase-based scanning.

Templated on Overwrite for compile-time dispatch (no per-pixel branch). AA uses precomputed shift+reciprocal — zero Coord multiplies.

Definition at line 403 of file primitives.h.

                                                                      {
    PixelT* ptr = &buf[py * w + sc.xmin];
    fl::i32 cross = cross_start;
    fl::i32 dot = dot_start;
    int px = sc.xmin;
    const fl::i32 thr = sc.threshold_q;
    const fl::i32 neg_thr = -thr;
 
    // Phase 1: Skip pixels outside the band
    while (px <= sc.xmax && (cross >= thr || cross < neg_thr)) {
        cross += sc.dy_q;
        dot += sc.dx_q;
        ++ptr; ++px;
    }
 
    // Hoist per-row endcap ey values (py is constant within a row)
    fl::i32 py8 = static_cast<fl::i32>(py) << 8;
    fl::i32 ey8_y0 = py8 - sc.y0_8;
    fl::i32 ey8_y1 = py8 - sc.y1_8;
 
    // Phase 2: Process visible pixels (|cross| < threshold)
    while (px <= sc.xmax && cross < thr && cross >= neg_thr) {
        fl::i32 abs_cross = (cross < 0) ? -cross : cross;
        bool on_segment = (dot >= 0 && dot <= sc.len2_q);
 
        if (on_segment) {
            // Integer AA: shift+multiply (no Coord multiply)
            fl::u16 shifted = static_cast<fl::u16>(
                static_cast<fl::u32>(abs_cross) >> sc.aa_shift);
            fl::u8 linear_idx = static_cast<fl::u8>((shifted * sc.aa_inv) >> 8);
            // Fast approximate x/255 ≈ (x + 1 + (x >> 8)) >> 8
            fl::u16 sq = static_cast<fl::u16>(linear_idx) * linear_idx;
            fl::u8 sq_idx = static_cast<fl::u8>((sq + 1 + (sq >> 8)) >> 8);
            PixelT c = sc.color;
            c.nscale8(FL_PGM_READ_BYTE_NEAR(&distanceAA_LUT[sq_idx]));
            if (Overwrite) *ptr = c; else *ptr += c;
        } else if (sc.cap == LineCap::ROUND) {
            // Endpoint distance in 8.8 fixed-point
            fl::i32 ex8;
            fl::i16 ey_s;
            if (dot < 0) {
                ex8 = (static_cast<fl::i32>(px) << 8) - sc.x0_8;
                ey_s = static_cast<fl::i16>(ey8_y0);
            } else {
                ex8 = (static_cast<fl::i32>(px) << 8) - sc.x1_8;
                ey_s = static_cast<fl::i16>(ey8_y1);
            }
            fl::i16 ex_s = static_cast<fl::i16>(ex8);
            // 16×16→32 multiply (4 MUL on AVR vs ~70 for 32×32)
            fl::i32 ed2 = static_cast<fl::i32>(ex_s) * ex_s +
                          static_cast<fl::i32>(ey_s) * ey_s;
            if (ed2 < sc.r_max2_8) {
                fl::u16 shifted = static_cast<fl::u16>(
                    static_cast<fl::u32>(ed2) >> sc.cap_shift);
                fl::u8 idx = static_cast<fl::u8>((shifted * sc.cap_inv) >> 8);
                PixelT c = sc.color;
                c.nscale8(FL_PGM_READ_BYTE_NEAR(&distanceAA_LUT[idx]));
                if (Overwrite) *ptr = c; else *ptr += c;
            }
        } else if (sc.cap == LineCap::SQUARE) {
            if (dot >= -sc.dot_ext_q && dot <= sc.len2_q + sc.dot_ext_q) {
                fl::u16 shifted = static_cast<fl::u16>(
                    static_cast<fl::u32>(abs_cross) >> sc.aa_shift);
                fl::u8 linear_idx = static_cast<fl::u8>((shifted * sc.aa_inv) >> 8);
                fl::u16 sq = static_cast<fl::u16>(linear_idx) * linear_idx;
                fl::u8 sq_idx = static_cast<fl::u8>((sq + 1 + (sq >> 8)) >> 8);
                PixelT c = sc.color;
                c.nscale8(FL_PGM_READ_BYTE_NEAR(&distanceAA_LUT[sq_idx]));
                if (Overwrite) *ptr = c; else *ptr += c;
            }
        }
        // FLAT: pixels outside [0, len2] are silently dropped
 
        cross += sc.dy_q;
        dot += sc.dx_q;
        ++ptr; ++px;
    }
    // Phase 3: remaining pixels are outside the band — nothing to do
}

References distanceAA_LUT, fl::FL_NO_EXCEPT, FL_PGM_READ_BYTE_NEAR, and renderStrokeRow().

Referenced by drawStrokeLineCore(), and renderStrokeRow().

Here is the call graph for this function:

Here is the caller graph for this function: