GitCorner

Code

ossartcraftvectorcraft🌐
2bc41aeb8602
//! Tool cursors drawn as vector glyphs (egui only offers system cursors). Black shapes with a white
//! halo, hotspot at `p`, one shape per tool: solid arrow (Selection), hollow arrow (Direct
//! Selection), pen nib with state badges, crosshair for drawing tools, curved arrows for rotate.
//!
//! The desktop app shows them as OS cursors ([`Images`]): the system moves those itself, at once,
//! while a cursor painted into the window follows the pointer a few frames late (#444).

/// Platform-neutral bitmap requests for the interim macOS host adapter.
#[cfg(any(target_os = "macos", test))]
pub mod native_request;

use egui::epaint::{Mesh, TessellationOptions, Tessellator, Vertex};
use egui::{Color32, CustomCursorImage, Painter, Pos2, Shape, Stroke, Vec2, pos2, vec2};
use vectorcraft_tools::Cursor;

const INK: Color32 = Color32::BLACK;
const HALO: Color32 = Color32::WHITE;

/// The shapes of one cursor glyph.
#[derive(Default)]
struct Ink(Vec<Shape>);

impl Ink {
    fn add(&mut self, s: Shape) {
        self.0.push(s);
    }
    fn line_segment(&mut self, pts: [Pos2; 2], stroke: Stroke) {
        self.add(Shape::line_segment(pts, stroke));
    }
    fn circle_stroke(&mut self, c: Pos2, r: f32, stroke: Stroke) {
        self.add(Shape::circle_stroke(c, r, stroke));
    }
    fn circle_filled(&mut self, c: Pos2, r: f32, fill: Color32) {
        self.add(Shape::circle_filled(c, r, fill));
    }
}

fn poly(p: &mut Ink, pts: Vec<Pos2>, fill: Color32, stroke: Color32) {
    // Halo first (thicker white outline), then the glyph.
    p.add(Shape::closed_line(pts.clone(), Stroke::new(3.0, HALO)));
    p.add(Shape::convex_polygon(pts.clone(), fill, Stroke::NONE));
    p.add(Shape::closed_line(pts, Stroke::new(1.0, stroke)));
}

fn line(p: &mut Ink, a: Pos2, b: Pos2) {
    p.line_segment([a, b], Stroke::new(3.0, HALO));
    p.line_segment([a, b], Stroke::new(1.2, INK));
}

fn arrow_points(o: Pos2) -> Vec<Pos2> {
    // Classic pointer, tip at o.
    [(0.0, 0.0), (0.0, 15.0), (3.8, 11.4), (6.4, 17.0), (8.6, 16.0), (6.1, 10.6), (11.0, 10.6)].iter().map(|(x, y)| o + vec2(*x, *y)).collect()
}

fn arrow(p: &mut Ink, o: Pos2, hollow: bool) {
    let pts = arrow_points(o);
    // The arrow is concave: draw as a filled mesh of two convex parts, then outline.
    p.add(Shape::closed_line(pts.clone(), Stroke::new(3.0, HALO)));
    let fill = if hollow { HALO } else { INK };
    p.add(Shape::convex_polygon(vec![pts[0], pts[1], pts[2], pts[5], pts[6]], fill, Stroke::NONE));
    p.add(Shape::convex_polygon(vec![pts[2], pts[3], pts[4], pts[5]], fill, Stroke::NONE));
    p.add(Shape::closed_line(pts, Stroke::new(1.0, INK)));
}

fn crosshair(p: &mut Ink, o: Pos2) {
    for (a, b) in
        [(vec2(-9.0, 0.0), vec2(-2.0, 0.0)), (vec2(2.0, 0.0), vec2(9.0, 0.0)), (vec2(0.0, -9.0), vec2(0.0, -2.0)), (vec2(0.0, 2.0), vec2(0.0, 9.0))]
    {
        line(p, o + a, o + b);
    }
}

/// A pipette pointing down-left: the sampling tip is the hotspot, with the tube and bulb above
/// right. Drawn here so bitmap and painted cursors share the same original glyph (#1269).
fn eyedropper(p: &mut Ink, o: Pos2) {
    let tube = [(0.0, 0.0), (1.0, -5.0), (14.0, -18.0), (18.0, -14.0), (5.0, -1.0)];
    poly(p, tube.iter().map(|(x, y)| o + vec2(*x, *y)).collect(), HALO, INK);
    let bulb = o + vec2(20.0, -20.0);
    p.circle_filled(bulb, 6.5, HALO);
    p.circle_filled(bulb, 5.0, INK);
    line(p, o + vec2(11.0, -19.0), o + vec2(19.0, -11.0));
}

/// The selection arrow's axis: the midline between its two edges at the tip, a unit vector.
/// The pen nib lies along it, so swapping between the Pen and the selection tools (Cmd/Ctrl)
/// doesn't rotate the cursor.
fn arrow_axis() -> Vec2 {
    let a = arrow_points(Pos2::ZERO);
    let (e1, e2) = (a[1] - a[0], a[6] - a[0]);
    (e1.normalized() + e2.normalized()).normalized()
}

/// The Pen family's nib: the pen-tool icon's, swung round onto the selection arrow's axis
/// (`arrow_axis`, down-right) so swapping to the selection tools doesn't rotate the cursor, its
/// point on the hotspot `o`. In nib coordinates `u` runs along the axis and `v` across it: the
/// silhouette is symmetric about the axis — the point, shoulders flaring to their widest
/// two-thirds back, then a narrower flat heel. The slit runs back along the axis from the point,
/// widening into the round breather hole; both are cut to the halo's white. Every Pen cursor is
/// this nib plus a badge below right of it saying what a click does.
fn pen(p: &mut Ink, o: Pos2, badge: &str) {
    let d = arrow_axis();
    let n = vec2(-d.y, d.x);
    let at = |u: f32, v: f32| o + u * d + v * n;
    poly(p, vec![at(0.0, 0.0), at(10.5, -6.3), at(15.5, -3.0), at(15.5, 3.0), at(10.5, 6.3)], INK, INK);
    // The slit is a wedge opening at the point, widening into the round breather hole.
    p.add(Shape::convex_polygon(vec![at(2.0, 0.0), at(10.4, -0.85), at(10.4, 0.85)], HALO, Stroke::NONE));
    p.circle_filled(at(11.8, 0.0), 1.7, HALO);
    let b = o + vec2(13.0, 12.0);
    match badge {
        "o" => {
            p.circle_stroke(b + vec2(3.0, 3.0), 3.0, Stroke::new(3.0, HALO));
            p.circle_stroke(b + vec2(3.0, 3.0), 3.0, Stroke::new(1.2, INK));
        }
        "+" => strokes(p, &[vec![b + vec2(0.0, 3.0), b + vec2(6.0, 3.0)], vec![b + vec2(3.0, 0.0), b + vec2(3.0, 6.0)]]),
        "-" => line(p, b + vec2(0.0, 3.0), b + vec2(6.0, 3.0)),
        "/" => line(p, b + vec2(0.0, 6.0), b + vec2(5.0, 0.0)),
        "~" => {
            // A quarter circle bulging up-left, from the badge's bottom-left to its top-right.
            let c = b + vec2(7.0, 7.0);
            let arc: Vec<Pos2> = (0..=8).map(|i| c + egui::Vec2::angled(std::f32::consts::PI * (1.0 + i as f32 / 16.0)) * 6.0).collect();
            p.add(Shape::line(arc.clone(), Stroke::new(3.0, HALO)));
            p.add(Shape::line(arc, Stroke::new(1.2, INK)));
        }
        // Join: a segment running into a square end point.
        "j" => {
            line(p, b + vec2(0.0, 6.0), b + vec2(3.5, 2.5));
            let sq = [(3.0, -1.0), (7.0, -1.0), (7.0, 3.0), (3.0, 3.0)].map(|(x, y)| b + vec2(x, y));
            poly(p, sq.to_vec(), INK, INK);
        }
        "^" => strokes(p, &[vec![b + vec2(0.0, 6.0), b + vec2(3.0, 0.0)], vec![b + vec2(3.0, 0.0), b + vec2(6.0, 6.0)]]),
        "*" => {
            // The new-path star: eight spokes on the badge's centre.
            strokes(
                p,
                &[
                    vec![b + vec2(0.6, 0.6), b + vec2(5.4, 5.4)],
                    vec![b + vec2(5.4, 0.6), b + vec2(0.6, 5.4)],
                    vec![b + vec2(3.0, 0.0), b + vec2(3.0, 6.0)],
                    vec![b + vec2(0.0, 3.0), b + vec2(6.0, 3.0)],
                ],
            );
        }
        _ => {}
    }
}

/// The Anchor Point tool's caret (as its toolbar icon): a small hollow square on the anchor at
/// the hotspot, legs spreading down from its lower corners. Every halo goes under every stroke, so
/// the legs join the square.
fn anchor_point(p: &mut Ink, o: Pos2) {
    let s = 2.5;
    let square = vec![o + vec2(-s, -s), o + vec2(s, -s), o + vec2(s, s), o + vec2(-s, s)];
    let legs = [[o + vec2(-s, s), o + vec2(-7.5, 13.0)], [o + vec2(s, s), o + vec2(7.5, 13.0)]];
    for leg in legs {
        p.line_segment(leg, Stroke::new(3.0, HALO));
    }
    p.add(Shape::closed_line(square.clone(), Stroke::new(3.0, HALO)));
    p.add(Shape::convex_polygon(square.clone(), HALO, Stroke::NONE));
    for leg in legs {
        p.line_segment(leg, Stroke::new(1.2, INK));
    }
    p.add(Shape::closed_line(square, Stroke::new(1.0, INK)));
}

/// Halos under every stroke first, then the ink, so crossing strokes don't cut each other.
fn strokes(p: &mut Ink, parts: &[Vec<Pos2>]) {
    for s in parts {
        p.add(Shape::line(s.clone(), Stroke::new(3.0, HALO)));
    }
    for s in parts {
        p.add(Shape::line(s.clone(), Stroke::new(1.2, INK)));
    }
}

/// A stemless arrowhead, tip at `o`.
fn arrowhead(o: Pos2) -> Vec<Pos2> {
    vec![o, o + vec2(0.0, 14.0), o + vec2(4.2, 10.4), o + vec2(10.0, 10.0)]
}

/// Direct Selection over an anchor: the white arrow with a small square at its lower right,
/// filled when the anchor's path is selected.
fn arrow_square(p: &mut Ink, o: Pos2, filled: bool) {
    arrow(p, o, true);
    let b = o + vec2(11.0, 13.0);
    let square = [(0.0, 0.0), (5.0, 0.0), (5.0, 5.0), (0.0, 5.0)].map(|(x, y)| b + vec2(x, y)).to_vec();
    poly(p, square, if filled { INK } else { HALO }, INK);
}

/// The Reshape Segment cursor: a black arrowhead with a small curve between two anchor marks at
/// its lower right.
fn reshape_segment(p: &mut Ink, o: Pos2) {
    poly(p, arrowhead(o), INK, INK);
    let (a, c) = (o + vec2(10.0, 19.0), o + vec2(19.0, 19.0));
    let curve: Vec<Pos2> = (0..=12)
        .map(|i| {
            let t = i as f32 / 12.0;
            a + (c - a) * t - vec2(0.0, 4.5 * (std::f32::consts::PI * t).sin())
        })
        .collect();
    strokes(p, &[curve]);
    for m in [a, c] {
        let mark = [(-1.5, -1.5), (1.5, -1.5), (1.5, 1.5), (-1.5, 1.5)].map(|(x, y)| m + vec2(x, y)).to_vec();
        poly(p, mark, INK, INK);
    }
}

/// Group Selection: the white arrow with a plus at its lower right.
fn arrow_plus(p: &mut Ink, o: Pos2) {
    arrow(p, o, true);
    let c = o + vec2(14.0, 15.0);
    strokes(p, &[vec![c - vec2(3.5, 0.0), c + vec2(3.5, 0.0)], vec![c - vec2(0.0, 3.5), c + vec2(0.0, 3.5)]]);
}

/// An Alt-drag copy: a black arrowhead in front of a white one set down and to the right.
fn double_arrowhead(p: &mut Ink, o: Pos2) {
    poly(p, arrowhead(o + vec2(4.0, 4.0)), HALO, INK);
    poly(p, arrowhead(o), INK, INK);
}

fn double_arrow(p: &mut Ink, o: Pos2, dir: egui::Vec2) {
    let d = dir.normalized() * 8.0;
    let n = vec2(-d.y, d.x) * 0.45;
    line(p, o - d, o + d);
    for (tip, back) in [(o + d, o + d * 0.45), (o - d, o - d * 0.45)] {
        poly(p, vec![tip, back + n, back - n], INK, INK);
    }
}

/// Two single arrows side by side across the hotspot, pointing opposite ways along `dir`: a side
/// sliding past its opposite one, as a shear does.
fn shear(p: &mut Ink, o: Pos2, dir: egui::Vec2) {
    let d = dir.normalized() * 7.0;
    let n = vec2(-d.y, d.x) / 7.0;
    for (side, way) in [(-3.5, 1.0), (3.5, -1.0)] {
        let (c, d) = (o + n * side, d * way);
        line(p, c - d, c + d * 0.55);
        let back = c + d * 0.4;
        poly(p, vec![c + d, back + n * 2.6, back - n * 2.6], INK, INK);
    }
}

/// A curved double arrow over the hotspot: an arc with an arrowhead at each end, pointing on along
/// the arc (#701). The arc bows up, or toward `octant` (0 up, then clockwise in 45° steps): beside a
/// bounding box it wraps the corner the pointer is at.
fn rotate(p: &mut Ink, o: Pos2, octant: u8) {
    const R: f32 = 8.0;
    let (a0, a1) = (std::f32::consts::PI * 0.12, std::f32::consts::PI * 0.88);
    // Clockwise on screen (y down) by whole octants.
    let (s, c) = (f32::from(octant % 8) * std::f32::consts::FRAC_PI_4).sin_cos();
    let turn = |v: Vec2| vec2(v.x * c - v.y * s, v.x * s + v.y * c);
    let at = |a: f32| o + turn(vec2(a.cos() * R, -a.sin() * R));
    let pts: Vec<Pos2> = (0..=12).map(|i| at(a0 + (a1 - a0) * i as f32 / 12.0)).collect();
    p.add(Shape::line(pts.clone(), Stroke::new(3.2, HALO)));
    p.add(Shape::line(pts, Stroke::new(1.3, INK)));
    // Each head points away from the arc, along its tangent there.
    for (a, away) in [(a0, -1.0f32), (a1, 1.0)] {
        let t = turn(vec2(-a.sin(), -a.cos()) * away);
        let n = vec2(-t.y, t.x);
        let (end, tip) = (at(a) - t * 1.5, at(a) + t * 4.5);
        poly(p, vec![tip, end + n * 1.8, end - n * 1.8], INK, INK);
    }
}

/// Live Corners: the hollow arrow with a rounded-corner badge.
fn corner_radius(p: &mut Ink, o: Pos2) {
    arrow(p, o, true);
    let b = o + vec2(12.0, 13.0);
    let mut pts = vec![b + vec2(0.0, 10.0)];
    pts.extend((0..=8).map(|i| {
        let a = std::f32::consts::PI * (1.0 + 0.5 * i as f32 / 8.0);
        b + vec2(4.0 + 4.0 * a.cos(), 4.0 + 4.0 * a.sin())
    }));
    pts.push(b + vec2(10.0, 0.0));
    p.add(Shape::line(pts.clone(), Stroke::new(3.0, HALO)));
    p.add(Shape::line(pts, Stroke::new(1.2, INK)));
}

/// Over a bracket of type on a path: the arrow with a bracket (a stem standing on a baseline,
/// with a foot) below right.
fn path_bracket(p: &mut Ink, o: Pos2) {
    arrow(p, o, false);
    let b = o + vec2(13.0, 13.0);
    let stem = [b + vec2(3.0, 0.0), b + vec2(3.0, 10.0)];
    let foot = [b + vec2(3.0, 0.0), b + vec2(7.0, 0.0)];
    let base = [b + vec2(0.0, 8.0), b + vec2(10.0, 8.0)];
    for (w, c) in [(3.0, HALO), (1.2, INK)] {
        for l in [stem, foot, base] {
            p.line_segment(l, Stroke::new(w, c));
        }
    }
}

/// Over the type widget: the arrow with a type badge (a T) below right.
fn type_widget(p: &mut Ink, o: Pos2) {
    arrow(p, o, false);
    let b = o + vec2(12.0, 13.0);
    line(p, b, b + vec2(8.0, 0.0));
    line(p, b + vec2(4.0, 0.0), b + vec2(4.0, 9.0));
}

/// Overflow text the Selection tool carries after a click on the red out port: a small block of
/// lines at the hotspot (where a new frame's top-left would go).
fn loaded_text(p: &mut Ink, o: Pos2) {
    let tl = o;
    let br = o + vec2(14.0, 11.0);
    let frame = vec![tl, pos2(br.x, tl.y), br, pos2(tl.x, br.y)];
    poly(p, frame, HALO, INK);
    for y in [3.0, 6.5, 10.0] {
        line(p, tl + vec2(2.0, y), tl + vec2(12.0, y));
    }
}

/// Loaded text over an object a click threads it into: the loaded text's block with a link
/// badge (two chain rings) below right.
fn loaded_text_link(p: &mut Ink, o: Pos2) {
    loaded_text(p, o);
    let rings = [o + vec2(13.0, 17.0), o + vec2(18.0, 17.0)];
    for c in rings {
        p.circle_stroke(c, 3.2, Stroke::new(3.2, HALO));
    }
    for c in rings {
        p.circle_stroke(c, 3.2, Stroke::new(1.3, INK));
    }
}

/// The gradient annotator's stop cursors: the arrow with a plus (add a stop) or minus (delete it)
/// badge.
fn stop_badge(p: &mut Ink, o: Pos2, add: bool) {
    arrow(p, o, false);
    let b = o + vec2(13.0, 13.0);
    line(p, b, b + vec2(6.0, 0.0));
    if add {
        line(p, b + vec2(3.0, -3.0), b + vec2(3.0, 3.0));
    }
}

/// A slice badge: a small rectangle cut by a line, at `b` (its top left).
fn slice_badge(p: &mut Ink, b: Pos2) {
    let pts = vec![b, b + vec2(8.0, 0.0), b + vec2(8.0, 6.0), b + vec2(0.0, 6.0)];
    poly(p, pts, HALO, INK);
    line(p, b + vec2(4.0, 0.0), b + vec2(4.0, 6.0));
}

/// The Slice tool: a crosshair with a blade below right of the hotspot.
fn slice(p: &mut Ink, o: Pos2) {
    crosshair(p, o);
    let b = o + vec2(7.0, 7.0);
    poly(p, vec![b, b + vec2(9.0, 4.0), b + vec2(10.0, 7.0), b + vec2(3.0, 6.0)], HALO, INK);
    line(p, b + vec2(8.0, 6.0), b + vec2(12.0, 12.0));
}

/// The Width tool: the hollow arrow with a stroke that swells in the middle (a width point),
/// plus a badge: `+` over a stroke (a drag adds a point), a bar across the swell over a width point
/// (a drag moves or widens it).
fn width(p: &mut Ink, o: Pos2, badge: &str) {
    arrow(p, o, true);
    let b = o + vec2(11.0, 18.0);
    let top: Vec<Pos2> = (0..=8)
        .map(|i| {
            let t = i as f32 / 8.0;
            b + vec2(12.0 * t, -3.5 * (std::f32::consts::PI * t).sin())
        })
        .collect();
    let mut lens = top.clone();
    lens.extend(top.iter().rev().map(|q| pos2(q.x, 2.0 * b.y - q.y)));
    p.add(Shape::closed_line(lens.clone(), Stroke::new(3.0, HALO)));
    p.add(Shape::closed_line(lens, Stroke::new(1.2, INK)));
    match badge {
        "+" => {
            let c = b + vec2(16.0, -6.0);
            line(p, c - vec2(3.0, 0.0), c + vec2(3.0, 0.0));
            line(p, c - vec2(0.0, 3.0), c + vec2(0.0, 3.0));
        }
        "point" => line(p, b + vec2(6.0, -6.0), b + vec2(6.0, 6.0)),
        _ => {}
    }
}

fn ibeam(p: &mut Ink, o: Pos2) {
    line(p, o + vec2(0.0, -8.0), o + vec2(0.0, 8.0));
    line(p, o + vec2(-3.0, -8.0), o + vec2(3.0, -8.0));
    line(p, o + vec2(-3.0, 8.0), o + vec2(3.0, 8.0));
    line(p, o + vec2(-2.0, 3.0), o + vec2(2.0, 3.0));
}

/// A type tool over a path: the Text I-beam (turned a quarter turn for vertical type) with a badge
/// below right of it, as the Pen and the Blend tool mark what a click does: a small frame with
/// lines of type in it for area type inside a closed path, a smooth curve with a point on it for
/// type along a path.
fn type_in_path(p: &mut Ink, o: Pos2, vertical: bool, on_path: bool) {
    let at = |x: f32, y: f32| if vertical { o + vec2(-y, x) } else { o + vec2(x, y) };
    line(p, at(0.0, -8.0), at(0.0, 8.0));
    line(p, at(-3.0, -8.0), at(3.0, -8.0));
    line(p, at(-3.0, 8.0), at(3.0, 8.0));
    line(p, at(-2.0, 3.0), at(2.0, 3.0));
    let b = o + if vertical { vec2(2.0, 6.0) } else { vec2(6.0, 2.0) };
    if on_path {
        // A quarter-wave rising to the right, smooth at this size.
        let curve: Vec<Pos2> = (0..=16)
            .map(|i| {
                let t = i as f32 / 16.0;
                b + vec2(10.0 * t, 8.0 - 8.0 * (t * std::f32::consts::FRAC_PI_2).sin().powf(1.6))
            })
            .collect();
        strokes(p, &[curve]);
        let dot = b + vec2(4.0, 8.0 - 8.0 * (0.4 * std::f32::consts::FRAC_PI_2).sin().powf(1.6));
        p.circle_filled(dot, 2.4, HALO);
        p.circle_filled(dot, 1.5, INK);
    } else {
        poly(p, vec![b, b + vec2(9.0, 0.0), b + vec2(9.0, 9.0), b + vec2(0.0, 9.0)], HALO, INK);
        let rows: Vec<Vec<Pos2>> = if vertical {
            [6.5, 4.5, 2.5].iter().map(|&x| vec![b + vec2(x, 2.5), b + vec2(x, 6.5)]).collect()
        } else {
            [2.5, 4.5, 6.5].iter().map(|&y| vec![b + vec2(2.5, y), b + vec2(6.5, y)]).collect()
        };
        for r in rows {
            p.add(Shape::line(r, Stroke::new(1.0, INK)));
        }
    }
}

/// The Blend tool: a crosshair with a square below right of the hotspot, hollow away from art,
/// filled over an object; over an anchor point a ringed dot (the blend starts there).
fn blend(p: &mut Ink, o: Pos2, badge: Cursor) {
    crosshair(p, o);
    let b = o + vec2(9.0, 9.0);
    if badge == Cursor::BlendAnchor {
        p.circle_stroke(b + vec2(3.5, 3.5), 3.5, Stroke::new(3.0, HALO));
        p.circle_stroke(b + vec2(3.5, 3.5), 3.5, Stroke::new(1.2, INK));
        p.circle_filled(b + vec2(3.5, 3.5), 1.4, INK);
        return;
    }
    let fill = if badge == Cursor::BlendObject { INK } else { HALO };
    poly(p, vec![b, b + vec2(7.0, 0.0), b + vec2(7.0, 7.0), b + vec2(0.0, 7.0)], fill, INK);
}

/// The Shape Builder: a crosshair with a plus badge below right of the hotspot (merge mode), or a
/// minus (erase mode).
fn shape_builder(p: &mut Ink, o: Pos2, erase: bool) {
    crosshair(p, o);
    let c = o + vec2(12.0, 12.0);
    line(p, c - vec2(3.5, 0.0), c + vec2(3.5, 0.0));
    if !erase {
        line(p, c - vec2(0.0, 3.5), c + vec2(0.0, 3.5));
    }
}

/// The Live Paint Bucket: a paint bucket tipped toward the hotspot at its lower left, its mouth
/// down-left with a rim across it, and a drop on the hotspot. Empty (white) with a small drop where
/// a click paints nothing; filled, with a larger drop, where a click fills a face.
fn paint_bucket(p: &mut Ink, o: Pos2, filled: bool) {
    // `u` runs from the hotspot up-right into the bucket, `v` across it.
    let (d, n) = (vec2(1.0, -1.0).normalized(), vec2(1.0, 1.0).normalized());
    let at = |u: f32, v: f32| o + u * d + v * n;
    poly(p, vec![at(5.5, -6.0), at(16.5, -4.5), at(16.5, 4.5), at(5.5, 6.0)], if filled { INK } else { HALO }, INK);
    poly(p, vec![at(4.5, -7.0), at(6.5, -7.0), at(6.5, 7.0), at(4.5, 7.0)], INK, INK);
    if filled {
        p.circle_filled(o, 3.5, HALO);
        p.circle_filled(o, 2.2, INK);
    } else {
        p.circle_filled(o, 2.5, HALO);
        p.circle_filled(o, 1.25, INK);
    }
}

/// The Live Paint Bucket over an edge it paints: a brush, its bristles' tip on the hotspot, the
/// white ferrule and the black handle running up-right.
fn paint_brush(p: &mut Ink, o: Pos2) {
    let (d, n) = (vec2(1.0, -1.0).normalized(), vec2(1.0, 1.0).normalized());
    let at = |u: f32, v: f32| o + u * d + v * n;
    let bristles = vec![at(0.0, 0.0), at(4.0, -2.2), at(6.0, -2.2), at(6.0, 2.2), at(4.0, 2.2)];
    let ferrule = vec![at(6.0, -2.0), at(9.0, -2.0), at(9.0, 2.0), at(6.0, 2.0)];
    let handle = vec![at(9.0, -1.5), at(19.0, -1.2), at(19.0, 1.2), at(9.0, 1.5)];
    // Every halo first, so no part's halo covers another's outline.
    for part in [&bristles, &ferrule, &handle] {
        p.add(Shape::closed_line(part.clone(), Stroke::new(3.0, HALO)));
    }
    for (part, fill) in [(bristles, INK), (ferrule, HALO), (handle, INK)] {
        p.add(Shape::convex_polygon(part.clone(), fill, Stroke::NONE));
        p.add(Shape::closed_line(part, Stroke::new(1.0, INK)));
    }
}

/// The Knife and the Trim at Crossings Tool: a knife, the blade's point on the hotspot, the white
/// blade with its straight back and curved edge, then the black handle running up-right.
fn knife(p: &mut Ink, o: Pos2) {
    let (d, n) = (vec2(1.0, -1.0).normalized(), vec2(1.0, 1.0).normalized());
    let at = |u: f32, v: f32| o + u * d + v * n;
    let blade = vec![at(0.0, 0.0), at(11.0, -2.5), at(11.0, 3.0), at(6.0, 2.8), at(2.5, 1.6)];
    let handle = vec![at(11.0, -2.0), at(20.0, -1.8), at(21.0, 0.2), at(20.0, 2.2), at(11.0, 2.5)];
    // Both halos first, so neither covers the other's outline.
    for part in [&blade, &handle] {
        p.add(Shape::closed_line(part.clone(), Stroke::new(3.0, HALO)));
    }
    for (part, fill) in [(blade, HALO), (handle, INK)] {
        p.add(Shape::convex_polygon(part.clone(), fill, Stroke::NONE));
        p.add(Shape::closed_line(part, Stroke::new(1.0, INK)));
    }
}

/// Live Paint Selection: the solid arrow with a badge at its lower right saying what a click
/// selects: a filled square over a face ([`Cursor::LivePaintSelectFace`]), a short line between two
/// anchor marks over an edge ([`Cursor::LivePaintSelectEdge`]), an x where it selects nothing.
fn live_paint_select(p: &mut Ink, o: Pos2, part: Cursor) {
    arrow(p, o, false);
    let b = o + vec2(12.0, 13.0);
    match part {
        Cursor::LivePaintSelectFace => {
            poly(p, [(0.0, 0.0), (6.0, 0.0), (6.0, 6.0), (0.0, 6.0)].map(|(x, y)| b + vec2(x, y)).to_vec(), INK, INK);
        }
        Cursor::LivePaintSelectEdge => {
            let (a, c) = (b + vec2(0.0, 7.0), b + vec2(7.0, 0.0));
            strokes(p, &[vec![a, c]]);
            for m in [a, c] {
                poly(p, [(-1.5, -1.5), (1.5, -1.5), (1.5, 1.5), (-1.5, 1.5)].map(|(x, y)| m + vec2(x, y)).to_vec(), INK, INK);
            }
        }
        _ => strokes(p, &[vec![b, b + vec2(6.0, 6.0)], vec![b + vec2(6.0, 0.0), b + vec2(0.0, 6.0)]]),
    }
}

/// The Hand tool and Space: an open hand (palm and four fingers, thumb to the left), or the same
/// hand closed while it drags the view. Windows has no system hand that isn't a pointing finger
/// (winit maps egui's Grab and Grabbing to the four-headed move cursor), so it is drawn like the
/// other tool cursors. Hotspot in the palm.
fn hand(p: &mut Ink, o: Pos2, closed: bool) {
    // Thumb out to the left, four fingers up from the palm (open) or folded over it (closed),
    // then the palm, a rounded block below the hotspot, over their bases.
    let mut parts = vec![vec![o + vec2(-7.0, 0.0), o + vec2(-13.0, -4.0), o + vec2(-14.0, -1.0), o + vec2(-9.0, 5.0)]];
    for (i, x) in [-5.5f32, -1.75, 2.0, 5.75].into_iter().enumerate() {
        let top = if closed {
            -5.0
        } else if i == 0 || i == 3 {
            -11.0
        } else {
            -14.0
        };
        parts.push(vec![o + vec2(x - 1.5, 0.0), o + vec2(x - 1.5, top), o + vec2(x + 1.5, top), o + vec2(x + 1.5, 0.0)]);
    }
    parts.push(vec![o + vec2(-7.0, -2.0), o + vec2(7.25, -2.0), o + vec2(8.0, 6.0), o + vec2(4.0, 11.0), o + vec2(-5.0, 11.0), o + vec2(-9.0, 5.0)]);
    // Every halo first, so no part's halo covers another's outline.
    for part in &parts {
        p.add(Shape::closed_line(part.clone(), Stroke::new(3.0, HALO)));
    }
    for part in parts {
        p.add(Shape::convex_polygon(part.clone(), HALO, Stroke::NONE));
        p.add(Shape::closed_line(part, Stroke::new(1.0, INK)));
    }
}

/// The Zoom tool: a magnifier with a plus in the lens (Alt: a minus), the lens centred on the
/// hotspot, the handle down to the right.
fn magnifier(p: &mut Ink, o: Pos2, out: bool) {
    const R: f32 = 7.0;
    p.circle_stroke(o, R, Stroke::new(3.0, HALO));
    let d = vec2(R * 0.72, R * 0.72);
    line(p, o + d, o + d + vec2(7.0, 7.0));
    p.circle_filled(o, R, HALO);
    p.circle_stroke(o, R, Stroke::new(1.2, INK));
    // Inside the white lens, without halos: a halo would cut the plus's other bar.
    let bar = Stroke::new(1.2, INK);
    p.line_segment([o - vec2(3.5, 0.0), o + vec2(3.5, 0.0)], bar);
    if !out {
        p.line_segment([o - vec2(0.0, 3.5), o + vec2(0.0, 3.5)], bar);
    }
}

/// Every cursor with a glyph: its own, drawn here, or the one it borrows.
#[cfg(test)]
const GLYPHS: [Cursor; 99] = [
    Cursor::Hand,
    Cursor::HandGrab,
    Cursor::ZoomIn,
    Cursor::ZoomOut,
    Cursor::Arrow,
    Cursor::ArrowHollow,
    Cursor::DirectAnchor,
    Cursor::DirectAnchorSelected,
    Cursor::ReshapeSegment,
    Cursor::GroupSelection,
    Cursor::SelectionCopy,
    Cursor::Move,
    Cursor::Crosshair,
    Cursor::ResizeH,
    Cursor::ResizeV,
    Cursor::ResizeNwSe,
    Cursor::ResizeNeSw,
    Cursor::ShearH,
    Cursor::ShearV,
    Cursor::Rotate,
    Cursor::RotateToward(1),
    Cursor::CornerRadius,
    Cursor::Pen,
    Cursor::PenDrawing,
    Cursor::PenAdd,
    Cursor::PenDelete,
    Cursor::PenClose,
    Cursor::PenContinue,
    Cursor::PenJoin,
    Cursor::PenConvert,
    Cursor::AnchorPoint,
    Cursor::Curvature,
    Cursor::Text,
    Cursor::Eyedropper,
    Cursor::AddStop,
    Cursor::RemoveStop,
    Cursor::Slice,
    Cursor::SliceSelect,
    Cursor::Width,
    Cursor::WidthAdd,
    Cursor::WidthPoint,
    Cursor::Blend,
    Cursor::BlendObject,
    Cursor::BlendAnchor,
    Cursor::ObjectsOnPath,
    Cursor::PathBracket,
    Cursor::TypeWidget,
    Cursor::LoadedText,
    Cursor::LoadedTextLink,
    Cursor::ShapeBuilder,
    Cursor::ShapeBuilderErase,
    Cursor::Lasso,
    Cursor::MagicWand,
    Cursor::Pencil,
    Cursor::PencilNew,
    Cursor::PencilClose,
    Cursor::PencilStraight,
    Cursor::PencilContinue,
    Cursor::Paintbrush,
    Cursor::PaintbrushClose,
    Cursor::BlobBrush,
    Cursor::Eraser,
    Cursor::Smooth,
    Cursor::PathEraser,
    Cursor::Join,
    Cursor::Knife,
    Cursor::Shaper,
    Cursor::LivePaintBucket,
    Cursor::LivePaintBucketFace,
    Cursor::LivePaintBucketEdge,
    Cursor::LivePaintSelectFace,
    Cursor::LivePaintSelectEdge,
    Cursor::LivePaintSelectOutside,
    Cursor::Measure,
    Cursor::PrintTiling,
    Cursor::SymbolSprayer,
    Cursor::SymbolShifter,
    Cursor::SymbolScruncher,
    Cursor::SymbolSizer,
    Cursor::SymbolSpinner,
    Cursor::SymbolStainer,
    Cursor::SymbolScreener,
    Cursor::SymbolStyler,
    Cursor::TypeVertical,
    Cursor::TypeArea,
    Cursor::TypeAreaVertical,
    Cursor::TypeOnPath,
    Cursor::TypeOnPathVertical,
    Cursor::Scissors,
    Cursor::MeshAdd,
    Cursor::PuppetPin,
    Cursor::AnchorEraser,
    Cursor::ExtendPath,
    Cursor::MeasureInspect,
    Cursor::ParametricShape,
    Cursor::CornerTool,
    Cursor::SlideAnchor,
    Cursor::SharedEdge,
    Cursor::SmartPen,
];

/// The shapes of cursor `c` with its hotspot at `p`; `None` for cursors that stay system cursors
/// (the busy states): the one drawn here, else the glyph of the cursor it borrows
/// ([`Cursor::stand_in`]).
fn glyph(c: Cursor, p: Pos2) -> Option<Vec<Shape>> {
    let ink = &mut Ink::default();
    // A cursor not drawn yet: the one it borrows.
    if let Some(stand_in) = c.stand_in() {
        return glyph(stand_in, p);
    }
    match c {
        Cursor::Arrow => arrow(ink, p, false),
        Cursor::ArrowHollow => arrow(ink, p, true),
        Cursor::DirectAnchor => arrow_square(ink, p, false),
        Cursor::DirectAnchorSelected => arrow_square(ink, p, true),
        Cursor::ReshapeSegment => reshape_segment(ink, p),
        Cursor::GroupSelection => arrow_plus(ink, p),
        Cursor::SelectionCopy => double_arrowhead(ink, p),
        Cursor::Move => {
            arrow(ink, p, false);
            double_arrow(ink, p + vec2(15.0, 18.0), vec2(1.0, 0.0));
        }
        Cursor::Crosshair => crosshair(ink, p),
        // Only the centre: the tool draws the tip's outline round it, at the zoom.
        Cursor::BlobBrush | Cursor::Eraser => {
            ink.circle_filled(p, 2.5, HALO);
            ink.circle_filled(p, 1.25, INK);
        }
        // The Pencil's crosshair with the Pen's star where the closing ring goes.
        Cursor::PencilNew => {
            crosshair(ink, p);
            let b = p + vec2(5.0, 5.0);
            strokes(ink, &[vec![b, b + vec2(6.0, 6.0)], vec![b + vec2(6.0, 0.0), b + vec2(0.0, 6.0)], vec![b + vec2(3.0, -1.0), b + vec2(3.0, 7.0)]]);
        }
        // The crosshair the Pencil and the Paintbrush borrow, with the PenClose ring below right.
        Cursor::PencilClose | Cursor::PaintbrushClose => {
            crosshair(ink, p);
            ink.circle_stroke(p + vec2(8.0, 8.0), 3.0, Stroke::new(3.0, HALO));
            ink.circle_stroke(p + vec2(8.0, 8.0), 3.0, Stroke::new(1.2, INK));
        }
        // The Pencil's crosshair with a short level line where the closing ring goes.
        Cursor::PencilStraight => {
            crosshair(ink, p);
            line(ink, p + vec2(3.55, 8.5), p + vec2(13.45, 8.5));
        }
        // The Pencil's crosshair with a short line rising to the right where the closing ring goes:
        // the stroke carries on from the path.
        Cursor::PencilContinue => {
            crosshair(ink, p);
            line(ink, p + vec2(5.0, 12.0), p + vec2(12.0, 5.0));
        }
        Cursor::Eyedropper => eyedropper(ink, p),
        Cursor::ResizeH => double_arrow(ink, p, vec2(1.0, 0.0)),
        Cursor::ResizeV => double_arrow(ink, p, vec2(0.0, 1.0)),
        Cursor::ResizeNwSe => double_arrow(ink, p, vec2(1.0, 1.0)),
        Cursor::ResizeNeSw => double_arrow(ink, p, vec2(1.0, -1.0)),
        Cursor::ShearH => shear(ink, p, vec2(1.0, 0.0)),
        Cursor::ShearV => shear(ink, p, vec2(0.0, -1.0)),
        Cursor::Rotate => rotate(ink, p, 0),
        Cursor::RotateToward(octant) => rotate(ink, p, octant),
        Cursor::CornerRadius => corner_radius(ink, p),
        Cursor::Pen => pen(ink, p, "*"),
        Cursor::PenDrawing => pen(ink, p, ""),
        Cursor::PenAdd => pen(ink, p, "+"),
        Cursor::PenDelete => pen(ink, p, "-"),
        Cursor::PenClose => pen(ink, p, "o"),
        Cursor::PenContinue => pen(ink, p, "/"),
        Cursor::AnchorPoint => anchor_point(ink, p),
        Cursor::Curvature => pen(ink, p, "~"),
        Cursor::PenJoin => pen(ink, p, "j"),
        Cursor::PenConvert => pen(ink, p, "^"),
        Cursor::Text => ibeam(ink, p),
        Cursor::TypeArea => type_in_path(ink, p, false, false),
        Cursor::TypeAreaVertical => type_in_path(ink, p, true, false),
        Cursor::TypeOnPath => type_in_path(ink, p, false, true),
        Cursor::TypeOnPathVertical => type_in_path(ink, p, true, true),
        Cursor::AddStop => stop_badge(ink, p, true),
        Cursor::RemoveStop => stop_badge(ink, p, false),
        Cursor::Slice => slice(ink, p),
        Cursor::SliceSelect => {
            arrow(ink, p, false);
            slice_badge(ink, p + vec2(11.0, 14.0));
        }
        Cursor::Width => width(ink, p, ""),
        Cursor::WidthAdd => width(ink, p, "+"),
        Cursor::WidthPoint => width(ink, p, "point"),
        Cursor::Blend | Cursor::BlendObject | Cursor::BlendAnchor => blend(ink, p, c),
        Cursor::PathBracket => path_bracket(ink, p),
        Cursor::TypeWidget => type_widget(ink, p),
        Cursor::LoadedText => loaded_text(ink, p),
        Cursor::LoadedTextLink => loaded_text_link(ink, p),
        Cursor::ShapeBuilder => shape_builder(ink, p, false),
        Cursor::ShapeBuilderErase => shape_builder(ink, p, true),
        Cursor::LivePaintBucket => paint_bucket(ink, p, false),
        Cursor::LivePaintBucketFace => paint_bucket(ink, p, true),
        Cursor::LivePaintBucketEdge => paint_brush(ink, p),
        Cursor::Knife => knife(ink, p),
        Cursor::LivePaintSelectFace | Cursor::LivePaintSelectEdge | Cursor::LivePaintSelectOutside => live_paint_select(ink, p, c),
        Cursor::Hand => hand(ink, p, false),
        Cursor::HandGrab => hand(ink, p, true),
        Cursor::ZoomIn => magnifier(ink, p, false),
        Cursor::ZoomOut => magnifier(ink, p, true),
        _ => return None,
    }
    Some(std::mem::take(&mut ink.0))
}

/// Paint cursor `c` at `p`, `scale` times its size, on the given (foreground) painter, where the
/// window can't show it as an OS cursor ([`OS_CURSORS`]). Returns false for cursors that stay
/// system cursors.
pub fn paint(painter: &Painter, c: Cursor, p: Pos2, scale: f32) -> bool {
    let place = egui::emath::TSTransform::new(p.to_vec2(), scale);
    glyph(c, Pos2::ZERO)
        .map(|shapes| {
            painter.extend(shapes.into_iter().map(|mut s| {
                s.transform(place);
                s
            }))
        })
        .is_some()
}

/// Does the window show the glyphs as OS cursors ([`Images`])? Not on macOS, which sizes a cursor
/// bitmap in points (a Retina one would show twice as big, or blurred), nor on the web (eframe has no
/// bitmap cursors there): the web paints them into the window ([`paint`]); the macOS desktop host
/// uses its native request adapter instead.
pub const OS_CURSORS: bool = !cfg!(any(target_os = "macos", target_arch = "wasm32"));

/// Does this window show the glyphs as OS cursors, on a build that can ([`OS_CURSORS`])? Not on
/// Wayland, where the compositor decides how big a cursor bitmap shows: Hyprland shows each pixel
/// as a point, twice too big on a 2× display (#1645). The window paints them there, as PhotoCraft
/// and PdfCraft do.
pub fn os_cursors(build: bool, wayland: bool) -> bool {
    build && !wayland
}

/// The cursor a panel shows where a click or a drop adds something, such as a stop under the
/// Gradient panel's ramp or a copy of rows Alt-dragged in the Layers panel (#8217): the white arrow
/// with a plus that Group Selection shows for a click that adds the next group. Windows has no system copy cursor (winit shows the plain arrow for
/// `CursorIcon::Copy`), so where the window shows glyphs as OS cursors ([`os_cursors`]) the panel
/// hands it this glyph; elsewhere (macOS, Wayland, the web, `VECTORCRAFT_SYSTEM_CURSORS`) the
/// system's copy cursor shows (#8241). Set every frame it shows: the canvas and egui reset it.
pub(crate) fn set_add_cursor(app: &mut crate::VectorcraftApp, ctx: &egui::Context) {
    ctx.set_cursor_icon(egui::CursorIcon::Copy);
    if add_cursor_is_a_glyph(app) {
        // As the canvas sizes its glyphs (User Interface › Scale Cursor Proportional to UI).
        let ui_scale = if app.session.prefs.scale_cursor_with_ui { 1.0 } else { ctx.zoom_factor() };
        ctx.set_cursor_image(app.canvas.cursors.get(Cursor::GroupSelection, ctx.pixels_per_point() / ui_scale));
    }
}

/// Does [`set_add_cursor`] hand the OS its glyph (rather than ask for the system copy cursor)?
/// Where the window shows glyphs as OS cursors, unless `VECTORCRAFT_SYSTEM_CURSORS` opts out.
pub(crate) fn add_cursor_is_a_glyph(app: &crate::VectorcraftApp) -> bool {
    std::env::var_os("VECTORCRAFT_SYSTEM_CURSORS").is_none() && os_cursors(OS_CURSORS, app.services.wayland)
}

/// Does the window hide the pointer only while it is the key window? macOS does: winit hides it with
/// a cursor rect holding a transparent cursor, and macOS applies the rect only in the key window.
/// Over a window behind another app or under a sheet, the system pointer shows (#2020).
pub const HIDES_ONLY_WHEN_KEY: bool = cfg!(target_os = "macos");

/// Does the window paint a glyph over a hidden pointer? Not where it cannot hide the system pointer
/// (no cursor theme on Wayland, [`crate::Services::no_cursor_theme`]: winit sets no pointer then,
/// and a hidden one would not come back over the panels, #2450), or where the system shows its pointer without the focus
/// ([`HIDES_ONLY_WHEN_KEY`]): the system pointer shows alone there.
pub fn paint_glyphs(hides_only_when_key: bool, focused: bool, no_cursor_theme: bool) -> bool {
    !no_cursor_theme && (focused || !hides_only_when_key)
}

/// The cursor bitmaps handed to the OS, by (cursor, pixels per point): each glyph is rasterized
/// once, and handing the same `Arc` every frame keeps the window's OS cursor instead of making a
/// new one.
#[derive(Default)]
pub struct Images(Vec<(Cursor, f32, CustomCursorImage)>);

impl Images {
    /// Cursor `c` for a display of `ppp` physical pixels per point; `None` for cursors that stay
    /// system cursors.
    pub fn get(&mut self, c: Cursor, ppp: f32) -> Option<CustomCursorImage> {
        if let Some((.., image)) = self.0.iter().find(|(k, s, _)| *k == c && *s == ppp) {
            return Some(image.clone());
        }
        let image = rasterize(c, ppp)?;
        // A few dozen glyphs at the scales of the displays the window visited.
        if self.0.len() >= 128 {
            self.0.clear();
        }
        self.0.push((c, ppp, image.clone()));
        Some(image)
    }
}

/// The largest side of a cursor bitmap, in pixels (the glyphs span under 50 points).
const MAX_SIDE: f32 = 256.0;

/// Cursor `c` as a straight-alpha RGBA bitmap at `ppp` pixels per point, tessellated (anti-aliased)
/// as egui would paint it, the hotspot on a pixel corner.
fn rasterize(c: Cursor, ppp: f32) -> Option<CustomCursorImage> {
    if !(ppp.is_finite() && ppp > 0.0) {
        return None;
    }
    let shapes = glyph(c, Pos2::ZERO)?;
    let mut tessellator = Tessellator::new(ppp, TessellationOptions::default(), [1, 1], vec![]);
    let mut mesh = Mesh::default();
    for shape in shapes {
        tessellator.tessellate_shape(shape, &mut mesh);
    }
    let bounds = mesh.calc_bounds();
    // The hotspot must lie inside the bitmap.
    let min = (bounds.min.to_vec2() * ppp).floor().min(Vec2::ZERO);
    let max = (bounds.max.to_vec2() * ppp).ceil().max(Vec2::splat(1.0));
    let size = max - min;
    if !(size.x <= MAX_SIDE && size.y <= MAX_SIDE) {
        return None;
    }
    let (w, h) = (size.x as usize, size.y as usize);
    let mut px = vec![[0.0; 4]; w * h];
    let corner = |v: &Vertex| (v.pos.to_vec2() * ppp - min, v.color);
    for &[i, j, k] in mesh.indices.as_chunks::<3>().0 {
        if let (Some(a), Some(b), Some(c)) = (mesh.vertices.get(i as usize), mesh.vertices.get(j as usize), mesh.vertices.get(k as usize)) {
            fill_triangle(&mut px, w, [corner(a), corner(b), corner(c)]);
        }
    }
    let rgba: Vec<u8> = px
        .iter()
        .flat_map(|&[r, g, b, a]| {
            let k = if a > 0.0 { 1.0 / a } else { 0.0 };
            [r * k, g * k, b * k, a].map(|x| (x * 255.0).round().clamp(0.0, 255.0) as u8)
        })
        .collect();
    Some(CustomCursorImage { rgba: rgba.into(), size: [w as u16, h as u16], hotspot: [-min.x as u16, -min.y as u16] })
}

/// Blend triangle `t` (pixel positions and premultiplied colours, interpolated across it) over `px`
/// (premultiplied RGBA, `w` pixels a row) at the pixel centres it covers, as the GPU blends egui's
/// meshes. A centre on an edge goes to one of the two triangles sharing it, so seams aren't doubled.
fn fill_triangle(px: &mut [[f32; 4]], w: usize, t: [(Vec2, Color32); 3]) {
    let edge = |a: Vec2, b: Vec2, p: Vec2| (b.x - a.x) * (p.y - a.y) - (b.y - a.y) * (p.x - a.x);
    let [a, mut b, mut c] = t;
    let mut area = edge(a.0, b.0, c.0);
    if area < 0.0 {
        std::mem::swap(&mut b, &mut c);
        area = -area;
    }
    if area.is_nan() || area <= 1e-6 || w == 0 {
        return;
    }
    // Of the two triangles sharing an edge (walking it in opposite directions), one owns it.
    let owns = |u: Vec2, v: Vec2| v.y > u.y || (v.y == u.y && v.x > u.x);
    let h = px.len() / w;
    let lo = a.0.min(b.0).min(c.0).max(Vec2::ZERO);
    let hi = a.0.max(b.0).max(c.0).min(vec2(w as f32, h as f32));
    for y in lo.y.floor() as usize..hi.y.ceil() as usize {
        for x in lo.x.floor() as usize..hi.x.ceil() as usize {
            let p = vec2(x as f32 + 0.5, y as f32 + 0.5);
            let weights = [(b.0, c.0), (c.0, a.0), (a.0, b.0)].map(|(u, v)| (edge(u, v, p), owns(u, v)));
            if !weights.iter().all(|&(e, own)| e > 0.0 || (e == 0.0 && own)) {
                continue;
            }
            let Some(dst) = px.get_mut(y * w + x) else { continue };
            let [wa, wb, wc] = weights.map(|(e, _)| e / area);
            let src: [f32; 4] = std::array::from_fn(|i| {
                let channel = |col: Color32| f32::from(col.to_array()[i]);
                (wa * channel(a.1) + wb * channel(b.1) + wc * channel(c.1)) / 255.0
            });
            let keep = 1.0 - src[3];
            *dst = std::array::from_fn(|i| src[i] + dst[i] * keep);
        }
    }
}

#[cfg(test)]
mod tests;