1 files changed, 52 insertions, 31 deletions

diff --git a/wgpu/src/text.rs b/wgpu/src/text.rs
index bf37abe5..c5670102 100644
--- a/wgpu/src/text.rs
+++ b/wgpu/src/text.rs
@@ -11,6 +11,8 @@ pub const BUILTIN_ICONS: iced_native::Font = iced_native::Font::External {
 
 pub const CHECKMARK_ICON: char = '\u{F00C}';
 
+const FALLBACK_FONT: &[u8] = include_bytes!("../fonts/Lato-Regular.ttf");
+
 #[derive(Debug)]
 pub struct Pipeline {
     draw_brush: RefCell<wgpu_glyph::GlyphBrush<'static, ()>>,
@@ -20,29 +22,43 @@ pub struct Pipeline {
 }
 
 impl Pipeline {
-    pub fn new(device: &mut wgpu::Device) -> Self {
+    pub fn new(
+        device: &mut wgpu::Device,
+        format: wgpu::TextureFormat,
+        default_font: Option<&[u8]>,
+    ) -> Self {
         // TODO: Font customization
         let font_source = font::Source::new();
 
-        let default_font = font_source
-            .load(&[font::Family::SansSerif, font::Family::Serif])
-            .expect("Find sans-serif or serif font");
+        let default_font =
+            default_font.map(|slice| slice.to_vec()).unwrap_or_else(|| {
+                font_source
+                    .load(&[font::Family::SansSerif, font::Family::Serif])
+                    .unwrap_or_else(|_| FALLBACK_FONT.to_vec())
+            });
+
+        let load_glyph_brush = |font: Vec<u8>| {
+            let builder =
+                wgpu_glyph::GlyphBrushBuilder::using_fonts_bytes(vec![
+                    font.clone()
+                ])?;
+
+            Ok((
+                builder,
+                glyph_brush::GlyphBrushBuilder::using_font_bytes(font).build(),
+            ))
+        };
 
-        let mono_font = font_source
-            .load(&[font::Family::Monospace])
-            .expect("Find monospace font");
+        let (brush_builder, measure_brush) = load_glyph_brush(default_font)
+            .unwrap_or_else(|_: wgpu_glyph::rusttype::Error| {
+                log::warn!("System font failed to load. Falling back to embedded font...");
 
-        let draw_brush =
-            wgpu_glyph::GlyphBrushBuilder::using_fonts_bytes(vec![
-                mono_font,
-                default_font.clone(),
-            ])
-            .initial_cache_size((2048, 2048))
-            .build(device, wgpu::TextureFormat::Bgra8UnormSrgb);
+                load_glyph_brush(FALLBACK_FONT.to_vec()).expect("Load fallback font")
+            });
 
-        let measure_brush =
-            glyph_brush::GlyphBrushBuilder::using_font_bytes(default_font)
-                .build();
+        let draw_brush = brush_builder
+            .initial_cache_size((2048, 2048))
+            .build(device, format);
 
         Pipeline {
             draw_brush: RefCell::new(draw_brush),
@@ -95,14 +111,7 @@ impl Pipeline {
             text: content,
             scale: wgpu_glyph::Scale { x: size, y: size },
             bounds: (bounds.width, bounds.height),
-
-            // TODO: This is a bit hacky. We are loading the debug font as the
-            // first font in the `draw_brush`. The `measure_brush` does not
-            // contain this, hence we subtract 1.
-            //
-            // This should go away once we unify `draw_brush` and
-            // `measure_brush`.
-            font_id: wgpu_glyph::FontId(font_id - 1),
+            font_id: wgpu_glyph::FontId(font_id),
             ..Default::default()
         };
 
@@ -134,16 +143,28 @@ impl Pipeline {
         // it uses a lifetimed `GlyphCalculatorGuard` with side-effects on drop.
         // This makes stuff quite inconvenient. A manual method for trimming the
         // cache would make our lives easier.
-        let _ = self
-            .measure_brush
-            .borrow_mut()
-            .process_queued(|_, _| {}, |_| {})
-            .expect("Trim text measurements");
+        loop {
+            let action = self
+                .measure_brush
+                .borrow_mut()
+                .process_queued(|_, _| {}, |_| {});
+
+            match action {
+                Ok(_) => break,
+                Err(glyph_brush::BrushError::TextureTooSmall { suggested }) => {
+                    let (width, height) = suggested;
+
+                    self.measure_brush
+                        .borrow_mut()
+                        .resize_texture(width, height);
+                }
+            }
+        }
     }
 
     pub fn find_font(&self, font: iced_native::Font) -> wgpu_glyph::FontId {
         match font {
-            iced_native::Font::Default => wgpu_glyph::FontId(1),
+            iced_native::Font::Default => wgpu_glyph::FontId(0),
             iced_native::Font::External { name, bytes } => {
                 if let Some(font_id) = self.draw_font_map.borrow().get(name) {
                     return *font_id;