Update Skrifa to 0.22.0

Cargo.toml

@@ -42,7 +42,7 @@ vello = { version = "0.2.0", path = "vello" }
 vello_encoding = { version = "0.2.0", path = "vello_encoding" }
 vello_shaders = { version = "0.2.0", path = "vello_shaders" }
 bytemuck = { version = "1.16.0", features = ["derive"] }
-skrifa = "0.19.3"
+skrifa = "0.22.0"
 peniko = "0.2.0"
 futures-intrusive = "0.5.0"
 raw-window-handle = "0.6.2"

examples/scenes/src/simple_text.rs

@@ -3,12 +3,10 @@
 
 use std::sync::Arc;
 
-use vello::glyph::Glyph;
 use vello::kurbo::Affine;
 use vello::peniko::{Blob, Brush, BrushRef, Color, Font, StyleRef};
-use vello::skrifa::raw::FontRef;
-use vello::skrifa::MetadataProvider;
-use vello::Scene;
+use vello::skrifa::{raw::FontRef, MetadataProvider};
+use vello::{Glyph, Scene};
 
 // This is very much a hack to get things working.
 // On Windows, can set this to "c:\\Windows\\Fonts\\seguiemj.ttf" to get color emoji
@@ -179,7 +177,7 @@ impl SimpleText {
                     let x = pen_x;
                     pen_x += advance;
                     Some(Glyph {
-                        id: gid.to_u16() as u32,
+                        id: gid.to_u32(),
                         x,
                         y: pen_y,
                     })

vello/src/lib.rs

@@ -97,10 +97,8 @@ pub use peniko;
 /// 2D geometry, with a focus on curves.
 pub use peniko::kurbo;
 
-#[doc(hidden)]
 pub use skrifa;
-
-pub mod glyph;
+pub use vello_encoding::Glyph;
 
 #[cfg(feature = "wgpu")]
 pub use wgpu;

vello/src/scene.rs

@@ -464,7 +464,7 @@ impl<'a> DrawGlyphs<'a> {
         loop {
             let ppem = self.run.font_size;
             let outline_glyphs = (&mut glyphs).take_while(|glyph| {
-                let glyph_id = GlyphId::new(glyph.id.try_into().unwrap());
+                let glyph_id = GlyphId::new(glyph.id);
                 match colour_collection.get(glyph_id) {
                     Some(color) => {
                         final_glyph = Some((EmojiLikeGlyph::Colr(color), *glyph));

vello/src/scene/bitmap.rs

@@ -26,7 +26,7 @@ impl<'a> BitmapStrikes<'a> {
     /// This will prefer `sbix`, `CBDT`, and `CBLC` formats in that order.
     ///
     /// To select a specific format, use [`with_format`](Self::with_format).
-    pub fn new(font: &impl TableProvider<'a>) -> Self {
+    pub fn new(font: &(impl TableProvider<'a> + MetadataProvider<'a>)) -> Self {
         for format in [BitmapFormat::Sbix, BitmapFormat::Cbdt, BitmapFormat::Ebdt] {
             if let Some(strikes) = Self::with_format(font, format) {
                 return strikes;
@@ -38,7 +38,10 @@ impl<'a> BitmapStrikes<'a> {
     /// Creates a new `BitmapStrikes` for the given font and format.
     ///
     /// Returns `None` if the requested format is not available.
-    pub fn with_format(font: &impl TableProvider<'a>, format: BitmapFormat) -> Option<Self> {
+    pub fn with_format(
+        font: &(impl TableProvider<'a> + MetadataProvider<'a>),
+        format: BitmapFormat,
+    ) -> Option<Self> {
         let kind = match format {
             BitmapFormat::Sbix => StrikesKind::Sbix(
                 font.sbix().ok()?,

vello_encoding/src/glyph_cache.rs

@@ -8,7 +8,7 @@ use super::{Encoding, StreamOffsets};
 
 use peniko::{Font, Style};
 use skrifa::instance::{NormalizedCoord, Size};
-use skrifa::outline::{HintingInstance, HintingMode, LcdLayout, OutlineGlyphFormat};
+use skrifa::outline::{HintingInstance, HintingOptions, OutlineGlyphFormat};
 use skrifa::{GlyphId, MetadataProvider, OutlineGlyphCollection};
 
 #[derive(Default)]
@@ -162,7 +162,7 @@ impl<'a> GlyphCacheSession<'a> {
             entry.serial = self.serial;
             return Some((entry.encoding.clone(), entry.stream_sizes));
         }
-        let outline = self.outlines.get(GlyphId::new(key.glyph_id as u16))?;
+        let outline = self.outlines.get(GlyphId::new(key.glyph_id))?;
         let mut encoding = self.free_list.pop().unwrap_or_default();
         let encoding_ptr = Arc::make_mut(&mut encoding);
         encoding_ptr.reset();
@@ -245,13 +245,19 @@ pub(crate) struct HintKey<'a> {
 
 impl<'a> HintKey<'a> {
     fn instance(&self) -> Option<HintingInstance> {
-        HintingInstance::new(self.outlines, self.size, self.coords, HINTING_MODE).ok()
+        HintingInstance::new(self.outlines, self.size, self.coords, HINTING_OPTIONS).ok()
     }
 }
 
-const HINTING_MODE: HintingMode = HintingMode::Smooth {
-    lcd_subpixel: Some(LcdLayout::Horizontal),
-    preserve_linear_metrics: true,
+const HINTING_OPTIONS: HintingOptions = HintingOptions {
+    engine: skrifa::outline::Engine::AutoFallback,
+    target: skrifa::outline::Target::Smooth {
+        mode: skrifa::outline::SmoothMode::Lcd,
+        // TODO: Set based on whether the anti-aliasing mode is Area?
+        symmetric_rendering: false,
+        // TODO: Does Parley handle layout in a hinting-aware way?
+        preserve_linear_metrics: true,
+    },
 };
 
 #[derive(Default)]
@@ -278,7 +284,7 @@ impl HintCache {
             entry.font_index = key.font_index;
             entry
                 .instance
-                .reconfigure(key.outlines, key.size, key.coords, HINTING_MODE)
+                .reconfigure(key.outlines, key.size, key.coords, HINTING_OPTIONS)
                 .ok()?;
         }
         Some(&entry.instance)