Move text logic in iced_wgpu to a text module

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/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),
         }
     }
 
@@ -298,7 +272,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 +357,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 +382,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,7 +1,7 @@
 use crate::{Primitive, Renderer};
 use iced_native::{layout, text, Color, Layout, MouseCursor, Size, Text};
 
-use wgpu_glyph::{GlyphCruncher, Section};
+use wgpu_glyph::Section;
 
 use std::f32;
 
@@ -21,13 +21,7 @@ impl text::Renderer for Renderer {
             ..Default::default()
         };
 
-        let (width, height) = if let Some(bounds) =
+        let (width, height) = self.text_pipeline.measure(&section);
-            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));
 

wgpu/src/renderer/widget/text_input.rs

@@ -70,41 +70,26 @@ impl text_input::Renderer for Renderer {
         };
 
         let (contents_primitive, offset) = if text_input.state.is_focused {
-            use wgpu_glyph::{GlyphCruncher, Scale, Section};
+            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
+            let (mut text_value_width, _) =
-                .text_measurements
+                self.text_pipeline.measure(&Section {
-                .borrow_mut()
-                .glyph_bounds(Section {
                     text: text_before_cursor,
                     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,106 @@
+mod font;
+
+use crate::Transformation;
+use std::cell::RefCell;
+
+pub struct Pipeline {
+    draw_brush: wgpu_glyph::GlyphBrush<'static, ()>,
+    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![
+                default_font.clone(),
+                mono_font,
+            ])
+            .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,
+            measure_brush: RefCell::new(measure_brush),
+        }
+    }
+
+    pub fn overlay_font(&self) -> wgpu_glyph::FontId {
+        wgpu_glyph::FontId(1)
+    }
+
+    pub fn queue(&mut self, section: wgpu_glyph::Section) {
+        self.draw_brush.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
+            .draw_queued_with_transform_and_scissoring(
+                device,
+                encoder,
+                target,
+                transformation.into(),
+                region,
+            )
+            .expect("Draw text");
+    }
+
+    pub fn measure(&self, section: &wgpu_glyph::Section<'_>) -> (f32, f32) {
+        use wgpu_glyph::GlyphCruncher;
+
+        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) {
+        // 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
+        // cache would make our lives easier.
+        self.measure_brush
+            .borrow_mut()
+            .process_queued(|_, _| {}, |_| {})
+            .expect("Trim text measurements");
+    }
+}