Render: rectangle and outline path gradients

Path gradients that follow a rectangle (path="rect") or the shape's own
outline (path="shape") were drawn as circles. They're now rasterised into
a small image of the bounds: rect takes the larger of the horizontal and
vertical shares of the distance from the focus to the edge (X-shaped
contours), shape the share of the way from the focus to the outline along
the same ray (an ellipse gives ellipses, a triangle triangles), as
measured on PowerPoint's export. The two path probe decks now match it to
a mean pixel difference of 1.7 and 0.6 (from 15.6 and 22).

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

crates/render/src/compound.rs

@@ -0,0 +1,242 @@
+//! Compound outlines (`a:ln/@cmpd`): double, thick-thin, thin-thick and triple lines.
+//!
+//! PowerPoint splits the line's width into bands across the path, measured from its left side
+//! (looking along the path) to its right, as these shares of the width (read from PowerPoint's
+//! export of 24 pt lines of each kind):
+//! - double: 1/3 line, 1/3 gap, 1/3 line;
+//! - thin-thick: 1/5 line, 1/5 gap, 3/5 line; thick-thin the mirror;
+//! - triple: 1/6 line, 1/6 gap, 1/3 line, 1/6 gap, 1/6 line.
+//!
+//! On a shape drawn clockwise (all presets) the left side is the outside.
+
+use deckcraft_model::style::Compound;
+use kurbo::{BezPath, CubicBez, ParamCurve, PathEl, PathSeg, Point, Vec2};
+
+/// The bands of `c` as (from, to) shares of the width, left side first.
+pub fn bands(c: Compound) -> &'static [(f64, f64)] {
+    match c {
+        Compound::Single => &[(0.0, 1.0)],
+        Compound::Double => &[(0.0, 1.0 / 3.0), (2.0 / 3.0, 1.0)],
+        Compound::ThinThick => &[(0.0, 0.2), (0.4, 1.0)],
+        Compound::ThickThin => &[(0.0, 0.6), (0.8, 1.0)],
+        Compound::Triple => &[(0.0, 1.0 / 6.0), (2.0 / 6.0, 4.0 / 6.0), (5.0 / 6.0, 1.0)],
+    }
+}
+
+/// Unit normal pointing to the right of travel (y down), or None for a zero-length tangent.
+fn right(t: Vec2) -> Option<Vec2> {
+    let l = t.hypot();
+    (l > 1e-12 && l.is_finite()).then(|| Vec2::new(-t.y, t.x) / l)
+}
+
+/// `path` moved `d` to the right of travel (negative: to the left). Line corners meet at their
+/// miter point (bevelled when sharper than about 11°); curves are offset by kurbo; other joins are
+/// bridged by a straight line.
+pub fn offset(path: &BezPath, d: f64, tolerance: f64) -> BezPath {
+    let mut out = BezPath::new();
+    if d.abs() < 1e-9 {
+        return path.clone();
+    }
+    // Each subpath as segments, offset one by one.
+    let mut segs: Vec<PathSeg> = Vec::new();
+    let mut closed = false;
+    let flush = |segs: &mut Vec<PathSeg>, closed: bool, out: &mut BezPath| {
+        let pieces: Vec<(PathSeg, BezPath)> = segs.iter().filter_map(|s| offset_seg(*s, d, tolerance).map(|p| (*s, p))).collect();
+        let begin = out.elements().len();
+        for (i, (seg, piece)) in pieces.iter().enumerate() {
+            let Some(PathEl::MoveTo(p)) = piece.elements().first().copied() else { continue };
+            match i.checked_sub(1).and_then(|j| pieces.get(j)) {
+                None => out.move_to(p),
+                Some((prev, _)) => join(out, *prev, *seg, p, d),
+            }
+            for e in piece.elements().iter().skip(1) {
+                out.push(*e);
+            }
+        }
+        if closed && let (Some((last, _)), Some((first, piece))) = (pieces.last(), pieces.first()) {
+            if let Some(PathEl::MoveTo(p)) = piece.elements().first().copied() {
+                // Lines meeting at the start: both ends move to their miter point.
+                match miter(*last, *first, d) {
+                    Some(m) if is_line(*last) && is_line(*first) => {
+                        set_last(out, m);
+                        if let Some(PathEl::MoveTo(_)) = out.elements().get(begin) {
+                            out.elements_mut()[begin] = PathEl::MoveTo(m);
+                        }
+                    }
+                    _ => out.line_to(p),
+                }
+            }
+            out.close_path();
+        }
+        segs.clear();
+    };
+    let mut start = Point::ZERO;
+    let mut cur = Point::ZERO;
+    for el in path.elements() {
+        match *el {
+            PathEl::MoveTo(p) => {
+                flush(&mut segs, closed, &mut out);
+                closed = false;
+                start = p;
+                cur = p;
+            }
+            PathEl::LineTo(p) => {
+                segs.push(PathSeg::Line(kurbo::Line::new(cur, p)));
+                cur = p;
+            }
+            PathEl::QuadTo(a, b) => {
+                segs.push(PathSeg::Quad(kurbo::QuadBez::new(cur, a, b)));
+                cur = b;
+            }
+            PathEl::CurveTo(a, b, c) => {
+                segs.push(PathSeg::Cubic(CubicBez::new(cur, a, b, c)));
+                cur = c;
+            }
+            PathEl::ClosePath => {
+                if (cur - start).hypot() > 1e-9 {
+                    segs.push(PathSeg::Line(kurbo::Line::new(cur, start)));
+                }
+                closed = true;
+                flush(&mut segs, closed, &mut out);
+                closed = false;
+                cur = start;
+            }
+        }
+    }
+    flush(&mut segs, closed, &mut out);
+    out
+}
+
+fn offset_seg(s: PathSeg, d: f64, tolerance: f64) -> Option<BezPath> {
+    // Far-off or non-finite geometry (hostile files) is left out rather than offset.
+    let sane = |p: Point| p.is_finite() && p.x.abs() < 1e7 && p.y.abs() < 1e7;
+    let ok = match s {
+        PathSeg::Line(l) => sane(l.p0) && sane(l.p1),
+        PathSeg::Quad(q) => sane(q.p0) && sane(q.p1) && sane(q.p2),
+        PathSeg::Cubic(c) => sane(c.p0) && sane(c.p1) && sane(c.p2) && sane(c.p3),
+    };
+    if !ok || !d.is_finite() {
+        return None;
+    }
+    match s {
+        PathSeg::Line(l) => {
+            let n = right(l.p1 - l.p0)?;
+            let mut p = BezPath::new();
+            p.move_to(l.p0 + n * d);
+            p.line_to(l.p1 + n * d);
+            Some(p)
+        }
+        PathSeg::Quad(q) => offset_seg(PathSeg::Cubic(q.raise()), d, tolerance),
+        PathSeg::Cubic(c) => {
+            // Nearly straight cubics (collinear control points) are offset as lines.
+            let chord = c.p3 - c.p0;
+            let flat = |p: Point| chord.cross(p - c.p0).abs() <= 1e-9 * chord.hypot2().max(1e-18);
+            if flat(c.p1) && flat(c.p2) {
+                return offset_seg(PathSeg::Line(kurbo::Line::new(c.p0, c.p3)), d, tolerance);
+            }
+            let mut p = BezPath::new();
+            kurbo::offset::offset_cubic(c, d, tolerance, &mut p);
+            Some(p)
+        }
+    }
+}
+
+/// The segment's tangent at its start and at its end (the first non-zero control vector).
+fn tangents(s: PathSeg) -> (Vec2, Vec2) {
+    let first = |v: &[Vec2]| v.iter().copied().find(|v| v.hypot2() > 1e-18).unwrap_or(Vec2::ZERO);
+    match s {
+        PathSeg::Line(l) => (l.p1 - l.p0, l.p1 - l.p0),
+        PathSeg::Quad(q) => (first(&[q.p1 - q.p0, q.p2 - q.p0]), first(&[q.p2 - q.p1, q.p2 - q.p0])),
+        PathSeg::Cubic(c) => (first(&[c.p1 - c.p0, c.p2 - c.p0, c.p3 - c.p0]), first(&[c.p3 - c.p2, c.p3 - c.p1, c.p3 - c.p0])),
+    }
+}
+
+fn is_line(s: PathSeg) -> bool {
+    matches!(s, PathSeg::Line(_))
+}
+
+/// Move the path's last point to `p`.
+fn set_last(out: &mut BezPath, p: Point) {
+    if let Some(e) = out.elements_mut().last_mut() {
+        match e {
+            PathEl::MoveTo(q) | PathEl::LineTo(q) => *q = p,
+            PathEl::QuadTo(_, q) => *q = p,
+            PathEl::CurveTo(_, _, q) => *q = p,
+            PathEl::ClosePath => {}
+        }
+    }
+}
+
+/// Where the offsets of `prev` and `next` meet at their shared corner (their miter point), or
+/// None for a corner sharper than about 11 degrees or a degenerate tangent.
+fn miter(prev: PathSeg, next: PathSeg, d: f64) -> Option<Point> {
+    let (_, t0) = tangents(prev);
+    let (t1, _) = tangents(next);
+    let (n0, n1) = (right(t0)?, right(t1)?);
+    let denom = 1.0 + n0.dot(n1);
+    (denom > 0.02).then(|| prev.end() + (n0 + n1) * (d / denom)).filter(|m| m.is_finite())
+}
+
+/// Join the offset of `prev` (ending at `out`'s current point) to the offset of `next`, which
+/// starts at `p`: two lines meet at their miter point (both ends moved there, so an inner corner
+/// doesn't loop); anything else is bridged straight.
+fn join(out: &mut BezPath, prev: PathSeg, next: PathSeg, p: Point, d: f64) {
+    match miter(prev, next, d) {
+        Some(m) if is_line(prev) && is_line(next) => set_last(out, m),
+        Some(m) => {
+            out.line_to(m);
+            out.line_to(p);
+        }
+        None => out.line_to(p),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use kurbo::Shape;
+
+    #[test]
+    fn bands_split_the_width_like_powerpoint() {
+        for c in [Compound::Single, Compound::Double, Compound::ThinThick, Compound::ThickThin, Compound::Triple] {
+            let b = bands(c);
+            assert_eq!(b.first().map(|x| x.0), Some(0.0));
+            assert_eq!(b.last().map(|x| x.1), Some(1.0));
+            assert!(b.windows(2).all(|w| w[0].1 < w[1].0), "{c:?}: bands in order with gaps");
+        }
+        // Thin-thick: the thin line on the left, thick-thin its mirror.
+        let (tt, th) = (bands(Compound::ThinThick), bands(Compound::ThickThin));
+        assert!((tt[0].1 - tt[0].0) < (tt[1].1 - tt[1].0));
+        assert!((th[0].1 - th[0].0) > (th[1].1 - th[1].0));
+    }
+
+    #[test]
+    fn offsetting_a_rectangle_grows_or_shrinks_it() {
+        // Clockwise in y-down coordinates: the left of travel is the outside.
+        let r = kurbo::Rect::new(0.0, 0.0, 100.0, 50.0).to_path(0.1);
+        let out = offset(&r, -5.0, 0.01).bounding_box();
+        assert!(
+            (out.x0 + 5.0).abs() < 1e-6 && (out.y0 + 5.0).abs() < 1e-6 && (out.x1 - 105.0).abs() < 1e-6 && (out.y1 - 55.0).abs() < 1e-6,
+            "{out:?}"
+        );
+        let inn = offset(&r, 5.0, 0.01).bounding_box();
+        assert!((inn.x0 - 5.0).abs() < 1e-6 && (inn.y1 - 45.0).abs() < 1e-6, "{inn:?}");
+        // Corners meet at their miter points: the area is the offset rectangle's.
+        assert!((offset(&r, -5.0, 0.01).area().abs() - 110.0 * 60.0).abs() < 1e-6);
+    }
+
+    #[test]
+    fn offsetting_a_circle_changes_its_radius() {
+        let c = kurbo::Circle::new((50.0, 50.0), 20.0).to_path(0.01);
+        let b = offset(&c, 4.0, 0.01).bounding_box();
+        let w = b.width() / 2.0;
+        assert!((w - 16.0).abs() < 0.2 || (w - 24.0).abs() < 0.2, "radius {w}");
+        // A hostile path never panics and yields finite output.
+        let mut p = BezPath::new();
+        p.move_to((0.0, 0.0));
+        p.line_to((0.0, 0.0));
+        p.curve_to((f64::MAX, 0.0), (0.0, f64::MIN_POSITIVE), (1.0, 1.0));
+        p.close_path();
+        let _ = offset(&p, 3.0, 0.01);
+    }
+}

crates/render/src/lib.rs

@@ -9,10 +9,15 @@
 
 mod chart;
 mod colr;
+
+mod compound;
 mod images;
 mod morph_path;
 mod morph_text;
 mod paint;
+mod pattern;
+
+mod pathgrad;
 mod placed;
 mod ramp;
 mod table;
@@ -940,6 +945,19 @@ fn stroke(ctx: &mut RenderContext, rctx: &Ctx, line: &Line, ph: Option<Rgba>, pa
         }
         _ => ctx.set_paint(color(Rgba::BLACK, alpha)),
     }
+    // Compound lines: each band stroked along the path moved to its place across the width.
+    let compound = line.compound.unwrap_or_default();
+    if compound != deckcraft_model::style::Compound::Single && lw * scale_of(m) >= 1.5 {
+        let tolerance = 0.1 / scale_of(m).max(1e-6);
+        for &(a, b) in compound::bands(compound) {
+            let d = (-0.5 + (a + b) / 2.0) * lw;
+            let mut band = sk.clone();
+            band.width = (b - a) * lw;
+            ctx.set_stroke(band);
+            ctx.stroke_path(&compound::offset(path, d, tolerance));
+        }
+        return;
+    }
     ctx.set_stroke(sk);
     ctx.stroke_path(path);
 }

crates/render/src/paint.rs

@@ -37,6 +37,41 @@ pub fn fill_path(
             }
             let stops: Vec<(f64, Rgba)> = g.stops.iter().map(|s| (s.pos, shade(rctx.color(&s.color, ph), mode))).collect();
             ctx.set_paint(gradient(&g.shape, stops, bounds, alpha));
+
+            let mut stops: Vec<(f64, Rgba)> = g.stops.iter().map(|s| (s.pos.clamp(0.0, 1.0), shade(rctx.color(&s.color, ph), mode))).collect();
+            stops.sort_by(|a, b| a.0.total_cmp(&b.0));
+            // Rectangle and outline paths: rasterised (see `pathgrad`).
+            if let GradientShape::Path { path: kind, focus } = &g.shape
+                && matches!(kind.as_str(), "rect" | "shape")
+            {
+                crate::pathgrad::fill(ctx, kind, *focus, &crate::ramp::expand(&stops), bounds, path, m, alpha);
+                return;
+            }
+            // PowerPoint's ramp between stops (linear light, S-shaped), see `ramp`.
+            let stops: Vec<peniko::ColorStop> =
+                crate::ramp::expand(&stops).into_iter().map(|(o, c)| peniko::ColorStop { offset: o as f32, color: color(c, alpha).into() }).collect();
+            let grad = match &g.shape {
+                GradientShape::Linear { angle, .. } => {
+                    // Angle measured clockwise from left→right; span the bounds along that direction.
+                    let a = angle.to_radians();
+                    let (dx, dy) = (a.cos(), a.sin());
+                    let c = bounds.center();
+                    let half = (bounds.width() * dx.abs() + bounds.height() * dy.abs()) / 2.0;
+                    peniko::Gradient::new_linear(Point::new(c.x - dx * half, c.y - dy * half), Point::new(c.x + dx * half, c.y + dy * half))
+                        .with_stops(stops.as_slice())
+                }
+                GradientShape::Path { focus, .. } => {
+                    let fx = bounds.x0 + bounds.width() * (focus[0] + (1.0 - focus[2])) / 2.0;
+                    let fy = bounds.y0 + bounds.height() * (focus[1] + (1.0 - focus[3])) / 2.0;
+                    // Reach the farthest corner, so a gradient from a corner covers the whole box.
+                    let r = [(bounds.x0, bounds.y0), (bounds.x1, bounds.y0), (bounds.x0, bounds.y1), (bounds.x1, bounds.y1)]
+                        .iter()
+                        .map(|(x, y)| ((x - fx).powi(2) + (y - fy).powi(2)).sqrt())
+                        .fold(1e-6, f64::max);
+                    peniko::Gradient::new_radial(Point::new(fx, fy), r as f32).with_stops(stops.as_slice())
+                }
+            };
+            ctx.set_paint(grad);
             ctx.fill_path(path);
         }
         Fill::Picture(pf) => {
@@ -47,55 +82,11 @@ pub fn fill_path(
         Fill::Pattern(p) => {
             let fg = rctx.color(&p.fg, ph);
             let bg = rctx.color(&p.bg, ph);
-            ctx.set_paint(color(bg, alpha));
-            ctx.fill_path(path);
-            ctx.push_clip_layer(path);
-            ctx.set_paint(color(fg, alpha));
-            pattern(ctx, &p.preset, bounds, m);
-            ctx.pop_layer();
+            crate::pattern::fill(ctx, &p.preset, fg, bg, alpha, path, m);
         }
     }
 }
 
-/// Draw a pattern's foreground marks over `bounds` (8 pt cells).
-fn pattern(ctx: &mut RenderContext, preset: &str, b: Rect, m: Affine) {
-    let k = crate::scale_of(m);
-    let cell = 6.0 / if k.is_finite() { k.clamp(0.25, 4.0) } else { 1.0 };
-    let cell = cell.max(2.0);
-    let mut p = BezPath::new();
-    let (nx, ny) = (((b.width() / cell).ceil() as i64).clamp(0, 2000), ((b.height() / cell).ceil() as i64).clamp(0, 2000));
-    let lw = cell * 0.18;
-    let dense = preset.starts_with("dk") || preset.contains("50") || preset.contains("75") || preset.contains("90");
-    for j in 0..=ny {
-        for i in 0..=nx {
-            let x = b.x0 + i as f64 * cell;
-            let y = b.y0 + j as f64 * cell;
-            let r = match preset {
-                p if p.contains("Horz") || p == "horz" || p.contains("horzBrick") => Rect::new(x, y, x + cell, y + lw),
-                p if p.contains("Vert") || p == "vert" => Rect::new(x, y, x + lw, y + cell),
-                p if p.contains("cross") || p.contains("Grid") || p.contains("grid") => {
-                    p_add(&mut p_rect(x, y, cell, lw), &mut BezPath::new());
-                    Rect::new(x, y, x + cell, y + lw).union(Rect::new(x, y, x + lw, y + cell))
-                }
-                _ => {
-                    let d = if dense { cell * 0.35 } else { cell * 0.2 };
-                    Rect::new(x, y, x + d, y + d)
-                }
-            };
-            p.extend(r.to_path(0.1).iter());
-            if preset.contains("cross") || preset.contains("Grid") || preset.contains("grid") {
-                p.extend(Rect::new(x, y, x + lw, y + cell).to_path(0.1).iter());
-            }
-        }
-    }
-    ctx.fill_path(&p);
-}
-
-fn p_rect(x: f64, y: f64, w: f64, h: f64) -> BezPath {
-    Rect::new(x, y, x + w, y + h).to_path(0.1)
-}
-fn p_add(_a: &mut BezPath, _b: &mut BezPath) {}
-
 /// `pf` with its duotone colours resolved to plain RGB against the slide's colours and the
 /// placeholder colour `ph` (theme background pictures recolour with `phClr`), so the decoded-image
 /// cache can apply and key them without a colour scheme.

crates/render/src/pathgrad.rs

@@ -0,0 +1,220 @@
+//! Path gradients (`a:path`) that follow a rectangle or the shape's own outline, which no vello
+//! gradient draws: they're rasterised into a small image of the bounds and painted with it.
+//!
+//! Measured on PowerPoint's export (black to grey to white from the centre):
+//! - `rect`: the colour position is the larger of the horizontal and vertical distances from the
+//!   focus, each as a share of the distance to that side's edge (X-shaped contours);
+//! - `shape`: contours are the outline scaled about the focus (an ellipse gives ellipses, a
+//!   triangle triangles): the share of the way from the focus to the outline along the same ray.
+//!
+//! `circle` stays a radial vello gradient (see `paint::gradient`).
+
+use std::sync::Arc;
+
+use deckcraft_color::Rgba;
+use kurbo::{Affine, BezPath, PathEl, Point, Rect};
+use vello_cpu::{Pixmap, RenderContext, peniko};
+
+/// Longest side of the rasterised gradient, in pixels (bilinear sampling smooths the rest).
+const MAX_SIDE: f64 = 384.0;
+
+/// Colour position (0 at the focus, 1 at the edge) of `p` for path `kind` in `bounds` with the
+/// focus rect `focus` (fractions inset from left, top, right, bottom), `outline` being the
+/// shape's flattened polygon(s) for `shape`.
+pub fn position(kind: &str, bounds: Rect, focus: [f64; 4], outline: &[Vec<Point>], p: Point) -> f64 {
+    let f = Rect::new(
+        bounds.x0 + bounds.width() * focus[0].clamp(0.0, 1.0),
+        bounds.y0 + bounds.height() * focus[1].clamp(0.0, 1.0),
+        bounds.x1 - bounds.width() * focus[2].clamp(0.0, 1.0),
+        bounds.y1 - bounds.height() * focus[3].clamp(0.0, 1.0),
+    );
+    let f = if f.x0 <= f.x1 && f.y0 <= f.y1 { f } else { Rect::from_center_size(f.center(), (0.0, 0.0)) };
+    match kind {
+        "shape" if !outline.is_empty() => shape_position(outline, f.center(), p),
+        _ => {
+            // Distance outside the focus rect along each axis, over the room to that side's edge.
+            let axis = |v: f64, lo: f64, hi: f64, edge_lo: f64, edge_hi: f64| {
+                if v < lo {
+                    (lo - v) / (lo - edge_lo).max(1e-9)
+                } else if v > hi {
+                    (v - hi) / (edge_hi - hi).max(1e-9)
+                } else {
+                    0.0
+                }
+            };
+            axis(p.x, f.x0, f.x1, bounds.x0, bounds.x1).max(axis(p.y, f.y0, f.y1, bounds.y0, bounds.y1)).clamp(0.0, 1.0)
+        }
+    }
+}
+
+/// The share of the way from `c` to the outline along the ray through `p` (1 when the ray meets
+/// no edge).
+fn shape_position(outline: &[Vec<Point>], c: Point, p: Point) -> f64 {
+    let d = p - c;
+    let len = d.hypot();
+    if len < 1e-9 {
+        return 0.0;
+    }
+    // Nearest crossing of the ray c + s·d (s > 0) with an edge.
+    let mut best = f64::INFINITY;
+    for poly in outline {
+        for w in poly.windows(2) {
+            let (a, b) = (w[0], w[1]);
+            let e = b - a;
+            let den = d.cross(e);
+            if den.abs() < 1e-12 {
+                continue;
+            }
+            let ac = a - c;
+            let s = ac.cross(e) / den;
+            let u = ac.cross(d) / den;
+            if s > 1e-9 && (-1e-9..=1.0 + 1e-9).contains(&u) {
+                best = best.min(s);
+            }
+        }
+    }
+    if best.is_finite() { (1.0 / best).clamp(0.0, 1.0) } else { 1.0 }
+}
+
+/// The outline flattened into closed polygons.
+pub fn polygons(path: &BezPath) -> Vec<Vec<Point>> {
+    let mut out: Vec<Vec<Point>> = Vec::new();
+    let mut cur: Vec<Point> = Vec::new();
+    kurbo::flatten(path.iter(), 0.25, |el| match el {
+        PathEl::MoveTo(p) => {
+            if cur.len() > 1 {
+                out.push(std::mem::take(&mut cur));
+            }
+            cur = vec![p];
+        }
+        PathEl::LineTo(p) => cur.push(p),
+        PathEl::ClosePath => {
+            if let Some(f) = cur.first().copied() {
+                cur.push(f);
+            }
+        }
+        _ => {}
+    });
+    if cur.len() > 1 {
+        out.push(cur);
+    }
+    for poly in &mut out {
+        if let (Some(f), Some(l)) = (poly.first().copied(), poly.last().copied())
+            && (f - l).hypot() > 1e-9
+        {
+            poly.push(f);
+        }
+    }
+    out.retain(|p| p.len() > 2 && p.len() < 100_000);
+    out
+}
+
+/// A 256-entry colour ramp for the sorted, already expanded `stops` (linear in sRGB between them).
+pub fn ramp(stops: &[(f64, Rgba)]) -> Vec<Rgba> {
+    (0..256)
+        .map(|i| {
+            let t = i as f64 / 255.0;
+            let after = stops.iter().position(|s| s.0 >= t);
+            match after {
+                Some(0) | None => stops.get(after.unwrap_or(stops.len().saturating_sub(1))).map(|s| s.1).unwrap_or(Rgba::BLACK),
+                Some(j) => {
+                    let (Some(a), Some(b)) = (stops.get(j - 1), stops.get(j)) else { return Rgba::BLACK };
+                    let k = if b.0 - a.0 > 1e-12 { (t - a.0) / (b.0 - a.0) } else { 1.0 };
+                    a.1.lerp(b.1, k)
+                }
+            }
+        })
+        .collect()
+}
+
+/// Fill `path` with a `rect` or `shape` path gradient of `stops` (sorted and expanded, see
+/// `ramp::expand`) over `bounds`, faded by `alpha`; `m` maps the path to the output.
+#[allow(clippy::too_many_arguments)]
+pub fn fill(ctx: &mut RenderContext, kind: &str, focus: [f64; 4], stops: &[(f64, Rgba)], bounds: Rect, path: &BezPath, m: Affine, alpha: f64) {
+    if bounds.width() <= 0.0 || bounds.height() <= 0.0 || !bounds.is_finite() || stops.is_empty() {
+        return;
+    }
+    let k = crate::scale_of(m);
+    let k = if k.is_finite() && k > 0.0 { k } else { 1.0 };
+    let longest = bounds.width().max(bounds.height()) * k;
+    let s = (MAX_SIDE / longest).min(1.0) * k;
+    let (pw, ph) = (((bounds.width() * s).ceil() as u32).clamp(1, 4096), ((bounds.height() * s).ceil() as u32).clamp(1, 4096));
+    let outline = if kind == "shape" { polygons(path) } else { Vec::new() };
+    let lut = ramp(stops);
+    let a = alpha.clamp(0.0, 1.0);
+    let mut data = Vec::with_capacity((pw * ph) as usize);
+    for j in 0..ph {
+        for i in 0..pw {
+            let p = Point::new(bounds.x0 + (i as f64 + 0.5) / pw as f64 * bounds.width(), bounds.y0 + (j as f64 + 0.5) / ph as f64 * bounds.height());
+            let t = position(kind, bounds, focus, &outline, p);
+            let c = lut.get((t * 255.0).round().clamp(0.0, 255.0) as usize).copied().unwrap_or(Rgba::BLACK);
+            let ca = (c.a as f64 * a).round().clamp(0.0, 255.0);
+            let mul = |v: u8| (v as f64 * ca / 255.0).round().clamp(0.0, 255.0) as u8;
+            data.push(vello_cpu::color::PremulRgba8 { r: mul(c.r), g: mul(c.g), b: mul(c.b), a: ca as u8 });
+        }
+    }
+    let pm = Arc::new(Pixmap::from_parts(data, pw as u16, ph as u16));
+    ctx.set_transform(m);
+    ctx.set_paint(vello_cpu::Image {
+        image: vello_cpu::ImageSource::Pixmap(pm),
+        sampler: peniko::ImageSampler { quality: peniko::ImageQuality::Medium, ..Default::default() },
+    });
+    ctx.set_paint_transform(
+        Affine::translate(bounds.origin().to_vec2()) * Affine::scale_non_uniform(bounds.width() / pw as f64, bounds.height() / ph as f64),
+    );
+    ctx.fill_path(path);
+    ctx.reset_paint_transform();
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use kurbo::Shape;
+
+    const CENTRE: [f64; 4] = [0.5, 0.5, 0.5, 0.5];
+
+    #[test]
+    fn rect_paths_take_the_larger_axis_share() {
+        // PowerPoint, 280x200 box from the centre: 20 px across is 1/7, 20 px down is 1/5.
+        let b = Rect::new(0.0, 0.0, 280.0, 200.0);
+        let at = |x: f64, y: f64| position("rect", b, CENTRE, &[], Point::new(x, y));
+        assert!((at(160.0, 100.0) - 20.0 / 140.0).abs() < 1e-9);
+        assert!((at(140.0, 120.0) - 20.0 / 100.0).abs() < 1e-9);
+        assert!((at(168.0, 120.0) - 0.2).abs() < 1e-9, "the diagonal takes the larger share");
+        assert_eq!(at(0.0, 0.0), 1.0);
+        // From a corner (fillToRect 0,0,100%,100%): the far corner is the end.
+        let corner = [0.0, 0.0, 1.0, 1.0];
+        assert!((position("rect", b, corner, &[], Point::new(140.0, 50.0)) - 0.5).abs() < 1e-9);
+    }
+
+    #[test]
+    fn shape_paths_follow_the_outline() {
+        let b = Rect::new(0.0, 0.0, 280.0, 200.0);
+        let ellipse = polygons(&kurbo::Ellipse::from_rect(b).to_path(0.01));
+        let at = |x: f64, y: f64| position("shape", b, CENTRE, &ellipse, Point::new(x, y));
+        assert!((at(160.0, 100.0) - 20.0 / 140.0).abs() < 0.01);
+        assert!((at(140.0, 120.0) - 0.2).abs() < 0.01);
+        // Half way to the outline along any ray is 0.5.
+        let (dx, dy) = (140.0 * 0.6, 100.0 * 0.8);
+        assert!((at(140.0 + dx * 0.5, 100.0 + dy * 0.5) - 0.5).abs() < 0.01);
+        // A triangle: half way from its centre to its apex is 0.5.
+        let mut tri = BezPath::new();
+        tri.move_to((140.0, 0.0));
+        tri.line_to((280.0, 200.0));
+        tri.line_to((0.0, 200.0));
+        tri.close_path();
+        let polys = polygons(&tri);
+        assert!((position("shape", b, CENTRE, &polys, Point::new(140.0, 50.0)) - 0.5).abs() < 1e-6);
+    }
+
+    #[test]
+    fn the_ramp_runs_through_the_stops() {
+        let stops = [(0.0, Rgba::rgb(0, 0, 0)), (0.5, Rgba::rgb(128, 128, 128)), (1.0, Rgba::rgb(255, 255, 255))];
+        let r = ramp(&stops);
+        assert_eq!(r.len(), 256);
+        assert_eq!(r[0], Rgba::rgb(0, 0, 0));
+        assert_eq!(r[255], Rgba::rgb(255, 255, 255));
+        assert!((r[64].r as i32 - 64).abs() <= 2);
+        assert!(ramp(&[(0.3, Rgba::rgb(9, 9, 9))]).iter().all(|c| *c == Rgba::rgb(9, 9, 9)));
+    }
+}

crates/render/src/pattern.rs

@@ -0,0 +1,208 @@
+//! Preset pattern fills (`a:pattFill`): an 8×8 two-colour tile, each cell one 96-dpi pixel
+//! (0.75 pt) of the slide, as PowerPoint draws them.
+//!
+//! The tiles were read from PowerPoint's own slide export of every preset (black on white, at
+//! exactly two output pixels per pattern pixel), so the marks, their density and their phase
+//! match it. Bit 7 of each row is the leftmost cell; a set bit is the foreground colour.
+
+use std::sync::Arc;
+
+use deckcraft_color::Rgba;
+use kurbo::{Affine, BezPath};
+use vello_cpu::{Pixmap, RenderContext, peniko};
+
+/// Side of one pattern cell, in points.
+pub const CELL: f64 = 0.75;
+
+const TILES: &[(&str, [u8; 8])] = &[
+    ("pct5", [0x80, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00]),
+    ("pct10", [0x80, 0x00, 0x08, 0x00, 0x80, 0x00, 0x08, 0x00]),
+    ("pct20", [0x88, 0x00, 0x22, 0x00, 0x88, 0x00, 0x22, 0x00]),
+    ("pct25", [0x88, 0x22, 0x88, 0x22, 0x88, 0x22, 0x88, 0x22]),
+    ("pct30", [0xAA, 0x44, 0xAA, 0x11, 0xAA, 0x44, 0xAA, 0x11]),
+    ("pct40", [0xAA, 0x55, 0xAA, 0x51, 0xAA, 0x55, 0xAA, 0x15]),
+    ("pct50", [0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55]),
+    ("pct60", [0xEE, 0x55, 0xBB, 0x55, 0xEE, 0x55, 0xBB, 0x55]),
+    ("pct70", [0x77, 0xDD, 0x77, 0xDD, 0x77, 0xDD, 0x77, 0xDD]),
+    ("pct75", [0x77, 0xFF, 0xDD, 0xFF, 0x77, 0xFF, 0xDD, 0xFF]),
+    ("pct80", [0xEF, 0xFF, 0xFE, 0xFF, 0xEF, 0xFF, 0xFE, 0xFF]),
+    ("pct90", [0xFF, 0xFF, 0xFF, 0xF7, 0xFF, 0xFF, 0xFF, 0x7F]),
+    ("horz", [0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]),
+    ("vert", [0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    ("ltHorz", [0xFF, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00]),
+    ("ltVert", [0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88]),
+    ("dkHorz", [0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00]),
+    ("dkVert", [0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC]),
+    ("narHorz", [0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00]),
+    ("narVert", [0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+    ("dashHorz", [0xF0, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00]),
+    ("dashVert", [0x80, 0x80, 0x80, 0x80, 0x08, 0x08, 0x08, 0x08]),
+    ("cross", [0xFF, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    ("dnDiag", [0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01]),
+    ("upDiag", [0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80]),
+    ("ltDnDiag", [0x88, 0x44, 0x22, 0x11, 0x88, 0x44, 0x22, 0x11]),
+    ("ltUpDiag", [0x11, 0x22, 0x44, 0x88, 0x11, 0x22, 0x44, 0x88]),
+    ("dkDnDiag", [0xCC, 0x66, 0x33, 0x99, 0xCC, 0x66, 0x33, 0x99]),
+    ("dkUpDiag", [0x33, 0x66, 0xCC, 0x99, 0x33, 0x66, 0xCC, 0x99]),
+    ("wdDnDiag", [0xC1, 0xE0, 0x70, 0x38, 0x1C, 0x0E, 0x07, 0x83]),
+    ("wdUpDiag", [0x83, 0x07, 0x0E, 0x1C, 0x38, 0x70, 0xE0, 0xC1]),
+    ("dashDnDiag", [0x00, 0x00, 0x88, 0x44, 0x22, 0x11, 0x00, 0x00]),
+    ("dashUpDiag", [0x00, 0x00, 0x11, 0x22, 0x44, 0x88, 0x00, 0x00]),
+    ("diagCross", [0x81, 0x42, 0x24, 0x18, 0x18, 0x24, 0x42, 0x81]),
+    ("smCheck", [0x99, 0x66, 0x66, 0x99, 0x99, 0x66, 0x66, 0x99]),
+    ("lgCheck", [0xF0, 0xF0, 0xF0, 0xF0, 0x0F, 0x0F, 0x0F, 0x0F]),
+    ("smGrid", [0xFF, 0x88, 0x88, 0x88, 0xFF, 0x88, 0x88, 0x88]),
+    ("lgGrid", [0xFF, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    ("dotGrid", [0xAA, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00]),
+    ("smConfetti", [0x80, 0x08, 0x40, 0x02, 0x10, 0x01, 0x20, 0x04]),
+    ("lgConfetti", [0xB1, 0x30, 0x03, 0x1B, 0xD8, 0xC0, 0x0C, 0x8D]),
+    ("horzBrick", [0xFF, 0x80, 0x80, 0x80, 0xFF, 0x08, 0x08, 0x08]),
+    ("diagBrick", [0x01, 0x02, 0x04, 0x08, 0x18, 0x24, 0x42, 0x81]),
+    ("solidDmnd", [0x10, 0x38, 0x7C, 0xFE, 0x7C, 0x38, 0x10, 0x00]),
+    ("openDmnd", [0x82, 0x44, 0x28, 0x10, 0x28, 0x44, 0x82, 0x01]),
+    ("dotDmnd", [0x80, 0x00, 0x22, 0x00, 0x08, 0x00, 0x22, 0x00]),
+    ("plaid", [0xAA, 0x55, 0xAA, 0x55, 0xF0, 0xF0, 0xF0, 0xF0]),
+    ("sphere", [0x77, 0x89, 0x8F, 0x8F, 0x77, 0x98, 0xF8, 0xF8]),
+    ("weave", [0x88, 0x54, 0x22, 0x45, 0x88, 0x14, 0x22, 0x51]),
+    ("divot", [0x00, 0x10, 0x08, 0x10, 0x00, 0x80, 0x01, 0x80]),
+    ("shingle", [0x03, 0x84, 0x48, 0x30, 0x0C, 0x02, 0x01, 0x01]),
+    ("wave", [0x00, 0x18, 0x25, 0xC0, 0x00, 0x18, 0x25, 0xC0]),
+    ("trellis", [0xFF, 0x66, 0xFF, 0x99, 0xFF, 0x66, 0xFF, 0x99]),
+    ("zigZag", [0x81, 0x42, 0x24, 0x18, 0x81, 0x42, 0x24, 0x18]),
+];
+
+/// The 8×8 tile of preset `name` (`pct50` for an unknown name).
+pub fn tile(name: &str) -> [u8; 8] {
+    TILES
+        .iter()
+        .find(|(n, _)| *n == name)
+        .or_else(|| TILES.iter().find(|(n, _)| *n == "pct50"))
+        .map(|(_, t)| *t)
+        .unwrap_or([0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55])
+}
+
+/// Is cell (`x`, `y`) of the tile the foreground?
+pub fn is_fg(tile: &[u8; 8], x: usize, y: usize) -> bool {
+    tile.get(y % 8).is_some_and(|row| row & (0x80 >> (x % 8)) != 0)
+}
+
+fn premul(c: Rgba, alpha: f64) -> vello_cpu::color::PremulRgba8 {
+    let a = (c.a as f64 * alpha.clamp(0.0, 1.0)).round().clamp(0.0, 255.0);
+    let m = |v: u8| (v as f64 * a / 255.0).round().clamp(0.0, 255.0) as u8;
+    vello_cpu::color::PremulRgba8 { r: m(c.r), g: m(c.g), b: m(c.b), a: a as u8 }
+}
+
+/// Fill `path` (in the space `m` maps to the output) with preset `name` in `fg` on `bg`, faded by
+/// `alpha`.
+pub fn fill(ctx: &mut RenderContext, name: &str, fg: Rgba, bg: Rgba, alpha: f64, path: &BezPath, m: Affine) {
+    let det = m.determinant();
+    if !det.is_finite() || det.abs() <= 1e-12 {
+        return;
+    }
+    let t = tile(name);
+    let (f, b) = (premul(fg, alpha), premul(bg, alpha));
+    let data: Vec<vello_cpu::color::PremulRgba8> = (0..64).map(|i| if is_fg(&t, i % 8, i / 8) { f } else { b }).collect();
+    let pm = Arc::new(Pixmap::from_parts(data, 8, 8));
+    ctx.set_transform(m);
+    ctx.set_paint(vello_cpu::Image {
+        image: vello_cpu::ImageSource::Pixmap(pm),
+        sampler: peniko::ImageSampler {
+            x_extend: peniko::Extend::Repeat,
+            y_extend: peniko::Extend::Repeat,
+            quality: peniko::ImageQuality::Low,
+            alpha: 1.0,
+        },
+    });
+    // Cells are laid out on the output from its origin (the slide's top-left corner), so
+    // neighbouring shapes' patterns line up, as in PowerPoint.
+    let k = crate::scale_of(m);
+    let k = if k.is_finite() && k > 0.0 { k } else { 1.0 };
+    ctx.set_paint_transform(m.inverse() * Affine::scale(CELL * k));
+    ctx.fill_path(path);
+    ctx.reset_paint_transform();
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn every_drawingml_preset_has_a_tile() {
+        // ECMA-376 ST_PresetPatternVal.
+        let all = [
+            "pct5",
+            "pct10",
+            "pct20",
+            "pct25",
+            "pct30",
+            "pct40",
+            "pct50",
+            "pct60",
+            "pct70",
+            "pct75",
+            "pct80",
+            "pct90",
+            "horz",
+            "vert",
+            "ltHorz",
+            "ltVert",
+            "dkHorz",
+            "dkVert",
+            "narHorz",
+            "narVert",
+            "dashHorz",
+            "dashVert",
+            "cross",
+            "dnDiag",
+            "upDiag",
+            "ltDnDiag",
+            "ltUpDiag",
+            "dkDnDiag",
+            "dkUpDiag",
+            "wdDnDiag",
+            "wdUpDiag",
+            "dashDnDiag",
+            "dashUpDiag",
+            "diagCross",
+            "smCheck",
+            "lgCheck",
+            "smGrid",
+            "lgGrid",
+            "dotGrid",
+            "smConfetti",
+            "lgConfetti",
+            "horzBrick",
+            "diagBrick",
+            "solidDmnd",
+            "openDmnd",
+            "dotDmnd",
+            "plaid",
+            "sphere",
+            "weave",
+            "divot",
+            "shingle",
+            "wave",
+            "trellis",
+            "zigZag",
+        ];
+        assert_eq!(all.len(), 54);
+        for n in all {
+            assert!(TILES.iter().any(|(t, _)| *t == n), "{n}");
+        }
+        assert_eq!(TILES.len(), 54);
+    }
+
+    #[test]
+    fn percent_presets_get_denser() {
+        // The pctN tiles set more cells as N grows (PowerPoint's own: pct5 sets 2 of 64, pct50
+        // half, pct90 all but 2).
+        let share = |n: &str| {
+            let t = tile(n);
+            (0..64).filter(|i| is_fg(&t, i % 8, i / 8)).count()
+        };
+        let names = ["pct5", "pct10", "pct20", "pct25", "pct30", "pct40", "pct50", "pct60", "pct70", "pct75", "pct80", "pct90"];
+        assert!(names.windows(2).all(|w| share(w[0]) <= share(w[1])), "{:?}", names.map(share));
+        assert_eq!((share("pct5"), share("pct50"), share("pct90")), (2, 32, 62));
+        assert_eq!(tile("nonsense"), tile("pct50"));
+    }
+}

crates/render/src/tests.rs

@@ -750,3 +750,99 @@ fn text_glow_and_shadow_are_drawn() {
     let grey = |p: &[u8; 4]| p[0] > 60 && p[0] < 230 && p[0] == p[1] && p[1] == p[2];
     assert!(count(&img, &grey) > count(&base, &grey) + 300, "a grey shadow appears");
 }
+
+#[test]
+fn pattern_fills_draw_powerpoints_tiles() {
+    // dkVert at one output pixel per pattern cell (0.75 pt): columns 11001100… across, as
+    // PowerPoint's export draws it; pct50 is a checkerboard.
+    use deckcraft_model::style::{Fill, PatternFill};
+    let rgb = |v| ColorRef::rgb(deckcraft_color::Rgba::rgb(v, v, v));
+    let shape = |id, x: f64, preset: &str| Shape {
+        id: ShapeId(id),
+        xfrm: Some(Xfrm::new(x, 0.0, 60.0, 60.0)),
+        fill: Some(Fill::Pattern(PatternFill { preset: preset.into(), fg: rgb(0), bg: rgb(255) })),
+        line: Some(deckcraft_model::style::Line { fill: Some(Fill::None), ..Default::default() }),
+        ..Default::default()
+    };
+    let p = deck_with(vec![shape(750, 0.0, "dkVert"), shape(751, 120.0, "pct50")]);
+    let img = render_slide(&p, 0, &RenderOpts { scale: 4.0 / 3.0, ..Default::default() });
+    let dark = |x: u32, y: u32| img.pixel(x, y)[0] < 128;
+    let row: Vec<bool> = (8..16).map(|x| dark(x, 20)).collect();
+    assert_eq!(row, [true, true, false, false, true, true, false, false], "dkVert columns");
+    assert!((8..16).all(|y| dark(8, y) == dark(8, 20)), "dkVert is vertical");
+    // pct50 starts at slide x = 120 pt = 160 px.
+    for (x, y) in [(168, 8), (169, 9), (170, 12)] {
+        assert_ne!(dark(x, y), dark(x + 1, y), "pct50 alternates across at {x},{y}");
+        assert_eq!(dark(x, y), dark(x + 1, y + 1), "pct50 repeats diagonally at {x},{y}");
+    }
+}
+
+#[test]
+fn compound_lines_draw_their_bands() {
+    // A 24 pt outline on a rectangle, as PowerPoint's export draws each kind (top edge, outside
+    // first): double 8/8/8, thin-thick 4.8/4.8/14.4, triple 4/4/8/4/4.
+    use deckcraft_model::style::{Compound, Fill, Line};
+    let runs = |c: Compound| {
+        let sh = Shape {
+            id: ShapeId(760),
+            xfrm: Some(Xfrm::new(100.0, 100.0, 300.0, 200.0)),
+            fill: Some(Fill::solid(ColorRef::rgb(deckcraft_color::Rgba::rgb(255, 255, 255)))),
+            line: Some(Line {
+                fill: Some(Fill::solid(ColorRef::rgb(deckcraft_color::Rgba::rgb(0, 0, 0)))),
+                width: Some(24.0),
+                compound: Some(c),
+                ..Default::default()
+            }),
+            ..Default::default()
+        };
+        let p = deck_with(vec![sh]);
+        let img = render_slide(&p, 0, &RenderOpts { scale: 2.0, ..Default::default() });
+        // Down the middle of the top edge (y 100 pt), from 80 pt to 120 pt: lengths of dark and
+        // light runs in points.
+        let mut out: Vec<(bool, f64)> = vec![];
+        for y in 160..240 {
+            let dark = img.pixel(500, y)[0] < 128;
+            match out.last_mut() {
+                Some((d, n)) if *d == dark => *n += 0.5,
+                _ => out.push((dark, 0.5)),
+            }
+        }
+        out.into_iter().filter(|(d, _)| *d).map(|(_, n)| n).collect::<Vec<f64>>()
+    };
+    let close = |got: Vec<f64>, want: &[f64]| got.len() == want.len() && got.iter().zip(want).all(|(g, w)| (g - w).abs() <= 1.0);
+    assert!(close(runs(Compound::Single), &[24.0]));
+    let d = runs(Compound::Double);
+    assert!(close(d.clone(), &[8.0, 8.0]), "{d:?}");
+    let t = runs(Compound::ThinThick);
+    assert!(close(t.clone(), &[4.8, 14.4]), "{t:?}");
+    let k = runs(Compound::ThickThin);
+    assert!(close(k.clone(), &[14.4, 4.8]), "{k:?}");
+    let tri = runs(Compound::Triple);
+    assert!(close(tri.clone(), &[4.0, 8.0, 4.0]), "{tri:?}");
+}
+
+#[test]
+fn rect_path_gradients_draw_x_shaped_contours() {
+    // path="rect" from the centre, black to grey to white (linear): PowerPoint's colour position is
+    // the larger axis share, so 20 pt right of centre in a 280x200 box is 1/7 and 20 pt down 1/5.
+    use deckcraft_model::style::{Fill, Gradient, GradientShape, GradientStop};
+    let stop = |pos, v| GradientStop { pos, color: ColorRef::rgb(deckcraft_color::Rgba::rgb(v, v, v)) };
+    let sh = Shape {
+        id: ShapeId(770),
+        xfrm: Some(Xfrm::new(0.0, 0.0, 280.0, 200.0)),
+        fill: Some(Fill::Gradient(Gradient {
+            stops: vec![stop(0.0, 0), stop(0.5, 128), stop(1.0, 255)],
+            shape: GradientShape::Path { path: "rect".into(), focus: [0.5, 0.5, 0.5, 0.5] },
+            rotate_with_shape: true,
+        })),
+        line: Some(deckcraft_model::style::Line { fill: Some(Fill::None), ..Default::default() }),
+        ..Default::default()
+    };
+    let p = deck_with(vec![sh]);
+    let img = render_slide(&p, 0, &RenderOpts { scale: 1.0, ..Default::default() });
+    let v = |x: u32, y: u32| img.pixel(x, y)[0] as f64;
+    assert!((v(160, 100) - 255.0 / 7.0).abs() < 6.0, "{}", v(160, 100));
+    assert!((v(140, 120) - 51.0).abs() < 6.0, "{}", v(140, 120));
+    // Along the diagonal to a corner the colour follows the vertical share.
+    assert!((v(168, 120) - 51.0).abs() < 6.0, "{}", v(168, 120));
+}