GitCorner

Code

ossartcraftfilmcraft🌐
f67d38b35cc5
//! Stylize, Perspective and generator effects (plus the Legacy and obsolete generators).

use std::collections::VecDeque;

use filmcraft_project::EffectInstance;
use filmcraft_time::Tick;
use rayon::prelude::*;

use super::{
    FxCtx, Image, Vec2, alpha_of, blend_simple, blur_plane, bv, chv, cv, dec, enc, fbm, fv, generate, hash01, lerp3, lin, luma, noise3, offv, over, pv,
    smoothstep,
};

/// Brush Strokes: a painterly look from short directional strokes (angle jittered per cell).
pub fn brush_strokes(img: &mut Image, e: &EffectInstance, cx: &FxCtx) {
    let base_ang = fv(e, "angle", cx).to_radians();
    let size = (fv(e, "size", cx) * cx.px_scale).max(0.0);
    let len = fv(e, "length", cx) * cx.px_scale;
    if len < 0.5 && size < 0.5 {
        return;
    }
    let density = fv(e, "density", cx).max(0.05);
    let rnd = fv(e, "randomness", cx);
    let surface = chv(e, "surface");
    let blend = fv(e, "blend", cx) / 100.0;
    let cell = (len.max(2.0) / density).max(2.0);
    let steps = (len.ceil() as usize).clamp(2, 24);
    let src = img.clone();
    let w = img.w;
    img.px.par_chunks_mut(w * 4).enumerate().for_each(|(y, row)| {
        for x in 0..w {
            let (px, py) = (x as f32 + 0.5, y as f32 + 0.5);
            let (cxi, cyi) = ((px / cell).floor() as i64, (py / cell).floor() as i64);
            let jit = (hash01(cxi, cyi, 1, 77) - 0.5) * rnd * std::f32::consts::FRAC_PI_2;
            let a = base_ang + jit;
            let (dx, dy) = (a.cos(), -a.sin());
            let (nx, ny) = (-dy, dx);
            let mut acc = [0.0f32; 4];
            let mut n = 0.0;
            for i in 0..steps {
                let t = (i as f32 / (steps - 1) as f32 - 0.5) * len;
                for s in [-0.5f32, 0.0, 0.5] {
                    let q = src.sample_bilinear_clamped(px + dx * t + nx * s * size, py + dy * t + ny * s * size);
                    for k in 0..4 {
                        acc[k] += q[k];
                    }
                    n += 1.0;
                }
            }
            // bristle texture across the stroke
            let perp = px * nx + py * ny;
            let bristle = 1.0 + 0.1 * noise3(perp / size.max(1.0), (px * dx + py * dy) / len.max(1.0), cxi as f32 * 0.37, 5);
            let mut o = acc.map(|v| v / n);
            for v in &mut o[..3] {
                *v *= bristle;
            }
            let cov = (0.75 + 0.25 * hash01(cxi, cyi, 3, 77)).min(1.0);
            let o = match surface {
                1 => o.map(|v| v * cov),
                2 | 3 => {
                    let bg = if surface == 2 { 1.0 } else { 0.0 };
                    let mut b = [bg, bg, bg, 1.0];
                    over(&mut b, o.map(|v| v * cov));
                    b
                }
                _ => o,
            };
            let orig = src.get(x, y);
            for k in 0..4 {
                row[x * 4 + k] = o[k] + (orig[k] - o[k]) * blend;
            }
        }
    });
}

/// Color Emboss: emboss relief that keeps the picture's colours.
pub fn color_emboss(img: &mut Image, e: &EffectInstance, cx: &FxCtx) {
    let dir = (fv(e, "direction", cx) as f64).to_radians();
    let relief = fv(e, "relief", cx) * cx.px_scale.max(0.25);
    let contrast = fv(e, "contrast", cx) / 100.0;
    let blend = fv(e, "blend", cx) / 100.0;
    let (dx, dy) = ((dir.cos() as f32) * relief, (-dir.sin() as f32) * relief);
    let src = img.clone();
    img.map_rgb(|c, x, y| {
        let a = src.sample_bilinear_clamped(x as f32 + 0.5 + dx, y as f32 + 0.5 + dy);
        let b = src.sample_bilinear_clamped(x as f32 + 0.5 - dx, y as f32 + 0.5 - dy);
        let d = luma(Image::unpremul(a)) - luma(Image::unpremul(b));
        let v = enc(c);
        let o = v.map(|q| (q + d * contrast * 2.0).clamp(0.0, 1.0));
        dec(lerp3(o, v, blend))
    });
}

/// Roughen Edges: fractal-eroded alpha edges (Roughen, Cut, Spiky, Rusty, Photocopy…).
pub fn roughen_edges(img: &mut Image, e: &EffectInstance, cx: &FxCtx) {
    let kind = chv(e, "edge_type");
    let border = fv(e, "border", cx) * cx.px_scale;
    if border < 0.5 {
        return;
    }
    let sharp = fv(e, "sharpness", cx).max(0.0);
    let infl = fv(e, "influence", cx).clamp(0.0, 1.0);
    let scale = (fv(e, "scale", cx) / 100.0 * 30.0 * cx.px_scale).max(0.5);
    let stretch = 2f32.powf(fv(e, "stretch", cx));
    let off = offv(e, "offset", cx);
    let cplx = fv(e, "complexity", cx).clamp(1.0, 10.0);
    let evo = fv(e, "evolution", cx) / 360.0;
    let seed = fv(e, "seed", cx).max(0.0) as u64;
    let ec = lin(cv(e, "edge_color", cx));
    let colored = matches!(kind, 1 | 5 | 7);
    let a = alpha_of(img);
    let depth = blur_plane(&a, img.w, img.h, border * 0.5);
    let w = img.w;
    img.px.par_chunks_mut(w * 4).enumerate().for_each(|(y, row)| {
        for x in 0..w {
            let i = y * w + x;
            let p = &mut row[x * 4..x * 4 + 4];
            if p[3] <= 1e-6 {
                continue;
            }
            let (u, v) = ((x as f32 + off.x as f32) / (scale * stretch), (y as f32 + off.y as f32) * stretch / scale);
            let mut n = fbm(u, v, evo, cplx, seed);
            if kind == 3 {
                n = 1.0 - 2.0 * n.abs();
            }
            let d = depth[i];
            let mut k = ((d - 0.5 + n * infl * 0.5) * (1.0 + sharp * 4.0) + 0.5).clamp(0.0, 1.0);
            if kind == 2 {
                k = if k > 0.5 { 1.0 } else { 0.0 };
            }
            if matches!(kind, 4..=7) {
                // rust / photocopy: holes eaten into the border region
                let hole = fbm(u * 2.3 + 11.0, v * 2.3, evo, cplx, seed + 1);
                if d < 0.97 && hole > 0.25 {
                    k *= 1.0 - smoothstep(0.25, 0.4, hole) * (1.0 - d);
                }
            }
            if colored && d < 0.97 {
                let t = (1.0 - d) * 1.5;
                let c = Image::unpremul([p[0], p[1], p[2], p[3]]);
                let col = lerp3(c, ec, t.min(1.0));
                for c in 0..3 {
                    p[c] = col[c] * p[3];
                }
            }
            if matches!(kind, 6 | 7) {
                let c = Image::unpremul([p[0], p[1], p[2], p[3]]);
                let l = if luma(enc(c)) > 0.5 { 1.0 } else { 0.0 };
                if kind == 6 {
                    for c in 0..3 {
                        p[c] = l * p[3];
                    }
                }
            }
            for v in p.iter_mut() {
                *v *= k;
            }
        }
    });
}

/// Long Shadow: an extruded, optionally fading shadow behind the layer's alpha. The per-pixel
/// step distance to the shape along the shadow direction is found by doubling (min-plus).
pub fn long_shadow(img: &mut Image, e: &EffectInstance, cx: &FxCtx) {
    let ang = (fv(e, "angle", cx) as f64).to_radians();
    // A shadow longer than the picture's diagonal looks the same as one that long, and an
    // infinite length kept the doubling loop below from ever ending.
    let len = fv(e, "length", cx) * cx.px_scale;
    if len.is_nan() || len < 0.5 {
        return;
    }
    // the fade still runs over the requested `len`; only the passes and the cutoff stop at the extent
    let reach = len.min((img.w + img.h) as f32);
    let col = lin(cv(e, "color", cx));
    let op = fv(e, "opacity", cx) / 100.0;
    let fade = bv(e, "fade");
    let only = bv(e, "only");
    let (dx, dy) = (ang.sin() as f32, -ang.cos() as f32);
    let (w, h) = (img.w, img.h);
    let inf = f32::INFINITY;
    let mut d: Vec<f32> = img.px.par_chunks(4).map(|p| if p[3] > 0.5 { 0.0 } else { inf }).collect();
    let mut s = 1.0f32;
    while s <= reach * 2.0 {
        let prev = d.clone();
        d.par_chunks_mut(w).enumerate().for_each(|(y, row)| {
            for (x, v) in row.iter_mut().enumerate() {
                let (sx, sy) = ((x as f32 - dx * s).round(), (y as f32 - dy * s).round());
                if sx >= 0.0 && sy >= 0.0 && (sx as usize) < w && (sy as usize) < h {
                    let q = prev[sy as usize * w + sx as usize] + s;
                    if q < *v {
                        *v = q;
                    }
                }
            }
        });
        s *= 2.0;
    }
    let mut sh: Vec<f32> = d.par_iter().map(|&v| if v <= reach { (if fade { 1.0 - v / len } else { 1.0 }) * op } else { 0.0 }).collect();
    sh = blur_plane(&sh, w, h, 0.6);
    img.px.par_chunks_mut(4).zip(sh.par_iter()).for_each(|(p, &a)| {
        let mut o = [col[0] * a, col[1] * a, col[2] * a, a];
        if !only {
            over(&mut o, [p[0], p[1], p[2], p[3]]);
        }
        p.copy_from_slice(&o);
    });
}

/// 1-D squared Euclidean distance transform: lower envelope of parabolas (Felzenszwalb &
/// Huttenlocher, "Distance Transforms of Sampled Functions", 2012).
fn edt_1d(f: &[f64], out: &mut [f64]) {
    let n = f.len();
    if n == 0 {
        return;
    }
    let mut v = vec![0usize; n];
    let mut z = vec![0f64; n + 1];
    let mut k = 0usize;
    z[0] = f64::NEG_INFINITY;
    z[1] = f64::INFINITY;
    let isect = |q: usize, p: usize| ((f[q] + (q * q) as f64) - (f[p] + (p * p) as f64)) / (2.0 * q as f64 - 2.0 * p as f64);
    for q in 1..n {
        let mut s = isect(q, v[k]);
        while s <= z[k] {
            k -= 1;
            s = isect(q, v[k]);
        }
        k += 1;
        v[k] = q;
        z[k] = s;
        z[k + 1] = f64::INFINITY;
    }
    k = 0;
    for (q, o) in out.iter_mut().enumerate() {
        while z[k + 1] < q as f64 {
            k += 1;
        }
        let p = v[k];
        *o = (q as f64 - p as f64).powi(2) + f[p];
    }
}

/// Euclidean distance from every pixel to the nearest pixel where `inside` is true.
pub(crate) fn distance_to(inside: &[bool], w: usize, h: usize) -> Vec<f32> {
    let big = 1e12f64;
    let mut g: Vec<f64> = inside.iter().map(|&b| if b { 0.0 } else { big }).collect();
    g.par_chunks_mut(w).for_each(|row| {
        let f = row.to_vec();
        edt_1d(&f, row);
    });
    let cols: Vec<Vec<f64>> = (0..w)
        .into_par_iter()
        .map(|x| {
            let f: Vec<f64> = (0..h).map(|y| g[y * w + x]).collect();
            let mut o = vec![0f64; h];
            edt_1d(&f, &mut o);
            o
        })
        .collect();
    let mut out = vec![0f32; w * h];
    for (x, c) in cols.iter().enumerate() {
        for y in 0..h {
            out[y * w + x] = c[y].sqrt() as f32;
        }
    }
    out
}

/// Stroke: a solid outline around the layer's alpha (outside, centred or inside the edge).
pub fn stroke(img: &mut Image, e: &EffectInstance, cx: &FxCtx) {
    let width = fv(e, "width", cx) * cx.px_scale;
    if width <= 0.0 {
        return;
    }
    let col = lin(cv(e, "color", cx));
    let op = fv(e, "opacity", cx) / 100.0;
    let pos = chv(e, "position");
    let only = bv(e, "only");
    // pad by one pixel so the frame border counts as an edge
    let (w, h) = (img.w + 2, img.h + 2);
    let mut inside = vec![false; w * h];
    for y in 0..img.h {
        for x in 0..img.w {
            inside[(y + 1) * w + x + 1] = img.px[(y * img.w + x) * 4 + 3] > 0.5;
        }
    }
    let outside: Vec<bool> = inside.iter().map(|b| !b).collect();
    let d_out = distance_to(&inside, w, h);
    let d_in = distance_to(&outside, w, h);
    let iw = img.w;
    img.px.par_chunks_mut(iw * 4).enumerate().for_each(|(y, row)| {
        for x in 0..iw {
            let i = (y + 1) * w + x + 1;
            // signed distance to the edge, positive outside (pixel centres sit ±0.5 from it)
            let s = if inside[i] { -(d_in[i] - 0.5) } else { d_out[i] - 0.5 };
            let (lo, hi) = match pos {
                0 => (0.0, width),
                1 => (-width / 2.0, width / 2.0),
                _ => (-width, 0.0),
            };
            let k = ((s - lo + 0.5).clamp(0.0, 1.0)).min((hi - s + 0.5).clamp(0.0, 1.0)) * op;
            let p = &mut row[x * 4..x * 4 + 4];
            if only {
                p.copy_from_slice(&[col[0] * k, col[1] * k, col[2] * k, k]);
            } else if k > 0.0 {
                over(p, [col[0] * k, col[1] * k, col[2] * k, k]);
            }
        }
    });
}

/// Gradient (26.2): linear / radial / reflected / diamond ramp with midpoint and scatter.
pub fn gradient(img: &mut Image, e: &EffectInstance, cx: &FxCtx) {
    let s = pv(e, "start", cx, img);
    let en = pv(e, "end", cx, img);
    let sc = cv(e, "start_color", cx);
    let ec = cv(e, "end_color", cx);
    let shape = chv(e, "shape");
    let scatter = fv(e, "scatter", cx) / 100.0;
    let mid = (fv(e, "midpoint", cx) / 100.0).clamp(0.01, 0.99);
    let gamma = (0.5f32).ln() / mid.ln();
    let blend = fv(e, "blend", cx) / 100.0;
    let (vx, vy) = ((en.x - s.x) as f32, (en.y - s.y) as f32);
    let l2 = (vx * vx + vy * vy).max(1e-6);
    let l = l2.sqrt();
    generate(img, |x, y, p| {
        let (dx, dy) = (x - s.x as f32, y - s.y as f32);
        let along = (dx * vx + dy * vy) / l2;
        let across = (-dx * vy + dy * vx) / l2;
        let mut t = match shape {
            1 => (dx * dx + dy * dy).sqrt() / l,
            2 => along.abs(),
            3 => along.abs() + across.abs(),
            _ => along,
        };
        if scatter > 0.0 {
            t += (hash01(x as i64, y as i64, 0, 13) - 0.5) * scatter * 0.1;
        }
        let t = t.clamp(0.0, 1.0).powf(gamma);
        let c = dec(lerp3([sc[0], sc[1], sc[2]], [ec[0], ec[1], ec[2]], t));
        let a = sc[3] + (ec[3] - sc[3]) * t;
        let g = [c[0] * a, c[1] * a, c[2] * a, a];
        [0, 1, 2, 3].map(|k| g[k] + (p[k] - g[k]) * blend)
    });
}

/// Block Dissolve (Legacy): random blocks disappear as Transition Completion rises.
pub fn block_dissolve(img: &mut Image, e: &EffectInstance, cx: &FxCtx) {
    let c = fv(e, "completion", cx) / 100.0;
    if c <= 0.0 {
        return;
    }
    let bw = (fv(e, "block_w", cx) * cx.px_scale).max(1.0);
    let bh = (fv(e, "block_h", cx) * cx.px_scale).max(1.0);
    let fe = fv(e, "feather", cx) / 100.0 * 0.5;
    let soft = bv(e, "soft");
    let w = img.w;
    img.px.par_chunks_mut(w * 4).enumerate().for_each(|(y, row)| {
        for x in 0..w {
            let r = hash01((x as f32 / bw) as i64, (y as f32 / bh) as i64, 0, 41);
            let a = if soft && fe > 0.0 {
                smoothstep(c - fe, c + fe, r)
            } else if r >= c {
                1.0
            } else {
                0.0
            };
            if c >= 1.0 || a < 1.0 {
                let a = if c >= 1.0 { 0.0 } else { a };
                for v in &mut row[x * 4..x * 4 + 4] {
                    *v *= a;
                }
            }
        }
    });
}

/// Alpha from a wipe source g (0..1): pixels whose g is below the completion vanish first.
#[inline]
fn wipe_alpha(g: f32, c: f32, soft: f32) -> f32 {
    if soft <= 1e-4 {
        return if c <= 0.0 || g >= c { 1.0 } else { 0.0 };
    }
    let t = c * (1.0 + soft);
    ((g - t + soft) / soft).clamp(0.0, 1.0)
}

/// Gradient Wipe (Legacy): reveals by the luminance of a gradient layer (another track, or this
/// layer's own luminance).
pub fn gradient_wipe(img: &mut Image, e: &EffectInstance, cx: &FxCtx) {
    let c = fv(e, "completion", cx) / 100.0;
    if c <= 0.0 {
        return;
    }
    let soft = fv(e, "softness", cx) / 100.0;
    let invert = bv(e, "invert");
    let layer = chv(e, "layer") as usize;
    let placement = chv(e, "placement");
    let track = if layer > 0 { cx.env.and_then(|env| env.track(layer - 1).map(|t| (t, env.layer_to_output()))) } else { None };
    let own = img.clone();
    let w = img.w;
    let (iw, ih) = (img.w as f32, img.h as f32);
    img.px.par_chunks_mut(w * 4).enumerate().for_each(|(y, row)| {
        for x in 0..w {
            let (px, py) = (x as f32 + 0.5, y as f32 + 0.5);
            let s = match &track {
                Some((t, m)) => match placement {
                    0 => t.get(x % t.w, y % t.h),
                    1 => t.sample_bilinear(px - iw / 2.0 + t.w as f32 / 2.0, py - ih / 2.0 + t.h as f32 / 2.0),
                    _ => {
                        let o = m.apply(Vec2::new(px as f64, py as f64));
                        t.sample_bilinear_clamped(o.x as f32, o.y as f32)
                    }
                },
                None => own.get(x, y),
            };
            let mut g = filmcraft_color::linear_to_srgb(luma([s[0], s[1], s[2]]).clamp(0.0, 1.0));
            if invert {
                g = 1.0 - g;
            }
            let a = wipe_alpha(g, c, soft);
            for v in &mut row[x * 4..x * 4 + 4] {
                *v *= a;
            }
        }
    });
}

/// Linear Wipe (Legacy): a straight edge sweeps across at Wipe Angle.
pub fn linear_wipe(img: &mut Image, e: &EffectInstance, cx: &FxCtx) {
    let c = fv(e, "completion", cx) / 100.0;
    if c <= 0.0 {
        return;
    }
    let ang = fv(e, "angle", cx).to_radians();
    let (dx, dy) = (ang.sin(), -ang.cos());
    let (w, h) = (img.w as f32, img.h as f32);
    // extent of the frame along the wipe direction
    let corners = [(0.0, 0.0), (w, 0.0), (0.0, h), (w, h)].map(|(x, y)| x * dx + y * dy);
    let (lo, hi) = (corners.iter().copied().fold(f32::INFINITY, f32::min), corners.iter().copied().fold(f32::NEG_INFINITY, f32::max));
    let ext = (hi - lo).max(1.0);
    let soft = fv(e, "feather", cx) * cx.px_scale / ext;
    let wi = img.w;
    img.px.par_chunks_mut(wi * 4).enumerate().for_each(|(y, row)| {
        for x in 0..wi {
            let g = ((x as f32 + 0.5) * dx + (y as f32 + 0.5) * dy - lo) / ext;
            let a = wipe_alpha(g, c, soft);
            for v in &mut row[x * 4..x * 4 + 4] {
                *v *= a;
            }
        }
    });
}

struct Rng(u64);
impl Rng {
    fn next(&mut self) -> f32 {
        self.0 = self.0.wrapping_add(0x9E37_79B9_7F4A_7C15);
        let mut z = self.0;
        z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
        z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
        ((z ^ (z >> 31)) >> 40) as f32 / (1u64 << 24) as f32
    }
    fn signed(&mut self) -> f32 {
        self.next() * 2.0 - 1.0
    }
}

/// A bolt between two points: midpoint displacement, `levels` of detail.
fn bolt(a: (f32, f32), b: (f32, f32), segs: usize, amp: f32, levels: usize, detail_amp: f32, rng: &mut Rng) -> Vec<(f32, f32)> {
    let mut pts = vec![a];
    let (dx, dy) = (b.0 - a.0, b.1 - a.1);
    let len = (dx * dx + dy * dy).sqrt().max(1e-3);
    let (nx, ny) = (-dy / len, dx / len);
    for i in 1..segs {
        let t = i as f32 / segs as f32;
        let o = rng.signed() * amp;
        pts.push((a.0 + dx * t + nx * o, a.1 + dy * t + ny * o));
    }
    pts.push(b);
    let mut a2 = amp / segs as f32 * 2.0 * detail_amp.max(0.05) * 4.0;
    for _ in 0..levels {
        let mut np = Vec::with_capacity(pts.len() * 2);
        for w in pts.windows(2) {
            let (p, q) = (w[0], w[1]);
            let (ex, ey) = (q.0 - p.0, q.1 - p.1);
            let l = (ex * ex + ey * ey).sqrt().max(1e-3);
            let o = rng.signed() * a2.min(l * 0.5);
            np.push(p);
            np.push(((p.0 + q.0) / 2.0 - ey / l * o, (p.1 + q.1) / 2.0 + ex / l * o));
        }
        if let Some(&last) = pts.last() {
            np.push(last);
        }
        pts = np;
        a2 *= 0.5;
    }
    pts
}

/// Most pixels Lightning scans for one frame (a 4K frame is 8.3 million; real bolts need a few million).
const MAX_LIGHTNING_PIXEL_VISITS: u64 = 1 << 28;

/// Lightning (obsolete): a seeded, re-striking bolt with branches, glow and core colours.
pub fn lightning(img: &mut Image, e: &EffectInstance, cx: &FxCtx) {
    let s = pv(e, "start", cx, img);
    let en = pv(e, "end", cx, img);
    let segs = fv(e, "segments", cx).clamp(1.0, 100.0) as usize;
    let dist = ((en.x - s.x).hypot(en.y - s.y)) as f32;
    let amp = fv(e, "amplitude", cx) / 100.0 * dist * 0.5;
    let levels = fv(e, "detail", cx).clamp(0.0, 6.0) as usize;
    let damp = fv(e, "detail_amplitude", cx);
    let branching = fv(e, "branching", cx);
    let speed = fv(e, "speed", cx) as f64;
    let width = (fv(e, "width", cx) * cx.px_scale).max(0.5);
    let core = fv(e, "core", cx);
    let outc = lin(cv(e, "outside", cx));
    let inc = lin(cv(e, "inside", cx));
    let mode = chv(e, "mode");
    let strike = (cx.seconds * speed / 10.0).floor() as u64;
    let mut rng = Rng(fv(e, "seed", cx).max(0.0) as u64 * 7919 + strike);
    let main = bolt((s.x as f32, s.y as f32), (en.x as f32, en.y as f32), segs, amp, levels, damp, &mut rng);
    let mut lines: Vec<(Vec<(f32, f32)>, f32)> = vec![(main.clone(), width)];
    for i in 1..main.len().saturating_sub(1) {
        if rng.next() < branching * 0.25 {
            let p = main[i];
            let (dx, dy) = (main[i + 1].0 - main[i - 1].0, main[i + 1].1 - main[i - 1].1);
            let a = dy.atan2(dx) + rng.signed() * 0.6;
            let l = dist * (0.15 + rng.next() * 0.25);
            let q = (p.0 + a.cos() * l, p.1 + a.sin() * l);
            lines.push((bolt(p, q, 4, amp * 0.4, levels.min(3), damp, &mut rng), width * 0.6));
        }
    }
    let (w, h) = (img.w, img.h);
    let mut dmap = vec![f32::INFINITY; w * h];
    // every segment scans a rectangle widened by the (project-supplied) width: stop at a budget
    let mut budget = MAX_LIGHTNING_PIXEL_VISITS;
    'lines: for (pts, lw) in &lines {
        for seg in pts.windows(2) {
            let (a, b) = (seg[0], seg[1]);
            let r = lw * 3.0;
            let (x0, x1) = ((a.0.min(b.0) - r).floor().max(0.0) as usize, ((a.0.max(b.0) + r).ceil().max(0.0) as usize).min(w));
            let (y0, y1) = ((a.1.min(b.1) - r).floor().max(0.0) as usize, ((a.1.max(b.1) + r).ceil().max(0.0) as usize).min(h));
            let (ex, ey) = (b.0 - a.0, b.1 - a.1);
            let l2 = (ex * ex + ey * ey).max(1e-6);
            let area = (x1.saturating_sub(x0) as u64).saturating_mul(y1.saturating_sub(y0) as u64);
            if area > budget {
                break 'lines;
            }
            budget -= area;
            for y in y0..y1 {
                for x in x0..x1 {
                    let (px, py) = (x as f32 + 0.5, y as f32 + 0.5);
                    let t = (((px - a.0) * ex + (py - a.1) * ey) / l2).clamp(0.0, 1.0);
                    let d = ((px - a.0 - ex * t).powi(2) + (py - a.1 - ey * t).powi(2)).sqrt() / lw;
                    let i = y * w + x;
                    if d < dmap[i] {
                        dmap[i] = d;
                    }
                }
            }
        }
    }
    img.px.par_chunks_mut(4).zip(dmap.par_iter()).for_each(|(p, &d)| {
        if !d.is_finite() {
            return;
        }
        let glow = (-(d * 1.6)).exp() * 0.9;
        let c = 1.0 - smoothstep(core * 0.5, core * 0.5 + 0.2, d);
        let col = lerp3(outc.map(|v| v * glow), inc, c);
        let a = glow.max(c).min(1.0);
        let base = Image::unpremul([p[0], p[1], p[2], p[3]]);
        let o = match mode {
            0 => {
                let mut q = [p[0], p[1], p[2], p[3]];
                over(&mut q, [col[0] * a, col[1] * a, col[2] * a, a]);
                p.copy_from_slice(&q);
                return;
            }
            m => blend_simple(m, base, col),
        };
        let na = p[3] + (1.0 - p[3]) * a;
        let mixed = lerp3(base, o, a);
        p.copy_from_slice(&[mixed[0] * na, mixed[1] * na, mixed[2] * na, na]);
    });
}

/// Cell Pattern (obsolete): Worley (cellular) noise patterns.
pub fn cell_pattern(img: &mut Image, e: &EffectInstance, cx: &FxCtx) {
    let pat = chv(e, "pattern");
    let invert = bv(e, "invert");
    let contrast = fv(e, "contrast", cx) / 100.0;
    let overflow = chv(e, "overflow");
    let disperse = fv(e, "disperse", cx).clamp(0.0, 1.5);
    let size = (fv(e, "size", cx) * cx.px_scale).max(1.0);
    let off = offv(e, "offset", cx);
    let evo = if pat == 3 { 0.0 } else { fv(e, "evolution", cx).to_radians() };
    let seed = fv(e, "seed", cx).max(0.0) as u64;
    generate(img, |x, y, _| {
        let (u, v) = ((x + off.x as f32) / size, (y + off.y as f32) / size);
        let (ci, cj) = (u.floor() as i64, v.floor() as i64);
        let (mut f1, mut f2, mut id) = (f32::INFINITY, f32::INFINITY, 0.0f32);
        for dj in -1..=1 {
            for di in -1..=1 {
                let (gi, gj) = (ci + di, cj + dj);
                let ph = hash01(gi, gj, 9, seed) * std::f32::consts::TAU;
                let jx = 0.5 + (hash01(gi, gj, 0, seed) - 0.5) * disperse + (evo + ph).cos() * 0.15 * disperse;
                let jy = 0.5 + (hash01(gi, gj, 1, seed) - 0.5) * disperse + (evo + ph).sin() * 0.15 * disperse;
                let d = ((gi as f32 + jx - u).powi(2) + (gj as f32 + jy - v).powi(2)).sqrt();
                if d < f1 {
                    f2 = f1;
                    f1 = d;
                    id = hash01(gi, gj, 2, seed);
                } else if d < f2 {
                    f2 = d;
                }
            }
        }
        let mut val = match pat {
            0 => (1.0 - f1 * 1.4).max(0.0),
            1 => (f2 - f1) * 2.0,
            2 | 3 => id,
            4 => id * smoothstep(0.0, 0.12, f2 - f1),
            5 => (f2 - f1) / (f2 + f1).max(1e-4) * 2.0,
            6 => ((f2 - f1) * 2.0 + id) * 0.5,
            _ => 1.0 - smoothstep(0.0, 0.12, (f1 - 0.35).abs()),
        };
        val = (val - 0.5) * contrast + 0.5;
        val = match overflow {
            1 => 1.0 / (1.0 + (-(val - 0.5) * 4.0).exp()),
            2 => {
                let m = val.rem_euclid(2.0);
                if m > 1.0 { 2.0 - m } else { m }
            }
            _ => val.clamp(0.0, 1.0),
        };
        if invert {
            val = 1.0 - val;
        }
        let g = filmcraft_color::srgb_to_linear(val);
        [g, g, g, 1.0]
    });
}

/// Checkerboard (obsolete): a checkerboard of Color and transparency.
pub fn checkerboard(img: &mut Image, e: &EffectInstance, cx: &FxCtx) {
    let a = pv(e, "anchor", cx, img);
    let cw = (fv(e, "width", cx) * cx.px_scale).max(1.0);
    let ch = if bv(e, "square") { cw } else { (fv(e, "height", cx) * cx.px_scale).max(1.0) };
    let fe = fv(e, "feather", cx) * cx.px_scale;
    let col = lin(cv(e, "color", cx));
    let op = fv(e, "opacity", cx) / 100.0;
    let mode = chv(e, "mode");
    generate(img, |x, y, p| {
        let (u, v) = ((x - a.x as f32) / cw, (y - a.y as f32) / ch);
        let par = ((u.floor() as i64 + v.floor() as i64).rem_euclid(2)) as f32;
        let edge = {
            let du = (u - u.round()).abs() * cw;
            let dv = (v - v.round()).abs() * ch;
            if fe > 0.0 { smoothstep(0.0, fe, du.min(dv)) } else { 1.0 }
        };
        let k = par * edge * op;
        match mode {
            0 => [col[0] * k, col[1] * k, col[2] * k, k],
            1 => {
                let mut q = p;
                over(&mut q, [col[0] * k, col[1] * k, col[2] * k, k]);
                q
            }
            m => {
                let base = Image::unpremul(p);
                let bm = [0u32, 0, 1, 3, 2, 4][m.min(5) as usize];
                let o = lerp3(base, blend_simple(bm, base, col), k);
                [o[0] * p[3], o[1] * p[3], o[2] * p[3], p[3]]
            }
        }
    });
}

/// Ellipse (obsolete): an anti-aliased elliptical ring, Inside Color at its core.
pub fn ellipse(img: &mut Image, e: &EffectInstance, cx: &FxCtx) {
    let c = pv(e, "center", cx, img);
    let (rx, ry) = ((fv(e, "width", cx) * cx.px_scale / 2.0).max(0.5), (fv(e, "height", cx) * cx.px_scale / 2.0).max(0.5));
    let th = (fv(e, "thickness", cx) * cx.px_scale).max(0.5);
    let soft = fv(e, "softness", cx) / 100.0;
    let inc = lin(cv(e, "inside", cx));
    let outc = lin(cv(e, "outside", cx));
    let comp = bv(e, "composite");
    let rmin = rx.min(ry);
    generate(img, |x, y, p| {
        let (dx, dy) = ((x - c.x as f32) / rx, (y - c.y as f32) / ry);
        let d = ((dx * dx + dy * dy).sqrt() - 1.0).abs() * rmin;
        let half = th / 2.0;
        let a = 1.0 - smoothstep(half * (1.0 - soft) - 0.5, half + 0.5, d);
        let inner = 1.0 - smoothstep(0.0, half, d);
        let col = lerp3(outc, inc, inner);
        let s = [col[0] * a, col[1] * a, col[2] * a, a];
        if comp {
            let mut q = p;
            over(&mut q, s);
            q
        } else {
            s
        }
    });
}

/// Paint Bucket (obsolete): flood fill from Fill Point within Tolerance.
pub fn paint_bucket(img: &mut Image, e: &EffectInstance, cx: &FxCtx) {
    let pt = pv(e, "point", cx, img);
    let (w, h) = (img.w, img.h);
    let (sx, sy) = (pt.x.floor() as isize, pt.y.floor() as isize);
    if sx < 0 || sy < 0 || sx as usize >= w || sy as usize >= h {
        return;
    }
    let sel = chv(e, "selector");
    let tol = fv(e, "tolerance", cx) / 255.0;
    let col = lin(cv(e, "color", cx));
    let op = fv(e, "opacity", cx) / 100.0;
    let mode = chv(e, "mode");
    let px = |i: usize| -> [f32; 4] {
        let p = &img.px[i * 4..i * 4 + 4];
        let c = enc(Image::unpremul([p[0], p[1], p[2], p[3]]));
        [c[0], c[1], c[2], p[3]]
    };
    let seed = px(sy as usize * w + sx as usize);
    let similar = |q: [f32; 4]| -> bool {
        match sel {
            0 => (0..4).all(|k| (q[k] - seed[k]).abs() <= tol),
            1 => (0..3).all(|k| (q[k] - seed[k]).abs() <= tol),
            2 => q[3] <= tol.max(1e-3),
            _ => (q[3] - seed[3]).abs() <= tol,
        }
    };
    let mut fill = vec![0f32; w * h];
    let mut queue = VecDeque::new();
    let start = sy as usize * w + sx as usize;
    if similar(seed) {
        fill[start] = 1.0;
        queue.push_back(start);
    }
    while let Some(i) = queue.pop_front() {
        let (x, y) = (i % w, i / w);
        let mut visit = |j: usize| {
            if fill[j] == 0.0 && similar(px(j)) {
                fill[j] = 1.0;
                queue.push_back(j);
            }
        };
        if x > 0 {
            visit(i - 1);
        }
        if x + 1 < w {
            visit(i + 1);
        }
        if y > 0 {
            visit(i - w);
        }
        if y + 1 < h {
            visit(i + w);
        }
    }
    if bv(e, "invert") {
        fill.iter_mut().for_each(|v| *v = 1.0 - *v);
    }
    let fill = blur_plane(&fill, w, h, 0.5);
    img.px.par_chunks_mut(4).zip(fill.par_iter()).for_each(|(p, &f)| {
        let k = f * op;
        if k <= 0.0 {
            return;
        }
        let s = [col[0] * k, col[1] * k, col[2] * k, k];
        match mode {
            1 => {
                let mut q = s;
                over(&mut q, [p[0], p[1], p[2], p[3]]);
                p.copy_from_slice(&q);
            }
            2..=4 => {
                let base = Image::unpremul([p[0], p[1], p[2], p[3]]);
                let bm = [0u32, 0, 1, 3, 2][mode as usize];
                let o = lerp3(base, blend_simple(bm, base, col), k);
                for c in 0..3 {
                    p[c] = o[c] * p[3];
                }
            }
            _ => over(p, s),
        }
    });
}

/// Most brush stamps Write-on keeps, and most pixels it paints, for one frame.
const MAX_WRITE_ON_STAMPS: usize = 1 << 20;
const MAX_WRITE_ON_PIXEL_VISITS: u64 = 1 << 28;
/// Interpolated candidate stamps looked at in all, on or off the canvas (a few per kept stamp).
const MAX_WRITE_ON_CANDIDATES: usize = 4 * MAX_WRITE_ON_STAMPS;

/// Write-on (obsolete): paints the animated Brush Position's path up to now.
pub fn write_on(img: &mut Image, e: &EffectInstance, cx: &FxCtx) {
    let Some(param) = e.param("brush") else { return };
    let col = lin(cv(e, "color", cx));
    let r = (fv(e, "size", cx) * cx.px_scale / 2.0).max(0.5);
    let hard = fv(e, "hardness", cx) / 100.0;
    let op = fv(e, "opacity", cx) / 100.0;
    let stroke_len = fv(e, "stroke_length", cx) as f64;
    let spacing = (fv(e, "spacing", cx) as f64).max(0.001);
    let style = chv(e, "style");
    let elapsed = cx.seconds.max(0.0);
    let n = ((elapsed / spacing).floor() as usize).min(20_000);
    let first = if stroke_len > 0.0 { ((elapsed - stroke_len) / spacing).ceil().max(0.0) as usize } else { 0 };
    let to_px = |t: f64| {
        let mt = cx.t - Tick::from_seconds_f64(elapsed - t);
        let v = param.vec2_at(mt);
        let (fx, fy) = (
            if v.x.is_nan() { img.w as f64 / 2.0 } else { v.x * cx.px_scale as f64 },
            if v.y.is_nan() { img.h as f64 / 2.0 } else { v.y * cx.px_scale as f64 },
        );
        (fx as f32, fy as f32)
    };
    let (w, h) = (img.w, img.h);
    // A stamp wholly off the canvas paints nothing and a repeat of the last stamp changes nothing
    // (coverage is a maximum), so neither is kept; the history is bounded as well.
    let (wf, hf) = (w as f32, h as f32);
    let visible = |p: (f32, f32)| p.0 + r + 1.0 >= 0.0 && p.0 - r - 1.0 < wf && p.1 + r + 1.0 >= 0.0 && p.1 - r - 1.0 < hf;
    let mut stamps: Vec<(f32, f32)> = Vec::new();
    let mut prev: Option<(f32, f32)> = None;
    let mut candidates = 0usize;
    'path: for i in first..=n {
        let p = to_px(i as f64 * spacing);
        if prev == Some(p) {
            continue;
        }
        if let Some(q) = prev {
            let d = ((p.0 - q.0).powi(2) + (p.1 - q.1).powi(2)).sqrt();
            let steps = (d / (r * 0.5)).ceil() as usize;
            for s in 1..steps.min(2000) {
                // off-canvas candidates keep no stamp, so they are counted here or a long off-canvas path would not be bounded
                candidates += 1;
                if candidates > MAX_WRITE_ON_CANDIDATES {
                    break 'path;
                }
                let t = s as f32 / steps as f32;
                let at = (q.0 + (p.0 - q.0) * t, q.1 + (p.1 - q.1) * t);
                if visible(at) && stamps.len() < MAX_WRITE_ON_STAMPS {
                    stamps.push(at);
                }
            }
        }
        if visible(p) && stamps.len() < MAX_WRITE_ON_STAMPS {
            stamps.push(p);
        }
        prev = Some(p);
    }
    let mut cov = vec![0f32; w * h];
    let mut budget = MAX_WRITE_ON_PIXEL_VISITS;
    for (sx, sy) in stamps {
        let (x0, x1) = ((sx - r - 1.0).floor().max(0.0) as usize, ((sx + r + 1.0).ceil().max(0.0) as usize).min(w));
        let (y0, y1) = ((sy - r - 1.0).floor().max(0.0) as usize, ((sy + r + 1.0).ceil().max(0.0) as usize).min(h));
        let area = (x1.saturating_sub(x0) as u64).saturating_mul(y1.saturating_sub(y0) as u64);
        if area > budget {
            break;
        }
        budget -= area;
        for y in y0..y1 {
            for x in x0..x1 {
                let d = ((x as f32 + 0.5 - sx).powi(2) + (y as f32 + 0.5 - sy).powi(2)).sqrt();
                let a = 1.0 - smoothstep(r * hard - 0.5, r + 0.5, d);
                let i = y * w + x;
                if a > cov[i] {
                    cov[i] = a;
                }
            }
        }
    }
    img.px.par_chunks_mut(4).zip(cov.par_iter()).for_each(|(p, &c)| {
        let k = c * op;
        match style {
            1 => p.copy_from_slice(&[col[0] * k, col[1] * k, col[2] * k, k]),
            2 => {
                for v in p.iter_mut() {
                    *v *= k;
                }
            }
            _ => over(p, [col[0] * k, col[1] * k, col[2] * k, k]),
        }
    });
}