Render: pattern fills draw PowerPoint's preset tiles

Pattern fills were approximated (dots, bars or a grid per family, on an
8-point cell), so pct30 looked like sparse dots and wave like a dot grid.
Every one of the 54 DrawingML presets now draws its 8x8 tile, each cell one
96-dpi pixel (0.75 pt), laid out from the slide's origin. The tiles were
read from PowerPoint's own export of each preset at two output pixels per
cell; the pattern probe deck now matches it to a mean pixel difference of
0.2 (from 62).

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

crates/render/src/lib.rs

@@ -13,6 +13,7 @@ mod images;
 mod morph_path;
 mod morph_text;
 mod paint;
+mod pattern;
 mod placed;
 mod ramp;
 mod table;
@@ -248,7 +249,7 @@ pub fn needs_filters(pres: &Presentation, slide: &Slide) -> bool {
                 return;
             }
             let (e, _) = resolve::effects(&rctx, s);
-            if e.is_some_and(|e| !e.is_empty()) {
+            if e.is_some_and(|e| !e.is_empty()) || text_has_effects(&rctx, s) {
                 any = true;
             }
         });
@@ -261,6 +262,20 @@ pub fn needs_filters(pres: &Presentation, slide: &Slide) -> bool {
     any
 }
 
+/// Does the shape's text have a shadow or glow (on a run, in its list style, or in the master's
+/// text styles it inherits)? Such text is blurred, which needs filters.
+fn text_has_effects(rctx: &Ctx, s: &Shape) -> bool {
+    use deckcraft_model::text::{ListStyle, RunProps};
+    let fx = |r: &RunProps| r.shadow.as_ref().is_some_and(|s| !s.inner) || r.glow.as_ref().is_some_and(|g| g.radius > 0.0);
+    let styled = |l: &ListStyle| l.levels.iter().flatten().any(|lv| fx(&lv.run));
+    let Some(t) = &s.text else { return false };
+    t.paragraphs.iter().any(|p| p.runs.iter().any(|r| fx(&r.props)) || fx(&p.end_props))
+        || styled(&t.list_style)
+        || styled(&rctx.master.title_style)
+        || styled(&rctx.master.body_style)
+        || styled(&rctx.master.other_style)
+}
+
 /// Render slide `index` at `opts.scale` pixels per point. A panic inside the renderer becomes a
 /// blank image (logged), never a crash.
 pub fn render_slide(pres: &Presentation, index: usize, opts: &RenderOpts) -> Image {
@@ -1124,6 +1139,15 @@ pub fn draw_layout_with(ctx: &mut RenderContext, l: &deckcraft_text::TextLayout,
     for d in l.decos.iter().filter(|d| d.behind) {
         deco(ctx, d);
     }
+    // Text shadows, then glows, under all the text.
+    for pass in [TextEffect::Shadow, TextEffect::Glow] {
+        for run in &l.runs {
+            let ps = para(run.para);
+            if ps.visible && ps.opacity > 0.001 {
+                text_effect(ctx, run, pass, m * Affine::translate(ps.offset), ps.opacity);
+            }
+        }
+    }
     for run in &l.runs {
         if (run.alpha <= 0.0 || run.color.a == 0) && run.outline.is_none() {
             continue;
@@ -1176,6 +1200,49 @@ fn line_bounds(li: &deckcraft_text::LineInfo) -> Option<Rect> {
     (r.is_finite() && r.width() > 0.0 && r.height() > 0.0).then_some(r)
 }
 
+#[derive(Clone, Copy, PartialEq)]
+enum TextEffect {
+    Shadow,
+    Glow,
+}
+
+/// Draw `run`'s shadow or glow (if it has one) under its glyphs, placed by `m`.
+fn text_effect(ctx: &mut RenderContext, run: &deckcraft_text::GlyphRun, which: TextEffect, m: Affine, opacity: f64) {
+    let Some(fx) = run.effects else { return };
+    let k = run.size / run.face.upem.max(1.0);
+    let skew = if run.fake_italic { Affine::new([1.0, 0.0, -0.2, 1.0, 0.0, 0.0]) } else { Affine::IDENTITY };
+    let px = scale_of(m);
+    let (c, sigma, offset, grow) = match (which, fx.shadow, fx.glow) {
+        (TextEffect::Shadow, Some(s), _) => (s.color, s.blur * 0.5 * px, Vec2::new(s.dx, s.dy), 0.0),
+        // Measured on PowerPoint's export: a text glow of radius r is solid to about a third of r
+        // past the glyph's edge and fades out by about two thirds of r.
+        (TextEffect::Glow, _, Some((gc, r))) => (gc, r * 0.15 * px, Vec2::ZERO, r * 0.68),
+        _ => return,
+    };
+    let alpha = (c.a as f64 / 255.0) * opacity;
+    if alpha <= 0.0 {
+        return;
+    }
+    ctx.set_transform(Affine::IDENTITY);
+    ctx.push_layer(None, None, Some(alpha as f32), None, Some(blur(sigma)));
+    ctx.set_paint(color(c.with_alpha(255), 1.0));
+    for (gid, x, y) in &run.glyphs {
+        let path = glyph(&run.face, *gid);
+        if path.elements().is_empty() {
+            continue;
+        }
+        // The offset is in slide space: a shadow falls the same way whatever the text's rotation.
+        let at = pre_translate(m * Affine::translate((*x, *y)), offset * px) * skew * Affine::scale(k);
+        ctx.set_transform(at);
+        ctx.fill_path(&path);
+        if grow > 0.0 {
+            ctx.set_stroke(kurbo::Stroke::new(grow / k.max(1e-9)).with_join(kurbo::Join::Round));
+            ctx.stroke_path(&path);
+        }
+    }
+    ctx.pop_layer();
+}
+
 /// Draw glyph `gid` of `run` with its origin (on the baseline) mapped by `at`, faded by `opacity`.
 pub(crate) fn draw_glyph(ctx: &mut RenderContext, run: &deckcraft_text::GlyphRun, gid: u32, at: Affine, opacity: f64) {
     draw_glyph_with(ctx, run, gid, at, opacity, None);

crates/render/src/paint.rs

@@ -47,55 +47,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/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

@@ -701,3 +701,78 @@ fn a_text_gradient_starts_over_on_every_line() {
         assert!(bottom(band) > 150, "line {band:?} ends at {}", bottom(band));
     }
 }
+
+/// A text box of big black "IIII" with `set` applied to its run.
+fn effect_text(set: impl Fn(&mut deckcraft_model::text::RunProps)) -> Presentation {
+    let mut sh = Shape { id: ShapeId(740), xfrm: Some(Xfrm::new(100.0, 100.0, 600.0, 300.0)), text_box: true, ..Default::default() };
+    let mut t = TextBody::from_text("IIII");
+    let props = &mut t.paragraphs[0].runs[0].props;
+    props.size = Some(100.0);
+    props.fill = Some(deckcraft_model::style::Fill::solid(ColorRef::rgb(deckcraft_color::Rgba::rgb(0, 0, 0))));
+    set(props);
+    sh.text = Some(t);
+    deck_with(vec![sh])
+}
+
+#[test]
+fn text_glow_and_shadow_are_drawn() {
+    let count = |img: &Image, f: &dyn Fn(&[u8; 4]) -> bool| img.pixels.as_chunks::<4>().0.iter().filter(|px| f(px)).count();
+    let green = |p: &[u8; 4]| p[1] > 150 && p[0] < 120 && p[2] < 120;
+    let plain = effect_text(|_| {});
+    assert!(!needs_filters(&plain, &plain.slides[0]));
+    let img = render_slide(&plain, 0, &RenderOpts { scale: 1.0, ..Default::default() });
+    assert_eq!(count(&img, &green), 0);
+    // Glow: a green halo hugging the letters, needing the blur filter.
+    let glow =
+        effect_text(|p| p.glow = Some(deckcraft_model::style::Glow { color: ColorRef::rgb(deckcraft_color::Rgba::rgb(0, 255, 0)), radius: 8.0 }));
+    assert!(needs_filters(&glow, &glow.slides[0]), "text glow blurs");
+    let img = render_slide(&glow, 0, &RenderOpts { scale: 1.0, threads: 4, ..Default::default() });
+    let halo = count(&img, &green);
+    assert!(halo > 300, "green halo pixels {halo}");
+    // Shadow: grey ink below and right of the letters, where the plain text has none.
+    let shadow = effect_text(|p| {
+        p.shadow = Some(deckcraft_model::style::Shadow {
+            color: ColorRef::rgb(deckcraft_color::Rgba { r: 0, g: 0, b: 0, a: 128 }),
+            blur: 2.0,
+            dist: 12.0,
+            dir: 45.0,
+            inner: false,
+            sx: 1.0,
+            sy: 1.0,
+            kx: 0.0,
+            ky: 0.0,
+            align: String::new(),
+            rotate_with_shape: false,
+        })
+    });
+    let img = render_slide(&shadow, 0, &RenderOpts { scale: 1.0, threads: 4, ..Default::default() });
+    let base = render_slide(&plain, 0, &RenderOpts { scale: 1.0, ..Default::default() });
+    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}");
+    }
+}

crates/text/src/lib.rs

@@ -57,6 +57,25 @@ pub struct GlyphRun {
     /// Alpha of the fill (0–1).
     pub alpha: f64,
     pub gradient: Option<deckcraft_model::style::Gradient>,
+    /// Shadow and glow behind the glyphs (`a:rPr/a:effectLst`).
+    pub effects: Option<RunEffects>,
+}
+
+/// A text run's shadow and glow, colours resolved.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct RunEffects {
+    pub shadow: Option<TextShadow>,
+    /// Glow colour (with its alpha) and radius in points.
+    pub glow: Option<(Rgba, f64)>,
+}
+
+/// An outer shadow: colour (with its alpha), blur radius and offset in points.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct TextShadow {
+    pub color: Rgba,
+    pub blur: f64,
+    pub dx: f64,
+    pub dy: f64,
 }
 
 impl std::fmt::Debug for GlyphRun {
@@ -174,6 +193,7 @@ struct Style {
     outline: Option<(Rgba, f64)>,
     link: bool,
     gradient: Option<deckcraft_model::style::Gradient>,
+    effects: Option<RunEffects>,
     /// "Regular", "Bold"… for the slot and fallback faces.
     style_name: &'static str,
     /// BCP 47 language (`a:rPr/@lang`), for shaping.
@@ -288,6 +308,7 @@ fn make_style(ctx: &Ctx, r: &RunProps, scale: f64, prompt: Option<Rgba>) -> Styl
         outline,
         link: r.link.is_some(),
         gradient,
+        effects: run_effects(ctx, r, scale),
         style_name: style_name(bold, italic),
         lang: r.lang.clone().filter(|l| !l.is_empty()),
         ea,
@@ -471,9 +492,7 @@ fn shape_para(ctx: &Ctx, shape: &Shape, body: &TextBody, pi: usize, scale: f64,
                 st.baseline = 0.0;
                 // Symbol fonts (Wingdings) aren't available: map common private-use bullets.
                 let ch = map_symbol_bullet(char, props.bullet_font.as_deref());
-                if !st.face.covers(ch.chars().next().unwrap_or('•')) {
-                    st.face = db.face("Inter", "Regular");
-                }
+                bullet_face(db, &mut st, &ch);
                 Some((ch, st))
             }
             Some(Bullet::AutoNum { scheme, start_at }) => {
@@ -483,8 +502,10 @@ fn shape_para(ctx: &Ctx, shape: &Shape, body: &TextBody, pi: usize, scale: f64,
                 }
                 rp.size = Some(lead.size.unwrap_or(18.0) * props.bullet_size.unwrap_or(1.0));
                 rp.underline = None;
-                let st = make_style(ctx, &rp, scale, opts.prompt_color);
-                Some((autonum(scheme, start_at.saturating_sub(1).saturating_add(number.unwrap_or(1))), st))
+                let mut st = make_style(ctx, &rp, scale, opts.prompt_color);
+                let label = autonum(scheme, start_at.saturating_sub(1).saturating_add(number.unwrap_or(1)));
+                bullet_face(db, &mut st, &label);
+                Some((label, st))
             }
             _ => None,
         }
@@ -492,8 +513,27 @@ fn shape_para(ctx: &Ctx, shape: &Shape, body: &TextBody, pi: usize, scale: f64,
     ParaShaped { cells, styles, faces, props, lead_size, lead_face, bullet, level: para.level, rtl }
 }
 
+/// A face that draws the bullet `label` when the bullet's own can't (circled numbers ①, arrows
+/// and other symbols missing from the text font), by the usual fallback.
+fn bullet_face(db: &FontDb, st: &mut Style, label: &str) {
+    let chars: Vec<char> = label.chars().collect();
+    if !chars.is_empty() && !deckcraft_fonts::covers_cluster(&st.face, &chars) {
+        st.face = db.cascade(&chars, std::slice::from_ref(&st.face), st.style_name);
+    }
+}
+
 /// Shape a logical paragraph into cells: bidi levels, per-grapheme faces, items of one level,
 /// script, face and shaping style, each shaped with the whole paragraph as context.
+/// A run's outer shadow and glow (inner shadows aren't drawn on text), at the layout's `scale`.
+fn run_effects(ctx: &Ctx, r: &RunProps, scale: f64) -> Option<RunEffects> {
+    let shadow = r.shadow.as_ref().filter(|s| !s.inner).map(|s| {
+        let a = s.dir.to_radians();
+        TextShadow { color: ctx.color(&s.color, None), blur: s.blur.max(0.0) * scale, dx: a.cos() * s.dist * scale, dy: a.sin() * s.dist * scale }
+    });
+    let glow = r.glow.as_ref().filter(|g| g.radius > 0.0).map(|g| (ctx.color(&g.color, None), g.radius * scale));
+    (shadow.is_some() || glow.is_some()).then_some(RunEffects { shadow, glow })
+}
+
 fn shape_cells(ctx: &Ctx, text: &str, char_style: &[usize], styles: &[Style], faces: &mut Vec<Arc<FontFace>>, rtl: bool) -> Vec<Cell> {
     let db = FontDb::global();
     let chars: Vec<char> = text.chars().collect();
@@ -1231,6 +1271,7 @@ fn layout_scaled(ctx: &Ctx, shape: &Shape, body: &TextBody, bp: &BodyProps, opts
                 link: false,
                 alpha: st.alpha,
                 gradient: None,
+                effects: None,
             });
         }
         // Group visually consecutive cells by (style, face).
@@ -1264,6 +1305,7 @@ fn layout_scaled(ctx: &Ctx, shape: &Shape, body: &TextBody, bp: &BodyProps, opts
                     link: st.link,
                     alpha: st.alpha,
                     gradient: st.gradient.clone(),
+                    effects: st.effects,
                 });
                 cur_key = key;
             }

crates/text/src/tests.rs

@@ -602,3 +602,25 @@ fn emoji_take_a_colour_face_when_one_is_installed() {
         assert!(l.runs.iter().filter(|r| r.cells.iter().all(|(_, c)| c.is_ascii())).all(|r| !r.face.is_color()), "the letters keep a text face");
     }
 }
+
+#[test]
+fn a_bullet_the_text_font_lacks_falls_back_to_a_face_that_has_it() {
+    // circleNumDbPlain numbers ①②…: the text font usually has no circled digits; PowerPoint draws
+    // them from a fallback font instead of a missing-glyph box. Skipped when no installed or
+    // bundled face has ①.
+    let db = FontDb::global();
+    if !db.cascade(&['①'], &[], "Regular").covers('①') {
+        return;
+    }
+    let (p, mut sh) = setup("One\nTwo", 600.0, 300.0);
+    for para in &mut sh.text.as_mut().unwrap().paragraphs {
+        para.props.bullet = Some(Bullet::AutoNum { scheme: "circleNumDbPlain".into(), start_at: 1 });
+    }
+    let l = lay(&p, &sh, 600.0, 300.0);
+    let bullets: Vec<_> = l.runs.iter().filter(|r| r.cells.is_empty()).collect();
+    assert_eq!(bullets.len(), 2);
+    for b in bullets {
+        assert!(b.face.covers('①'), "drawn with {}, which lacks the circled digit", b.face.family);
+        assert!(b.glyphs.iter().all(|g| g.0 != 0), "no missing-glyph box");
+    }
+}