Render: lock skrifa for colour glyphs

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

crates/render/src/lib.rs

@@ -13,7 +13,6 @@ mod images;
 mod morph_path;
 mod morph_text;
 mod paint;
-mod pattern;
 mod placed;
 mod ramp;
 mod table;
@@ -249,7 +248,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()) || text_has_effects(&rctx, s) {
+            if e.is_some_and(|e| !e.is_empty()) {
                 any = true;
             }
         });
@@ -262,20 +261,6 @@ 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 {
@@ -1139,15 +1124,6 @@ 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;
@@ -1157,24 +1133,8 @@ pub fn draw_layout_with(ctx: &mut RenderContext, l: &deckcraft_text::TextLayout,
             continue;
         }
         let m = m * Affine::translate(ps.offset);
-        // A gradient fill starts over on every line and spans that line's text (from its top to
-        // its bottom, from its first to its last character), as in PowerPoint.
-        let mut grads: Vec<(usize, peniko::Gradient)> = Vec::new();
         for (gid, x, y) in &run.glyphs {
-            let at = m * Affine::translate((*x, *y));
-            let Some(g) = run.gradient.as_ref().filter(|g| !g.stops.is_empty()) else {
-                draw_glyph(ctx, run, *gid, at, ps.opacity);
-                continue;
-            };
-            let li = line_at(l, run.para, *y);
-            if !grads.iter().any(|(i, _)| *i == li) {
-                let scheme = deckcraft_color::ColorScheme { name: String::new(), colors: [Rgba::BLACK; 12] };
-                let stops = g.stops.iter().map(|s| (s.pos, s.color.resolve(&scheme, None))).collect();
-                let bounds = l.lines.get(li).and_then(line_bounds).unwrap_or(tr);
-                grads.push((li, paint::gradient(&g.shape, stops, bounds, run.alpha * ps.opacity)));
-            }
-            let fill = grads.iter().find(|(i, _)| *i == li).map(|(_, g)| (g, Affine::translate((-*x, -*y))));
-            draw_glyph_with(ctx, run, *gid, at, ps.opacity, fill);
+            draw_glyph(ctx, run, *gid, m * Affine::translate((*x, *y)), ps.opacity);
         }
     }
     for d in l.decos.iter().filter(|d| !d.behind) {
@@ -1182,82 +1142,8 @@ pub fn draw_layout_with(ctx: &mut RenderContext, l: &deckcraft_text::TextLayout,
     }
 }
 
-/// The line of paragraph `para` holding a glyph on baseline `y` (the nearest baseline).
-fn line_at(l: &deckcraft_text::TextLayout, para: usize, y: f64) -> usize {
-    l.lines
-        .iter()
-        .enumerate()
-        .filter(|(_, li)| li.para == para)
-        .min_by(|a, b| (a.1.baseline - y).abs().total_cmp(&(b.1.baseline - y).abs()))
-        .map(|(i, _)| i)
-        .unwrap_or(0)
-}
-
-/// The box a line's text covers: its top and bottom, its first and last caret.
-fn line_bounds(li: &deckcraft_text::LineInfo) -> Option<Rect> {
-    let (x0, x1) = li.caret_x.iter().fold((f64::INFINITY, f64::NEG_INFINITY), |(a, b), x| (a.min(*x), b.max(*x)));
-    let r = Rect::new(x0, li.top, x1, li.bottom);
-    (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);
-}
-
-/// [`draw_glyph`], filled with `fill` (a gradient laid out in the text's space, and the map from
-/// the glyph's origin to that space) instead of the run's colour.
-fn draw_glyph_with(
-    ctx: &mut RenderContext,
-    run: &deckcraft_text::GlyphRun,
-    gid: u32,
-    at: Affine,
-    opacity: f64,
-    fill: Option<(&peniko::Gradient, Affine)>,
-) {
     let alpha = run.alpha * opacity;
     if (alpha <= 0.0 || run.color.a == 0) && run.outline.is_none() {
         return;
@@ -1274,14 +1160,7 @@ fn draw_glyph_with(
     }
     let skew = if run.fake_italic { Affine::new([1.0, 0.0, -0.2, 1.0, 0.0, 0.0]) } else { Affine::IDENTITY };
     ctx.set_transform(at * skew * Affine::scale(k));
-    if let Some((g, to_text)) = fill
-        && alpha > 0.0
-    {
-        ctx.set_paint(g.clone());
-        ctx.set_paint_transform((skew * Affine::scale(k)).inverse() * to_text);
-        ctx.fill_path(&path);
-        ctx.reset_paint_transform();
-    } else if alpha > 0.0 && run.color.a > 0 {
+    if alpha > 0.0 && run.color.a > 0 {
         ctx.set_paint(color(run.color, alpha));
         ctx.fill_path(&path);
         if run.fake_bold {

crates/render/src/paint.rs

@@ -35,8 +35,33 @@ pub fn fill_path(
             if g.stops.is_empty() {
                 return;
             }
-            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));
+            // 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,11 +72,55 @@ pub fn fill_path(
         Fill::Pattern(p) => {
             let fg = rctx.color(&p.fg, ph);
             let bg = rctx.color(&p.bg, ph);
-            crate::pattern::fill(ctx, &p.preset, fg, bg, alpha, path, m);
+            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();
         }
     }
 }
 
+/// 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.
@@ -62,38 +131,6 @@ pub fn resolved<'a>(rctx: &Ctx, pf: &'a PictureFill, ph: Option<Rgba>) -> std::b
     std::borrow::Cow::Owned(out)
 }
 
-/// The paint of a gradient of `shape` with `stops` (position, colour) spanning `bounds`, faded
-/// by `alpha`, ramping between stops as PowerPoint does (see `ramp`).
-pub fn gradient(shape: &GradientShape, mut stops: Vec<(f64, Rgba)>, bounds: Rect, alpha: f64) -> peniko::Gradient {
-    for s in &mut stops {
-        s.0 = s.0.clamp(0.0, 1.0);
-    }
-    stops.sort_by(|a, b| a.0.total_cmp(&b.0));
-    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();
-    match 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())
-        }
-    }
-}
-
 /// Draw a picture fill into `bounds` (shape-local) honouring crop and stretch/tile modes; an animated
 /// GIF shows its frame at `gif_time` seconds.
 pub fn picture(ctx: &mut RenderContext, pres: &Presentation, pf: &PictureFill, bounds: Rect, m: Affine, gif_time: Option<f64>) {

crates/render/src/pattern.rs

@@ -1,208 +0,0 @@
-//! 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

@@ -658,121 +658,3 @@ fn colour_glyphs_paint_their_layers() {
     // The text-colour glyph is as big as the other square.
     assert!((green as f64 / (red + blue) as f64 - 1.0).abs() < 0.1, "green {green} vs {}", red + blue);
 }
-
-#[test]
-fn a_text_gradient_starts_over_on_every_line() {
-    // PowerPoint fills each line of gradient text with the whole gradient, spanning that line
-    // (black at the top of every line to white at its bottom), not the text box.
-    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 mut sh = Shape { id: ShapeId(730), xfrm: Some(Xfrm::new(0.0, 0.0, 600.0, 500.0)), text_box: true, ..Default::default() };
-    let mut t = TextBody::from_text("HHHH\nHHHH");
-    for p in &mut t.paragraphs {
-        let props = &mut p.runs[0].props;
-        props.size = Some(80.0);
-        props.fill = Some(Fill::Gradient(Gradient {
-            stops: vec![stop(0.0, 0), stop(1.0, 255)],
-            shape: GradientShape::Linear { angle: 90.0, scaled: false },
-            rotate_with_shape: true,
-        }));
-    }
-    sh.text = Some(t);
-    let p = deck_with(vec![sh]);
-    let img = render_slide(&p, 0, &RenderOpts { scale: 1.0, ..Default::default() });
-    // Ink rows (any pixel not white), grouped into the two lines.
-    let ink = |y: u32| (0..600).any(|x| img.pixel(x, y)[0] < 250);
-    let mut bands: Vec<(u32, u32)> = vec![];
-    for y in 0..500 {
-        if ink(y) {
-            match bands.last_mut() {
-                Some(b) if b.1 + 1 == y => b.1 = y,
-                _ => bands.push((y, y)),
-            }
-        }
-    }
-    assert_eq!(bands.len(), 2, "{bands:?}");
-    // The darkest ink in the first rows of each line.
-    let top = |b: (u32, u32)| (b.0..b.0 + 6).flat_map(|y| (0..600).map(move |x| (x, y))).map(|(x, y)| img.pixel(x, y)[0]).min().unwrap();
-    let (a, b) = (top(bands[0]), top(bands[1]));
-    assert!(a < 140 && (a as i32 - b as i32).abs() < 25, "line tops {a} and {b}: the second line starts dark again");
-    // ...and each line ends light.
-    let bottom = |b: (u32, u32)| (b.1 - 5..=b.1).flat_map(|y| (0..600).map(move |x| (x, y))).map(|(x, y)| img.pixel(x, y)[0]).min().unwrap();
-    for band in bands {
-        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,25 +57,6 @@ 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 {
@@ -193,7 +174,6 @@ 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.
@@ -265,14 +245,7 @@ fn make_style(ctx: &Ctx, r: &RunProps, scale: f64, prompt: Option<Rgba>) -> Styl
     let size = (r.size.unwrap_or(18.0) * scale).clamp(0.5, 4000.0);
     let (mut color, alpha, gradient) = match &r.fill {
         Some(Fill::Solid { color }) => (ctx.color(color, None), color.alpha(), None),
-        Some(Fill::Gradient(g)) => {
-            // Colours resolved here (theme, colour map), so the renderer needs no colour scheme.
-            let mut g = g.clone();
-            for s in &mut g.stops {
-                s.color = deckcraft_model::ColorRef::rgb(ctx.color(&s.color, None));
-            }
-            (g.stops.first().map(|s| ctx.color(&s.color, None)).unwrap_or(Rgba::BLACK), 1.0, Some(g))
-        }
+        Some(Fill::Gradient(g)) => (g.stops.first().map(|s| ctx.color(&s.color, None)).unwrap_or(Rgba::BLACK), 1.0, Some(g.clone())),
         Some(Fill::None) => (Rgba::TRANSPARENT, 0.0, None),
         _ => (resolve::text_color(ctx, r), 1.0, None),
     };
@@ -308,7 +281,6 @@ 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,
@@ -492,7 +464,9 @@ 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());
-                bullet_face(db, &mut st, &ch);
+                if !st.face.covers(ch.chars().next().unwrap_or('•')) {
+                    st.face = db.face("Inter", "Regular");
+                }
                 Some((ch, st))
             }
             Some(Bullet::AutoNum { scheme, start_at }) => {
@@ -502,10 +476,8 @@ 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 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))
+                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))
             }
             _ => None,
         }
@@ -513,27 +485,8 @@ 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();
@@ -1271,7 +1224,6 @@ 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).
@@ -1305,7 +1257,6 @@ 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,25 +602,3 @@ 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");
-    }
-}