Move text logic in iced_wgpu to a text module

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");
+    }
+}