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/src') 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 From 6857829dc3171fd68065498b6cd29f0ef02a8d43 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Wed, 13 Nov 2019 07:22:21 +0100 Subject: Draft `Font` type and implement `Text::font` --- wgpu/src/primitive.rs | 3 +- wgpu/src/renderer.rs | 2 ++ wgpu/src/renderer/widget/text.rs | 14 +++----- wgpu/src/renderer/widget/text_input.rs | 18 +++++----- wgpu/src/text.rs | 66 ++++++++++++++++++++++++++++++---- 5 files changed, 75 insertions(+), 28 deletions(-) (limited to 'wgpu/src') 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(§ion); + 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>, + draw_font_map: RefCell>, + measure_brush: RefCell>, } @@ -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 + } + } + } } -- cgit