Merge pull request #54 from hecrj/feature/external-fonts

Custom font support

core/src/font.rs

@@ -0,0 +1,8 @@
+#[derive(Debug, Clone, Copy)]
+pub enum Font {
+    Default,
+    External {
+        name: &'static str,
+        bytes: &'static [u8],
+    },
+}

core/src/lib.rs

@@ -3,6 +3,7 @@ pub mod widget;
 mod align;
 mod background;
 mod color;
+mod font;
 mod length;
 mod point;
 mod rectangle;
@@ -11,6 +12,7 @@ mod vector;
 pub use align::Align;
 pub use background::Background;
 pub use color::Color;
+pub use font::Font;
 pub use length::Length;
 pub use point::Point;
 pub use rectangle::Rectangle;

core/src/widget/text.rs

@@ -1,5 +1,5 @@
 //! Write some text for your users to read.
-use crate::{Color, Length};
+use crate::{Color, Font, Length};
 
 /// A paragraph of text.
 ///
@@ -16,6 +16,7 @@ pub struct Text {
     pub content: String,
     pub size: Option<u16>,
     pub color: Option<Color>,
+    pub font: Font,
     pub width: Length,
     pub height: Length,
     pub horizontal_alignment: HorizontalAlignment,
@@ -31,6 +32,7 @@ impl Text {
             content: String::from(label),
             size: None,
             color: None,
+            font: Font::Default,
             width: Length::Fill,
             height: Length::Shrink,
             horizontal_alignment: HorizontalAlignment::Left,
@@ -54,6 +56,11 @@ impl Text {
         self
     }
 
+    pub fn font(mut self, font: Font) -> Self {
+        self.font = font;
+        self
+    }
+
     /// Sets the width of the [`Text`] boundaries.
     ///
     /// [`Text`]: struct.Text.html

native/src/lib.rs

@@ -216,7 +216,7 @@ mod size;
 mod user_interface;
 
 pub use iced_core::{
-    Align, Background, Color, Length, Point, Rectangle, Vector,
+    Align, Background, Color, Font, Length, Point, Rectangle, Vector,
 };
 
 pub use element::Element;

src/winit.rs

@@ -2,7 +2,8 @@ pub use iced_wgpu::{Primitive, Renderer};
 
 pub use iced_winit::{
     button, scrollable, slider, text, text_input, winit, Align, Background,
-    Checkbox, Color, Image, Length, Radio, Scrollable, Slider, Text, TextInput,
+    Checkbox, Color, Font, Image, Length, Radio, Scrollable, Slider, Text,
+    TextInput,
 };
 
 pub type Element<'a, Message> = iced_winit::Element<'a, Message, Renderer>;

wgpu/src/lib.rs

@@ -1,8 +1,8 @@
-mod font;
 mod image;
 mod primitive;
 mod quad;
 mod renderer;
+mod text;
 mod transformation;
 
 pub(crate) use crate::image::Image;

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,
     },

wgpu/src/renderer.rs

@@ -1,4 +1,4 @@
-use crate::{font, quad, Image, Primitive, Quad, Transformation};
+use crate::{quad, text, Image, Primitive, Quad, Transformation};
 use iced_native::{
     renderer::Debugger, renderer::Windowed, Background, Color, Layout,
     MouseCursor, Point, Rectangle, Vector, Widget,
@@ -7,11 +7,8 @@ use iced_native::{
 use wgpu::{
     Adapter, BackendBit, CommandEncoderDescriptor, Device, DeviceDescriptor,
     Extensions, Limits, PowerPreference, Queue, RequestAdapterOptions,
-    TextureFormat,
 };
 
-use std::cell::RefCell;
-
 mod target;
 mod widget;
 
@@ -22,8 +19,7 @@ pub struct Renderer {
     queue: Queue,
     quad_pipeline: quad::Pipeline,
     image_pipeline: crate::image::Pipeline,
-    text_pipeline: wgpu_glyph::GlyphBrush<'static, ()>,
+    text_pipeline: text::Pipeline,
-    text_measurements: RefCell<glyph_brush::GlyphBrush<'static, ()>>,
 }
 
 pub struct Layer<'a> {
@@ -61,28 +57,7 @@ impl Renderer {
             limits: Limits { max_bind_groups: 2 },
         });
 
-        // TODO: Font customization
+        let text_pipeline = text::Pipeline::new(&mut device);
-        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 mono_font = font_source
-            .load(&[font::Family::Monospace])
-            .expect("Find monospace font");
-
-        let text_pipeline =
-            wgpu_glyph::GlyphBrushBuilder::using_fonts_bytes(vec![
-                default_font.clone(),
-                mono_font,
-            ])
-            .initial_cache_size((2048, 2048))
-            .build(&mut device, TextureFormat::Bgra8UnormSrgb);
-
-        let text_measurements =
-            glyph_brush::GlyphBrushBuilder::using_font_bytes(default_font)
-                .build();
-
         let quad_pipeline = quad::Pipeline::new(&mut device);
         let image_pipeline = crate::image::Pipeline::new(&mut device);
 
@@ -92,7 +67,6 @@ impl Renderer {
             quad_pipeline,
             image_pipeline,
             text_pipeline,
-            text_measurements: RefCell::new(text_measurements),
         }
     }
 
@@ -173,6 +147,7 @@ impl Renderer {
                 bounds,
                 size,
                 color,
+                font,
                 horizontal_alignment,
                 vertical_alignment,
             } => {
@@ -205,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 => {
@@ -298,7 +274,7 @@ impl Renderer {
         let first = layers.first().unwrap();
         let mut overlay = Layer::new(first.bounds, Vector::new(0, 0));
 
-        let font_id = wgpu_glyph::FontId(self.text_pipeline.fonts().len() - 1);
+        let font_id = self.text_pipeline.overlay_font();
         let scale = wgpu_glyph::Scale { x: 20.0, y: 20.0 };
 
         for (i, line) in lines.iter().enumerate() {
@@ -383,20 +359,18 @@ impl Renderer {
                 self.text_pipeline.queue(text);
             }
 
-            self.text_pipeline
+            self.text_pipeline.draw_queued(
-                .draw_queued_with_transform_and_scissoring(
+                &mut self.device,
-                    &mut self.device,
+                encoder,
-                    encoder,
+                target,
-                    target,
+                transformation,
-                    transformation.into(),
+                wgpu_glyph::Region {
-                    wgpu_glyph::Region {
+                    x: bounds.x,
-                        x: bounds.x,
+                    y: bounds.y,
-                        y: bounds.y,
+                    width: bounds.width,
-                        width: bounds.width,
+                    height: bounds.height,
-                        height: bounds.height,
+                },
-                    },
+            );
-                )
-                .expect("Draw text");
         }
     }
 }
@@ -410,15 +384,7 @@ impl iced_native::Renderer for Renderer {
     ) -> iced_native::layout::Node {
         let node = element.layout(self, &iced_native::layout::Limits::NONE);
 
-        // Trim measurements cache
+        self.text_pipeline.clear_measurement_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
-        // cache would make our lives easier.
-        self.text_measurements
-            .borrow_mut()
-            .process_queued(|_, _| {}, |_| {})
-            .expect("Trim text measurements");
 
         node
     }

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::{GlyphCruncher, Section};
-
 use std::f32;
 
 // TODO: Obtain from renderer configuration
@@ -14,20 +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 {
+        let (width, height) =
-            text: &text.content,
+            self.text_pipeline
-            scale: wgpu_glyph::Scale { x: size, y: size },
+                .measure(&text.content, size, text.font, bounds);
-            bounds: (bounds.width, bounds.height),
-            ..Default::default()
-        };
-
-        let (width, height) = if let Some(bounds) =
-            self.text_measurements.borrow_mut().glyph_bounds(&section)
-        {
-            (bounds.width().ceil(), bounds.height().ceil())
-        } else {
-            (0.0, 0.0)
-        };
 
         let size = limits.resolve(Size::new(width, height));
 
@@ -41,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,
             },

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,41 +71,23 @@ impl text_input::Renderer for Renderer {
         };
 
         let (contents_primitive, offset) = if text_input.state.is_focused {
-            use wgpu_glyph::{GlyphCruncher, 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
+            let (mut text_value_width, _) = self.text_pipeline.measure(
-                .text_measurements
+                text_before_cursor,
-                .borrow_mut()
+                size,
-                .glyph_bounds(Section {
+                Font::Default,
-                    text: text_before_cursor,
+                Size::new(f32::INFINITY, text_bounds.height),
-                    bounds: (f32::INFINITY, text_bounds.height),
+            );
-                    scale: Scale { x: size, y: size },
-                    ..Default::default()
-                })
-                .map(|bounds| bounds.width().round())
-                .unwrap_or(0.0);
 
             let spaces_at_the_end =
                 text_before_cursor.len() - text_before_cursor.trim_end().len();
 
             if spaces_at_the_end > 0 {
-                let space_width = {
+                let space_width = self.text_pipeline.space_width(size);
-                    let glyph_brush = self.text_measurements.borrow();
-
-                    // TODO: Select appropriate font
-                    let font = &glyph_brush.fonts()[0];
-
-                    font.glyph(' ')
-                        .scaled(Scale { x: size, y: size })
-                        .h_metrics()
-                        .advance_width
-                };
-
                 text_value_width += spaces_at_the_end as f32 * space_width;
             }
 

wgpu/src/text.rs

@@ -0,0 +1,158 @@
+mod font;
+
+use crate::Transformation;
+
+use std::cell::RefCell;
+use std::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, ()>>,
+}
+
+impl Pipeline {
+    pub fn new(device: &mut wgpu::Device) -> 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 mono_font = font_source
+            .load(&[font::Family::Monospace])
+            .expect("Find monospace 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);
+
+        let measure_brush =
+            glyph_brush::GlyphBrushBuilder::using_font_bytes(default_font)
+                .build();
+
+        Pipeline {
+            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(0)
+    }
+
+    pub fn queue(&mut self, section: wgpu_glyph::Section) {
+        self.draw_brush.borrow_mut().queue(section);
+    }
+
+    pub fn draw_queued(
+        &mut self,
+        device: &mut wgpu::Device,
+        encoder: &mut wgpu::CommandEncoder,
+        target: &wgpu::TextureView,
+        transformation: Transformation,
+        region: wgpu_glyph::Region,
+    ) {
+        self.draw_brush
+            .borrow_mut()
+            .draw_queued_with_transform_and_scissoring(
+                device,
+                encoder,
+                target,
+                transformation.into(),
+                region,
+            )
+            .expect("Draw text");
+    }
+
+    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)
+        {
+            (bounds.width().ceil(), bounds.height().ceil())
+        } else {
+            (0.0, 0.0)
+        }
+    }
+
+    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 clear_measurement_cache(&mut self) {
+        // 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
+        // cache would make our lives easier.
+        self.measure_brush
+            .borrow_mut()
+            .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
+            }
+        }
+    }
+}