Draft `Font` type and implement `Text::font`

5 files changed, 75 insertions, 28 deletions

diff --git a/wgpu/src/primitive.rs b/wgpu/src/primitive.rs
index 8e40e3a6..b9f1ca6f 100644
--- a/wgpu/src/primitive.rs
+++ b/wgpu/src/primitive.rs
@@ -1,4 +1,4 @@
-use iced_native::{text, Background, Color, Rectangle, Vector};
+use iced_native::{text, Background, Color, Font, Rectangle, Vector};
 
 #[derive(Debug, Clone)]
 pub enum Primitive {
@@ -11,6 +11,7 @@ pub enum Primitive {
         bounds: Rectangle,
         color: Color,
         size: f32,
+        font: Font,
         horizontal_alignment: text::HorizontalAlignment,
         vertical_alignment: text::VerticalAlignment,
     },
diff --git a/wgpu/src/renderer.rs b/wgpu/src/renderer.rs
index 6441043c..d3bdc878 100644
--- a/wgpu/src/renderer.rs
+++ b/wgpu/src/renderer.rs
@@ -147,6 +147,7 @@ impl Renderer {
                 bounds,
                 size,
                 color,
+                font,
                 horizontal_alignment,
                 vertical_alignment,
             } => {
@@ -179,6 +180,7 @@ impl Renderer {
                     bounds: (bounds.width, bounds.height),
                     scale: wgpu_glyph::Scale { x: *size, y: *size },
                     color: color.into_linear(),
+                    font_id: self.text_pipeline.find_font(*font),
                     layout: wgpu_glyph::Layout::default()
                         .h_align(match horizontal_alignment {
                             iced_native::text::HorizontalAlignment::Left => {
diff --git a/wgpu/src/renderer/widget/text.rs b/wgpu/src/renderer/widget/text.rs
index 65b23c5e..a8ead70b 100644
--- a/wgpu/src/renderer/widget/text.rs
+++ b/wgpu/src/renderer/widget/text.rs
@@ -1,8 +1,6 @@
 use crate::{Primitive, Renderer};
 use iced_native::{layout, text, Color, Layout, MouseCursor, Size, Text};
 
-use wgpu_glyph::Section;
-
 use std::f32;
 
 // TODO: Obtain from renderer configuration
@@ -14,14 +12,9 @@ impl text::Renderer for Renderer {
         let size = text.size.map(f32::from).unwrap_or(DEFAULT_TEXT_SIZE);
         let bounds = limits.max();
 
-        let section = Section {
-            text: &text.content,
-            scale: wgpu_glyph::Scale { x: size, y: size },
-            bounds: (bounds.width, bounds.height),
-            ..Default::default()
-        };
-
-        let (width, height) = self.text_pipeline.measure(&section);
+        let (width, height) =
+            self.text_pipeline
+                .measure(&text.content, size, text.font, bounds);
 
         let size = limits.resolve(Size::new(width, height));
 
@@ -35,6 +28,7 @@ impl text::Renderer for Renderer {
                 size: text.size.map(f32::from).unwrap_or(DEFAULT_TEXT_SIZE),
                 bounds: layout.bounds(),
                 color: text.color.unwrap_or(Color::BLACK),
+                font: text.font,
                 horizontal_alignment: text.horizontal_alignment,
                 vertical_alignment: text.vertical_alignment,
             },
diff --git a/wgpu/src/renderer/widget/text_input.rs b/wgpu/src/renderer/widget/text_input.rs
index f37c879c..855e945c 100644
--- a/wgpu/src/renderer/widget/text_input.rs
+++ b/wgpu/src/renderer/widget/text_input.rs
@@ -2,7 +2,7 @@ use crate::{Primitive, Renderer};
 
 use iced_native::{
     text::HorizontalAlignment, text::VerticalAlignment, text_input, Background,
-    Color, MouseCursor, Point, Rectangle, TextInput, Vector,
+    Color, Font, MouseCursor, Point, Rectangle, Size, TextInput, Vector,
 };
 use std::f32;
 
@@ -60,6 +60,7 @@ impl text_input::Renderer for Renderer {
                 [0.3, 0.3, 0.3]
             }
             .into(),
+            font: Font::Default,
             bounds: Rectangle {
                 width: f32::INFINITY,
                 ..text_bounds
@@ -70,20 +71,17 @@ impl text_input::Renderer for Renderer {
         };
 
         let (contents_primitive, offset) = if text_input.state.is_focused {
-            use wgpu_glyph::{Scale, Section};
-
             let text_before_cursor = &text_input
                 .value
                 .until(text_input.state.cursor_position(&text_input.value))
                 .to_string();
 
-            let (mut text_value_width, _) =
-                self.text_pipeline.measure(&Section {
-                    text: text_before_cursor,
-                    bounds: (f32::INFINITY, text_bounds.height),
-                    scale: Scale { x: size, y: size },
-                    ..Default::default()
-                });
+            let (mut text_value_width, _) = self.text_pipeline.measure(
+                text_before_cursor,
+                size,
+                Font::Default,
+                Size::new(f32::INFINITY, text_bounds.height),
+            );
 
             let spaces_at_the_end =
                 text_before_cursor.len() - text_before_cursor.trim_end().len();
diff --git a/wgpu/src/text.rs b/wgpu/src/text.rs
index d6565195..3205fe55 100644
--- a/wgpu/src/text.rs
+++ b/wgpu/src/text.rs
@@ -1,10 +1,14 @@
 mod font;
 
 use crate::Transformation;
+
 use std::cell::RefCell;
+use std::collections::HashMap;
 
 pub struct Pipeline {
-    draw_brush: wgpu_glyph::GlyphBrush<'static, ()>,
+    draw_brush: RefCell<wgpu_glyph::GlyphBrush<'static, ()>>,
+    draw_font_map: RefCell<HashMap<String, wgpu_glyph::FontId>>,
+
     measure_brush: RefCell<glyph_brush::GlyphBrush<'static, ()>>,
 }
 
@@ -23,8 +27,8 @@ impl Pipeline {
 
         let draw_brush =
             wgpu_glyph::GlyphBrushBuilder::using_fonts_bytes(vec![
-                default_font.clone(),
                 mono_font,
+                default_font.clone(),
             ])
             .initial_cache_size((2048, 2048))
             .build(device, wgpu::TextureFormat::Bgra8UnormSrgb);
@@ -34,17 +38,19 @@ impl Pipeline {
                 .build();
 
         Pipeline {
-            draw_brush,
+            draw_brush: RefCell::new(draw_brush),
+            draw_font_map: RefCell::new(HashMap::new()),
+
             measure_brush: RefCell::new(measure_brush),
         }
     }
 
     pub fn overlay_font(&self) -> wgpu_glyph::FontId {
-        wgpu_glyph::FontId(1)
+        wgpu_glyph::FontId(0)
     }
 
     pub fn queue(&mut self, section: wgpu_glyph::Section) {
-        self.draw_brush.queue(section);
+        self.draw_brush.borrow_mut().queue(section);
     }
 
     pub fn draw_queued(
@@ -56,6 +62,7 @@ impl Pipeline {
         region: wgpu_glyph::Region,
     ) {
         self.draw_brush
+            .borrow_mut()
             .draw_queued_with_transform_and_scissoring(
                 device,
                 encoder,
@@ -66,9 +73,32 @@ impl Pipeline {
             .expect("Draw text");
     }
 
-    pub fn measure(&self, section: &wgpu_glyph::Section<'_>) -> (f32, f32) {
+    pub fn measure(
+        &self,
+        content: &str,
+        size: f32,
+        font: iced_native::Font,
+        bounds: iced_native::Size,
+    ) -> (f32, f32) {
         use wgpu_glyph::GlyphCruncher;
 
+        let wgpu_glyph::FontId(font_id) = self.find_font(font);
+
+        let section = wgpu_glyph::Section {
+            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 font.
+            //
+            // This should go away once we improve the debug view and integrate
+            // it as just another UI app.
+            font_id: wgpu_glyph::FontId(font_id - 1),
+            ..Default::default()
+        };
+
         if let Some(bounds) =
             self.measure_brush.borrow_mut().glyph_bounds(section)
         {
@@ -93,7 +123,6 @@ impl Pipeline {
     }
 
     pub fn clear_measurement_cache(&mut self) {
-        // Trim measurements cache
         // TODO: We should probably use a `GlyphCalculator` for this. However,
         // it uses a lifetimed `GlyphCalculatorGuard` with side-effects on drop.
         // This makes stuff quite inconvenient. A manual method for trimming the
@@ -103,4 +132,27 @@ impl Pipeline {
             .process_queued(|_, _| {}, |_| {})
             .expect("Trim text measurements");
     }
+
+    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::External { name, bytes } => {
+                if let Some(font_id) = self.draw_font_map.borrow().get(name) {
+                    return *font_id;
+                }
+
+                // TODO: Find a way to share font data
+                let _ = self.measure_brush.borrow_mut().add_font_bytes(bytes);
+
+                let font_id =
+                    self.draw_brush.borrow_mut().add_font_bytes(bytes);
+
+                self.draw_font_map
+                    .borrow_mut()
+                    .insert(String::from(name), font_id);
+
+                font_id
+            }
+        }
+    }
 }