Update `glyph_brush` and `glow_glyph`

3 files changed, 40 insertions, 56 deletions

diff --git a/glow/Cargo.toml b/glow/Cargo.toml
index dd6bbefc..a18fffe1 100644
--- a/glow/Cargo.toml
+++ b/glow/Cargo.toml
@@ -15,12 +15,12 @@ svg = []
 
 [dependencies]
 glow = "0.4"
-glow_glyph = "0.1"
+glow_glyph = "0.2"
+glyph_brush = "0.7"
 euclid = "0.20"
 bytemuck = "1.2"
 glam = "0.8"
 log = "0.4"
-glyph_brush = "0.6"
 
 [dependencies.iced_native]
 version = "0.2"
diff --git a/glow/src/backend.rs b/glow/src/backend.rs
index c98aa5fe..6bd443ad 100644
--- a/glow/src/backend.rs
+++ b/glow/src/backend.rs
@@ -101,7 +101,6 @@ impl Backend {
             for text in layer.text.iter() {
                 // Target physical coordinates directly to avoid blurry text
                 let text = glow_glyph::Section {
-                    text: text.content,
                     // TODO: We `round` here to avoid rerasterizing text when
                     // its position changes slightly. This can make text feel a
                     // bit "jumpy". We may be able to do better once we improve
@@ -123,12 +122,18 @@ impl Backend {
                         (text.bounds.width * scale_factor).ceil(),
                         (text.bounds.height * scale_factor).ceil(),
                     ),
-                    scale: glow_glyph::Scale {
-                        x: text.size * scale_factor,
-                        y: text.size * scale_factor,
-                    },
-                    color: text.color,
-                    font_id: self.text_pipeline.find_font(text.font),
+                    text: vec![glow_glyph::Text {
+                        text: text.content,
+                        scale: glow_glyph::ab_glyph::PxScale {
+                            x: text.size * scale_factor,
+                            y: text.size * scale_factor,
+                        },
+                        font_id: self.text_pipeline.find_font(text.font),
+                        extra: glow_glyph::Extra {
+                            color: text.color,
+                            z: 0.0,
+                        },
+                    }],
                     layout: glow_glyph::Layout::default()
                         .h_align(match text.horizontal_alignment {
                             HorizontalAlignment::Left => {
@@ -191,10 +196,6 @@ impl backend::Text for Backend {
     ) -> (f32, f32) {
         self.text_pipeline.measure(contents, size, font, bounds)
     }
-
-    fn space_width(&self, size: f32) -> f32 {
-        self.text_pipeline.space_width(size)
-    }
 }
 
 #[cfg(feature = "image")]
diff --git a/glow/src/text.rs b/glow/src/text.rs
index 0a11b64f..6dc7882c 100644
--- a/glow/src/text.rs
+++ b/glow/src/text.rs
@@ -1,13 +1,13 @@
 use crate::Transformation;
+use glow_glyph::ab_glyph;
 use iced_graphics::font;
 use std::{cell::RefCell, collections::HashMap};
 
 #[derive(Debug)]
 pub struct Pipeline {
-    draw_brush: RefCell<glow_glyph::GlyphBrush<'static>>,
+    draw_brush: RefCell<glow_glyph::GlyphBrush>,
     draw_font_map: RefCell<HashMap<String, glow_glyph::FontId>>,
-
-    measure_brush: RefCell<glyph_brush::GlyphBrush<'static, ()>>,
+    measure_brush: RefCell<glyph_brush::GlyphBrush<()>>,
 }
 
 impl Pipeline {
@@ -22,36 +22,29 @@ impl Pipeline {
                     .unwrap_or_else(|_| font::FALLBACK.to_vec())
             });
 
-        let load_glyph_brush = |font: Vec<u8>| {
-            let builder =
-                glow_glyph::GlyphBrushBuilder::using_fonts_bytes(vec![
-                    font.clone()
-                ])?;
-
-            Ok((
-                builder,
-                glyph_brush::GlyphBrushBuilder::using_font_bytes(font).build(),
-            ))
-        };
-
-        let (brush_builder, measure_brush) = load_glyph_brush(default_font)
-            .unwrap_or_else(|_: glow_glyph::rusttype::Error| {
+        let font = ab_glyph::FontArc::try_from_vec(default_font)
+            .unwrap_or_else(|_| {
                 log::warn!(
-                    "System font failed to load. \
-                    Falling back to embedded font..."
+                    "System font failed to load. Falling back to \
+                    embedded font..."
                 );
 
-                load_glyph_brush(font::FALLBACK.to_vec())
+                ab_glyph::FontArc::try_from_slice(font::FALLBACK)
                     .expect("Load fallback font")
             });
 
         let draw_brush =
-            brush_builder.initial_cache_size((2048, 2048)).build(gl);
+            glow_glyph::GlyphBrushBuilder::using_font(font.clone())
+                .initial_cache_size((2048, 2048))
+                .draw_cache_multithread(false) // TODO: Expose as a configuration flag
+                .build(&gl);
+
+        let measure_brush =
+            glyph_brush::GlyphBrushBuilder::using_font(font).build();
 
         Pipeline {
             draw_brush: RefCell::new(draw_brush),
             draw_font_map: RefCell::new(HashMap::new()),
-
             measure_brush: RefCell::new(measure_brush),
         }
     }
@@ -88,10 +81,13 @@ impl Pipeline {
         let glow_glyph::FontId(font_id) = self.find_font(font);
 
         let section = glow_glyph::Section {
-            text: content,
-            scale: glow_glyph::Scale { x: size, y: size },
             bounds: (bounds.width, bounds.height),
-            font_id: glow_glyph::FontId(font_id),
+            text: vec![glow_glyph::Text {
+                text: content,
+                scale: size.into(),
+                font_id: glow_glyph::FontId(font_id),
+                extra: glow_glyph::Extra::default(),
+            }],
             ..Default::default()
         };
 
@@ -104,20 +100,6 @@ impl Pipeline {
         }
     }
 
-    pub fn space_width(&self, size: f32) -> f32 {
-        use glow_glyph::GlyphCruncher;
-
-        let glyph_brush = self.measure_brush.borrow();
-
-        // TODO: Select appropriate font
-        let font = &glyph_brush.fonts()[0];
-
-        font.glyph(' ')
-            .scaled(glow_glyph::Scale { x: size, y: size })
-            .h_metrics()
-            .advance_width
-    }
-
     pub fn trim_measurement_cache(&mut self) {
         // TODO: We should probably use a `GlyphCalculator` for this. However,
         // it uses a lifetimed `GlyphCalculatorGuard` with side-effects on drop.
@@ -150,11 +132,12 @@ impl Pipeline {
                     return *font_id;
                 }
 
-                // TODO: Find a way to share font data
-                let _ = self.measure_brush.borrow_mut().add_font_bytes(bytes);
+                let font = ab_glyph::FontArc::try_from_slice(bytes)
+                    .expect("Load font");
+
+                let _ = self.measure_brush.borrow_mut().add_font(font.clone());
 
-                let font_id =
-                    self.draw_brush.borrow_mut().add_font_bytes(bytes);
+                let font_id = self.draw_brush.borrow_mut().add_font(font);
 
                 let _ = self
                     .draw_font_map