me/iced
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

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

Browse source 
Custom font support
This commit is contained in:
Héctor Ramón 2019-11-14 06:47:43 +01:00 • committed by GitHub
commit a16dab9cf2
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
12 changed files with 214 additions and 100 deletions
Download patch file Download diff file Expand all files Collapse all files

8
core/src/font.rs Normal file
View file

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

2
core/src/lib.rs
View file

@ -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;

9
core/src/widget/text.rs
View file

@ -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

2
native/src/lib.rs
View file

@ -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;

3
src/winit.rs
View file

@ -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>;

2
wgpu/src/lib.rs
View file

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

3
wgpu/src/primitive.rs
View file

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

72
wgpu/src/renderer.rs
View file

@ -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<glyph_brush::GlyphBrush<'static, ()>>,
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),
}
}
@ -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
.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 +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
// 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
}

20
wgpu/src/renderer/widget/text.rs
View file

@ -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 {
text: &text.content,
scale: wgpu_glyph::Scale { x: size, y: size },
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 (width, height) =
self.text_pipeline
.measure(&text.content, size, text.font, bounds);
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,
},

35
wgpu/src/renderer/widget/text_input.rs
View file

@ -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
.text_measurements
.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 (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();
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;
}

158
wgpu/src/text.rs Normal file
View file

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

0
wgpu/src/font.rs → wgpu/src/text/font.rs
View file