mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-19 17:05:55 +01:00
Merge pull request #3719 from lehni/feature/colr
Type: COLR colour fonts draw and export as vector art
This commit is contained in:
25 files changed
+1454
-39
No files matched your search
Generated
+1
@@ -4990,6 +4990,7 @@ dependencies = [
|
||||
"unicode-segmentation",
|
||||
"vectorcraft-doc",
|
||||
"vectorcraft-geom",
|
||||
"vello_cpu 0.2.0",
|
||||
"windows-registry",
|
||||
"write-fonts",
|
||||
]
|
||||
|
||||
+3
-1
@@ -9,7 +9,7 @@
|
||||
|
||||
**Stage: alpha** · next: beta, ~13 points (ready for real work ~62% → ~75%, and reliable `.ai` exchange) and ~170–270 h away
|
||||
|
||||
> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-22 · **Change:** minor (G2: the Effect Gallery shipped (#2883): Effect › Effect Gallery… browses the Artistic, Brush Strokes, Distort, Sketch, Stylize and Texture filters, edits each filter's settings, builds an ordered stack (add, reorder, hide, remove) with a live canvas preview, and OK applies it as separate appearance effects in one undo step; remaining: filter thumbnails and a preview area inside the dialog; G2 estimate 4–6 → 1–2 h; Raster effects 82% → 85% (power-user view 49% → 52%), estimated, a modest move because the named missing dialog landed without thumbnails or an in-dialog preview; previously: colour emoji fonts with bitmap glyphs (`sbix`, `CBDT`) draw and export; headline numbers unchanged; previously:; Affinity import AF.5: master pages, tables, paragraph formats, shadows, glows, outlines, overlays and embedded documents; ruby (ふりがな) for live text: `type.ruby` sets or removes a reading over a byte range, above or below (right of the column in vertical type), aligned, sized and overhanging or squeezed; saved natively, laid out with line growth, drawn on the canvas and in SVG/PDF (outlines where ruby is present); headline numbers unchanged; previously:; 3D: original Standard, Diffuse, Top Left and Right lighting presets; command access, effective-setting recognition and preview/history; scores and estimates unchanged; Print: Japanese paper sizes in the Print dialog's Media list — JIS B4 257 × 364 mm, JIS B5 182 × 257 mm and JIS B6 128 × 182 mm beside the ISO B4/B5 (which keep their ISO 216 sizes), はがき, 往復はがき, 封筒 長形3号/長形4号/角形2号/角形3号 and 四六判; about 90 community PRs of 2026-10-19: Objects on Path, the Simplify slider, Pencil Edit Selected Paths in the middle of a path, Georgian, and more; Background Export progress dialog with Cancel, #2564; about 85 community PRs of 2026-10-18: Justification…, Word .docx placed as area type, CCITT Group 3 TIFF, Roman Hanging Punctuation, blend spines edited with the Anchor Point tool, shadows and glows in stack order, coloured 3D lights, a Dutch catalog completed; 3D lighting: one to ten colored lights, smooth colored Inflate, legacy white-light appearance preserved; surface batching and restored seam minimum; scores and estimates unchanged; about 145 community PRs of 2026-10-17: image-decode overflow guards, opaque floating panels, MCP export cancel and progress, editable Illustrator EPS import, scoped `doc_inspect`, Dutch, Danish and Indonesian, Simplified Chinese messages, screen-reader names; headline numbers unchanged; about 160 community PRs of 2026-10-15/16: PDF import crash fixes, Dimension tool, legacy `.ai` save, Intertwine, web pen input, Image Trace fixes, `.ai`/EPS/PDF import fidelity, Bulgarian, Greek, Swedish and Finnish catalogs; headline numbers unchanged) · **Target:** Adobe Illustrator 2026 (30.x)
|
||||
> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-23 · **Change:** minor (COLR colour fonts (v0 and v1) draw and export as vector art; previously: G2: the Effect Gallery shipped (#2883): Effect › Effect Gallery… browses the Artistic, Brush Strokes, Distort, Sketch, Stylize and Texture filters, edits each filter's settings, builds an ordered stack (add, reorder, hide, remove) with a live canvas preview, and OK applies it as separate appearance effects in one undo step; remaining: filter thumbnails and a preview area inside the dialog; G2 estimate 4–6 → 1–2 h; Raster effects 82% → 85% (power-user view 49% → 52%), estimated, a modest move because the named missing dialog landed without thumbnails or an in-dialog preview; previously: colour emoji fonts with bitmap glyphs (`sbix`, `CBDT`) draw and export; headline numbers unchanged; previously:; Affinity import AF.5: master pages, tables, paragraph formats, shadows, glows, outlines, overlays and embedded documents; ruby (ふりがな) for live text: `type.ruby` sets or removes a reading over a byte range, above or below (right of the column in vertical type), aligned, sized and overhanging or squeezed; saved natively, laid out with line growth, drawn on the canvas and in SVG/PDF (outlines where ruby is present); headline numbers unchanged; previously:; 3D: original Standard, Diffuse, Top Left and Right lighting presets; command access, effective-setting recognition and preview/history; scores and estimates unchanged; Print: Japanese paper sizes in the Print dialog's Media list — JIS B4 257 × 364 mm, JIS B5 182 × 257 mm and JIS B6 128 × 182 mm beside the ISO B4/B5 (which keep their ISO 216 sizes), はがき, 往復はがき, 封筒 長形3号/長形4号/角形2号/角形3号 and 四六判; about 90 community PRs of 2026-10-19: Objects on Path, the Simplify slider, Pencil Edit Selected Paths in the middle of a path, Georgian, and more; Background Export progress dialog with Cancel, #2564; about 85 community PRs of 2026-10-18: Justification…, Word .docx placed as area type, CCITT Group 3 TIFF, Roman Hanging Punctuation, blend spines edited with the Anchor Point tool, shadows and glows in stack order, coloured 3D lights, a Dutch catalog completed; 3D lighting: one to ten colored lights, smooth colored Inflate, legacy white-light appearance preserved; surface batching and restored seam minimum; scores and estimates unchanged; about 145 community PRs of 2026-10-17: image-decode overflow guards, opaque floating panels, MCP export cancel and progress, editable Illustrator EPS import, scoped `doc_inspect`, Dutch, Danish and Indonesian, Simplified Chinese messages, screen-reader names; headline numbers unchanged; about 160 community PRs of 2026-10-15/16: PDF import crash fixes, Dimension tool, legacy `.ai` save, Intertwine, web pen input, Image Trace fixes, `.ai`/EPS/PDF import fidelity, Bulgarian, Greek, Swedish and Finnish catalogs; headline numbers unchanged) · **Target:** Adobe Illustrator 2026 (30.x)
|
||||
|
||||
VectorCraft is a clean-room, open-source, pure-Rust reimplementation of the Adobe Illustrator workflow. It runs
|
||||
on macOS, Windows, Linux, FreeBSD and the web (WASM), and agents can drive all of it over MCP, the CLI and a JSON
|
||||
@@ -128,6 +128,7 @@ Ranked; detail in [docs/roadmap.md](docs/roadmap.md) and [docs/gaps.md](docs/gap
|
||||
|
||||
## Progress log
|
||||
|
||||
- 2026-10-23: COLR colour fonts (v0 and v1, as in Noto Color Emoji's vector build, Segoe UI Emoji, Nabla) draw as vector art: their layers' colours, gradients, clips and blend modes on the canvas and in SVG, EPS, legacy `.ai` and PDF, and as editable paths with Create Outlines; glyphs using sweep gradients or compositing modes are drawn as images of the glyph.
|
||||
- 2026-10-22: The Effect Gallery shipped (#2883): Effect › Effect Gallery… browses the Artistic, Brush Strokes, Distort, Sketch, Stylize and Texture filters, edits each filter's settings, builds an ordered stack (add, reorder, hide, remove) with a live canvas preview, and OK applies it as separate appearance effects in one undo step. Filter thumbnails and a preview area inside the dialog remain ([Filter Gallery overview](https://helpx.adobe.com/photoshop/desktop/effects-filters/get-started-with-filters/filter-gallery.html)). Raster effects 82% → 85% (estimated); headline numbers unchanged.
|
||||
- 2026-10-22: Colour emoji fonts with bitmap glyphs draw and export: `sbix` (Apple Color Emoji, macOS's emoji font) and `CBDT` (bitmap Noto Color Emoji) glyphs show as their pictures on the canvas, whatever the type's fill, scale and turn with the type, and export to PDF (in the font's Type 3 glyphs, or as images), SVG (images when type is outlined; live text leaves emoji to the viewer), EPS and legacy `.ai` (images); Create Outlines turns them into embedded images. Fonts with bitmaps but no outlines, such as Noto Color Emoji, are now found among the installed fonts. COLR and OpenType SVG fonts remain; headline numbers unchanged.
|
||||
|
||||
@@ -195,6 +196,7 @@ The full pre-standard record of what landed is kept in [docs/roadmap.md](docs/ro
|
||||
|
||||
| Date | Change | Summary |
|
||||
|---|---|---|
|
||||
| 2026-10-23 | minor | Progress log row for COLR colour fonts; headline numbers unchanged. |
|
||||
| 2026-10-22 | minor | G2: the Effect Gallery shipped (#2883): Effect › Effect Gallery… browses the Artistic, Brush Strokes, Distort, Sketch, Stylize and Texture filters, edits each filter's settings, builds an ordered stack (add, reorder, hide, remove) with a live canvas preview, and OK applies it as separate appearance effects in one undo step; remaining: filter thumbnails and a preview area inside the dialog; G2 estimate 4–6 → 1–2 h; Raster effects 82% → 85% (power-user view 49% → 52%), estimated, a modest move because the named missing dialog landed without thumbnails or an in-dialog preview. |
|
||||
| 2026-10-22 | minor | Progress log row for colour emoji fonts with bitmap glyphs; headline numbers unchanged. |
|
||||
| 2026-10-22 | minor | Effects: Sketch › Conté Crayon; measured Photoshop-style filters 57/57, the Effect Gallery remains (G2 estimate 4–6 h). |
|
||||
|
||||
@@ -573,6 +573,11 @@ fn create_outlines(s: &mut Session, _: &Value) -> Result<Value> {
|
||||
children.push(Arc::new(Node::new(d.alloc_id(), NodeKind::Image(Box::new(im)))));
|
||||
continue;
|
||||
}
|
||||
// COLR glyphs become groups of their layers, in place, with ids of the document's.
|
||||
if let Some(art) = g.placed_colour(t.xf) {
|
||||
children.push(Arc::new(d.reid(&art)));
|
||||
continue;
|
||||
}
|
||||
let path = PathData::from_bezpath(&g.outline).transformed(t.xf);
|
||||
if path.is_empty() {
|
||||
continue;
|
||||
|
||||
@@ -1071,3 +1071,25 @@ fn offset_path_that_leaves_nothing_says_so() {
|
||||
let e = s.execute("object.path.offsetPath", &json!({"offset": -20})).unwrap_err().to_string();
|
||||
assert!(e.contains("leaves nothing") && !e.contains("select paths"), "{e}");
|
||||
}
|
||||
|
||||
/// COLR glyphs become groups of their layers: real paths with their colours and gradients, the
|
||||
/// composite's blend mode kept, every node with an id of the document's.
|
||||
#[test]
|
||||
fn create_outlines_turns_colr_glyphs_into_layer_groups() {
|
||||
use vectorcraft_text::test_fonts::{COLOUR_CHAR, colr_family, colr_font};
|
||||
vectorcraft_text::FontDb::global().add_font(colr_font(true).unwrap());
|
||||
let mut s = session();
|
||||
s.execute("text.create", &json!({"x": 10, "y": 50, "text": format!("{COLOUR_CHAR}F"), "size": 32, "font": colr_family(true)})).unwrap();
|
||||
let r = ids(&s.execute("type.createOutlines", &json!({})).unwrap());
|
||||
let g = node(&s, r[0]);
|
||||
let ch = g.children().unwrap();
|
||||
assert!(matches!(ch[0].kind, NodeKind::Group { .. }), "the glyph's group: {:?}", ch[0].kind_label());
|
||||
assert!(matches!(ch[1].kind, NodeKind::Path { .. } | NodeKind::Compound { .. }), "the `F` an outline");
|
||||
let mut nodes = vec![];
|
||||
ch[0].walk(&mut |n| nodes.push((n.id, n.blend, n.appearance.fill_paint())));
|
||||
assert!(nodes.iter().any(|(_, _, p)| matches!(p, vectorcraft_color::Paint::Gradient(_))), "its gradients");
|
||||
assert!(nodes.iter().any(|(_, b, _)| *b == vectorcraft_color::BlendMode::Multiply), "its multiply");
|
||||
let d = &s.doc().unwrap().doc;
|
||||
let mut seen = std::collections::HashSet::new();
|
||||
assert!(nodes.iter().all(|(id, ..)| d.node(*id).is_some() && seen.insert(*id)), "ids of the document's, each once");
|
||||
}
|
||||
@@ -1293,6 +1293,10 @@ impl<'a> Writer<'a> {
|
||||
if let Some((image, to_text)) = g.placed_image() {
|
||||
self.image(Some(&image.blob), image.width, image.height, t.xf * to_text);
|
||||
}
|
||||
// COLR glyphs: their layers, as art.
|
||||
if let Some(art) = g.placed_colour(t.xf) {
|
||||
self.node(&art, false);
|
||||
}
|
||||
}
|
||||
self.line("U");
|
||||
}
|
||||
|
||||
@@ -591,6 +591,10 @@ impl<'a> Scene<'a> {
|
||||
let key = format!("\u{0}glyph\u{0}{}", image.blob.content_key());
|
||||
self.image(&key, Some(&image.blob), image.width, image.height, to_text);
|
||||
}
|
||||
// COLR glyphs: their layers, as art (in text space, as the images).
|
||||
if let Some(art) = g.placed_colour(Affine::IDENTITY) {
|
||||
self.node(&art, true);
|
||||
}
|
||||
}
|
||||
if bp.elements().is_empty() {
|
||||
continue;
|
||||
|
||||
@@ -518,3 +518,20 @@ fn colour_bitmap_glyphs_are_images() {
|
||||
// origin (2 px), in text space.
|
||||
assert!(ps.contains("[32 0 0 32 4 -24] cm"), "{ps}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn colr_glyphs_are_vector_art() {
|
||||
use vectorcraft_doc::{CharStyle, TextObject};
|
||||
use vectorcraft_text::test_fonts::{COLOUR_CHAR, colr_family, colr_font};
|
||||
vectorcraft_text::FontDb::global().add_font(colr_font(false).unwrap());
|
||||
let d = doc_with(|d| {
|
||||
let fill = vectorcraft_color::Paint::solid(vectorcraft_color::Color::rgb(0.0, 0.0, 1.0));
|
||||
let st = CharStyle { font_family: colr_family(false).into(), size: 32.0, fill, ..CharStyle::default() };
|
||||
vec![Node::new(d.alloc_id(), NodeKind::Text(Box::new(TextObject::point(Point::new(20.0, 100.0), &COLOUR_CHAR.to_string(), st))))]
|
||||
});
|
||||
let ps = text(&export(&d, &opts(&d), None, None).unwrap());
|
||||
checked_page(&ps);
|
||||
assert!(!ps.contains("/Width"), "no image: {ps}");
|
||||
assert!(ps.contains("1 0 0 rg"), "the red layer: {ps}");
|
||||
assert!(ps.contains("0 0 1 rg"), "the foreground layer in the fill: {ps}");
|
||||
}
|
||||
@@ -93,7 +93,8 @@ fn write_with(doc: &Document, o: LegacyAiOptions) -> LegacyAiOutput {
|
||||
/// in their first stop's color.
|
||||
fn as_printed(doc: &Document, o: &LegacyAiOptions) -> Document {
|
||||
// A run's glyphs, laid out, as one path with the run's fill (the renderer draws no type), and
|
||||
// its colour bitmap glyphs as images (their pixels added to `images`).
|
||||
// its colour bitmap glyphs as images (their pixels added to `images`), its COLR glyphs as their
|
||||
// layers.
|
||||
fn outlined(t: &vectorcraft_doc::TextObject, images: &mut std::collections::BTreeMap<String, ImageBlob>) -> Node {
|
||||
let layout = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t);
|
||||
let mut nodes: Vec<Arc<Node>> = t
|
||||
@@ -116,6 +117,8 @@ fn as_printed(doc: &Document, o: &LegacyAiOptions) -> Document {
|
||||
let im = ImageObject { key, width: image.width, height: image.height, xf: t.xf * to_text, link: None, placement: Default::default() };
|
||||
nodes.push(Arc::new(Node::new(vectorcraft_doc::NodeId(0), NodeKind::Image(Box::new(im)))));
|
||||
}
|
||||
// COLR glyphs: their layers.
|
||||
nodes.extend(layout.glyphs.iter().filter_map(|g| g.placed_colour(t.xf)).map(Arc::new));
|
||||
Node::group(vectorcraft_doc::NodeId(0), nodes)
|
||||
}
|
||||
fn plain(nodes: &mut Vec<Arc<Node>>, o: &LegacyAiOptions, images: &mut std::collections::BTreeMap<String, ImageBlob>) {
|
||||
@@ -1175,3 +1178,20 @@ fn colour_bitmap_glyphs_of_outlined_type_are_images() {
|
||||
assert_eq!(images.len(), 1, "{text}");
|
||||
assert!(images[0][2].ends_with(" ] 0 0 16 16 16 16 8 3 0 0 0 0 XI"), "{:?}", images[0]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn colr_glyphs_of_outlined_type_are_vector_art() {
|
||||
use vectorcraft_doc::{CharStyle, TextObject};
|
||||
use vectorcraft_text::test_fonts::{COLOUR_CHAR, colr_family, colr_font};
|
||||
vectorcraft_text::FontDb::global().add_font(colr_font(false).unwrap());
|
||||
let mut doc = Document::new(200.0, 100.0);
|
||||
let st = CharStyle { font_family: colr_family(false).into(), size: 32.0, ..CharStyle::default() };
|
||||
// Cyrillic, which 8-bit text can't hold: the type is written as outlines.
|
||||
let t = TextObject::point(vectorcraft_geom::Point::new(20.0, 60.0), &format!("{COLOUR_CHAR}\u{416}"), st);
|
||||
let l = doc.layers[0].id;
|
||||
let id = doc.alloc_id();
|
||||
doc.insert(Some(l), 0, Node::new(id, NodeKind::Text(Box::new(t)))).unwrap();
|
||||
let text = String::from_utf8(write(&doc).bytes).unwrap();
|
||||
assert!(rasters(&text).is_empty(), "no images: {text}");
|
||||
assert!(text.contains("1 0 0 Xa"), "the red layer: {text}");
|
||||
}
|
||||
@@ -1605,6 +1605,10 @@ impl Exporter<'_> {
|
||||
s.push_transform(&text_space);
|
||||
for g in images.iter().filter_map(|&gi| layout.glyphs.get(gi)) {
|
||||
self.glyph_image(s, g);
|
||||
// COLR glyphs: their layers, as art.
|
||||
if let Some(art) = g.placed_colour(Affine::IDENTITY) {
|
||||
self.node(s, &art, page, true);
|
||||
}
|
||||
}
|
||||
s.pop();
|
||||
// Characters with neither fill nor stroke (a scanned page's recognized text), or whose
|
||||
@@ -1683,21 +1687,22 @@ impl Exporter<'_> {
|
||||
/// text space; `text` is the plain text, whose characters the glyphs stand for, which makes
|
||||
/// the text selectable and searchable) → the outlines of the glyphs left to draw as paths:
|
||||
/// those of fonts that can't be embedded, and missing glyphs. Glyphs sharing a font, a frame
|
||||
/// (size, scale, rotation) and a baseline are written together. Colour bitmap glyphs (emoji),
|
||||
/// with `images`, are written as text too, which draws their images; the indices of those it
|
||||
/// can't write are returned with the outlines.
|
||||
/// (size, scale, rotation) and a baseline are written together. Colour glyphs (bitmap emoji,
|
||||
/// COLR), with `images`, are written as text too, which draws their images or layers; the
|
||||
/// indices of those it can't write are returned with the outlines.
|
||||
fn glyph_text(&mut self, s: &mut Surface, layout: &TextLayout, run: usize, text: &str, fill: &Paint, images: bool) -> (BezPath, Vec<usize>) {
|
||||
let (mut rest, mut unwritten) = (BezPath::new(), vec![]);
|
||||
let mut line: Option<GlyphLine> = None;
|
||||
for (gi, g) in layout.glyphs.iter().enumerate().filter(|(_, g)| g.run == run) {
|
||||
if g.image.is_some() && !images {
|
||||
let coloured = g.image.is_some() || g.colour.is_some();
|
||||
if coloured && !images {
|
||||
continue;
|
||||
}
|
||||
let range = g.byte..g.byte + g.len;
|
||||
let ch = text.get(range.clone()).and_then(|t| t.chars().next());
|
||||
// Spaces are written too (text extraction needs them); control characters and soft
|
||||
// hyphens draw nothing.
|
||||
let blank = g.outline.elements().is_empty() && g.image.is_none();
|
||||
let blank = g.outline.elements().is_empty() && !coloured;
|
||||
if blank && !ch.is_some_and(|c| c.is_whitespace() && !c.is_control()) {
|
||||
continue;
|
||||
}
|
||||
@@ -1709,7 +1714,7 @@ impl Exporter<'_> {
|
||||
let det = g.xf.determinant();
|
||||
let Some((font, upem)) = font.filter(|(_, upem)| det.is_finite() && det.abs() > 1e-9 && (1e-3..=1e5).contains(&(upem * sy))) else {
|
||||
rest.extend(g.outline.iter());
|
||||
if g.image.is_some() {
|
||||
if coloured {
|
||||
unwritten.push(gi);
|
||||
}
|
||||
continue;
|
||||
|
||||
@@ -1068,3 +1068,35 @@ fn dithered_perceptual_gradients_export_as_images_with_noise_on_the_fill() {
|
||||
assert_ne!(export_with(true, false), export_with(false, false), "the fill's pixels carry the noise");
|
||||
assert_eq!(export_with(true, true), export_with(false, true), "a stroke has no dither");
|
||||
}
|
||||
|
||||
/// COLR glyphs in the PDF: as real text, in their font's Type 3 glyphs (the foreground layer in
|
||||
/// the fill); outlined, as vector art, a sweep glyph as an image.
|
||||
#[test]
|
||||
fn colr_glyphs_export_as_vector_art() {
|
||||
use vectorcraft_text::test_fonts::{COLOUR_CHAR, COLR_SWEEP_CHAR, colr_family, colr_font};
|
||||
for v1 in [false, true] {
|
||||
vectorcraft_text::FontDb::global().add_font(colr_font(v1).unwrap());
|
||||
}
|
||||
let page = |v1: bool, ch: char, outline_text: bool| {
|
||||
let mut d = doc(300.0, 100.0);
|
||||
let fill = Paint::solid(Color::rgb(0.0, 0.0, 1.0));
|
||||
let st = CharStyle { font_family: colr_family(v1).into(), size: 24.0, fill, ..CharStyle::default() };
|
||||
add(&mut d, Node::new(NodeId(0), NodeKind::Text(Box::new(TextObject::point(Point::new(10.0, 50.0), &ch.to_string(), st)))));
|
||||
let mut o = PdfOptions::uncompressed();
|
||||
o.settings.advanced.outline_text = outline_text;
|
||||
import_with_report(&export(&d, &o).unwrap(), &ImportOptions::default()).unwrap().document
|
||||
};
|
||||
let fills = |d: &Document| -> Vec<Paint> { leaves(d).iter().map(|n| n.appearance.fill_paint()).collect() };
|
||||
let near =
|
||||
|p: &Paint, rgb: [f32; 3]| matches!(p, Paint::Solid { color, .. } if color.to_rgb().iter().zip(rgb).all(|(a, b)| (a - b).abs() < 0.02));
|
||||
for outline_text in [false, true] {
|
||||
let v0 = fills(&page(false, COLOUR_CHAR, outline_text));
|
||||
assert!(v0.iter().any(|p| near(p, [1.0, 0.0, 0.0])), "the red layer (outlined {outline_text}): {v0:?}");
|
||||
assert!(v0.iter().any(|p| near(p, [0.0, 0.0, 1.0])), "the foreground layer in the fill (outlined {outline_text}): {v0:?}");
|
||||
}
|
||||
let v1 = page(true, COLOUR_CHAR, true);
|
||||
assert!(!leaves(&v1).iter().any(|n| matches!(n.kind, NodeKind::Image(_))), "vector art");
|
||||
assert!(fills(&v1).iter().any(|p| matches!(p, Paint::Gradient(_))), "with its gradients");
|
||||
let sweep = page(true, COLR_SWEEP_CHAR, true);
|
||||
assert!(leaves(&sweep).iter().any(|n| matches!(n.kind, NodeKind::Image(_))), "a sweep glyph is an image");
|
||||
}
|
||||
@@ -1817,6 +1817,10 @@ impl Renderer {
|
||||
b.apply_affine(t.xf * *to_text);
|
||||
self.hairline(ctx, f, &b, [0, 0, 0, 255]);
|
||||
}
|
||||
// COLR glyphs: their layers' outlines.
|
||||
for (_, art) in &g.colours {
|
||||
self.draw_colour_glyph(ctx, f, art, t.xf);
|
||||
}
|
||||
self.draw_inlines(ctx, f, t, g);
|
||||
return;
|
||||
}
|
||||
@@ -1863,6 +1867,9 @@ impl Renderer {
|
||||
overprint(ctx, false);
|
||||
self.draw_glyph_image(ctx, f, image, t.xf * *to_text);
|
||||
}
|
||||
for (_, art) in g.colours.iter().filter(|(r, _)| *r == i) {
|
||||
self.draw_colour_glyph(ctx, f, art, t.xf);
|
||||
}
|
||||
let path = g.run(i);
|
||||
let path = path.as_ref();
|
||||
if path.elements().is_empty() {
|
||||
@@ -1919,6 +1926,15 @@ impl Renderer {
|
||||
}
|
||||
}
|
||||
|
||||
/// Draw COLR glyph `art` (its layers in text space) through `xf` (text space → document), as
|
||||
/// art: kept between frames as symbol art is ([`Self::placed_art`]).
|
||||
fn draw_colour_glyph(&mut self, ctx: &mut RenderContext, f: &Frame, art: &Arc<Node>, xf: Affine) {
|
||||
let (node, kept) = self.placed_art(art, xf, true, None);
|
||||
let outer = std::mem::replace(&mut self.made_again, !kept);
|
||||
self.draw_node(ctx, f, &node, true);
|
||||
self.made_again = outer;
|
||||
}
|
||||
|
||||
/// Draw colour bitmap glyph `image` through `xf` (its pixels → document space), its pixels
|
||||
/// decoded once and kept with the images' pixels.
|
||||
fn draw_glyph_image(&mut self, ctx: &mut RenderContext, f: &Frame, image: &vectorcraft_text::GlyphImage, xf: Affine) {
|
||||
@@ -2372,6 +2388,8 @@ struct TextGeom {
|
||||
inlines: Vec<vectorcraft_text::InlineGlyph>,
|
||||
/// Colour bitmap glyphs: (run, image, its pixels → text space), in text order.
|
||||
images: Vec<(usize, Arc<vectorcraft_text::GlyphImage>, Affine)>,
|
||||
/// COLR colour glyphs: (run, their layers placed in text space), in text order.
|
||||
colours: Vec<(usize, Arc<Node>)>,
|
||||
}
|
||||
|
||||
impl TextGeom {
|
||||
@@ -2421,6 +2439,7 @@ impl TextGeom {
|
||||
+ self.spans.len() * size_of::<(usize, usize, usize)>()
|
||||
+ self.inlines.len() * size_of::<vectorcraft_text::InlineGlyph>()
|
||||
+ self.images.len() * size_of::<(usize, Arc<vectorcraft_text::GlyphImage>, Affine)>()
|
||||
+ self.colours.iter().map(|(_, art)| lru::node_bytes(art)).sum::<usize>()
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2501,12 +2520,15 @@ fn text_geom_snapped(t: &TextObject, snap: Option<Affine>) -> TextGeom {
|
||||
.collect();
|
||||
let (mut substituted_fonts, mut substituted_glyphs, mut alternate_candidates) = (BezPath::new(), BezPath::new(), vec![]);
|
||||
let plain = t.plain_text();
|
||||
let mut images = vec![];
|
||||
let (mut images, mut colours) = (vec![], vec![]);
|
||||
for g in &layout.glyphs {
|
||||
push(&mut all, g.run, &g.outline);
|
||||
if let Some((image, xf)) = g.placed_image() {
|
||||
images.push((g.run, image.clone(), xf));
|
||||
}
|
||||
if let Some(art) = g.placed_colour(Affine::IDENTITY) {
|
||||
colours.push((g.run, Arc::new(art)));
|
||||
}
|
||||
let Some(&(missing, face)) = faces.get(g.run) else { continue };
|
||||
let Some(line) = layout.lines.get(g.line) else { continue };
|
||||
let mut cell = Rect::new(g.origin.x, g.origin.y - line.ascent, g.origin.x + g.advance, g.origin.y + line.descent).to_path(0.1);
|
||||
@@ -2546,6 +2568,7 @@ fn text_geom_snapped(t: &TextObject, snap: Option<Affine>) -> TextGeom {
|
||||
alternate_glyphs: std::sync::OnceLock::new(),
|
||||
inlines: layout.inlines,
|
||||
images,
|
||||
colours,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2619,6 +2642,8 @@ mod tests_clip;
|
||||
#[cfg(test)]
|
||||
mod tests_cmykblend;
|
||||
#[cfg(test)]
|
||||
mod tests_colrglyphs;
|
||||
#[cfg(test)]
|
||||
mod tests_container;
|
||||
#[cfg(test)]
|
||||
mod tests_dither;
|
||||
|
||||
@@ -0,0 +1,89 @@
|
||||
//! COLR colour glyphs: drawn as their layers (or, for paints documents have no form for, their
|
||||
//! image), which the type's fill doesn't paint, except in the layers in the foreground colour.
|
||||
|
||||
use vectorcraft_color::{Color, Paint};
|
||||
use vectorcraft_doc::text::{CharStyle, TextObject};
|
||||
use vectorcraft_doc::{Node, NodeKind};
|
||||
use vectorcraft_geom::Point;
|
||||
use vectorcraft_text::test_fonts::{COLOUR_CHAR, COLR_SWEEP_CHAR, colr_family, colr_font};
|
||||
|
||||
use super::*;
|
||||
|
||||
/// 100 pt `text` in the COLR test font (v1 or v0), filled magenta, its baseline at (20, 120)
|
||||
/// turned by `turn` about there, on a white 160×160 page.
|
||||
fn render(v1: bool, text: char, turn: f64, opts: RenderOptions) -> Rendered {
|
||||
let _adding = crate::tests_fontchange::adding_fonts();
|
||||
vectorcraft_text::FontDb::global().add_font(colr_font(v1).unwrap());
|
||||
let mut d = Document::new(160.0, 160.0);
|
||||
let st = CharStyle { font_family: colr_family(v1).into(), size: 100.0, fill: Paint::solid(Color::rgb(1.0, 0.0, 1.0)), ..Default::default() };
|
||||
let mut t = TextObject::point(Point::new(20.0, 120.0), &text.to_string(), st);
|
||||
t.xf = Affine::rotate_about(turn, (20.0, 120.0)) * t.xf;
|
||||
let n = Node::new(d.alloc_id(), NodeKind::Text(Box::new(t)));
|
||||
let l = d.layers[0].id;
|
||||
d.insert(Some(l), 0, n).unwrap();
|
||||
Renderer::new().render(&d, 160, 160, Affine::IDENTITY, &RenderOptions { background: Some([255, 255, 255, 255]), ..opts })
|
||||
}
|
||||
|
||||
/// The box of the pixels `like` says yes to.
|
||||
fn ink(img: &Rendered, like: impl Fn([u8; 4]) -> bool) -> Option<(u32, u32, u32, u32)> {
|
||||
let mut b: Option<(u32, u32, u32, u32)> = None;
|
||||
for y in 0..img.height {
|
||||
for x in 0..img.width {
|
||||
if like(img.pixel(x, y)) {
|
||||
b = Some(b.map_or((x, y, x, y), |(x0, y0, x1, y1)| (x0.min(x), y0.min(y), x1.max(x), y1.max(y))));
|
||||
}
|
||||
}
|
||||
}
|
||||
b
|
||||
}
|
||||
|
||||
fn magenta(p: [u8; 4]) -> bool {
|
||||
p[0] > 200 && p[2] > 200 && p[1] < 60
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn colr_layers_draw_their_colours_not_the_fill() {
|
||||
let img = render(true, COLOUR_CHAR, 0.0, RenderOptions::default());
|
||||
// The `O` with its linear gradient red → blue from x 0 to 500 units (20 to 70 pt).
|
||||
let reddish = ink(&img, |p| p[0] > 180 && p[2] < 90 && p[1] < 60).expect("red at the gradient's start");
|
||||
let bluish = ink(&img, |p| p[2] > 180 && p[0] < 90 && p[1] < 60).expect("blue at its end");
|
||||
assert!(reddish.0 < bluish.0, "red left of blue: {reddish:?} {bluish:?}");
|
||||
assert!(ink(&img, magenta).is_none(), "the fill doesn't paint the glyph");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_foreground_layer_takes_the_fill() {
|
||||
let img = render(false, COLOUR_CHAR, 0.0, RenderOptions::default());
|
||||
assert!(ink(&img, magenta).is_some(), "the `I` layer is in the foreground colour");
|
||||
assert!(ink(&img, |p| p == [255, 0, 0, 255]).is_some(), "the `O` layer in red");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn turned_type_turns_its_colour_layers() {
|
||||
let size = |turn| {
|
||||
let (x0, y0, x1, y1) = ink(&render(false, COLOUR_CHAR, turn, RenderOptions::default()), magenta).unwrap();
|
||||
(x1 - x0, y1 - y0)
|
||||
};
|
||||
let (w, h) = size(0.0);
|
||||
assert!(h > w * 3, "the `I` stands: {w}×{h}");
|
||||
let (w, h) = size(std::f64::consts::FRAC_PI_2);
|
||||
assert!(w > h * 3, "turned, it lies: {w}×{h}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn outline_mode_shows_the_layers_outlines() {
|
||||
let filled = render(false, COLOUR_CHAR, 0.0, RenderOptions::default());
|
||||
let outlined = render(false, COLOUR_CHAR, 0.0, RenderOptions { outline: true, ..Default::default() });
|
||||
let (x0, y0, x1, y1) = ink(&filled, |p| p == [255, 0, 0, 255]).unwrap();
|
||||
let dark = |p: [u8; 4]| p[0] < 128 && p[1] < 128 && p[2] < 128;
|
||||
assert!(ink(&outlined, |p| p == [255, 0, 0, 255]).is_none(), "no colours in outline mode");
|
||||
let (ox0, oy0, ox1, oy1) = ink(&outlined, dark).expect("the outlines show");
|
||||
assert!(ox0 <= x0 + 2 && oy0 <= y0 + 2 && ox1 + 2 >= x1 && oy1 + 2 >= y1, "around the layers: {:?} {:?}", (ox0, oy0, ox1, oy1), (x0, y0, x1, y1));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_sweep_glyph_draws_its_image() {
|
||||
let img = render(true, COLR_SWEEP_CHAR, 0.0, RenderOptions::default());
|
||||
assert!(ink(&img, |p| p[0] > 180 && p[1] < 60 && p[2] < 120).is_some(), "red where the sweep starts");
|
||||
assert!(ink(&img, magenta).is_none());
|
||||
}
|
||||
@@ -1910,6 +1910,10 @@ impl Writer<'_> {
|
||||
xml_escape(&href)
|
||||
));
|
||||
}
|
||||
// COLR glyphs: their layers, as art.
|
||||
for art in lay.glyphs.iter().filter_map(|g| g.placed_colour(Affine::IDENTITY)) {
|
||||
self.node(&art);
|
||||
}
|
||||
self.xf = saved;
|
||||
self.depth -= 1;
|
||||
self.line("</g>");
|
||||
@@ -2103,8 +2107,9 @@ impl Writer<'_> {
|
||||
let mut face: Option<Arc<FontFace>> = None;
|
||||
for g in &lay.glyphs {
|
||||
let Some(st) = t.runs.get(g.run).map(|r| &r.style) else { continue };
|
||||
// A colour bitmap font's subset would hold no bitmaps: its emoji are left to the viewer.
|
||||
if g.image.is_some() {
|
||||
// A colour font's subset would hold no bitmaps or COLR layers: its emoji are left to the
|
||||
// viewer.
|
||||
if g.image.is_some() || g.colour.is_some() {
|
||||
self.warn("colour emoji fonts are not embedded: viewers show emoji in their own fonts");
|
||||
continue;
|
||||
}
|
||||
|
||||
@@ -42,3 +42,43 @@ fn embedded_fonts_leave_bitmap_glyphs_to_the_viewer() {
|
||||
assert!(out.warnings.iter().any(|w| w.contains("emoji")), "{:?}", out.warnings);
|
||||
assert!(out.svg.contains(&format!("{COLOUR_CHAR}F")), "the character stays text");
|
||||
}
|
||||
|
||||
/// `ch` in the COLR test font (v1 or v0), 24 pt, filled blue.
|
||||
fn colr_doc(v1: bool, ch: char) -> Document {
|
||||
use vectorcraft_text::test_fonts::{colr_family, colr_font};
|
||||
vectorcraft_text::FontDb::global().add_font(colr_font(v1).unwrap());
|
||||
let mut d = Document::new(200.0, 100.0);
|
||||
let fill = vectorcraft_doc::color::Paint::solid(vectorcraft_doc::color::Color::rgb8(0, 0, 255));
|
||||
let st = CharStyle { font_family: colr_family(v1).into(), size: 24.0, fill, ..CharStyle::default() };
|
||||
let n = Node::new(d.alloc_id(), NodeKind::Text(Box::new(TextObject::point(Point::new(10.0, 50.0), &ch.to_string(), st))));
|
||||
let l = d.layers[0].id;
|
||||
d.insert(Some(l), 0, n).unwrap();
|
||||
d
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn outlined_text_writes_colr_glyphs_as_vector_art() {
|
||||
let svg = export_full(&colr_doc(true, COLOUR_CHAR), &ExportOptions { outline_text: true, ..Default::default() }, None).svg;
|
||||
assert!(!svg.contains("<image "), "{svg}");
|
||||
assert!(svg.contains("<linearGradient") && svg.contains("<radialGradient"), "{svg}");
|
||||
assert!(svg.contains("<clipPath"), "the clip box: {svg}");
|
||||
assert!(svg.contains("mix-blend-mode:multiply") || svg.contains("mix-blend-mode: multiply"), "{svg}");
|
||||
let v0 = export_full(&colr_doc(false, COLOUR_CHAR), &ExportOptions { outline_text: true, ..Default::default() }, None).svg;
|
||||
assert!(v0.contains("#f00") || v0.contains("#ff0000"), "the red layer: {v0}");
|
||||
assert!(v0.contains("#00f") || v0.contains("#0000ff"), "the foreground layer in the fill: {v0}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn outlined_text_writes_a_sweep_glyph_as_its_image() {
|
||||
use vectorcraft_text::test_fonts::COLR_SWEEP_CHAR;
|
||||
let svg = export_full(&colr_doc(true, COLR_SWEEP_CHAR), &ExportOptions { outline_text: true, ..Default::default() }, None).svg;
|
||||
assert_eq!(svg.matches("<image ").count(), 1, "{svg}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn embedded_fonts_leave_colr_glyphs_to_the_viewer() {
|
||||
let out = export_full(&colr_doc(false, COLOUR_CHAR), &ExportOptions { embed_fonts: true, ..Default::default() }, None);
|
||||
assert!(!out.svg.contains("base64,"), "no subset without its colour layers: {}", out.svg);
|
||||
assert!(out.warnings.iter().any(|w| w.contains("emoji")), "{:?}", out.warnings);
|
||||
assert!(out.svg.contains(COLOUR_CHAR), "the character stays text");
|
||||
}
|
||||
@@ -28,6 +28,9 @@ icu_segmenter = "2.3"
|
||||
# Grapheme clusters (a Thai consonant with its vowel and tone marks, an accented letter, an emoji
|
||||
# sequence) for caret movement; MIT OR Apache-2.0, already in the build.
|
||||
unicode-segmentation = "1.13"
|
||||
# Draws COLR colour glyphs whose paints documents have no form for (sweep gradients, compositing
|
||||
# modes) into images: the canvas's renderer, already in the build.
|
||||
vello_cpu = { workspace = true }
|
||||
# Builds a small variable font for tests (`test_fonts`; no font file is committed). MIT OR
|
||||
# Apache-2.0, already in the build through subsetter.
|
||||
write-fonts = { version = "0.48", optional = true }
|
||||
|
||||
@@ -0,0 +1,581 @@
|
||||
//! COLR colour glyphs (v0 layers, v1 paint graphs): read into a tree of document nodes in font
|
||||
//! units (y down, as outlines are), which the renderer, the exporters and Create Outlines draw and
|
||||
//! keep as they do any art. A glyph whose paints VectorCraft has no form for is drawn into an image
|
||||
//! instead, as bitmap glyphs are ([`GlyphImage`]); [`Tree::unsupported`] names what made it one.
|
||||
|
||||
use std::sync::Arc;
|
||||
|
||||
use kurbo::{Affine, BezPath, Point, Rect, Shape, Vec2};
|
||||
use skrifa::color::{Brush, ColorGlyph, ColorGlyphCollection, ColorPainter, ColorPalettes, ColorStop, CompositeMode, Extend, Transform};
|
||||
use skrifa::instance::{LocationRef, Size};
|
||||
use skrifa::outline::DrawSettings;
|
||||
use skrifa::raw::TableProvider;
|
||||
use skrifa::raw::types::BoundingBox;
|
||||
use skrifa::{GlyphId, MetadataProvider};
|
||||
use vectorcraft_doc::color::{BlendMode, Color, Gradient, GradientGeom, GradientKind, GradientPaint, GradientStop, Paint};
|
||||
use vectorcraft_doc::{Appearance, FillLayer, ImageBlob, Node, NodeId, NodeKind};
|
||||
use vectorcraft_geom::PathData;
|
||||
use vello_cpu::peniko;
|
||||
|
||||
use crate::GlyphImage;
|
||||
use crate::fontdb::FlipPen;
|
||||
|
||||
/// The most nodes a colour glyph's tree may have: past it, a font's glyph draws its outline.
|
||||
const MAX_COLR_NODES: usize = 4096;
|
||||
/// The deepest the groups of a colour glyph may nest.
|
||||
const MAX_COLR_DEPTH: usize = 64;
|
||||
/// The pixels per em an image of a colour glyph is drawn at.
|
||||
const FALLBACK_PPEM: f64 = 256.0;
|
||||
/// The largest side of such an image, in pixels.
|
||||
const MAX_FALLBACK_SIDE: f64 = 1024.0;
|
||||
/// The id of the layers' nodes: none, as the art exporters make on the fly has (Create Outlines
|
||||
/// gives them ids of the document's).
|
||||
const NO_ID: NodeId = NodeId(u64::MAX);
|
||||
/// Font units y up → y down.
|
||||
const FLIP: Affine = Affine::new([1.0, 0.0, 0.0, -1.0, 0.0, 0.0]);
|
||||
|
||||
/// A colour glyph as VectorCraft draws it.
|
||||
#[derive(Clone)]
|
||||
pub(crate) enum ColourContent {
|
||||
/// Its layers as document nodes in font units (y down): a group.
|
||||
Art(Arc<Node>),
|
||||
/// Its picture, for paints VectorCraft has no form for.
|
||||
Image(Arc<GlyphImage>),
|
||||
}
|
||||
|
||||
/// Does `font` have COLR colour glyphs?
|
||||
pub(crate) fn has_colour_layers(font: &skrifa::FontRef<'_>) -> bool {
|
||||
font.colr().is_ok()
|
||||
}
|
||||
|
||||
/// Glyph `gid`'s colour content in `font` at `location`, palette 0's colours and `foreground` for
|
||||
/// palette index 0xFFFF, and whether it used `foreground`; `None` when it isn't a colour glyph, or
|
||||
/// its graph doesn't read (a cycle, too deep, too many layers).
|
||||
pub(crate) fn colour_glyph(
|
||||
font: &skrifa::FontRef<'_>,
|
||||
location: LocationRef<'_>,
|
||||
upem: f64,
|
||||
gid: u32,
|
||||
foreground: Color,
|
||||
) -> (Option<ColourContent>, bool) {
|
||||
let Some(glyph) = ColorGlyphCollection::new(font).get(GlyphId::new(gid)) else { return (None, false) };
|
||||
let mut tree = Tree::new(font, location, foreground);
|
||||
if glyph.paint(location, &mut tree).is_err() {
|
||||
return (None, false);
|
||||
}
|
||||
let used = tree.foreground_used;
|
||||
if tree.unsupported.is_some() {
|
||||
// What it paints, y up, for a glyph without a clip box.
|
||||
let painted = tree.painted.map(|b| FLIP.transform_rect_bbox(b));
|
||||
return (raster(&glyph, font, location, upem, foreground, painted).map(|i| ColourContent::Image(Arc::new(i))), used);
|
||||
}
|
||||
(tree.finish().map(ColourContent::Art), used)
|
||||
}
|
||||
|
||||
/// Palette 0's colours with their alpha.
|
||||
fn palette(font: &skrifa::FontRef<'_>) -> Vec<(Color, f32)> {
|
||||
let palettes = ColorPalettes::new(font);
|
||||
let Some(palette) = palettes.get(0) else { return vec![] };
|
||||
palette.colors().iter().map(|c| (Color::rgb8(c.red, c.green, c.blue), f32::from(c.alpha) / 255.0)).collect()
|
||||
}
|
||||
|
||||
/// The colour and alpha of palette entry `index` (0xFFFF: `foreground`), times `alpha`; `None`
|
||||
/// for an entry the palette doesn't have.
|
||||
fn colour(palette: &[(Color, f32)], foreground: Color, index: u16, alpha: f32) -> Option<(Color, f32)> {
|
||||
let (c, a) = if index == 0xFFFF { (foreground, 1.0) } else { *palette.get(usize::from(index))? };
|
||||
Some((c, (a * alpha).clamp(0.0, 1.0)))
|
||||
}
|
||||
|
||||
fn affine(t: &Transform) -> Affine {
|
||||
Affine::new([t.xx, t.yx, t.xy, t.yy, t.dx, t.dy].map(f64::from))
|
||||
}
|
||||
|
||||
fn point(p: skrifa::raw::types::Point<f32>) -> Point {
|
||||
Point::new(f64::from(p.x), f64::from(p.y))
|
||||
}
|
||||
|
||||
fn box_path(b: &BoundingBox<f32>) -> BezPath {
|
||||
Rect::new(f64::from(b.x_min), f64::from(b.y_min), f64::from(b.x_max), f64::from(b.y_max)).to_path(0.1)
|
||||
}
|
||||
|
||||
/// Glyph `gid`'s outline in font units, y up (the font database's pen draws y down, as text
|
||||
/// space has it).
|
||||
fn outline(font: &skrifa::FontRef<'_>, location: LocationRef<'_>, gid: GlyphId) -> BezPath {
|
||||
let mut pen = FlipPen(BezPath::new());
|
||||
if let Some(g) = font.outline_glyphs().get(gid) {
|
||||
let _ = g.draw(DrawSettings::unhinted(Size::unscaled(), location), &mut pen);
|
||||
}
|
||||
let mut path = pen.0;
|
||||
path.apply_affine(FLIP);
|
||||
path
|
||||
}
|
||||
|
||||
/// A group being built: its clipping path, or the blend mode of a composite's layer.
|
||||
struct Open {
|
||||
clip: Option<BezPath>,
|
||||
blend: Option<BlendMode>,
|
||||
children: Vec<Arc<Node>>,
|
||||
/// A fill filled the clip's whole area: alone, it is the clip filled.
|
||||
flooded: bool,
|
||||
}
|
||||
|
||||
/// A [`ColorPainter`] building a colour glyph's tree.
|
||||
struct Tree<'a> {
|
||||
font: &'a skrifa::FontRef<'a>,
|
||||
location: LocationRef<'a>,
|
||||
palette: Vec<(Color, f32)>,
|
||||
foreground: Color,
|
||||
/// Font units y up → the tree's space (y down), with the paint graph's transforms.
|
||||
transforms: Vec<Affine>,
|
||||
groups: Vec<Open>,
|
||||
nodes: usize,
|
||||
/// What VectorCraft has no form for, the first one met: the glyph becomes an image.
|
||||
unsupported: Option<&'static str>,
|
||||
/// The graph is past [`MAX_COLR_NODES`] or [`MAX_COLR_DEPTH`].
|
||||
too_large: bool,
|
||||
/// The box of what it paints, in the tree's space.
|
||||
painted: Option<Rect>,
|
||||
/// It paints with the foreground colour (palette index 0xFFFF).
|
||||
foreground_used: bool,
|
||||
}
|
||||
|
||||
impl<'a> Tree<'a> {
|
||||
fn new(font: &'a skrifa::FontRef<'a>, location: LocationRef<'a>, foreground: Color) -> Self {
|
||||
let root = Open { clip: None, blend: Some(BlendMode::Normal), children: vec![], flooded: false };
|
||||
Tree {
|
||||
font,
|
||||
location,
|
||||
palette: palette(font),
|
||||
foreground,
|
||||
transforms: vec![FLIP],
|
||||
groups: vec![root],
|
||||
nodes: 0,
|
||||
unsupported: None,
|
||||
too_large: false,
|
||||
painted: None,
|
||||
foreground_used: false,
|
||||
}
|
||||
}
|
||||
|
||||
fn transform(&self) -> Affine {
|
||||
self.transforms.last().copied().unwrap_or(FLIP)
|
||||
}
|
||||
|
||||
fn add(&mut self, node: Node) {
|
||||
self.nodes += 1;
|
||||
self.too_large |= self.nodes > MAX_COLR_NODES;
|
||||
if let Some(g) = self.groups.last_mut().filter(|_| !self.too_large) {
|
||||
g.children.push(Arc::new(node));
|
||||
}
|
||||
}
|
||||
|
||||
fn open(&mut self, group: Open) {
|
||||
self.too_large |= self.groups.len() >= MAX_COLR_DEPTH;
|
||||
self.groups.push(group);
|
||||
}
|
||||
|
||||
/// Closes the innermost group into its parent: a clip with only the fill it clips is that
|
||||
/// filled path; an empty group goes.
|
||||
fn close(&mut self) {
|
||||
// The root stays open until `finish`.
|
||||
if self.groups.len() < 2 {
|
||||
return;
|
||||
}
|
||||
let Some(g) = self.groups.pop() else { return };
|
||||
if g.children.is_empty() {
|
||||
return;
|
||||
}
|
||||
let mut children = g.children;
|
||||
if let Some(clip) = g.clip {
|
||||
if let ([only], true) = (children.as_slice(), g.flooded) {
|
||||
let only = only.clone();
|
||||
return self.add_arc(only);
|
||||
}
|
||||
let mut path = Node::path(NO_ID, PathData::from_bezpath(&clip), Appearance::default());
|
||||
if let NodeKind::Path { clipping, .. } = &mut path.kind {
|
||||
*clipping = true;
|
||||
}
|
||||
children.insert(0, Arc::new(path));
|
||||
let mut group = Node::group(NO_ID, children);
|
||||
if let NodeKind::Group { clip, .. } = &mut group.kind {
|
||||
*clip = true;
|
||||
}
|
||||
return self.add(group);
|
||||
}
|
||||
let mut group = Node::group(NO_ID, children);
|
||||
group.isolate = true;
|
||||
group.blend = g.blend.unwrap_or(BlendMode::Normal);
|
||||
self.add(group);
|
||||
}
|
||||
|
||||
fn add_arc(&mut self, node: Arc<Node>) {
|
||||
if let Some(g) = self.groups.last_mut() {
|
||||
g.children.push(node);
|
||||
}
|
||||
}
|
||||
|
||||
/// The tree: the glyph as a group. It needs no isolation of its own: blend modes only come
|
||||
/// with composites, whose groups are isolated, so they never reach the art behind the type.
|
||||
fn finish(mut self) -> Option<Arc<Node>> {
|
||||
if self.too_large {
|
||||
return None;
|
||||
}
|
||||
while self.groups.len() > 1 {
|
||||
self.close();
|
||||
}
|
||||
let root = self.groups.pop()?;
|
||||
if root.children.is_empty() {
|
||||
return None;
|
||||
}
|
||||
Some(Arc::new(Node::group(NO_ID, root.children)))
|
||||
}
|
||||
|
||||
/// `brush` as a VectorCraft paint and opacity, in the tree's space; `None` with
|
||||
/// [`Self::unsupported`] set when it has no form there.
|
||||
fn paint(&mut self, brush: &Brush<'_>) -> Option<(Paint, f32)> {
|
||||
self.foreground_used |= match brush {
|
||||
Brush::Solid { palette_index, .. } => *palette_index == 0xFFFF,
|
||||
Brush::LinearGradient { color_stops, .. } | Brush::RadialGradient { color_stops, .. } | Brush::SweepGradient { color_stops, .. } => {
|
||||
color_stops.iter().any(|s| s.palette_index == 0xFFFF)
|
||||
}
|
||||
};
|
||||
let xf = self.transform();
|
||||
let stops = |stops: &[ColorStop], tree: &Self| -> Vec<GradientStop> {
|
||||
stops
|
||||
.iter()
|
||||
.filter_map(|s| {
|
||||
let (color, opacity) = colour(&tree.palette, tree.foreground, s.palette_index, s.alpha)?;
|
||||
Some(GradientStop { opacity, ..GradientStop::new(s.offset, color) })
|
||||
})
|
||||
.collect()
|
||||
};
|
||||
let gradient = |kind, stops: Vec<GradientStop>, geom| {
|
||||
let mut paint = GradientPaint::new(Gradient { kind, stops, ..Gradient::default() });
|
||||
paint.geom = Some(geom);
|
||||
Paint::Gradient(Box::new(paint))
|
||||
};
|
||||
match brush {
|
||||
Brush::Solid { palette_index, alpha } => {
|
||||
let (c, a) = colour(&self.palette, self.foreground, *palette_index, *alpha)?;
|
||||
Some((Paint::solid(c), a))
|
||||
}
|
||||
Brush::LinearGradient { p0, p1, color_stops, extend } => {
|
||||
if *extend != Extend::Pad {
|
||||
self.unsupported.get_or_insert("a repeating or reflecting gradient");
|
||||
return None;
|
||||
}
|
||||
let (p0, p1) = (point(*p0), point(*p1));
|
||||
let (stops, first, last) = normalized(stops(color_stops, self))?;
|
||||
// Stops past 0 and 1 move the ends instead.
|
||||
let mut geom = GradientGeom { start: p0.lerp(p1, f64::from(first)), end: p0.lerp(p1, f64::from(last)), aspect: 1.0, focal: None };
|
||||
geom.transform(xf, GradientKind::Linear);
|
||||
Some((gradient(GradientKind::Linear, stops, geom), 1.0))
|
||||
}
|
||||
Brush::RadialGradient { c0, r0, c1, r1, color_stops, extend } => {
|
||||
if *extend != Extend::Pad {
|
||||
self.unsupported.get_or_insert("a repeating or reflecting gradient");
|
||||
return None;
|
||||
}
|
||||
let (c0, c1, r0, r1) = (point(*c0), point(*c1), f64::from(*r0), f64::from(*r1));
|
||||
let concentric = (c0 - c1).hypot() < 1e-6;
|
||||
if (r0 > 1e-6 && !concentric) || r1 <= r0 || (c0 - c1).hypot() >= r1 {
|
||||
self.unsupported.get_or_insert("a radial gradient from a circle");
|
||||
return None;
|
||||
}
|
||||
let mut stops = stops(color_stops, self);
|
||||
if stops.iter().any(|s| !(0.0..=1.0).contains(&s.offset)) {
|
||||
self.unsupported.get_or_insert("a radial gradient with stops past its circles");
|
||||
return None;
|
||||
}
|
||||
// A start circle around the centre starts the stops further out.
|
||||
for s in &mut stops {
|
||||
s.offset = ((r0 + f64::from(s.offset) * (r1 - r0)) / r1) as f32;
|
||||
}
|
||||
let mut geom = GradientGeom { start: c1, end: c1 + Vec2::new(r1, 0.0), aspect: 1.0, focal: (!concentric).then_some(c0) };
|
||||
geom.transform(xf, GradientKind::Radial);
|
||||
Some((gradient(GradientKind::Radial, stops, geom), 1.0))
|
||||
}
|
||||
Brush::SweepGradient { .. } => {
|
||||
self.unsupported.get_or_insert("a sweep gradient");
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// `path` (in the tree's space) filled with `brush` (in the current transform's).
|
||||
fn fill_path(&mut self, path: &BezPath, brush: &Brush<'_>) {
|
||||
let b = path.bounding_box();
|
||||
self.painted = Some(self.painted.map_or(b, |p| p.union(b)));
|
||||
let Some((paint, opacity)) = self.paint(brush) else { return };
|
||||
let fill = vectorcraft_doc::AppearanceItem::Fill(FillLayer { opacity, ..FillLayer::new(paint) });
|
||||
self.add(Node::path(NO_ID, PathData::from_bezpath(path), Appearance { items: vec![fill], ..Appearance::default() }));
|
||||
}
|
||||
}
|
||||
|
||||
/// `stops` sorted, from 0 to 1 (as the gradient's ends then move), and where the first and last
|
||||
/// were; `None` without stops.
|
||||
fn normalized(mut stops: Vec<GradientStop>) -> Option<(Vec<GradientStop>, f32, f32)> {
|
||||
stops.sort_by(|a, b| a.offset.total_cmp(&b.offset));
|
||||
let (first, last) = (stops.first()?.offset, stops.last()?.offset);
|
||||
let span = last - first;
|
||||
for s in &mut stops {
|
||||
s.offset = if span > 0.0 { (s.offset - first) / span } else { 0.0 };
|
||||
}
|
||||
Some((stops, first, if span > 0.0 { last } else { first + 1.0 }))
|
||||
}
|
||||
|
||||
impl ColorPainter for Tree<'_> {
|
||||
fn push_transform(&mut self, transform: Transform) {
|
||||
let t = self.transform() * affine(&transform);
|
||||
self.transforms.push(t);
|
||||
}
|
||||
|
||||
fn pop_transform(&mut self) {
|
||||
if self.transforms.len() > 1 {
|
||||
self.transforms.pop();
|
||||
}
|
||||
}
|
||||
|
||||
fn push_clip_glyph(&mut self, glyph_id: GlyphId) {
|
||||
let mut clip = outline(self.font, self.location, glyph_id);
|
||||
clip.apply_affine(self.transform());
|
||||
self.open(Open { clip: Some(clip), blend: None, children: vec![], flooded: false });
|
||||
}
|
||||
|
||||
fn push_clip_box(&mut self, clip_box: BoundingBox<f32>) {
|
||||
let mut clip = box_path(&clip_box);
|
||||
clip.apply_affine(self.transform());
|
||||
self.open(Open { clip: Some(clip), blend: None, children: vec![], flooded: false });
|
||||
}
|
||||
|
||||
fn pop_clip(&mut self) {
|
||||
self.close();
|
||||
}
|
||||
|
||||
/// A fill fills the innermost clip's shape (a layer between them stays around it).
|
||||
fn fill(&mut self, brush: Brush<'_>) {
|
||||
let Some(at) = self.groups.iter().rposition(|g| g.clip.is_some()) else {
|
||||
self.unsupported.get_or_insert("a fill outside any glyph");
|
||||
return;
|
||||
};
|
||||
let Some(clip) = self.groups.get(at).and_then(|g| g.clip.clone()) else { return };
|
||||
if at + 1 == self.groups.len()
|
||||
&& let Some(g) = self.groups.last_mut()
|
||||
{
|
||||
g.flooded = g.children.is_empty();
|
||||
}
|
||||
self.fill_path(&clip, &brush);
|
||||
}
|
||||
|
||||
/// The glyph's outline filled, the brush moved by `brush_transform` (the glyph stays).
|
||||
fn fill_glyph(&mut self, glyph_id: GlyphId, brush_transform: Option<Transform>, brush: Brush<'_>) {
|
||||
let mut path = outline(self.font, self.location, glyph_id);
|
||||
path.apply_affine(self.transform());
|
||||
let brush_xf = self.transform() * brush_transform.as_ref().map_or(Affine::IDENTITY, affine);
|
||||
self.transforms.push(brush_xf);
|
||||
self.fill_path(&path, &brush);
|
||||
self.transforms.pop();
|
||||
}
|
||||
|
||||
fn push_layer(&mut self, mode: CompositeMode) {
|
||||
let blend = blend_mode(mode);
|
||||
if blend.is_none() {
|
||||
self.unsupported.get_or_insert("a compositing mode other than blending");
|
||||
}
|
||||
self.open(Open { clip: None, blend, children: vec![], flooded: false });
|
||||
}
|
||||
|
||||
fn pop_layer(&mut self) {
|
||||
self.close();
|
||||
}
|
||||
}
|
||||
|
||||
/// COLRv1's blend composite modes as VectorCraft's (`SrcOver` is Normal); `None` for the
|
||||
/// Porter-Duff modes, which it has no form for.
|
||||
fn blend_mode(mode: CompositeMode) -> Option<BlendMode> {
|
||||
Some(match mode {
|
||||
CompositeMode::SrcOver => BlendMode::Normal,
|
||||
CompositeMode::Screen => BlendMode::Screen,
|
||||
CompositeMode::Overlay => BlendMode::Overlay,
|
||||
CompositeMode::Darken => BlendMode::Darken,
|
||||
CompositeMode::Lighten => BlendMode::Lighten,
|
||||
CompositeMode::ColorDodge => BlendMode::ColorDodge,
|
||||
CompositeMode::ColorBurn => BlendMode::ColorBurn,
|
||||
CompositeMode::HardLight => BlendMode::HardLight,
|
||||
CompositeMode::SoftLight => BlendMode::SoftLight,
|
||||
CompositeMode::Difference => BlendMode::Difference,
|
||||
CompositeMode::Exclusion => BlendMode::Exclusion,
|
||||
CompositeMode::Multiply => BlendMode::Multiply,
|
||||
CompositeMode::HslHue => BlendMode::Hue,
|
||||
CompositeMode::HslSaturation => BlendMode::Saturation,
|
||||
CompositeMode::HslColor => BlendMode::Color,
|
||||
CompositeMode::HslLuminosity => BlendMode::Luminosity,
|
||||
_ => return None,
|
||||
})
|
||||
}
|
||||
|
||||
/// Colour glyph `glyph` drawn into an image at [`FALLBACK_PPEM`], placed in font units (y down)
|
||||
/// as bitmap glyphs are, in its clip box or else the box of what it `painted` (y up); `None` when
|
||||
/// it paints nothing or doesn't draw.
|
||||
fn raster(
|
||||
glyph: &ColorGlyph<'_>,
|
||||
font: &skrifa::FontRef<'_>,
|
||||
location: LocationRef<'_>,
|
||||
upem: f64,
|
||||
foreground: Color,
|
||||
painted: Option<Rect>,
|
||||
) -> Option<GlyphImage> {
|
||||
let b = glyph.bounding_box(location, Size::unscaled()).map(|b| Rect::new(b.x_min.into(), b.y_min.into(), b.x_max.into(), b.y_max.into()));
|
||||
// Without a clip box, the box of what it paints (`painted`, y up).
|
||||
let b = b.or(painted).filter(|b| b.area() > 0.0)?;
|
||||
let s = (FALLBACK_PPEM / upem.max(1.0)).min(MAX_FALLBACK_SIDE / b.width().max(b.height()));
|
||||
if !(s.is_finite() && s > 0.0) {
|
||||
return None;
|
||||
}
|
||||
let (w, h) = ((b.width() * s).ceil() as u16, (b.height() * s).ceil() as u16);
|
||||
if w == 0 || h == 0 {
|
||||
return None;
|
||||
}
|
||||
// Font units y up → pixels.
|
||||
let to_pixels = Affine::new([s, 0.0, 0.0, -s, -b.x0 * s, b.y1 * s]);
|
||||
let mut ctx = vello_cpu::RenderContext::new(w, h);
|
||||
let mut painter = Pixels { ctx: &mut ctx, font, location, palette: palette(font), foreground, transforms: vec![to_pixels], width: w, height: h };
|
||||
glyph.paint(location, &mut painter).ok()?;
|
||||
ctx.flush();
|
||||
let mut pm = vello_cpu::Pixmap::new(w, h);
|
||||
ctx.render(&mut pm, &mut vello_cpu::Resources::new());
|
||||
let png = pm.into_png().ok()?;
|
||||
let xf = Affine::new([1.0 / s, 0.0, 0.0, 1.0 / s, b.x0, -b.y1]);
|
||||
Some(GlyphImage { blob: ImageBlob::png(png), width: u32::from(w), height: u32::from(h), xf })
|
||||
}
|
||||
|
||||
/// A [`ColorPainter`] drawing a colour glyph with vello_cpu.
|
||||
struct Pixels<'a, 'c> {
|
||||
ctx: &'c mut vello_cpu::RenderContext,
|
||||
font: &'a skrifa::FontRef<'a>,
|
||||
location: LocationRef<'a>,
|
||||
palette: Vec<(Color, f32)>,
|
||||
foreground: Color,
|
||||
transforms: Vec<Affine>,
|
||||
width: u16,
|
||||
height: u16,
|
||||
}
|
||||
|
||||
impl Pixels<'_, '_> {
|
||||
fn transform(&self) -> Affine {
|
||||
self.transforms.last().copied().unwrap_or_default()
|
||||
}
|
||||
|
||||
fn peniko_colour(&self, index: u16, alpha: f32) -> peniko::Color {
|
||||
let (c, a) = colour(&self.palette, self.foreground, index, alpha).unwrap_or((Color::BLACK, 0.0));
|
||||
let [r, g, b, a] = c.to_rgba8(a);
|
||||
peniko::Color::from_rgba8(r, g, b, a)
|
||||
}
|
||||
|
||||
fn clip(&mut self, path: &BezPath) {
|
||||
self.ctx.set_transform(self.transform());
|
||||
self.ctx.push_clip_layer(path);
|
||||
}
|
||||
}
|
||||
|
||||
impl ColorPainter for Pixels<'_, '_> {
|
||||
fn push_transform(&mut self, transform: Transform) {
|
||||
let t = self.transform() * affine(&transform);
|
||||
self.transforms.push(t);
|
||||
}
|
||||
|
||||
fn pop_transform(&mut self) {
|
||||
if self.transforms.len() > 1 {
|
||||
self.transforms.pop();
|
||||
}
|
||||
}
|
||||
|
||||
fn push_clip_glyph(&mut self, glyph_id: GlyphId) {
|
||||
let path = outline(self.font, self.location, glyph_id);
|
||||
self.clip(&path);
|
||||
}
|
||||
|
||||
fn push_clip_box(&mut self, clip_box: BoundingBox<f32>) {
|
||||
self.clip(&box_path(&clip_box));
|
||||
}
|
||||
|
||||
fn pop_clip(&mut self) {
|
||||
self.ctx.pop_layer();
|
||||
}
|
||||
|
||||
fn fill(&mut self, brush: Brush<'_>) {
|
||||
let stops = |stops: &[ColorStop]| -> Vec<peniko::ColorStop> {
|
||||
stops.iter().map(|s| peniko::ColorStop::from((s.offset, self.peniko_colour(s.palette_index, s.alpha)))).collect()
|
||||
};
|
||||
let extend = |e: Extend| match e {
|
||||
Extend::Repeat => peniko::Extend::Repeat,
|
||||
Extend::Reflect => peniko::Extend::Reflect,
|
||||
_ => peniko::Extend::Pad,
|
||||
};
|
||||
let paint: peniko::Brush = match brush {
|
||||
Brush::Solid { palette_index, alpha } => peniko::Brush::Solid(self.peniko_colour(palette_index, alpha)),
|
||||
Brush::LinearGradient { p0, p1, color_stops, extend: e } => {
|
||||
peniko::Gradient::new_linear(point(p0), point(p1)).with_stops(stops(color_stops).as_slice()).with_extend(extend(e)).into()
|
||||
}
|
||||
Brush::RadialGradient { c0, r0, c1, r1, color_stops, extend: e } => peniko::Gradient::new_two_point_radial(point(c0), r0, point(c1), r1)
|
||||
.with_stops(stops(color_stops).as_slice())
|
||||
.with_extend(extend(e))
|
||||
.into(),
|
||||
Brush::SweepGradient { c0, start_angle, end_angle, color_stops, extend: e } => {
|
||||
peniko::Gradient::new_sweep(point(c0), start_angle.to_radians(), end_angle.to_radians())
|
||||
.with_stops(stops(color_stops).as_slice())
|
||||
.with_extend(extend(e))
|
||||
.into()
|
||||
}
|
||||
};
|
||||
// Everything the image shows, in the paint's space.
|
||||
let xf = self.transform();
|
||||
let all = xf.inverse().transform_rect_bbox(Rect::new(0.0, 0.0, f64::from(self.width), f64::from(self.height)));
|
||||
self.ctx.set_transform(xf);
|
||||
match paint {
|
||||
peniko::Brush::Solid(c) => self.ctx.set_paint(c),
|
||||
peniko::Brush::Gradient(g) => self.ctx.set_paint(g),
|
||||
peniko::Brush::Image(_) => return,
|
||||
}
|
||||
self.ctx.fill_rect(&all);
|
||||
}
|
||||
|
||||
fn push_layer(&mut self, mode: CompositeMode) {
|
||||
use peniko::{BlendMode as Mode, Compose, Mix};
|
||||
let (mix, compose) = match mode {
|
||||
CompositeMode::Clear => (Mix::Normal, Compose::Clear),
|
||||
CompositeMode::Src => (Mix::Normal, Compose::Copy),
|
||||
CompositeMode::Dest => (Mix::Normal, Compose::Dest),
|
||||
CompositeMode::DestOver => (Mix::Normal, Compose::DestOver),
|
||||
CompositeMode::SrcIn => (Mix::Normal, Compose::SrcIn),
|
||||
CompositeMode::DestIn => (Mix::Normal, Compose::DestIn),
|
||||
CompositeMode::SrcOut => (Mix::Normal, Compose::SrcOut),
|
||||
CompositeMode::DestOut => (Mix::Normal, Compose::DestOut),
|
||||
CompositeMode::SrcAtop => (Mix::Normal, Compose::SrcAtop),
|
||||
CompositeMode::DestAtop => (Mix::Normal, Compose::DestAtop),
|
||||
CompositeMode::Xor => (Mix::Normal, Compose::Xor),
|
||||
CompositeMode::Plus => (Mix::Normal, Compose::Plus),
|
||||
CompositeMode::Screen => (Mix::Screen, Compose::SrcOver),
|
||||
CompositeMode::Overlay => (Mix::Overlay, Compose::SrcOver),
|
||||
CompositeMode::Darken => (Mix::Darken, Compose::SrcOver),
|
||||
CompositeMode::Lighten => (Mix::Lighten, Compose::SrcOver),
|
||||
CompositeMode::ColorDodge => (Mix::ColorDodge, Compose::SrcOver),
|
||||
CompositeMode::ColorBurn => (Mix::ColorBurn, Compose::SrcOver),
|
||||
CompositeMode::HardLight => (Mix::HardLight, Compose::SrcOver),
|
||||
CompositeMode::SoftLight => (Mix::SoftLight, Compose::SrcOver),
|
||||
CompositeMode::Difference => (Mix::Difference, Compose::SrcOver),
|
||||
CompositeMode::Exclusion => (Mix::Exclusion, Compose::SrcOver),
|
||||
CompositeMode::Multiply => (Mix::Multiply, Compose::SrcOver),
|
||||
CompositeMode::HslHue => (Mix::Hue, Compose::SrcOver),
|
||||
CompositeMode::HslSaturation => (Mix::Saturation, Compose::SrcOver),
|
||||
CompositeMode::HslColor => (Mix::Color, Compose::SrcOver),
|
||||
CompositeMode::HslLuminosity => (Mix::Luminosity, Compose::SrcOver),
|
||||
_ => (Mix::Normal, Compose::SrcOver),
|
||||
};
|
||||
self.ctx.push_layer(None, Some(Mode::new(mix, compose)), None, None, None);
|
||||
}
|
||||
|
||||
fn pop_layer(&mut self) {
|
||||
self.ctx.pop_layer();
|
||||
}
|
||||
}
|
||||
+84
-19
@@ -14,6 +14,8 @@ use skrifa::string::StringId;
|
||||
use skrifa::{GlyphId, MetadataProvider, Tag};
|
||||
|
||||
use crate::GlyphImage;
|
||||
use crate::colr::ColourContent;
|
||||
use vectorcraft_doc::color::Color;
|
||||
|
||||
/// The family used when a requested family is unknown (Illustrator's Myriad Pro analogue).
|
||||
pub const FALLBACK_FAMILY: &str = "Source Sans 3";
|
||||
@@ -136,6 +138,8 @@ pub struct FontFace {
|
||||
icf_margins: std::sync::OnceLock<IcfMargins>,
|
||||
/// Has `sbix` or `CBDT` strikes: colour bitmap glyphs ([`FontDb::glyph_image`]).
|
||||
colour_bitmaps: bool,
|
||||
/// Has `COLR` colour glyphs ([`FontDb::glyph_colour`]).
|
||||
colour_layers: bool,
|
||||
}
|
||||
|
||||
/// Where the ideographic character face (ICF) lies inside the ideographic em box: its distance
|
||||
@@ -414,28 +418,65 @@ type PostScriptNames = HashMap<String, (String, String)>;
|
||||
/// are neither a loaded nor an installed family.
|
||||
type CanonicalNames = HashMap<(String, String), (String, String)>;
|
||||
|
||||
/// The glyph images [`FontDb::glyph_image`] keeps by face and glyph, and their PNGs' bytes in all.
|
||||
#[derive(Default)]
|
||||
struct GlyphImages {
|
||||
images: HashMap<(u32, u32), Option<Arc<GlyphImage>>>,
|
||||
/// [`FontDb::glyph_image`]'s answers by face and glyph.
|
||||
type GlyphImages = GlyphCache<(u32, u32), Arc<GlyphImage>>;
|
||||
/// [`FontDb::glyph_colour`]'s answers by face and glyph, and the foreground colour for glyphs that
|
||||
/// paint with it.
|
||||
type GlyphColours = GlyphCache<(u32, u32, Option<[u8; 4]>), ColourContent>;
|
||||
|
||||
/// What a glyph's colour content (an image, layers) takes of memory, in bytes.
|
||||
trait Weight {
|
||||
fn bytes(&self) -> usize;
|
||||
}
|
||||
|
||||
impl Weight for Arc<GlyphImage> {
|
||||
fn bytes(&self) -> usize {
|
||||
self.blob.bytes.len()
|
||||
}
|
||||
}
|
||||
|
||||
impl Weight for ColourContent {
|
||||
fn bytes(&self) -> usize {
|
||||
match self {
|
||||
ColourContent::Image(i) => i.bytes(),
|
||||
// Roughly what a path node with its outline and fill takes.
|
||||
ColourContent::Art(art) => {
|
||||
let mut nodes = 0;
|
||||
art.walk(&mut |_| nodes += 1);
|
||||
nodes * 512
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The colour content of glyphs ([`FontDb::glyph_image`], [`FontDb::glyph_colour`]) kept by
|
||||
/// face, glyph and what else it depends on, and its bytes in all.
|
||||
struct GlyphCache<K, V> {
|
||||
kept: HashMap<K, Option<V>>,
|
||||
bytes: usize,
|
||||
}
|
||||
|
||||
impl GlyphImages {
|
||||
/// Keeps `image` (or that there is none), first letting go of all it keeps when that would
|
||||
/// take more than [`IMAGE_CACHE_MAX`] images or [`IMAGE_CACHE_BYTES`]. A glyph it keeps
|
||||
impl<K, V> Default for GlyphCache<K, V> {
|
||||
fn default() -> Self {
|
||||
Self { kept: HashMap::new(), bytes: 0 }
|
||||
}
|
||||
}
|
||||
|
||||
impl<K: std::hash::Hash + Eq, V: Weight> GlyphCache<K, V> {
|
||||
/// Keeps `value` (or that there is none), first letting go of all it keeps when that would
|
||||
/// take more than [`IMAGE_CACHE_MAX`] glyphs or [`IMAGE_CACHE_BYTES`]. A glyph it keeps
|
||||
/// already, which another thread looked up meanwhile, stays as it is.
|
||||
fn keep(&mut self, key: (u32, u32), image: Option<Arc<GlyphImage>>) {
|
||||
if self.images.contains_key(&key) {
|
||||
fn keep(&mut self, key: K, value: Option<V>) {
|
||||
if self.kept.contains_key(&key) {
|
||||
return;
|
||||
}
|
||||
let bytes = image.as_ref().map_or(0, |i| i.blob.bytes.len());
|
||||
if self.images.len() >= IMAGE_CACHE_MAX || self.bytes.saturating_add(bytes) > IMAGE_CACHE_BYTES {
|
||||
self.images.clear();
|
||||
let bytes = value.as_ref().map_or(0, Weight::bytes);
|
||||
if self.kept.len() >= IMAGE_CACHE_MAX || self.bytes.saturating_add(bytes) > IMAGE_CACHE_BYTES {
|
||||
self.kept.clear();
|
||||
self.bytes = 0;
|
||||
}
|
||||
self.bytes += bytes;
|
||||
self.images.insert(key, image);
|
||||
self.kept.insert(key, value);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -445,6 +486,7 @@ pub struct FontDb {
|
||||
outlines: Mutex<HashMap<(u32, u32), Arc<BezPath>>>,
|
||||
/// [`FontDb::glyph_image`]'s answers per (face, glyph), misses too.
|
||||
images: Mutex<GlyphImages>,
|
||||
colours: Mutex<GlyphColours>,
|
||||
catalog: RwLock<Catalog>,
|
||||
/// The installed faces by PostScript name (documents name fonts so: PDF, EPS, .ai).
|
||||
postscript: RwLock<PostScriptNames>,
|
||||
@@ -1554,6 +1596,7 @@ fn make_face(bytes: FontBytes, index: u32, spec: FaceStyle, path: Option<std::pa
|
||||
let underline = decoration(m.underline, (-0.075 * upem, 0.05 * upem));
|
||||
let strikeout = decoration(m.strikeout, (x_height * 0.5 + 0.025 * upem, 0.05 * upem));
|
||||
let colour_bitmaps = crate::bitmap::has_colour_bitmaps(&f);
|
||||
let colour_layers = crate::colr::has_colour_layers(&f);
|
||||
Some(FontFace {
|
||||
keys,
|
||||
traits,
|
||||
@@ -1581,6 +1624,7 @@ fn make_face(bytes: FontBytes, index: u32, spec: FaceStyle, path: Option<std::pa
|
||||
ideographic_centre: std::sync::OnceLock::new(),
|
||||
icf_margins: std::sync::OnceLock::new(),
|
||||
colour_bitmaps,
|
||||
colour_layers,
|
||||
})
|
||||
}
|
||||
|
||||
@@ -1684,7 +1728,8 @@ impl FontDb {
|
||||
Self {
|
||||
faces: RwLock::new(faces),
|
||||
outlines: Mutex::new(HashMap::new()),
|
||||
images: Mutex::new(GlyphImages::default()),
|
||||
images: Mutex::new(GlyphCache::default()),
|
||||
colours: Mutex::new(GlyphCache::default()),
|
||||
catalog: RwLock::new(Catalog::new()),
|
||||
postscript: RwLock::new(PostScriptNames::new()),
|
||||
font_paths,
|
||||
@@ -2460,16 +2505,36 @@ impl FontDb {
|
||||
return None;
|
||||
}
|
||||
let key = (face.id, gid);
|
||||
if let Some(i) = self.images.lock().unwrap_or_else(|e| e.into_inner()).images.get(&key) {
|
||||
if let Some(i) = self.images.lock().unwrap_or_else(|e| e.into_inner()).kept.get(&key) {
|
||||
return i.clone();
|
||||
}
|
||||
let image = face.skrifa().and_then(|f| crate::bitmap::glyph_image(&f, face.upem, gid)).map(Arc::new);
|
||||
self.images.lock().unwrap_or_else(|e| e.into_inner()).keep(key, image.clone());
|
||||
image
|
||||
}
|
||||
|
||||
/// Glyph `gid`'s COLR colour content in `face`, its foreground layers in `foreground`, cached
|
||||
/// per (face, glyph), and per foreground colour for the glyphs that paint with it.
|
||||
pub(crate) fn glyph_colour(&self, face: &FontFace, gid: u32, foreground: Color) -> Option<ColourContent> {
|
||||
if !face.colour_layers {
|
||||
return None;
|
||||
}
|
||||
let keyed = Some(foreground.to_rgba8(1.0));
|
||||
{
|
||||
let cache = self.colours.lock().unwrap_or_else(|e| e.into_inner());
|
||||
if let Some(c) = cache.kept.get(&(face.id, gid, None)).or_else(|| cache.kept.get(&(face.id, gid, keyed))) {
|
||||
return c.clone();
|
||||
}
|
||||
}
|
||||
let (content, used) = face.skrifa().map_or((None, false), |f| crate::colr::colour_glyph(&f, face.location(), face.upem, gid, foreground));
|
||||
let key = (face.id, gid, if used { keyed } else { None });
|
||||
self.colours.lock().unwrap_or_else(|e| e.into_inner()).keep(key, content.clone());
|
||||
content
|
||||
}
|
||||
}
|
||||
|
||||
struct FlipPen(BezPath);
|
||||
/// A pen drawing outlines y down, as text space has them.
|
||||
pub(crate) struct FlipPen(pub(crate) BezPath);
|
||||
|
||||
impl OutlinePen for FlipPen {
|
||||
fn move_to(&mut self, x: f32, y: f32) {
|
||||
@@ -2641,16 +2706,16 @@ mod image_cache_tests {
|
||||
let blob = vectorcraft_doc::ImageBlob::png(vec![0; crate::bitmap::MAX_PNG_BYTES]);
|
||||
Some(Arc::new(GlyphImage { blob, width: 1, height: 1, xf: kurbo::Affine::IDENTITY }))
|
||||
};
|
||||
let mut cache = GlyphImages::default();
|
||||
let mut cache = GlyphCache::default();
|
||||
for gid in 0..20 {
|
||||
cache.keep((1, gid), image());
|
||||
assert!(cache.bytes <= IMAGE_CACHE_BYTES, "{} bytes after {} images", cache.bytes, gid + 1);
|
||||
}
|
||||
// The same glyph again, as when two threads look it up at once, counts once.
|
||||
cache.keep((1, 19), image());
|
||||
assert_eq!(cache.bytes, cache.images.values().flatten().map(|i| i.blob.bytes.len()).sum::<usize>());
|
||||
assert_eq!(cache.bytes, cache.kept.values().flatten().map(|i: &Arc<GlyphImage>| i.blob.bytes.len()).sum::<usize>());
|
||||
// A glyph without an image costs nothing, and is still kept.
|
||||
cache.keep((1, 99), None);
|
||||
assert!(cache.images.contains_key(&(1, 99)));
|
||||
assert!(cache.kept.contains_key(&(1, 99)));
|
||||
}
|
||||
}
|
||||
@@ -106,9 +106,24 @@ impl Ctx<'_> {
|
||||
fn emit(&mut self, g: &SGlyph, pre: Affine, origin: Point, angle: f64, advance: f64, line: usize) {
|
||||
// Control characters (tabs) and soft hyphens draw nothing (fonts map them to .notdef).
|
||||
let blank = g.is_soft_hyphen() || g.ch.is_control();
|
||||
// A colour bitmap glyph draws its image, not its outline.
|
||||
let image = if g.inline.is_some() || blank { None } else { self.db.glyph_image(&g.face, g.gid) };
|
||||
let src = if g.inline.is_some() || image.is_some() { std::sync::Arc::new(BezPath::new()) } else { self.db.outline(&g.face, g.gid) };
|
||||
// A colour glyph draws its layers (COLR) or its image (a bitmap, or COLR paints documents
|
||||
// have no form for), not its outline; COLR first. Layers in the foreground colour take
|
||||
// the run's fill, or black when it isn't a colour.
|
||||
let plain = g.inline.is_some() || blank;
|
||||
let foreground = match &self.style_at(g.byte).fill {
|
||||
vectorcraft_doc::color::Paint::Solid { color, .. } => *color,
|
||||
_ => vectorcraft_doc::color::Color::BLACK,
|
||||
};
|
||||
let (colour, image) = match (!plain).then(|| self.db.glyph_colour(&g.face, g.gid, foreground)).flatten() {
|
||||
Some(crate::colr::ColourContent::Art(art)) => (Some(art), None),
|
||||
Some(crate::colr::ColourContent::Image(image)) => (None, Some(image)),
|
||||
None => (None, (!plain).then(|| self.db.glyph_image(&g.face, g.gid)).flatten()),
|
||||
};
|
||||
let src = if g.inline.is_some() || image.is_some() || colour.is_some() {
|
||||
std::sync::Arc::new(BezPath::new())
|
||||
} else {
|
||||
self.db.outline(&g.face, g.gid)
|
||||
};
|
||||
// A glyph whose leading space was taken off (mojikumi) is drawn that much earlier: an
|
||||
// upright one in vertical type by moving it up the column once it stands upright.
|
||||
let upright = self.vertical && !self.on_path && g.tcy.is_none() && stands_upright(g);
|
||||
@@ -173,6 +188,7 @@ impl Ctx<'_> {
|
||||
rtl: g.level.is_rtl() && !self.vertical,
|
||||
scale: 1.0,
|
||||
image,
|
||||
colour,
|
||||
});
|
||||
}
|
||||
|
||||
@@ -730,6 +746,9 @@ fn finish_bounds(out: &mut TextLayout) {
|
||||
if let Some((image, xf)) = g.placed_image() {
|
||||
add(xf.transform_rect_bbox(image.rect()));
|
||||
}
|
||||
if let Some(b) = g.colour.as_ref().and_then(|c| c.geometric_bounds()) {
|
||||
add(g.xf.transform_rect_bbox(b));
|
||||
}
|
||||
}
|
||||
// Ruby: covered by its line's ascent, but its ink can overhang sideways past the line.
|
||||
for g in &out.ruby {
|
||||
@@ -2944,5 +2963,6 @@ fn ruby_glyph(g: &PositionedGlyph, m: Affine, run: usize, byte: usize, line: usi
|
||||
scale: 1.0,
|
||||
// Ruby draws outlines only.
|
||||
image: None,
|
||||
colour: None,
|
||||
}
|
||||
}
|
||||
+14
-1
@@ -11,6 +11,7 @@
|
||||
#![forbid(unsafe_code)]
|
||||
|
||||
mod bitmap;
|
||||
mod colr;
|
||||
mod composer;
|
||||
pub mod craft_fonts;
|
||||
pub mod edit;
|
||||
@@ -123,8 +124,11 @@ pub struct PositionedGlyph {
|
||||
/// included.
|
||||
pub scale: f64,
|
||||
/// A colour bitmap glyph (emoji), drawn through `xf` instead of an outline: its `outline` is
|
||||
/// empty.
|
||||
/// empty. Also a COLR glyph whose paints documents have no form for, drawn as an image.
|
||||
pub image: Option<Arc<GlyphImage>>,
|
||||
/// A COLR colour glyph's layers, drawn through `xf` instead of an outline: art in font units
|
||||
/// (y down), an isolated group. Its `outline` is empty.
|
||||
pub colour: Option<Arc<vectorcraft_doc::Node>>,
|
||||
}
|
||||
|
||||
impl PositionedGlyph {
|
||||
@@ -132,6 +136,13 @@ impl PositionedGlyph {
|
||||
pub fn placed_image(&self) -> Option<(&Arc<GlyphImage>, Affine)> {
|
||||
self.image.as_ref().map(|i| (i, self.xf * i.xf))
|
||||
}
|
||||
/// The glyph's COLR layers placed through `to_doc` (text space → where they go): a copy of
|
||||
/// [`Self::colour`], transformed, its nodes without ids.
|
||||
pub fn placed_colour(&self, to_doc: Affine) -> Option<vectorcraft_doc::Node> {
|
||||
let mut art = (**self.colour.as_ref()?).clone();
|
||||
art.transform(to_doc * self.xf, true);
|
||||
Some(art)
|
||||
}
|
||||
}
|
||||
|
||||
/// One line of laid-out text.
|
||||
@@ -612,6 +623,8 @@ mod tests_bidi;
|
||||
#[cfg(test)]
|
||||
mod tests_bitmaps;
|
||||
#[cfg(test)]
|
||||
mod tests_colr;
|
||||
#[cfg(test)]
|
||||
mod tests_combos;
|
||||
#[cfg(test)]
|
||||
mod tests_devanagari;
|
||||
|
||||
@@ -585,3 +585,94 @@ pub fn solid_png(side: u32, rgba: [u8; 4]) -> Vec<u8> {
|
||||
chunk(&mut out, b"IEND", &[]);
|
||||
out
|
||||
}
|
||||
|
||||
/// The palette of [`colr_font`] (palette 0, RGBA): its indices 0, 1 and 2.
|
||||
pub const COLR_RED: [u8; 4] = [255, 0, 0, 255];
|
||||
pub const COLR_BLUE: [u8; 4] = [0, 0, 255, 255];
|
||||
pub const COLR_GREEN: [u8; 4] = [0, 255, 0, 255];
|
||||
|
||||
/// The character whose glyph [`colr_font`]`(true)` paints with a sweep gradient.
|
||||
pub const COLR_SWEEP_CHAR: char = 'S';
|
||||
|
||||
/// The family of [`colr_font`] (COLRv1, or v0).
|
||||
pub fn colr_family(v1: bool) -> &'static str {
|
||||
if v1 { "Colrtest Paints" } else { "Colrtest Layers" }
|
||||
}
|
||||
|
||||
/// The glyph ids of `chars` in the bundled Source Sans 3.
|
||||
fn source_sans_gids<const N: usize>(chars: [char; N]) -> Option<[u16; N]> {
|
||||
let font = skrifa::FontRef::new(SOURCE_SANS).ok()?;
|
||||
let mut gids = [0; N];
|
||||
for (gid, ch) in gids.iter_mut().zip(chars) {
|
||||
*gid = u16::try_from(font.charmap().map(ch)?.to_u32()).ok()?;
|
||||
}
|
||||
Some(gids)
|
||||
}
|
||||
|
||||
const SOURCE_SANS: &[u8] = include_bytes!("../../../assets/fonts/SourceSans3-Regular.ttf");
|
||||
|
||||
/// The bundled Source Sans 3 Regular as family [`colr_family`], with `COLR` and `CPAL` tables
|
||||
/// written from the OpenType specification, palette 0 [`COLR_RED`], [`COLR_BLUE`], [`COLR_GREEN`].
|
||||
/// v0: [`COLOUR_CHAR`] is the outline of `O` in red, then that of `I` in the foreground colour
|
||||
/// (palette index 0xFFFF). v1: [`COLOUR_CHAR`] is, in a clip box, `O` filled with a linear
|
||||
/// gradient red → blue, `I` scaled by a half about the origin with a radial gradient blue → green,
|
||||
/// and `-` in green composited with Multiply over `-` in red; [`COLR_SWEEP_CHAR`] is `O` with a
|
||||
/// sweep gradient red → blue. Their outlines stay. `None` when it can't be built.
|
||||
pub fn colr_font(v1: bool) -> Option<Vec<u8>> {
|
||||
use write_fonts::tables::colr::{
|
||||
BaseGlyph, BaseGlyphList, BaseGlyphPaint, Clip, ClipBox, ClipList, ColorLine, ColorStop, Colr, CompositeMode, Extend, Layer, LayerList, Paint,
|
||||
};
|
||||
use write_fonts::types::{FWord, GlyphId16, UfWord};
|
||||
let [base, sweep, o, i, dash] = source_sans_gids([COLOUR_CHAR, COLR_SWEEP_CHAR, 'O', 'I', '-'])?;
|
||||
let (base, sweep, o, i, dash) = (GlyphId16::new(base), GlyphId16::new(sweep), GlyphId16::new(o), GlyphId16::new(i), GlyphId16::new(dash));
|
||||
let colr = if v1 {
|
||||
let one = F2Dot14::from_f32(1.0);
|
||||
let line = |from: u16, to: u16| {
|
||||
ColorLine::new(Extend::Pad, 2, vec![ColorStop::new(F2Dot14::from_f32(0.0), from, one), ColorStop::new(one, to, one)])
|
||||
};
|
||||
let w = FWord::new;
|
||||
let layers = vec![
|
||||
Paint::glyph(Paint::linear_gradient(line(0, 1), w(0), w(0), w(500), w(0), w(0), w(500)), o),
|
||||
Paint::scale_uniform(
|
||||
Paint::glyph(Paint::radial_gradient(line(1, 2), w(250), w(300), UfWord::new(0), w(250), w(300), UfWord::new(300)), i),
|
||||
F2Dot14::from_f32(0.5),
|
||||
),
|
||||
Paint::composite(Paint::glyph(Paint::solid(2, one), dash), CompositeMode::Multiply, Paint::glyph(Paint::solid(0, one), dash)),
|
||||
];
|
||||
let mut colr = Colr::new(0, None, None, 0);
|
||||
colr.layer_list = Some(LayerList::new(layers.len() as u32, layers)).into();
|
||||
let mut glyphs = vec![
|
||||
BaseGlyphPaint::new(base, Paint::colr_layers(3, 0)),
|
||||
BaseGlyphPaint::new(sweep, Paint::glyph(Paint::sweep_gradient(line(0, 1), w(250), w(300), F2Dot14::from_f32(0.0), one), o)),
|
||||
];
|
||||
glyphs.sort_by_key(|g| g.glyph_id);
|
||||
colr.base_glyph_list = Some(BaseGlyphList::new(glyphs.len() as u32, glyphs)).into();
|
||||
let clip = ClipBox::format_1(w(-50), w(-250), w(750), w(800));
|
||||
colr.clip_list = Some(ClipList::new(1, 1, vec![Clip::new(base, base, clip)])).into();
|
||||
colr
|
||||
} else {
|
||||
Colr::new(1, Some(vec![BaseGlyph::new(base, 0, 2)]), Some(vec![Layer::new(o, 0), Layer::new(i, 0xFFFF)]), 2)
|
||||
};
|
||||
colr_font_with(colr_family(v1), &colr)
|
||||
}
|
||||
|
||||
/// The bundled Source Sans 3 Regular as `family` with `colr` and [`colr_font`]'s palette.
|
||||
pub fn colr_font_with(family: &str, colr: &write_fonts::tables::colr::Colr) -> Option<Vec<u8>> {
|
||||
use write_fonts::tables::cpal::{ColorRecord, Cpal};
|
||||
let font = skrifa::FontRef::new(SOURCE_SANS).ok()?;
|
||||
let ps = family.replace(' ', "");
|
||||
let name = name_table(&[(1, family), (2, "Regular"), (4, &format!("{family} Regular")), (6, &format!("{ps}-Regular"))])?;
|
||||
let records = [COLR_RED, COLR_BLUE, COLR_GREEN].map(|[r, g, b, a]| ColorRecord::new(b, g, r, a)).to_vec();
|
||||
let cpal = Cpal::new(3, 1, 3, Some(records), vec![0]);
|
||||
let mut builder = FontBuilder::new();
|
||||
builder.add_raw(Tag::new(b"name"), name);
|
||||
builder.add_table(colr).ok()?;
|
||||
builder.add_table(&cpal).ok()?;
|
||||
for r in font.table_directory.table_records() {
|
||||
let tag = Tag::new(&r.tag().to_be_bytes());
|
||||
if !builder.contains(tag) {
|
||||
builder.add_raw(tag, font.table_data(r.tag())?.as_bytes());
|
||||
}
|
||||
}
|
||||
Some(builder.build())
|
||||
}
|
||||
@@ -161,6 +161,7 @@ fn lines_of_clusters(lines: &[&[(usize, usize, f64)]], rtl: bool) -> TextLayout
|
||||
rtl,
|
||||
scale: 1.0,
|
||||
image: None,
|
||||
colour: None,
|
||||
});
|
||||
x += advance;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,360 @@
|
||||
//! COLR colour glyphs (v0 layers, v1 paints): read as trees of document nodes in font units, or
|
||||
//! as an image for paints VectorCraft lacks, and laid out with the type.
|
||||
|
||||
use skrifa::MetadataProvider;
|
||||
use skrifa::color::ColorGlyphFormat;
|
||||
|
||||
use super::test_fonts::{COLOUR_CHAR, COLR_SWEEP_CHAR, colr_font};
|
||||
|
||||
#[test]
|
||||
fn colr_fonts_build_and_read() {
|
||||
for v1 in [false, true] {
|
||||
let bytes = colr_font(v1).expect("the test font builds");
|
||||
let font = skrifa::FontRef::new(&bytes).unwrap();
|
||||
let glyph = |ch| font.color_glyphs().get(font.charmap().map(ch).unwrap());
|
||||
let format = glyph(COLOUR_CHAR).map(|g| g.format());
|
||||
assert!(matches!((v1, format), (false, Some(ColorGlyphFormat::ColrV0)) | (true, Some(ColorGlyphFormat::ColrV1))), "v1 {v1}");
|
||||
assert_eq!(glyph(COLR_SWEEP_CHAR).is_some(), v1, "only v1 has the sweep glyph");
|
||||
}
|
||||
}
|
||||
|
||||
use std::sync::Arc;
|
||||
|
||||
use skrifa::instance::LocationRef;
|
||||
use vectorcraft_doc::color::{BlendMode, Color, GradientKind, Paint};
|
||||
use vectorcraft_doc::{Node, NodeKind};
|
||||
|
||||
use super::colr::{ColourContent, colour_glyph};
|
||||
use super::test_fonts::{COLR_GREEN, COLR_RED};
|
||||
|
||||
const FOREGROUND: Color = Color::Rgb { r: 0.25, g: 0.5, b: 0.75 };
|
||||
|
||||
/// [`colour_glyph`] of `ch` in `font`.
|
||||
fn content(font: &[u8], ch: char) -> Option<ColourContent> {
|
||||
let font = skrifa::FontRef::new(font).unwrap();
|
||||
let gid = font.charmap().map(ch).unwrap().to_u32();
|
||||
colour_glyph(&font, LocationRef::default(), 1000.0, gid, FOREGROUND).0
|
||||
}
|
||||
|
||||
fn art(font: &[u8], ch: char) -> Arc<Node> {
|
||||
match content(font, ch) {
|
||||
Some(ColourContent::Art(a)) => a,
|
||||
_ => panic!("vector art expected"),
|
||||
}
|
||||
}
|
||||
|
||||
fn children(n: &Node) -> &[Arc<Node>] {
|
||||
n.children().map(Vec::as_slice).unwrap_or_default()
|
||||
}
|
||||
|
||||
fn fill(n: &Node) -> Paint {
|
||||
n.appearance.fill_paint()
|
||||
}
|
||||
|
||||
fn rgb([r, g, b, _]: [u8; 4]) -> Color {
|
||||
Color::rgb8(r, g, b)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn v0_layers_are_paths_in_paint_order() {
|
||||
let root = art(&colr_font(false).unwrap(), COLOUR_CHAR);
|
||||
assert!(!root.isolate, "a group without blending needs no layer of its own");
|
||||
let layers = children(&root);
|
||||
assert_eq!(layers.len(), 2, "{layers:?}");
|
||||
assert!(layers.iter().all(|l| matches!(l.kind, NodeKind::Path { .. })));
|
||||
assert_eq!(fill(&layers[0]), Paint::solid(rgb(COLR_RED)));
|
||||
assert_eq!(fill(&layers[1]), Paint::solid(FOREGROUND), "palette index 0xFFFF is the foreground");
|
||||
// In font units, y down: the `O` stands above the baseline.
|
||||
let b = layers[0].geometric_bounds().unwrap();
|
||||
assert!(b.y1 <= 20.0 && b.y0 < -500.0 && b.width() > 400.0, "{b:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn v1_paints_become_gradients_clips_and_isolated_groups() {
|
||||
let root = art(&colr_font(true).unwrap(), COLOUR_CHAR);
|
||||
// The clip box clips the whole glyph.
|
||||
let [clipped] = children(&root) else { panic!("{:?}", children(&root)) };
|
||||
assert!(matches!(clipped.kind, NodeKind::Group { clip: true, .. }), "{:?}", clipped.kind);
|
||||
let layers = &children(clipped)[1..];
|
||||
assert_eq!(layers.len(), 3, "{layers:?}");
|
||||
let gradient = |n: &Node| match fill(n) {
|
||||
Paint::Gradient(g) => g,
|
||||
p => panic!("a gradient: {p:?}"),
|
||||
};
|
||||
let linear = gradient(&layers[0]);
|
||||
assert_eq!(linear.gradient.kind, GradientKind::Linear);
|
||||
let geom = linear.geom.unwrap();
|
||||
assert!((geom.start.x - 0.0).abs() < 1e-6 && (geom.end.x - 500.0).abs() < 1e-6, "{geom:?}");
|
||||
let radial = gradient(&layers[1]);
|
||||
assert_eq!(radial.gradient.kind, GradientKind::Radial);
|
||||
// Scaled by a half about the origin, y down: centre (125, -150), radius 150.
|
||||
let geom = radial.geom.unwrap();
|
||||
assert!((geom.start.x - 125.0).abs() < 1e-3 && (geom.start.y + 150.0).abs() < 1e-3, "{geom:?}");
|
||||
assert!(((geom.end - geom.start).hypot() - 150.0).abs() < 1e-3, "{geom:?}");
|
||||
// The composite: an isolated group, the backdrop, then the source multiplied over it.
|
||||
let composite = &layers[2];
|
||||
assert!(composite.isolate);
|
||||
let [backdrop, source] = children(composite) else { panic!("{:?}", children(composite)) };
|
||||
assert_eq!(fill(backdrop), Paint::solid(rgb(COLR_RED)));
|
||||
let source = children(source).first().cloned().unwrap_or_else(|| source.clone());
|
||||
assert_eq!(fill(&source), Paint::solid(rgb(COLR_GREEN)));
|
||||
assert!(children(composite)[1].blend == BlendMode::Multiply, "{:?}", children(composite)[1].blend);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_sweep_gradient_makes_the_glyph_an_image() {
|
||||
let Some(ColourContent::Image(image)) = content(&colr_font(true).unwrap(), COLR_SWEEP_CHAR) else { panic!("an image") };
|
||||
assert!(image.blob.bytes.starts_with(b"\x89PNG"));
|
||||
// The `O` is some 600 units tall: at 256 px per em, some 150 px.
|
||||
assert!((100..300).contains(&image.height), "{}", image.height);
|
||||
// Its pixels map back to the glyph's place in font units, y down.
|
||||
let b = image.xf.transform_rect_bbox(image.rect());
|
||||
assert!(b.y1 <= 20.0 && b.y0 < -500.0, "{b:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_colr_graph_that_paints_itself_is_no_colour_glyph() {
|
||||
use write_fonts::tables::colr::{BaseGlyphList, BaseGlyphPaint, Colr, Paint};
|
||||
use write_fonts::types::GlyphId16;
|
||||
let base = skrifa::FontRef::new(&colr_font(false).unwrap()).unwrap().charmap().map(COLOUR_CHAR).unwrap().to_u32();
|
||||
let base = GlyphId16::new(u16::try_from(base).unwrap());
|
||||
let mut colr = Colr::new(0, None, None, 0);
|
||||
colr.base_glyph_list = Some(BaseGlyphList::new(1, vec![BaseGlyphPaint::new(base, Paint::colr_glyph(base))])).into();
|
||||
let font = super::test_fonts::colr_font_with("Colrtest Loop", &colr).unwrap();
|
||||
assert!(content(&font, COLOUR_CHAR).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_colr_graph_nested_past_the_cap_is_no_colour_glyph() {
|
||||
use write_fonts::tables::colr::{BaseGlyphList, BaseGlyphPaint, Colr, Paint};
|
||||
use write_fonts::types::{F2Dot14, GlyphId16};
|
||||
let font = skrifa::FontRef::new(&colr_font(false).unwrap()).unwrap().charmap().map(COLOUR_CHAR).unwrap().to_u32();
|
||||
let base = GlyphId16::new(u16::try_from(font).unwrap());
|
||||
let mut paint = Paint::glyph(Paint::solid(0, F2Dot14::from_f32(1.0)), base);
|
||||
for _ in 0..200 {
|
||||
paint = Paint::scale_uniform(paint, F2Dot14::from_f32(1.0));
|
||||
}
|
||||
let mut colr = Colr::new(0, None, None, 0);
|
||||
colr.base_glyph_list = Some(BaseGlyphList::new(1, vec![BaseGlyphPaint::new(base, paint)])).into();
|
||||
let font = super::test_fonts::colr_font_with("Colrtest Deep", &colr).unwrap();
|
||||
assert!(content(&font, COLOUR_CHAR).is_none());
|
||||
}
|
||||
|
||||
// Layout: colour glyphs are laid out with their layers, which move with the type.
|
||||
|
||||
use kurbo::Point as KPoint;
|
||||
use vectorcraft_doc::{CharStyle, TextObject};
|
||||
|
||||
use super::test_fonts::colr_family;
|
||||
use super::{FontDb, layout};
|
||||
|
||||
fn colr_db(v1: bool) -> FontDb {
|
||||
let db = FontDb::with_font_dirs(vec![]);
|
||||
assert_eq!(db.add_font(colr_font(v1).expect("the test font builds")), 1);
|
||||
db
|
||||
}
|
||||
|
||||
fn colr_style(v1: bool) -> CharStyle {
|
||||
CharStyle { font_family: colr_family(v1).into(), size: 100.0, ..CharStyle::default() }
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_colr_glyph_lays_out_its_layers_with_an_empty_outline() {
|
||||
let db = colr_db(false);
|
||||
let l = layout(&db, &TextObject::point(KPoint::new(10.0, 50.0), &format!("{COLOUR_CHAR}F"), colr_style(false)));
|
||||
let (g, f) = (&l.glyphs[0], &l.glyphs[1]);
|
||||
assert!(g.outline.elements().is_empty(), "the layers replace the outline");
|
||||
assert_eq!(g.colour.as_deref().map(|c| children(c).len()), Some(2));
|
||||
assert!(g.image.is_none());
|
||||
assert!(f.colour.is_none() && !f.outline.elements().is_empty(), "other glyphs keep their outlines");
|
||||
// In text space at 100 pt: the `O` layer stands on the baseline (y 0), some 70 pt tall.
|
||||
let placed = g.placed_colour(kurbo::Affine::IDENTITY).unwrap();
|
||||
let b = placed.geometric_bounds().unwrap();
|
||||
assert!(b.y1.abs() < 3.0 && b.height() > 60.0 && b.height() < 80.0, "{b:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_foreground_layer_takes_the_runs_fill_and_black_for_a_gradient_fill() {
|
||||
let db = colr_db(false);
|
||||
let foreground = |fill: Paint| {
|
||||
let st = CharStyle { fill, ..colr_style(false) };
|
||||
let l = layout(&db, &TextObject::point(KPoint::ZERO, &COLOUR_CHAR.to_string(), st));
|
||||
let colour = l.glyphs[0].colour.clone().unwrap();
|
||||
children(&colour)[1].appearance.fill_paint()
|
||||
};
|
||||
let blue = Color::rgb8(0, 0, 200);
|
||||
assert_eq!(foreground(Paint::solid(blue)), Paint::solid(blue));
|
||||
assert_eq!(foreground(Paint::solid(FOREGROUND)), Paint::solid(FOREGROUND), "a new fill colour, a new glyph");
|
||||
let gradient = Paint::Gradient(Box::new(vectorcraft_doc::color::GradientPaint::new(Default::default())));
|
||||
assert_eq!(foreground(gradient), Paint::solid(Color::BLACK));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn layout_bounds_take_in_the_colour_layers() {
|
||||
let db = colr_db(true);
|
||||
let l = layout(&db, &TextObject::point(KPoint::new(10.0, 50.0), &COLOUR_CHAR.to_string(), colr_style(true)));
|
||||
let g = &l.glyphs[0];
|
||||
let b = g.placed_colour(kurbo::Affine::IDENTITY).unwrap().geometric_bounds().unwrap();
|
||||
assert!(l.bounds.contains_rect(b.inset(-0.01)) || l.bounds.contains_rect(b), "{:?} holds {b:?}", l.bounds);
|
||||
// The `O` layer is wider than the `E` the glyph advances by.
|
||||
assert!(b.width() > g.advance * 0.9, "{b:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_face_with_colr_and_sbix_draws_colr() {
|
||||
use write_fonts::FontBuilder;
|
||||
use write_fonts::types::Tag;
|
||||
let colr = colr_font(false).unwrap();
|
||||
let sbix = super::test_fonts::colour_bitmap_font(true).unwrap();
|
||||
let sbix = skrifa::FontRef::new(&sbix).unwrap();
|
||||
let font = skrifa::FontRef::new(&colr).unwrap();
|
||||
let mut builder = FontBuilder::new();
|
||||
builder.add_raw(Tag::new(b"sbix"), sbix.table_data(skrifa::Tag::new(b"sbix")).unwrap().as_bytes());
|
||||
for r in font.table_directory.table_records() {
|
||||
let tag = Tag::new(&r.tag().to_be_bytes());
|
||||
if !builder.contains(tag) {
|
||||
builder.add_raw(tag, font.table_data(r.tag()).unwrap().as_bytes());
|
||||
}
|
||||
}
|
||||
let db = FontDb::with_font_dirs(vec![]);
|
||||
assert_eq!(db.add_font(builder.build()), 1);
|
||||
let l = layout(&db, &TextObject::point(KPoint::ZERO, &COLOUR_CHAR.to_string(), colr_style(false)));
|
||||
assert!(l.glyphs[0].colour.is_some() && l.glyphs[0].image.is_none(), "vectors over bitmaps");
|
||||
}
|
||||
|
||||
/// A v1 font whose glyph of `base` is `paint`, given the glyph id of `O`, its layer list one
|
||||
/// red fill.
|
||||
fn v1_font(family: &str, base: char, paint: impl Fn(write_fonts::types::GlyphId16) -> ColrPaint) -> Vec<u8> {
|
||||
use write_fonts::tables::colr::{BaseGlyphList, BaseGlyphPaint, Colr, LayerList};
|
||||
use write_fonts::types::GlyphId16;
|
||||
let bytes = colr_font(false).unwrap();
|
||||
let font = skrifa::FontRef::new(&bytes).unwrap();
|
||||
let gid = |ch| GlyphId16::new(u16::try_from(font.charmap().map(ch).unwrap().to_u32()).unwrap());
|
||||
let mut colr = Colr::new(0, None, None, 0);
|
||||
colr.base_glyph_list = Some(BaseGlyphList::new(1, vec![BaseGlyphPaint::new(gid(base), paint(gid('O')))])).into();
|
||||
colr.layer_list = Some(LayerList::new(1, vec![solid(0)])).into();
|
||||
super::test_fonts::colr_font_with(family, &colr).unwrap()
|
||||
}
|
||||
|
||||
use write_fonts::tables::colr::Paint as ColrPaint;
|
||||
|
||||
fn solid(index: u16) -> ColrPaint {
|
||||
ColrPaint::solid(index, write_fonts::types::F2Dot14::from_f32(1.0))
|
||||
}
|
||||
|
||||
fn sweep() -> ColrPaint {
|
||||
use write_fonts::tables::colr::{ColorLine, ColorStop, Extend};
|
||||
use write_fonts::types::{F2Dot14, FWord};
|
||||
let one = F2Dot14::from_f32(1.0);
|
||||
let line = ColorLine::new(Extend::Pad, 2, vec![ColorStop::new(F2Dot14::from_f32(0.0), 0, one), ColorStop::new(one, 1, one)]);
|
||||
ColrPaint::sweep_gradient(line, FWord::new(250), FWord::new(300), F2Dot14::from_f32(0.0), one)
|
||||
}
|
||||
|
||||
/// A glyph filled with a composite of solid colours is vector art: the composite's fills fill
|
||||
/// the glyph around them.
|
||||
#[test]
|
||||
fn a_glyph_filled_with_a_composite_is_vector_art() {
|
||||
use write_fonts::tables::colr::CompositeMode;
|
||||
let font = v1_font("Colrtest Composite", COLOUR_CHAR, |o| ColrPaint::glyph(ColrPaint::composite(solid(2), CompositeMode::Multiply, solid(0)), o));
|
||||
assert!(matches!(content(&font, COLOUR_CHAR), Some(ColourContent::Art(_))));
|
||||
}
|
||||
|
||||
/// A colour of its own filling a (TrueType, quadratic) glyph's area is that glyph filled: one
|
||||
/// path, not a clipping group around a copy of it.
|
||||
#[test]
|
||||
fn a_glyph_filled_with_one_colour_is_one_path() {
|
||||
let font = v1_font("Colrtest Flood", COLOUR_CHAR, |o| ColrPaint::glyph(ColrPaint::colr_layers(1, 0), o));
|
||||
let root = art(&font, COLOUR_CHAR);
|
||||
let [only] = children(&root) else { panic!("{:?}", children(&root).iter().map(|c| c.kind_label()).collect::<Vec<_>>()) };
|
||||
assert!(matches!(only.kind, NodeKind::Path { .. }), "{}", only.kind_label());
|
||||
assert_eq!(fill(only), Paint::solid(rgb(COLR_RED)));
|
||||
}
|
||||
|
||||
/// A sweep glyph in a font without clip boxes, its base glyph without an outline (the space's,
|
||||
/// as COLRv1 fonts make them): its image is as large as what it paints.
|
||||
#[test]
|
||||
fn a_sweep_glyph_without_a_clip_box_or_outline_is_an_image_of_its_paint() {
|
||||
let font = v1_font("Colrtest Bare", ' ', |o| ColrPaint::glyph(sweep(), o));
|
||||
let Some(ColourContent::Image(image)) = content(&font, ' ') else { panic!("an image") };
|
||||
assert!((100..300).contains(&image.height), "{}", image.height);
|
||||
}
|
||||
|
||||
/// A transform that collapses the glyph (scale 0, from a font) draws nothing in its image,
|
||||
/// without panicking.
|
||||
#[test]
|
||||
fn a_collapsed_sweep_glyph_draws_nothing() {
|
||||
use write_fonts::tables::colr::{BaseGlyphList, BaseGlyphPaint, Clip, ClipBox, ClipList, Colr};
|
||||
use write_fonts::types::{F2Dot14, FWord, GlyphId16};
|
||||
let bytes = colr_font(false).unwrap();
|
||||
let read = skrifa::FontRef::new(&bytes).unwrap();
|
||||
let gid = |ch| GlyphId16::new(u16::try_from(read.charmap().map(ch).unwrap().to_u32()).unwrap());
|
||||
let mut colr = Colr::new(0, None, None, 0);
|
||||
let flat = ColrPaint::scale_uniform(ColrPaint::glyph(sweep(), gid('O')), F2Dot14::from_f32(0.0));
|
||||
colr.base_glyph_list = Some(BaseGlyphList::new(1, vec![BaseGlyphPaint::new(gid(COLOUR_CHAR), flat)])).into();
|
||||
// A clip box, so the image is made.
|
||||
let clip = ClipBox::format_1(FWord::new(0), FWord::new(0), FWord::new(500), FWord::new(500));
|
||||
colr.clip_list = Some(ClipList::new(1, 1, vec![Clip::new(gid(COLOUR_CHAR), gid(COLOUR_CHAR), clip)])).into();
|
||||
let font = super::test_fonts::colr_font_with("Colrtest Flat", &colr).unwrap();
|
||||
let Some(ColourContent::Image(image)) = content(&font, COLOUR_CHAR) else { panic!("an image") };
|
||||
assert!(image.blob.bytes.starts_with(b"\x89PNG"));
|
||||
}
|
||||
|
||||
/// Each paint documents have no form for makes the glyph an image.
|
||||
#[test]
|
||||
fn paints_documents_lack_make_the_glyph_an_image() {
|
||||
use write_fonts::tables::colr::{ColorLine, ColorStop, CompositeMode, Extend};
|
||||
use write_fonts::types::{F2Dot14, FWord, UfWord};
|
||||
let one = F2Dot14::from_f32(1.0);
|
||||
let line = |extend| ColorLine::new(extend, 2, vec![ColorStop::new(F2Dot14::from_f32(0.0), 0, one), ColorStop::new(one, 1, one)]);
|
||||
let w = FWord::new;
|
||||
type GlyphPaint<'a> = Box<dyn Fn(write_fonts::types::GlyphId16) -> ColrPaint + 'a>;
|
||||
let cases: [(&str, GlyphPaint<'_>); 3] = [
|
||||
("Colrtest Xor", Box::new(|o| ColrPaint::composite(ColrPaint::glyph(solid(2), o), CompositeMode::Xor, ColrPaint::glyph(solid(0), o)))),
|
||||
(
|
||||
"Colrtest Repeat",
|
||||
Box::new(move |o| ColrPaint::glyph(ColrPaint::linear_gradient(line(Extend::Repeat), w(0), w(0), w(100), w(0), w(0), w(100)), o)),
|
||||
),
|
||||
(
|
||||
"Colrtest Circles",
|
||||
Box::new(move |o| {
|
||||
ColrPaint::glyph(ColrPaint::radial_gradient(line(Extend::Pad), w(200), w(300), UfWord::new(50), w(250), w(300), UfWord::new(300)), o)
|
||||
}),
|
||||
),
|
||||
];
|
||||
for (family, paint) in cases {
|
||||
let font = v1_font(family, COLOUR_CHAR, paint);
|
||||
assert!(matches!(content(&font, COLOUR_CHAR), Some(ColourContent::Image(_))), "{family}");
|
||||
}
|
||||
}
|
||||
|
||||
/// A radial gradient whose start circle is around its centre is vector art, its stops moved out.
|
||||
#[test]
|
||||
fn a_radial_gradient_from_a_circle_around_its_centre_is_vector_art() {
|
||||
use write_fonts::tables::colr::{ColorLine, ColorStop, Extend};
|
||||
use write_fonts::types::{F2Dot14, FWord, UfWord};
|
||||
let one = F2Dot14::from_f32(1.0);
|
||||
let line = ColorLine::new(Extend::Pad, 2, vec![ColorStop::new(F2Dot14::from_f32(0.0), 0, one), ColorStop::new(one, 1, one)]);
|
||||
let w = FWord::new;
|
||||
let font = v1_font("Colrtest Ring", COLOUR_CHAR, |o| {
|
||||
ColrPaint::glyph(ColrPaint::radial_gradient(line.clone(), w(250), w(300), UfWord::new(100), w(250), w(300), UfWord::new(400)), o)
|
||||
});
|
||||
let root = art(&font, COLOUR_CHAR);
|
||||
let Paint::Gradient(g) = fill(&children(&root)[0]) else { panic!("a gradient") };
|
||||
let offsets: Vec<f32> = g.gradient.stops.iter().map(|s| s.offset).collect();
|
||||
assert_eq!(offsets, [0.25, 1.0], "the stops start a quarter of the way out");
|
||||
}
|
||||
|
||||
/// A glyph whose layers don't use the foreground colour is read once, whatever the type's fill.
|
||||
#[test]
|
||||
fn a_glyph_without_the_foreground_colour_is_read_once_for_every_fill() {
|
||||
let tree = |v1: bool, fill: Color| {
|
||||
let db = colr_db(v1);
|
||||
let st = CharStyle { fill: Paint::solid(fill), ..colr_style(v1) };
|
||||
let first = layout(&db, &TextObject::point(KPoint::ZERO, &COLOUR_CHAR.to_string(), st.clone())).glyphs[0].colour.clone().unwrap();
|
||||
let st = CharStyle { fill: Paint::solid(FOREGROUND), ..st };
|
||||
let other = layout(&db, &TextObject::point(KPoint::ZERO, &COLOUR_CHAR.to_string(), st)).glyphs[0].colour.clone().unwrap();
|
||||
Arc::ptr_eq(&first, &other)
|
||||
};
|
||||
assert!(tree(true, Color::rgb8(0, 0, 200)), "v1's glyph uses only its palette");
|
||||
assert!(!tree(false, Color::rgb8(0, 0, 200)), "v0's foreground layer follows the fill");
|
||||
}
|
||||
+9
-2
@@ -1,6 +1,6 @@
|
||||
# Gaps
|
||||
|
||||
> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-22 · **Change:** minor (G11: Shape Builder lines cut art of thousands of segments again, the reproduced case of #937; Artboard Options honors Scale Artwork with Artboard for preset, orientation and typed-size changes; both Fits keep artwork stationary; scores and estimates unchanged; G11: PDF text opens where the file draws it, #722; G2: the Effect Gallery shipped (#2883): Effect › Effect Gallery… browses the Artistic, Brush Strokes, Distort, Sketch, Stylize and Texture filters, edits each filter's settings, builds an ordered stack (add, reorder, hide, remove) with a live canvas preview, and OK applies it as separate appearance effects in one undo step; remaining: filter thumbnails and a preview area inside the dialog; G2 estimate 4–6 → 1–2 h; Raster effects 82% → 85% (power-user view 49% → 52%), estimated, a modest move because the named missing dialog landed without thumbnails or an in-dialog preview; previously: G4: colour emoji fonts with bitmap glyphs (`sbix`: Apple Color Emoji; `CBDT`: Noto Color Emoji) draw on the canvas and export: PDF Type 3 glyphs or images, SVG images with outlined text, EPS and legacy `.ai` images, Create Outlines images; COLR and OpenType SVG fonts remain; estimate unchanged; G13: gradient Dither (Illustrator 30.0): a Dither box in the Gradient panel (`paint.editGradient`/`paint.setFill` `dither`, saved in the native file) draws a linear or radial gradient fill with seeded fine noise that hides banding, on the canvas and in raster exports; SVG and PDF exports write the fill as an image at the Document Raster Effects resolution, as the public documentation describes dither; fills only, as documented; score and hours unchanged; G2: Effect › Sketch › Conté Crayon (Foreground Level, Background Level, Texture, Scaling, Relief, Light Direction, Invert; a black crayon in the dark areas and a white one in the light areas on textured mid-grey paper; ranges and defaults unverified VectorCraft choices); measured Photoshop-style filters 57/57, the Effect Gallery remains (4–6 h); Affinity import AF.5: master pages, tables, paragraph formats, shadows, glows, outlines, overlays and embedded documents; Recolor Artwork Edit chips scroll within the available screen height (#3416); small palettes retain their tab height; scores and estimates unchanged; Blend panel Type and Ramp control step easing with a separate color Shift (#2539); Blend Options retains spacing and orientation; polynomial curves are original approximations; Shape Builder Gap Detection shares Live Paint’s spatial gap finder and temporary merge bridges (#2526); Custom is capped at 72 pt in the existing options dialog; filter plug-ins read and set effect records and stroke joins, caps and miter limits, G17; 3D: original Standard, Diffuse, Top Left and Right lighting presets; command access, effective-setting recognition and preview/history; scores and estimates unchanged; G1: one selected clip group's Properties panel has Edit Clipping Path and Edit Contents at its top; the selection tools take a clipping path on its outline, over the art it clips; Polygon and Star exact-size placement remembers the chosen count for later drags and dialog openings; Cancel preserves the previous count; Live trace result bounds and selection highlights exclude the retained bitmap except in source-image views; live-effect plug-ins given their object's fills and strokes and the item they sit on, G17; plug-in parameters: labels, units, groups, help and conditions in their dialogs, text and number-list parameters, up to 256 of them, G17; exporter plug-ins: plug-in file formats in Export As and document.export, G17; G2: Effect › Artistic › Smudge Stick, Sponge and Watercolor; Sketch › Bas Relief, Charcoal, Photocopy and Stamp, #2533; Photoshop filters 45/57, 12 remaining (8–14 h); on-canvas Mirror Repeat axis, #2877; G12: Background Export progress dialog with Cancel, #2564; status-readout sample widths cached by language, document unit and pixels per point; status messages and readouts use stable responsive allocations sized for localized labels and ordinary coordinates; cached canvas dimensions match the renderer limit before cache-key creation, view construction and worker submission; cached canvas reprojection preserves scale during resize, rotation and DPI changes; on-canvas Mirror Repeat axis, #2877; G12: Background Export progress dialog with Cancel, #2564; 3D lighting: one to ten colored lights, smooth colored Inflate, legacy white-light appearance preserved; surface batching and restored seam minimum; scores and estimates unchanged; Blend spine Anchor Point conversions, selection/stacking priority and Shift regression coverage (#2544); scores and hours unchanged; transparency grid visibility saved in native documents, #1968; G6: MCP cancellation, progress notifications and busy answers during long exports, #2165, #2171, #2172; EPS editing data: legacy mLine truncated
|
||||
> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-23 · **Change:** minor (COLR colour fonts (v0 and v1) draw and export as vector art; previously: G11: Shape Builder lines cut art of thousands of segments again, the reproduced case of #937; Artboard Options honors Scale Artwork with Artboard for preset, orientation and typed-size changes; both Fits keep artwork stationary; scores and estimates unchanged; G11: PDF text opens where the file draws it, #722; G2: the Effect Gallery shipped (#2883): Effect › Effect Gallery… browses the Artistic, Brush Strokes, Distort, Sketch, Stylize and Texture filters, edits each filter's settings, builds an ordered stack (add, reorder, hide, remove) with a live canvas preview, and OK applies it as separate appearance effects in one undo step; remaining: filter thumbnails and a preview area inside the dialog; G2 estimate 4–6 → 1–2 h; Raster effects 82% → 85% (power-user view 49% → 52%), estimated, a modest move because the named missing dialog landed without thumbnails or an in-dialog preview; previously: G4: colour emoji fonts with bitmap glyphs (`sbix`: Apple Color Emoji; `CBDT`: Noto Color Emoji) draw on the canvas and export: PDF Type 3 glyphs or images, SVG images with outlined text, EPS and legacy `.ai` images, Create Outlines images; COLR and OpenType SVG fonts remain; estimate unchanged; G13: gradient Dither (Illustrator 30.0): a Dither box in the Gradient panel (`paint.editGradient`/`paint.setFill` `dither`, saved in the native file) draws a linear or radial gradient fill with seeded fine noise that hides banding, on the canvas and in raster exports; SVG and PDF exports write the fill as an image at the Document Raster Effects resolution, as the public documentation describes dither; fills only, as documented; score and hours unchanged; G2: Effect › Sketch › Conté Crayon (Foreground Level, Background Level, Texture, Scaling, Relief, Light Direction, Invert; a black crayon in the dark areas and a white one in the light areas on textured mid-grey paper; ranges and defaults unverified VectorCraft choices); measured Photoshop-style filters 57/57, the Effect Gallery remains (4–6 h); Affinity import AF.5: master pages, tables, paragraph formats, shadows, glows, outlines, overlays and embedded documents; Recolor Artwork Edit chips scroll within the available screen height (#3416); small palettes retain their tab height; scores and estimates unchanged; Blend panel Type and Ramp control step easing with a separate color Shift (#2539); Blend Options retains spacing and orientation; polynomial curves are original approximations; Shape Builder Gap Detection shares Live Paint’s spatial gap finder and temporary merge bridges (#2526); Custom is capped at 72 pt in the existing options dialog; filter plug-ins read and set effect records and stroke joins, caps and miter limits, G17; 3D: original Standard, Diffuse, Top Left and Right lighting presets; command access, effective-setting recognition and preview/history; scores and estimates unchanged; G1: one selected clip group's Properties panel has Edit Clipping Path and Edit Contents at its top; the selection tools take a clipping path on its outline, over the art it clips; Polygon and Star exact-size placement remembers the chosen count for later drags and dialog openings; Cancel preserves the previous count; Live trace result bounds and selection highlights exclude the retained bitmap except in source-image views; live-effect plug-ins given their object's fills and strokes and the item they sit on, G17; plug-in parameters: labels, units, groups, help and conditions in their dialogs, text and number-list parameters, up to 256 of them, G17; exporter plug-ins: plug-in file formats in Export As and document.export, G17; G2: Effect › Artistic › Smudge Stick, Sponge and Watercolor; Sketch › Bas Relief, Charcoal, Photocopy and Stamp, #2533; Photoshop filters 45/57, 12 remaining (8–14 h); on-canvas Mirror Repeat axis, #2877; G12: Background Export progress dialog with Cancel, #2564; status-readout sample widths cached by language, document unit and pixels per point; status messages and readouts use stable responsive allocations sized for localized labels and ordinary coordinates; cached canvas dimensions match the renderer limit before cache-key creation, view construction and worker submission; cached canvas reprojection preserves scale during resize, rotation and DPI changes; on-canvas Mirror Repeat axis, #2877; G12: Background Export progress dialog with Cancel, #2564; 3D lighting: one to ten colored lights, smooth colored Inflate, legacy white-light appearance preserved; surface batching and restored seam minimum; scores and estimates unchanged; Blend spine Anchor Point conversions, selection/stacking priority and Shift regression coverage (#2544); scores and hours unchanged; transparency grid visibility saved in native documents, #1968; G6: MCP cancellation, progress notifications and busy ansLine truncated
|
||||
|
||||
## Feature submission evidence
|
||||
|
||||
@@ -289,7 +289,13 @@ from G14 and the budget run of G15: **~170–270 h** one agent, ~50–80 h wall
|
||||
Fonts with bitmaps but no outlines (Noto Color Emoji) are now found among the installed fonts. Limits: `sbix`
|
||||
duplicate, flipped, JPEG and TIFF glyphs and `CBDT` BGRA and mask data draw nothing, nor do emoji in ruby or in
|
||||
enveloped or warped type; estimate unchanged.
|
||||
- **Missing:** colour fonts with COLR or OpenType SVG glyphs; CJK vertical
|
||||
- **Done:** COLR colour fonts (v0 and v1): a glyph's layers are vector art (solid colours, linear and radial
|
||||
gradients, clips, blend modes, palette 0, the foreground colour from the run's fill), placed with the type, drawn on
|
||||
the canvas, written as paths in SVG, EPS, legacy `.ai` and PDF with outlined text, as text in PDF, and editable
|
||||
paths with Create Outlines. Limits: glyphs using sweep gradients, Porter-Duff compositing, radial gradients from a
|
||||
circle that isn't the centre, or repeating gradients are images of the glyph until documents have those paints;
|
||||
estimate unchanged.
|
||||
- **Missing:** colour fonts with OpenType SVG glyphs; CJK vertical
|
||||
composition (mojikumi sets and dialog, kinsoku settings #633, manual tate-chu-yoko), Middle Eastern
|
||||
features beyond bidi and digit types (Character Direction, kashidas, composers), variable font axes, spell check with an open dictionary,
|
||||
Touch Type, Retype, Snap to Glyph; optional preservation of font sizes during group scaling (#1034 enhancement).
|
||||
@@ -510,6 +516,7 @@ separate. Scores and hours unchanged. [Behavior and command details](development
|
||||
|
||||
| Date | Change | Summary |
|
||||
|---|---|---|
|
||||
| 2026-10-23 | minor | G4: COLR colour fonts (v0 and v1) draw and export as vector art; paints documents lack (sweep gradients, Porter-Duff compositing, radial gradients from a circle, repeating gradients) draw the glyph as an image; OpenType SVG fonts remain; estimate unchanged. |
|
||||
| 2026-10-18 | minor | G11: Shape Builder on art of thousands of segments (traced outlines, type outlines): lines cut it again past 4,096 segments, where the planar map used to give up and the tool offered whole shapes (#937's reproduced case; the planar map's edge-source and face lookups were quadratic in the segments, now indexed, and the cap is 65,536); estimate unchanged until confirmed on the reporter's file |
|
||||
| 2026-10-22 | minor | G8: stacked geometry effects make at most 2 million anchors of a path and about 8 million lines to draw: Roughen, Zig Zag, Free Distort, Twist, the warps and Transform build within it, and an effect that would still pass it is left out (#3578). No entry closed, estimates unchanged. |
|
||||
| 2026-10-22 | minor | G13: gradient Method (30.0), Classic or Perceptual, in the Gradient panel, on the canvas, in raster exports and as images in SVG and PDF exports (with Dither, a Perceptual fill takes its noise); G13 estimate 14–24 h → 13–23 h. |
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Parity with Adobe Illustrator
|
||||
|
||||
> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-22 · **Change:** minor (Shape Builder: lines cut art of thousands of segments again, #937's reproduced case; scores unchanged until confirmed on the reporter's file; Artboard Options honors Scale Artwork with Artboard for preset, orientation and typed-size changes; both Fits keep artwork stationary; scores and estimates unchanged; File formats: PDF text opens where the file draws it, #722, score unchanged; G2: the Effect Gallery shipped (#2883): Effect › Effect Gallery… browses the Artistic, Brush Strokes, Distort, Sketch, Stylize and Texture filters, edits each filter's settings, builds an ordered stack (add, reorder, hide, remove) with a live canvas preview, and OK applies it as separate appearance effects in one undo step; remaining: filter thumbnails and a preview area inside the dialog; G2 estimate 4–6 → 1–2 h; Raster effects 82% → 85% (power-user view 49% → 52%), estimated, a modest move because the named missing dialog landed without thumbnails or an in-dialog preview; previously: colour emoji fonts with bitmap glyphs (`sbix`: Apple Color Emoji; `CBDT`: Noto Color Emoji) draw on the canvas and export: PDF Type 3 glyphs or images, SVG images with outlined text, EPS and legacy `.ai` images, Create Outlines images, see [type-parity.md](type-parity.md); scores unchanged; imported PDF type keeps a word space between two sizes (#3623); G13: gradient Dither (Illustrator 30.0): a Dither box in the Gradient panel (`paint.editGradient`/`paint.setFill` `dither`, saved in the native file) draws a linear or radial gradient fill with seeded fine noise that hides banding, on the canvas and in raster exports; SVG and PDF exports write the fill as an image at the Document Raster Effects resolution, as the public documentation describes dither; fills only, as documented; score and hours unchanged; #3546: `--automation-read-root` and `--automation-write-root` may each be given more than once (`vectorcraft-cli mcp` and the desktop app); a path inside any root of its kind is allowed, every confinement check unchanged. Scores and estimates unchanged; #3147: `vectorcraft-cli run --commands FILE` (or `-`) reads the steps from a JSON file or standard input (an array or JSON Lines, at most 64 MiB and 100,000 steps), among `--cmd` and `--export` in order; errors name the step. Scores and estimates unchanged; G2: Effect › Sketch › Conté Crayon (Foreground Level, Background Level, Texture, Scaling, Relief, Light Direction, Invert; a black crayon in the dark areas and a white one in the light areas on textured mid-grey paper; ranges and defaults unverified VectorCraft choices); measured Photoshop-style filters 57/57, the Effect Gallery remains (4–6 h); Affinity import AF.5: master pages, tables, paragraph formats, shadows, glows, outlines, overlays and embedded documents; Recolor Artwork Edit chips scroll within the available screen height (#3416); small palettes retain their tab height; scores and estimates unchanged; #3515: recent-font groups in font pickers; PDF/X-1a and PDF/X-3 flattening keeps a CMYK document's inks where it rasterizes, #2160; Blend panel Type and Ramp control step easing with a separate color Shift (#2539); Blend Options retains spacing and orientation; polynomial curves are original approximation; UI chrome: panels dock into any dock group or the icon column by dragging (UI.6), workspaces keep their layout changes (UI.7), dock groups collapse to their tabs by a double-click (UI.8); scores and hours unchanged; Shape Builder Gap Detection shares Live Paint’s spatial gap finder and temporary merge bridges (#2526); Custom is capped at 72 pt in the existing options dialog; Recolor model selection is available through the engine and MCP only (#2520); the dialog retains its existing controls; filter plug-ins read and set effect records and stroke joins, caps and miter limits, G17; the Print dialog's Media list has the Japanese papers: JIS B4 257 × 364 mm, JIS B5 182 × 257 mm and JIS B6 beside the ISO B4/B5, which keep their ISO 216 sizes, and はがき, 往復はがき, 封筒 長形3号/長形4号/角形2号/角形3号 and 四六判; a paper is named by its JSON id or its dialog label, any case and spacing; imported PDF type that is letter-spaced keeps its word spaces and no others; Fractional Widths: Character panel menu, per type object, on by default; System Layout remains a panel stub; scores unchanged; G4: manual Tate-chu-yoko; G4: No Break; scores unchanged; the selection tools take a clipping path on its outline, G1; Polygon and Star exact-size placement remembers the chosen count for later drags and dialog openings; Cancel preserves the previous count; Live trace result bounds and selection highlights exclude the retained bitmap except in source-image views; CSS swatch libraries retain fractional gradient stop positions; scores and hours unchanged; live-effect plug-ins given their object's fills and strokes and the itLine truncated
|
||||
> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-23 · **Change:** minor (COLR colour fonts (v0 and v1) draw and export as vector art; previously: Shape Builder: lines cut art of thousands of segments again, #937's reproduced case; scores unchanged until confirmed on the reporter's file; Artboard Options honors Scale Artwork with Artboard for preset, orientation and typed-size changes; both Fits keep artwork stationary; scores and estimates unchanged; File formats: PDF text opens where the file draws it, #722, score unchanged; G2: the Effect Gallery shipped (#2883): Effect › Effect Gallery… browses the Artistic, Brush Strokes, Distort, Sketch, Stylize and Texture filters, edits each filter's settings, builds an ordered stack (add, reorder, hide, remove) with a live canvas preview, and OK applies it as separate appearance effects in one undo step; remaining: filter thumbnails and a preview area inside the dialog; G2 estimate 4–6 → 1–2 h; Raster effects 82% → 85% (power-user view 49% → 52%), estimated, a modest move because the named missing dialog landed without thumbnails or an in-dialog preview; previously: colour emoji fonts with bitmap glyphs (`sbix`: Apple Color Emoji; `CBDT`: Noto Color Emoji) draw on the canvas and export: PDF Type 3 glyphs or images, SVG images with outlined text, EPS and legacy `.ai` images, Create Outlines images, see [type-parity.md](type-parity.md); scores unchanged; imported PDF type keeps a word space between two sizes (#3623); G13: gradient Dither (Illustrator 30.0): a Dither box in the Gradient panel (`paint.editGradient`/`paint.setFill` `dither`, saved in the native file) draws a linear or radial gradient fill with seeded fine noise that hides banding, on the canvas and in raster exports; SVG and PDF exports write the fill as an image at the Document Raster Effects resolution, as the public documentation describes dither; fills only, as documented; score and hours unchanged; #3546: `--automation-read-root` and `--automation-write-root` may each be given more than once (`vectorcraft-cli mcp` and the desktop app); a path inside any root of its kind is allowed, every confinement check unchanged. Scores and estimates unchanged; #3147: `vectorcraft-cli run --commands FILE` (or `-`) reads the steps from a JSON file or standard input (an array or JSON Lines, at most 64 MiB and 100,000 steps), among `--cmd` and `--export` in order; errors name the step. Scores and estimates unchanged; G2: Effect › Sketch › Conté Crayon (Foreground Level, Background Level, Texture, Scaling, Relief, Light Direction, Invert; a black crayon in the dark areas and a white one in the light areas on textured mid-grey paper; ranges and defaults unverified VectorCraft choices); measured Photoshop-style filters 57/57, the Effect Gallery remains (4–6 h); Affinity import AF.5: master pages, tables, paragraph formats, shadows, glows, outlines, overlays and embedded documents; Recolor Artwork Edit chips scroll within the available screen height (#3416); small palettes retain their tab height; scores and estimates unchanged; #3515: recent-font groups in font pickers; PDF/X-1a and PDF/X-3 flattening keeps a CMYK document's inks where it rasterizes, #2160; Blend panel Type and Ramp control step easing with a separate color Shift (#2539); Blend Options retains spacing and orientation; polynomial curves are original approximation; UI chrome: panels dock into any dock group or the icon column by dragging (UI.6), workspaces keep their layout changes (UI.7), dock groups collapse to their tabs by a double-click (UI.8); scores and hours unchanged; Shape Builder Gap Detection shares Live Paint’s spatial gap finder and temporary merge bridges (#2526); Custom is capped at 72 pt in the existing options dialog; Recolor model selection is available through the engine and MCP only (#2520); the dialog retains its existing controls; filter plug-ins read and set effect records and stroke joins, caps and miter limits, G17; the Print dialog's Media list has the Japanese papers: JIS B4 257 × 364 mm, JIS B5 182 × 257 mm and JIS B6 beside the ISO B4/B5, which keep their ISO 216 sizes, and はがき, 往復はがき, 封筒 長形3号/長形4号/角形2号/角形3号 and 四六判; a paper is named by its JSON id or its dialog label, any case and spacing; imported PDF type that is letter-spaced keeps its word spaces and no others; Fractional Widths: Character panel menu, per type object, on by default; System Layout remains a panel stub; scores unchanged; G4: manual Tate-chu-yoko; G4: No Break; scores unchanged; the selection tools take a clipping path on its outline, G1; Polygon and Star exact-size placement remembers the chosen count for later drags and dialog openings; Cancel preserves the previous count; Live trace result bounds and selection highlights exclude the retained bitmap except in source-image views; CSS swatch libraries retain fractional gradient stop positions; scores and hours unchangeLine truncated
|
||||
|
||||
## Feature submission evidence
|
||||
|
||||
@@ -464,6 +464,7 @@ since 2026-10-01.
|
||||
- **Artboard tab-switch follow-up:** changing the active document through its tab aligns the Artboard tool with the displayed board before Properties Delete; clicking the already-active tab preserves multiselection and Move/Scale Artwork options. Three headless `chrome::tests::artboard_document_tab_*` regressions cover actual tab A → B → A clicks followed by Properties Delete, surviving boards and guides, preserved artwork/symbols and Undo/Redo; controls cover same-tab multiselection, Move/Scale Artwork options and other tools. Historical focused validation on `dbd2497b` recorded one expected RED failure with two passing controls, then all three GREEN tests passed. All three also passed in historical full CI on `a0671777`. A full CI retry on the five-unit combined source at `a0671777` passed all seven stages with 6,613 test outcomes on 2026-10-14. An earlier full-CI run on the identical source panicked in the randomized `ai_mutated_save_never_panics` test; the cause remains unresolved. This five-fix batch does not claim to repair that failure.
|
||||
- **Artboard clean active-tab close (2026-10-15):** with the Artboard tool active, closing a clean active tab restores the surviving document's displayed board before Properties Delete. Nine targeted checks passed: three existing tab regressions, one clean close/Delete regression and five existing unsaved-document controls. The close regression checks the correct surviving board, preserved artwork/symbols and object selection, affected guides, one Delete edit, saved state and Undo/Redo. Three reviewed original full-app headless captures show the active tab before closing, the surviving document's shown board after closing, and the correct survivor after Properties Delete, using the actual tab × and Delete controls.
|
||||
- **Colour emoji with bitmap glyphs:** `sbix` (Apple Color Emoji) and `CBDT` (Noto Color Emoji) glyphs draw as their largest strike's PNG, placed with the type and unpainted by its fill; PDF writes them in Type 3 glyphs or as images, SVG as images with outlined text, EPS and legacy `.ai` as images, and Create Outlines makes embedded images. Synthetic test fonts in `crates/text/src/test_fonts.rs`; tests `crates/text/src/tests_bitmaps.rs`, `crates/render/src/tests_bitmapglyphs.rs`, `crates/svg/tests/colour_glyphs.rs`, `pdf::tests::colour_bitmap_glyphs_export_as_images`, the `eps` `colour_bitmap_glyphs_*` tests and `tests_pathops::create_outlines_turns_bitmap_glyphs_into_images`. COLR and OpenType SVG fonts remain.
|
||||
- **COLR colour fonts:** v0 and v1 glyphs draw as vector layers (solid colours, linear and radial gradients, clips, blend modes, the foreground colour from the run's fill) on the canvas, as paths in SVG, EPS, legacy `.ai` and PDF with outlined text, as Type 3 text in PDF, and as editable groups with Create Outlines; sweep gradients and Porter-Duff compositing draw the glyph as an image. Measured by `tests_colr`, `render::tests_colrglyphs`, `pdf::tests::colr_glyphs_export_as_vector_art`, `svg/tests/colour_glyphs.rs`, `eps` `colr_glyphs_*`, `tests_pathops::create_outlines_turns_colr_glyphs_into_layer_groups`. Scores unchanged (estimated).
|
||||
- **Character-style Auto leading:** capture and explicit style attributes retain Auto as a reset, distinct from omitted leading. Redefine and later numeric updates preserve local leading overrides; the Character Styles marker recognizes Auto correctly. Regression assertions cover partial definitions, Undo/Redo and native save/load serialization. Public references: [Character and paragraph styles](https://helpx.adobe.com/illustrator/using/character-paragraph-styles.html) and [Leading](https://helpx.adobe.com/illustrator/using/line-character-spacing.html).
|
||||
- **Text styles redefined to the defaults:** New and Redefine Character Style and Paragraph Style capture every attribute of the selected text, including those at their defaults (Auto kerning, Roman baseline alignment, the default Hyphenation options, the Every-line Composer, no tab stops), and `charStyle.setAttrs` and `paraStyle.setAttrs` keep an attribute set to its default value. After a redefinition, text whose value still equals the old definition's takes the new value, a default included; local overrides and attributes the new definition leaves out stay. The style panels show "+" only where the text differs from its style, including type with Auto alignment. Public reference: [Character and paragraph styles](https://web.archive.org/web/20260825113735/https://helpx.adobe.com/illustrator/using/character-paragraph-styles.html).
|
||||
- **Names of new styles and symbols:** `charStyle.new` and `paraStyle.new` trim the white space around the name they are given, as `charStyle.rename` and `paraStyle.rename` do, and refuse a name that is then empty; Duplicate names its copy from the trimmed name. `symbol.new` and `symbol.duplicate` trim the name as Symbol Options does, and `library.use` adds a library's text style under its trimmed name. Public reference: [Character and paragraph styles](https://web.archive.org/web/20260825113735/https://helpx.adobe.com/illustrator/using/character-paragraph-styles.html).
|
||||
@@ -1037,6 +1038,7 @@ applies to fills). Tests: `color::gradient::tests` (perceptual midpoint, expansi
|
||||
|
||||
| Date | Change | Summary |
|
||||
|---|---|---|
|
||||
| 2026-10-23 | minor | COLR colour fonts (v0 and v1) draw and export as vector art; evidence added; scores unchanged. |
|
||||
| 2026-10-18 | minor | Shape Builder on art of thousands of segments (traced outlines, type outlines): lines cut it again past 4,096 segments, where the planar map used to give up and the tool offered whole shapes (#937's reproduced case; the planar map's edge-source and face lookups were quadratic in the segments, now indexed, and the cap is 65,536); Path operations stays 80% and Shape Builder 70% until confirmed on the reporter's file (estimated) |
|
||||
| 2026-10-22 | minor | Colour and gradients: Illustrator 30.0's gradient Method, Classic or Perceptual (Gradient panel menu, canvas and raster exports, SVG/PDF as images at the raster effects resolution, native file); score and hours unchanged (estimated). |
|
||||
| 2026-10-22 | minor | G2: the Effect Gallery shipped (#2883): Effect › Effect Gallery… browses the Artistic, Brush Strokes, Distort, Sketch, Stylize and Texture filters, edits each filter's settings, builds an ordered stack (add, reorder, hide, remove) with a live canvas preview, and OK applies it as separate appearance effects in one undo step; remaining: filter thumbnails and a preview area inside the dialog; G2 estimate 4–6 → 1–2 h; Raster effects 82% → 85% (power-user view 49% → 52%), estimated, a modest move because the named missing dialog landed without thumbnails or an in-dialog preview. |
|
||||
|
||||
+3
-2
@@ -1,6 +1,6 @@
|
||||
# Type parity
|
||||
|
||||
> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-22 · **Change:** minor (colour emoji fonts with bitmap glyphs (`sbix`: Apple Color Emoji; `CBDT`: Noto Color Emoji) draw on the canvas and export: PDF Type 3 glyphs or images, SVG images with outlined text, EPS and legacy `.ai` images, Create Outlines images; scores unchanged; previously: #3515: recent-font groups in font pickers; manual Tate-chu-yoko marks characters across one em of a vertical column; System Layout: Character panel menu sets whole-point advances for every text object in the document (off by default); ruby (ふりがな) for live text: `type.ruby` sets or removes a reading over a byte range, above or below (right of the column in vertical type), start/centre/end aligned, sized and overhanging or squeezed; saved natively, laid out with its line growing, drawn on the canvas and in SVG/PDF (outlines where ruby is present); scores unchanged; previously:; Fractional Widths: Character panel menu turns whole-point advances on or off per type object, on by default; scores unchanged; type on a path threads, mixed with area type in one thread; scores unchanged; No Break keeps marked characters on one line; scores unchanged; a click on the out port threads the text into a closed path, a new frame at the click or a dragged rectangle, #2572 in part; scores unchanged; native family labels fall back to localized legacy names when typographic names are English-only, #2208; scores unchanged; Cmd+Shift+C aligns centre off the Mac, #1940; tab leaders are drawn in the tab's gap, #1877; type in symbols, pattern tiles, graph designs and opacity masks gets its layout bounds back on opening a native file, #1738; score unchanged; Escape while typing ends the edit, #1686; Select › Same on type, #1737; `justify` when creating point type, #1748; scores unchanged; OpenType stylistic sets, alternates, figure styles, superscript and subscript as character features, #1607; a wide word in non-rectangular area type moves down, #1615; scores unchanged; Character Styles New/Redefine capture the first selected character at run boundaries and end prior typing before capture; boundary and typing-history input tests and full workspace CI pass; scores and hours unchanged; Character styles retain explicit Auto leading, propagate resets and preserve local leading overrides; scores and hours unchanged; Linux font folders from fontconfig, #1529; commands and MCP `add_text` report area type that does not fit its frame, #1471; Tabs panel stop drags, #1458; Fit Headline in a frame one line tall, #1444; frames and paths beyond a billion points hold no text, #1451; scores unchanged; missing glyphs are looked for again after a font rescan, #1376; scores unchanged; Full-name font matching (#1258); Windows font-service QA pending; scores unchanged; Middle Eastern digit types: Character panel menu › Digits, `{digits}`; the font menu's script filter lists Thai fonts; Thai, Lao, Khmer and Myanmar lines break between words; the caret steps over whole clusters such as Thai consonants with their marks; Thai typed in a font without Thai falls back to a font made for Thai; earlier: Proportional Metrics in vertical type, `vpal`, #966; Cmd+Shift+C aligns centre off the Mac, a double-click on area type's bottom handle turns on Auto Size, #1940; MCP `add_text` exposes the existing `vertical` option for point, area and path type; horizontal remains the default; scores and hours unchanged; Vertical fullwidth question and exclamation marks keep their nominal glyph upright when the font has no vertical alternate; scores and hours unchanged. tab leaders are drawn in the tab's gap, #1877; type in symbols, pattern tiles, graph designs and opacity masks gets its layout bounds back on opening a native file, #1738; score unchanged; Escape while typing ends the edit, #1686; Select › Same on type, #1737; `justify` when creating point type, #1748; scores unchanged; OpenType stylistic sets, alternates, figure styles, superscript and subscript as character features, #1607; a wide word in non-rectangular area type moves down, #1615; scores unchanged; Character Styles New/Redefine capture the first selected character at run boundaries and end prior typing before capture; boundary and typing-history input tests and full workspace CI pass; scores and hours unchanged; Character styles retain explicit Auto leading, propagate resets and preserve local leading overrides; scores and hours unchanged; Linux font folders from fontconfig, #1529; commands and MCP `add_text` report area type that does not fit its frame, #1471; Tabs panel stop drags, #1458; Fit Headline in a frame one line tall, #1444; frames and paths beyond a billion points hold no text, #1451; scores unchanged; missing glyphs are looked for again after a font rescan, #1376; scores unchanged; Full-name font matching (#1258); Windows font-service QA pending; scores unchanged; Middle Eastern digit types: Character panel menu › Digits, `{digits}`; Line truncated
|
||||
> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-23 · **Change:** minor (COLR colour fonts (v0 and v1) draw and export as vector art; previously: colour emoji fonts with bitmap glyphs (`sbix`: Apple Color Emoji; `CBDT`: Noto Color Emoji) draw on the canvas and export: PDF Type 3 glyphs or images, SVG images with outlined text, EPS and legacy `.ai` images, Create Outlines images; scores unchanged; previously: #3515: recent-font groups in font pickers; manual Tate-chu-yoko marks characters across one em of a vertical column; System Layout: Character panel menu sets whole-point advances for every text object in the document (off by default); ruby (ふりがな) for live text: `type.ruby` sets or removes a reading over a byte range, above or below (right of the column in vertical type), start/centre/end aligned, sized and overhanging or squeezed; saved natively, laid out with its line growing, drawn on the canvas and in SVG/PDF (outlines where ruby is present); scores unchanged; previously:; Fractional Widths: Character panel menu turns whole-point advances on or off per type object, on by default; scores unchanged; type on a path threads, mixed with area type in one thread; scores unchanged; No Break keeps marked characters on one line; scores unchanged; a click on the out port threads the text into a closed path, a new frame at the click or a dragged rectangle, #2572 in part; scores unchanged; native family labels fall back to localized legacy names when typographic names are English-only, #2208; scores unchanged; Cmd+Shift+C aligns centre off the Mac, #1940; tab leaders are drawn in the tab's gap, #1877; type in symbols, pattern tiles, graph designs and opacity masks gets its layout bounds back on opening a native file, #1738; score unchanged; Escape while typing ends the edit, #1686; Select › Same on type, #1737; `justify` when creating point type, #1748; scores unchanged; OpenType stylistic sets, alternates, figure styles, superscript and subscript as character features, #1607; a wide word in non-rectangular area type moves down, #1615; scores unchanged; Character Styles New/Redefine capture the first selected character at run boundaries and end prior typing before capture; boundary and typing-history input tests and full workspace CI pass; scores and hours unchanged; Character styles retain explicit Auto leading, propagate resets and preserve local leading overrides; scores and hours unchanged; Linux font folders from fontconfig, #1529; commands and MCP `add_text` report area type that does not fit its frame, #1471; Tabs panel stop drags, #1458; Fit Headline in a frame one line tall, #1444; frames and paths beyond a billion points hold no text, #1451; scores unchanged; missing glyphs are looked for again after a font rescan, #1376; scores unchanged; Full-name font matching (#1258); Windows font-service QA pending; scores unchanged; Middle Eastern digit types: Character panel menu › Digits, `{digits}`; the font menu's script filter lists Thai fonts; Thai, Lao, Khmer and Myanmar lines break between words; the caret steps over whole clusters such as Thai consonants with their marks; Thai typed in a font without Thai falls back to a font made for Thai; earlier: Proportional Metrics in vertical type, `vpal`, #966; Cmd+Shift+C aligns centre off the Mac, a double-click on area type's bottom handle turns on Auto Size, #1940; MCP `add_text` exposes the existing `vertical` option for point, area and path type; horizontal remains the default; scores and hours unchanged; Vertical fullwidth question and exclamation marks keep their nominal glyph upright when the font has no vertical alternate; scores and hours unchanged. tab leaders are drawn in the tab's gap, #1877; type in symbols, pattern tiles, graph designs and opacity masks gets its layout bounds back on opening a native file, #1738; score unchanged; Escape while typing ends the edit, #1686; Select › Same on type, #1737; `justify` when creating point type, #1748; scores unchanged; OpenType stylistic sets, alternates, figure styles, superscript and subscript as character features, #1607; a wide word in non-rectangular area type moves down, #1615; scores unchanged; Character Styles New/Redefine capture the first selected character at run boundaries and end prior typing before capture; boundary and typing-history input tests and full workspace CI pass; scores and hours unchanged; Character styles retain explicit Auto leading, propagate resets and preserve local leading overrides; scores and hours unchanged; Linux font folders from fontconfig, #1529; commands and MCP `add_text` report area type that does not fit its frame, #1471; Tabs panel stop drags, #1458; Fit Headline in a frame one line tall, #1444; frames and paths beyond a billion points hold no text, #1451; scores unchanged; missing glyphs are looked for again after a font rescan, #1376; scores unchanged; Full-name font matching (#1258); Windows font-service QA pending; scores unchanged; Line truncated
|
||||
|
||||
Type is Illustrator's largest single area by use (weight 13 of 105 across "Type core" and "Type advanced" in
|
||||
[target-app-parity.md](target-app-parity.md)). This checklist lists the features one by one. Status is from the
|
||||
@@ -33,7 +33,7 @@ against Illustrator's public documentation; **estimated** unless noted.
|
||||
| Full font-name matching (OpenType name ID 4) | done | #1258: loaded/cataloged faces and Missing Fonts searches; localized names and variable default faces; Windows font-service QA pending |
|
||||
| Variable fonts | partial | named instances as styles; Character panel › Variable Font sets each axis (`fontAxes`); the font menu's Variable filter is missing |
|
||||
| Fallback glyphs keep the text's weight and slant | done | #2491: a character from a fallback face is set in that family's face nearest the run's weight and slant; Bold Italic of a missing family is drawn Bold (Source Sans 3 has no Bold Italic) rather than Italic |
|
||||
| Colour fonts (bitmap, COLR, OpenType SVG) | partial | bitmap glyphs (`sbix`, `CBDT`) done: the largest strike's PNG, transformed with the type, fill and stroke ignored; PDF Type 3 glyphs or images, SVG images with outlined text (live text leaves emoji to the viewer, their fonts not embedded), EPS and legacy `.ai` images, Create Outlines images; not `sbix` duplicate, flipped, JPEG or TIFF glyphs, or `CBDT` BGRA or mask data, ruby, envelopes or warps. COLR and OpenType SVG missing. Evidence: `tests_bitmaps`, `render::tests_bitmapglyphs`, `pdf::tests::colour_bitmap_glyphs_export_as_images`, `svg/tests/colour_glyphs.rs`, `eps` `colour_bitmap_glyphs_*`, `tests_pathops::create_outlines_turns_bitmap_glyphs_into_images` |
|
||||
| Colour fonts (bitmap, COLR, OpenType SVG) | partial | bitmap glyphs (`sbix`, `CBDT`) done: the largest strike's PNG, transformed with the type, fill and stroke ignored; PDF Type 3 glyphs or images, SVG images with outlined text (live text leaves emoji to the viewer, their fonts not embedded), EPS and legacy `.ai` images, Create Outlines images; not `sbix` duplicate, flipped, JPEG or TIFF glyphs, or `CBDT` BGRA or mask data, ruby, envelopes or warps. COLR (v0 and v1) done: a glyph's layers as vector art (solid colours, linear and radial gradients, clip glyphs and boxes, blend modes, transforms, palette 0, the foreground colour from the run's fill, variable fonts at the face's instance), transformed with the type; drawn on the canvas, written as paths in SVG, EPS, legacy `.ai` and PDF with outlined text, as text in PDF (Type 3 glyphs), and Create Outlines makes groups of editable paths. Paints documents have no form for draw the glyph as an image (256 px per em): sweep gradients, Porter-Duff compositing, radial gradients from a circle that isn't the centre, repeating or reflecting gradients. Not ruby, envelopes or warps. OpenType SVG missing. Evidence: `tests_bitmaps`, `tests_colr`, `render::tests_bitmapglyphs`, `render::tests_colrglyphs`, `pdf::tests::colour_bitmap_glyphs_export_as_images`, `pdf::tests::colr_glyphs_export_as_vector_art`, `svg/tests/colour_glyphs.rs`, `eps` `colour_bitmap_glyphs_*` and `colr_glyphs_*`, `tests_pathops::create_outlines_turns_bitmap_glyphs_into_images`, `tests_pathops::create_outlines_turns_colr_glyphs_into_layer_groups` |
|
||||
| Every-line and Single-line composers | done | tuned by eye, never compared side by side |
|
||||
| Optical Margin Alignment | done | Type › Optical Margin Alignment, `type.opticalMarginAlignment`: per type object, with one setting for all the frames of a thread, in point and area type of left-to-right paragraphs, and at the brackets of type on a path whose first paragraph runs left to right; right-to-left paragraphs of point and area type, and type on a path whose first paragraph runs right to left, do not hang |
|
||||
| System Layout | done | Character panel menu › System Layout, `type.systemLayout`: the whole document, off by default and for documents from before it, saved only when on. On, every text object advances by whole points (at least one when a character takes space). New point, area and path type, threaded frames, placed text, graph and dimension labels and pasted plain text inherit it. Evidence: `tests::system_layout_rounds_positive_advances_to_whole_points`, `typecmd::area_tests::system_layout_sets_the_document_and_every_text_object`, `panels::character::tests::system_layout_menu_item_toggles_the_document` |
|
||||
@@ -68,6 +68,7 @@ Character Styles menu New/Redefine and footer New capture the first selected cha
|
||||
|
||||
| Date | Change | Summary |
|
||||
|---|---|---|
|
||||
| 2026-10-23 | minor | Colour fonts: COLR colour fonts (v0 and v1) draw and export as vector art: layers with solid colours, gradients, clips and blend modes on the canvas, in SVG, EPS, legacy `.ai` and PDF, and as editable paths with Create Outlines; paints documents lack (sweep gradients, compositing) as images of the glyph; scores unchanged |
|
||||
| 2026-10-22 | minor | Font pickers list recently applied families first (#3515), using the existing recent-font limit; search, filters, previews and keyboard selection share the same rows. Scores and estimates unchanged. |
|
||||
| 2026-10-21 | minor | Snap to Glyph marked done in the checklist (#3124); scores unchanged at this rounding |
|
||||
| 2026-10-21 | minor | Manual Tate-chu-yoko: Character panel menu marks characters that stand across one em of a vertical column; ruby and the up/down settings remain; scores unchanged |
|
||||
|
||||
Reference in new issue
Block a user