From f0b1e65ba4f8df173f8201585a1d81245e93ab94 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Wed, 13 Nov 2019 03:54:36 +0100 Subject: Move text logic in `iced_wgpu` to a `text` module --- wgpu/src/font.rs | 36 ----------- wgpu/src/lib.rs | 2 +- wgpu/src/renderer.rs | 70 ++++++---------------- wgpu/src/renderer/widget/text.rs | 10 +--- wgpu/src/renderer/widget/text_input.rs | 25 ++------ wgpu/src/text.rs | 106 +++++++++++++++++++++++++++++++++ wgpu/src/text/font.rs | 36 +++++++++++ 7 files changed, 167 insertions(+), 118 deletions(-) delete mode 100644 wgpu/src/font.rs create mode 100644 wgpu/src/text.rs create mode 100644 wgpu/src/text/font.rs (limited to 'wgpu') diff --git a/wgpu/src/font.rs b/wgpu/src/font.rs deleted file mode 100644 index 31df5bf4..00000000 --- a/wgpu/src/font.rs +++ /dev/null @@ -1,36 +0,0 @@ -pub use font_kit::error::SelectionError as LoadError; -pub use font_kit::family_name::FamilyName as Family; - -pub struct Source { - raw: font_kit::source::SystemSource, -} - -impl Source { - pub fn new() -> Self { - Source { - raw: font_kit::source::SystemSource::new(), - } - } - - pub fn load(&self, families: &[Family]) -> Result, LoadError> { - let font = self.raw.select_best_match( - families, - &font_kit::properties::Properties::default(), - )?; - - match font { - font_kit::handle::Handle::Path { path, .. } => { - use std::io::Read; - - let mut buf = Vec::new(); - let mut reader = std::fs::File::open(path).expect("Read font"); - let _ = reader.read_to_end(&mut buf); - - Ok(buf) - } - font_kit::handle::Handle::Memory { bytes, .. } => { - Ok(bytes.as_ref().clone()) - } - } - } -} diff --git a/wgpu/src/lib.rs b/wgpu/src/lib.rs index f504897d..d770f872 100644 --- a/wgpu/src/lib.rs +++ b/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; diff --git a/wgpu/src/renderer.rs b/wgpu/src/renderer.rs index e9df3550..6441043c 100644 --- a/wgpu/src/renderer.rs +++ b/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_measurements: RefCell>, + text_pipeline: text::Pipeline, } pub struct Layer<'a> { @@ -61,28 +57,7 @@ impl Renderer { limits: Limits { max_bind_groups: 2 }, }); - // 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 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 text_pipeline = text::Pipeline::new(&mut device); 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 - .draw_queued_with_transform_and_scissoring( - &mut self.device, - encoder, - target, - transformation.into(), - wgpu_glyph::Region { - x: bounds.x, - y: bounds.y, - width: bounds.width, - height: bounds.height, - }, - ) - .expect("Draw text"); + self.text_pipeline.draw_queued( + &mut self.device, + encoder, + target, + transformation, + wgpu_glyph::Region { + x: bounds.x, + y: bounds.y, + width: bounds.width, + height: bounds.height, + }, + ); } } } @@ -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 - // 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"); + self.text_pipeline.clear_measurement_cache(); node } diff --git a/wgpu/src/renderer/widget/text.rs b/wgpu/src/renderer/widget/text.rs index b9ccd787..65b23c5e 100644 --- a/wgpu/src/renderer/widget/text.rs +++ b/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) = - self.text_measurements.borrow_mut().glyph_bounds(§ion) - { - (bounds.width().ceil(), bounds.height().ceil()) - } else { - (0.0, 0.0) - }; + let (width, height) = self.text_pipeline.measure(§ion); let size = limits.resolve(Size::new(width, height)); diff --git a/wgpu/src/renderer/widget/text_input.rs b/wgpu/src/renderer/widget/text_input.rs index 75eb20f7..f37c879c 100644 --- a/wgpu/src/renderer/widget/text_input.rs +++ b/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 - .text_measurements - .borrow_mut() - .glyph_bounds(Section { + 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() - }) - .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 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 - }; - + let space_width = self.text_pipeline.space_width(size); text_value_width += spaces_at_the_end as f32 * space_width; } diff --git a/wgpu/src/text.rs b/wgpu/src/text.rs new file mode 100644 index 00000000..d6565195 --- /dev/null +++ b/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>, +} + +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"); + } +} diff --git a/wgpu/src/text/font.rs b/wgpu/src/text/font.rs new file mode 100644 index 00000000..31df5bf4 --- /dev/null +++ b/wgpu/src/text/font.rs @@ -0,0 +1,36 @@ +pub use font_kit::error::SelectionError as LoadError; +pub use font_kit::family_name::FamilyName as Family; + +pub struct Source { + raw: font_kit::source::SystemSource, +} + +impl Source { + pub fn new() -> Self { + Source { + raw: font_kit::source::SystemSource::new(), + } + } + + pub fn load(&self, families: &[Family]) -> Result, LoadError> { + let font = self.raw.select_best_match( + families, + &font_kit::properties::Properties::default(), + )?; + + match font { + font_kit::handle::Handle::Path { path, .. } => { + use std::io::Read; + + let mut buf = Vec::new(); + let mut reader = std::fs::File::open(path).expect("Read font"); + let _ = reader.read_to_end(&mut buf); + + Ok(buf) + } + font_kit::handle::Handle::Memory { bytes, .. } => { + Ok(bytes.as_ref().clone()) + } + } + } +} -- cgit