flowAdvect()

void fl::FlowFieldFP::flowAdvect ( i32 dt_raw )

private

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

                                                    {
    int w = mState.width;
    int h = mState.height;
 
    // fade = pow(0.5, dt / halfLife) — pure fixed-point
    constexpr s16x16 half_fp(0.5f);
    constexpr s16x16 min_persistence(0.001f);
    s16x16 dt_fp = s16x16::from_raw(dt_raw);
    s16x16 halfLife_fp = mPersistence_fp.raw() > min_persistence.raw()
                             ? mPersistence_fp
                             : min_persistence;
    i32 fade_raw = s16x16::pow(half_fp, dt_fp / halfLife_fp).raw();
 
    i32 shift_raw = mFlowShift_fp.raw();
 
    i32 w_q16 = static_cast<i32>(w) << 16;
    i32 h_q16 = static_cast<i32>(h) << 16;
 
    // Grab raw array pointers — avoids vector operator[] overhead in hot loops.
    i32 *__restrict__ r  = mState.r.data();
    i32 *__restrict__ g  = mState.g.data();
    i32 *__restrict__ b  = mState.b.data();
    i32 *__restrict__ tr = mState.tr.data();
    i32 *__restrict__ tg = mState.tg.data();
    i32 *__restrict__ tb = mState.tb.data();
 
    // Pass 1: horizontal row shift
    // Lerp: a + ((b-a)*f >> 16) uses 1 i64 mul instead of 2.
    // Note: f = (-sh) & 0xFFFF is constant per row; the compiler hoists it at -O3.
    for (int y = 0; y < h; y++) {
        i32 sh = static_cast<i32>((static_cast<i64>(mState.y_prof[y]) * shift_raw) >> 16);
        int row_base = y * w;
        for (int x = 0; x < w; x++) {
            i32 sx_raw = (static_cast<i32>(x) << 16) - sh;
            // Modular wrap (single iteration sufficient for typical shift values)
            if (sx_raw < 0) sx_raw += w_q16;
            else if (sx_raw >= w_q16) sx_raw -= w_q16;
            // Safety for extreme shift values
            if (sx_raw < 0) sx_raw += w_q16;
            if (sx_raw >= w_q16) sx_raw -= w_q16;
 
            int ix0 = sx_raw >> 16;  // Already in [0, w-1] after wrap
            int ix1 = (ix0 + 1 < w) ? ix0 + 1 : 0;
            i32 f = sx_raw & 0xFFFF;
 
            int src0 = row_base + ix0;
            int src1 = row_base + ix1;
            int dst  = row_base + x;
 
            tr[dst] = r[src0] + static_cast<i32>((static_cast<i64>(r[src1] - r[src0]) * f) >> 16);
            tg[dst] = g[src0] + static_cast<i32>((static_cast<i64>(g[src1] - g[src0]) * f) >> 16);
            tb[dst] = b[src0] + static_cast<i32>((static_cast<i64>(b[src1] - b[src0]) * f) >> 16);
        }
    }
 
    // Pass 2: vertical column shift + fade
    // Note: f = (-sh) & 0xFFFF is constant per column; the compiler hoists it at -O3.
    for (int x = 0; x < w; x++) {
        i32 sh = static_cast<i32>((static_cast<i64>(mState.x_prof[x]) * shift_raw) >> 16);
        for (int y = 0; y < h; y++) {
            i32 sy_raw = (static_cast<i32>(y) << 16) - sh;
            if (sy_raw < 0) sy_raw += h_q16;
            else if (sy_raw >= h_q16) sy_raw -= h_q16;
            if (sy_raw < 0) sy_raw += h_q16;
            if (sy_raw >= h_q16) sy_raw -= h_q16;
 
            int iy0 = sy_raw >> 16;
            int iy1 = (iy0 + 1 < h) ? iy0 + 1 : 0;
            i32 f = sy_raw & 0xFFFF;
 
            int src0 = iy0 * w + x;
            int src1 = iy1 * w + x;
            int dst  = y * w + x;
 
            // Lerp + fade in two steps (2 i64 muls per channel instead of 3)
            i32 interp_r = tr[src0] + static_cast<i32>((static_cast<i64>(tr[src1] - tr[src0]) * f) >> 16);
            i32 interp_g = tg[src0] + static_cast<i32>((static_cast<i64>(tg[src1] - tg[src0]) * f) >> 16);
            i32 interp_b = tb[src0] + static_cast<i32>((static_cast<i64>(tb[src1] - tb[src0]) * f) >> 16);
 
            r[dst] = static_cast<i32>((static_cast<i64>(interp_r) * fade_raw) >> 16);
            g[dst] = static_cast<i32>((static_cast<i64>(interp_g) * fade_raw) >> 16);
            b[dst] = static_cast<i32>((static_cast<i64>(interp_b) * fade_raw) >> 16);
        }
    }
}

References fl::fade_raw(), fl::FL_NO_EXCEPT, fl::s16x16::from_raw(), fl::g, mFlowShift_fp, mPersistence_fp, mState, fl::s16x16::pow(), fl::s16x16::raw(), fl::x, and fl::y.

Referenced by drawImpl().

Here is the call graph for this function:

Here is the caller graph for this function: