Update `glyph_brush` and `glow_glyph`

1 files changed, 26 insertions, 43 deletions

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