Update glyph_brush and glow_glyph

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"

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 {
+                    text: vec![glow_glyph::Text {
+                        text: text.content,
+                        scale: glow_glyph::ab_glyph::PxScale {
                             x: text.size * scale_factor,
                             y: text.size * scale_factor,
                         },
-                    color: text.color,
                         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")]

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<()>>,
-    measure_brush: RefCell<glyph_brush::GlyphBrush<'static, ()>>,
 }
 
 impl Pipeline {
@@ -22,36 +22,29 @@ impl Pipeline {
                     .unwrap_or_else(|_| font::FALLBACK.to_vec())
             });
 
-        let load_glyph_brush = |font: Vec<u8>| {
+        let font = ab_glyph::FontArc::try_from_vec(default_font)
-            let builder =
+            .unwrap_or_else(|_| {
-                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| {
                 log::warn!(
-                    "System font failed to load. \
+                    "System font failed to load. Falling back to \
-                    Falling back to embedded font..."
+                    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),
+            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 font = ab_glyph::FontArc::try_from_slice(bytes)
-                let _ = self.measure_brush.borrow_mut().add_font_bytes(bytes);
+                    .expect("Load font");
 
-                let font_id =
+                let _ = self.measure_brush.borrow_mut().add_font(font.clone());
-                    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

graphics/src/backend.rs

@@ -17,8 +17,6 @@ pub trait Text {
         font: Font,
         bounds: Size,
     ) -> (f32, f32);
-
-    fn space_width(&self, size: f32) -> f32;
 }
 
 pub trait Image {

graphics/src/widget/text_input.rs

@@ -37,16 +37,9 @@ where
     fn measure_value(&self, value: &str, size: u16, font: Font) -> f32 {
         let backend = self.backend();
 
-        let (mut width, _) =
+        let (width, _) =
             backend.measure(value, f32::from(size), font, Size::INFINITY);
 
-        let spaces_around = value.len() - value.trim().len();
-
-        if spaces_around > 0 {
-            let space_width = backend.space_width(size as f32);
-            width += spaces_around as f32 * space_width;
-        }
-
         width
     }
 

wgpu/src/backend.rs

@@ -250,10 +250,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")]

wgpu/src/text.rs

@@ -6,7 +6,6 @@ use std::{cell::RefCell, collections::HashMap};
 pub struct Pipeline {
     draw_brush: RefCell<wgpu_glyph::GlyphBrush<'static, ()>>,
     draw_font_map: RefCell<HashMap<String, wgpu_glyph::FontId>>,
-
     measure_brush: RefCell<glyph_brush::GlyphBrush<'static, ()>>,
 }
 
@@ -52,7 +51,6 @@ impl Pipeline {
         Pipeline {
             draw_brush: RefCell::new(draw_brush),
             draw_font_map: RefCell::new(HashMap::new()),
-
             measure_brush: RefCell::new(measure_brush),
         }
     }
@@ -109,20 +107,6 @@ impl Pipeline {
         }
     }
 
-    pub fn space_width(&self, size: f32) -> f32 {
-        use wgpu_glyph::GlyphCruncher;
-
-        let glyph_brush = self.measure_brush.borrow();
-
-        // TODO: Select appropriate font
-        let font = &glyph_brush.fonts()[0];
-
-        font.glyph(' ')
-            .scaled(wgpu_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.