summaryrefslogtreecommitdiffstats
path: root/wgpu/src
diff options
context:
space:
mode:
Diffstat (limited to 'wgpu/src')
-rw-r--r--wgpu/src/backend.rs75
-rw-r--r--wgpu/src/layer.rs29
-rw-r--r--wgpu/src/layer/text.rs19
-rw-r--r--wgpu/src/lib.rs2
-rw-r--r--wgpu/src/settings.rs6
-rw-r--r--wgpu/src/text.rs509
-rw-r--r--wgpu/src/window/compositor.rs9
7 files changed, 190 insertions, 459 deletions
diff --git a/wgpu/src/backend.rs b/wgpu/src/backend.rs
index 68d1f805..65c63f19 100644
--- a/wgpu/src/backend.rs
+++ b/wgpu/src/backend.rs
@@ -1,5 +1,5 @@
-use crate::core;
-use crate::core::{Color, Font, Point, Size};
+use crate::core::{Color, Size};
+use crate::graphics;
use crate::graphics::backend;
use crate::graphics::color;
use crate::graphics::{Transformation, Viewport};
@@ -29,9 +29,6 @@ pub struct Backend {
#[cfg(any(feature = "image", feature = "svg"))]
image_pipeline: image::Pipeline,
-
- default_font: Font,
- default_text_size: f32,
}
impl Backend {
@@ -57,9 +54,6 @@ impl Backend {
#[cfg(any(feature = "image", feature = "svg"))]
image_pipeline,
-
- default_font: settings.default_font,
- default_text_size: settings.default_text_size,
}
}
@@ -313,65 +307,11 @@ impl Backend {
impl crate::graphics::Backend for Backend {
type Primitive = primitive::Custom;
-
- fn trim_measurements(&mut self) {
- self.text_pipeline.trim_measurements();
- }
}
impl backend::Text for Backend {
- const ICON_FONT: Font = Font::with_name("Iced-Icons");
- const CHECKMARK_ICON: char = '\u{f00c}';
- const ARROW_DOWN_ICON: char = '\u{e800}';
-
- fn default_font(&self) -> Font {
- self.default_font
- }
-
- fn default_size(&self) -> f32 {
- self.default_text_size
- }
-
- fn measure(
- &self,
- contents: &str,
- size: f32,
- line_height: core::text::LineHeight,
- font: Font,
- bounds: Size,
- shaping: core::text::Shaping,
- ) -> Size {
- self.text_pipeline.measure(
- contents,
- size,
- line_height,
- font,
- bounds,
- shaping,
- )
- }
-
- fn hit_test(
- &self,
- contents: &str,
- size: f32,
- line_height: core::text::LineHeight,
- font: Font,
- bounds: Size,
- shaping: core::text::Shaping,
- point: Point,
- nearest_only: bool,
- ) -> Option<core::text::Hit> {
- self.text_pipeline.hit_test(
- contents,
- size,
- line_height,
- font,
- bounds,
- shaping,
- point,
- nearest_only,
- )
+ fn font_system(&self) -> &graphics::text::FontSystem {
+ self.text_pipeline.font_system()
}
fn load_font(&mut self, font: Cow<'static, [u8]>) {
@@ -381,14 +321,17 @@ impl backend::Text for Backend {
#[cfg(feature = "image")]
impl backend::Image for Backend {
- fn dimensions(&self, handle: &core::image::Handle) -> Size<u32> {
+ fn dimensions(&self, handle: &crate::core::image::Handle) -> Size<u32> {
self.image_pipeline.dimensions(handle)
}
}
#[cfg(feature = "svg")]
impl backend::Svg for Backend {
- fn viewport_dimensions(&self, handle: &core::svg::Handle) -> Size<u32> {
+ fn viewport_dimensions(
+ &self,
+ handle: &crate::core::svg::Handle,
+ ) -> Size<u32> {
self.image_pipeline.viewport_dimensions(handle)
}
}
diff --git a/wgpu/src/layer.rs b/wgpu/src/layer.rs
index b8f32db1..7a5a0f7c 100644
--- a/wgpu/src/layer.rs
+++ b/wgpu/src/layer.rs
@@ -10,7 +10,7 @@ pub use text::Text;
use crate::core;
use crate::core::alignment;
-use crate::core::{Color, Font, Point, Rectangle, Size, Vector};
+use crate::core::{Color, Font, Pixels, Point, Rectangle, Size, Vector};
use crate::graphics;
use crate::graphics::color;
use crate::graphics::Viewport;
@@ -56,14 +56,14 @@ impl<'a> Layer<'a> {
Layer::new(Rectangle::with_size(viewport.logical_size()));
for (i, line) in lines.iter().enumerate() {
- let text = Text {
+ let text = text::Cached {
content: line.as_ref(),
bounds: Rectangle::new(
Point::new(11.0, 11.0 + 25.0 * i as f32),
Size::INFINITY,
),
color: Color::new(0.9, 0.9, 0.9, 1.0),
- size: 20.0,
+ size: Pixels(20.0),
line_height: core::text::LineHeight::default(),
font: Font::MONOSPACE,
horizontal_alignment: alignment::Horizontal::Left,
@@ -71,13 +71,13 @@ impl<'a> Layer<'a> {
shaping: core::text::Shaping::Basic,
};
- overlay.text.push(text);
+ overlay.text.push(Text::Cached(text.clone()));
- overlay.text.push(Text {
+ overlay.text.push(Text::Cached(text::Cached {
bounds: text.bounds + Vector::new(-1.0, -1.0),
color: Color::BLACK,
..text
- });
+ }));
}
overlay
@@ -113,6 +113,19 @@ impl<'a> Layer<'a> {
current_layer: usize,
) {
match primitive {
+ Primitive::Paragraph {
+ paragraph,
+ position,
+ color,
+ } => {
+ let layer = &mut layers[current_layer];
+
+ layer.text.push(Text::Managed {
+ paragraph: paragraph.clone(),
+ position: *position + translation,
+ color: *color,
+ });
+ }
Primitive::Text {
content,
bounds,
@@ -126,7 +139,7 @@ impl<'a> Layer<'a> {
} => {
let layer = &mut layers[current_layer];
- layer.text.push(Text {
+ layer.text.push(Text::Cached(text::Cached {
content,
bounds: *bounds + translation,
size: *size,
@@ -136,7 +149,7 @@ impl<'a> Layer<'a> {
horizontal_alignment: *horizontal_alignment,
vertical_alignment: *vertical_alignment,
shaping: *shaping,
- });
+ }));
}
Primitive::Quad {
bounds,
diff --git a/wgpu/src/layer/text.rs b/wgpu/src/layer/text.rs
index ba1bdca8..b61615d6 100644
--- a/wgpu/src/layer/text.rs
+++ b/wgpu/src/layer/text.rs
@@ -1,10 +1,21 @@
use crate::core::alignment;
use crate::core::text;
-use crate::core::{Color, Font, Rectangle};
+use crate::core::{Color, Font, Pixels, Point, Rectangle};
+use crate::graphics::text::paragraph;
/// A paragraph of text.
-#[derive(Debug, Clone, Copy)]
-pub struct Text<'a> {
+#[derive(Debug, Clone)]
+pub enum Text<'a> {
+ Managed {
+ paragraph: paragraph::Weak,
+ position: Point,
+ color: Color,
+ },
+ Cached(Cached<'a>),
+}
+
+#[derive(Debug, Clone)]
+pub struct Cached<'a> {
/// The content of the [`Text`].
pub content: &'a str,
@@ -15,7 +26,7 @@ pub struct Text<'a> {
pub color: Color,
/// The size of the [`Text`] in logical pixels.
- pub size: f32,
+ pub size: Pixels,
/// The line height of the [`Text`].
pub line_height: text::LineHeight,
diff --git a/wgpu/src/lib.rs b/wgpu/src/lib.rs
index d1e4b7af..cd457072 100644
--- a/wgpu/src/lib.rs
+++ b/wgpu/src/lib.rs
@@ -22,7 +22,7 @@
)]
#![deny(
missing_debug_implementations,
- missing_docs,
+ //missing_docs,
unsafe_code,
unused_results,
clippy::extra_unused_lifetimes,
diff --git a/wgpu/src/settings.rs b/wgpu/src/settings.rs
index 266a2c87..c9338fec 100644
--- a/wgpu/src/settings.rs
+++ b/wgpu/src/settings.rs
@@ -1,5 +1,5 @@
//! Configure a renderer.
-use crate::core::Font;
+use crate::core::{Font, Pixels};
use crate::graphics::Antialiasing;
/// The settings of a [`Backend`].
@@ -21,7 +21,7 @@ pub struct Settings {
/// The default size of text.
///
/// By default, it will be set to `16.0`.
- pub default_text_size: f32,
+ pub default_text_size: Pixels,
/// The antialiasing strategy that will be used for triangle primitives.
///
@@ -59,7 +59,7 @@ impl Default for Settings {
present_mode: wgpu::PresentMode::AutoVsync,
internal_backend: wgpu::Backends::all(),
default_font: Font::default(),
- default_text_size: 16.0,
+ default_text_size: Pixels(16.0),
antialiasing: None,
}
}
diff --git a/wgpu/src/text.rs b/wgpu/src/text.rs
index fb13545d..da2062fe 100644
--- a/wgpu/src/text.rs
+++ b/wgpu/src/text.rs
@@ -1,20 +1,17 @@
use crate::core::alignment;
-use crate::core::font::{self, Font};
-use crate::core::text::{Hit, LineHeight, Shaping};
-use crate::core::{Pixels, Point, Rectangle, Size};
+use crate::core::{Rectangle, Size};
use crate::graphics::color;
+use crate::graphics::text::cache::{self, Cache};
+use crate::graphics::text::{FontSystem, Paragraph};
use crate::layer::Text;
-use rustc_hash::{FxHashMap, FxHashSet};
use std::borrow::Cow;
use std::cell::RefCell;
-use std::collections::hash_map;
-use std::hash::{BuildHasher, Hash, Hasher};
use std::sync::Arc;
#[allow(missing_debug_implementations)]
pub struct Pipeline {
- font_system: RefCell<glyphon::FontSystem>,
+ font_system: FontSystem,
renderers: Vec<glyphon::TextRenderer>,
atlas: glyphon::TextAtlas,
prepare_layer: usize,
@@ -28,12 +25,7 @@ impl Pipeline {
format: wgpu::TextureFormat,
) -> Self {
Pipeline {
- font_system: RefCell::new(glyphon::FontSystem::new_with_fonts(
- [glyphon::fontdb::Source::Binary(Arc::new(
- include_bytes!("../fonts/Iced-Icons.ttf").as_slice(),
- ))]
- .into_iter(),
- )),
+ font_system: FontSystem::new(),
renderers: Vec::new(),
atlas: glyphon::TextAtlas::with_color_mode(
device,
@@ -50,6 +42,10 @@ impl Pipeline {
}
}
+ pub fn font_system(&self) -> &FontSystem {
+ &self.font_system
+ }
+
pub fn load_font(&mut self, bytes: Cow<'static, [u8]>) {
let _ = self.font_system.get_mut().db_mut().load_font_source(
glyphon::fontdb::Source::Binary(Arc::new(bytes.into_owned())),
@@ -80,97 +76,137 @@ impl Pipeline {
let renderer = &mut self.renderers[self.prepare_layer];
let cache = self.cache.get_mut();
- if self.prepare_layer == 0 {
- cache.trim(Purpose::Drawing);
+ enum Allocation {
+ Paragraph(Paragraph),
+ Cache(cache::KeyHash),
}
- let keys: Vec<_> = sections
+ let allocations: Vec<_> = sections
.iter()
- .map(|section| {
- let (key, _) = cache.allocate(
- font_system,
- Key {
- content: section.content,
- size: section.size,
- line_height: f32::from(
- section
- .line_height
- .to_absolute(Pixels(section.size)),
- ),
- font: section.font,
- bounds: Size {
- width: section.bounds.width,
- height: section.bounds.height,
+ .map(|section| match section {
+ Text::Managed { paragraph, .. } => {
+ paragraph.upgrade().map(Allocation::Paragraph)
+ }
+ Text::Cached(text) => {
+ let (key, _) = cache.allocate(
+ font_system,
+ cache::Key {
+ content: text.content,
+ size: text.size.into(),
+ line_height: f32::from(
+ text.line_height.to_absolute(text.size),
+ ),
+ font: text.font,
+ bounds: Size {
+ width: bounds.width,
+ height: bounds.height,
+ },
+ shaping: text.shaping,
},
- shaping: section.shaping,
- },
- Purpose::Drawing,
- );
+ );
- key
+ Some(Allocation::Cache(key))
+ }
})
.collect();
- let bounds = bounds * scale_factor;
-
- let text_areas =
- sections
- .iter()
- .zip(keys.iter())
- .filter_map(|(section, key)| {
- let entry = cache.get(key).expect("Get cached buffer");
-
- let x = section.bounds.x * scale_factor;
- let y = section.bounds.y * scale_factor;
-
- let max_width = entry.bounds.width * scale_factor;
- let total_height = entry.bounds.height * scale_factor;
-
- let left = match section.horizontal_alignment {
- alignment::Horizontal::Left => x,
- alignment::Horizontal::Center => x - max_width / 2.0,
- alignment::Horizontal::Right => x - max_width,
- };
-
- let top = match section.vertical_alignment {
- alignment::Vertical::Top => y,
- alignment::Vertical::Center => y - total_height / 2.0,
- alignment::Vertical::Bottom => y - total_height,
- };
-
- let section_bounds = Rectangle {
- x: left,
- y: top,
- width: section.bounds.width * scale_factor,
- height: section.bounds.height * scale_factor,
- };
-
- let clip_bounds = bounds.intersection(&section_bounds)?;
-
- Some(glyphon::TextArea {
- buffer: &entry.buffer,
- left,
- top,
- scale: scale_factor,
- bounds: glyphon::TextBounds {
- left: clip_bounds.x as i32,
- top: clip_bounds.y as i32,
- right: (clip_bounds.x + clip_bounds.width) as i32,
- bottom: (clip_bounds.y + clip_bounds.height) as i32,
- },
- default_color: {
- let [r, g, b, a] =
- color::pack(section.color).components();
-
- glyphon::Color::rgba(
- (r * 255.0) as u8,
- (g * 255.0) as u8,
- (b * 255.0) as u8,
- (a * 255.0) as u8,
- )
- },
- })
- });
+ let layer_bounds = bounds * scale_factor;
+
+ let text_areas = sections.iter().zip(allocations.iter()).filter_map(
+ |(section, allocation)| {
+ let (
+ buffer,
+ bounds,
+ horizontal_alignment,
+ vertical_alignment,
+ color,
+ ) = match section {
+ Text::Managed {
+ position, color, ..
+ } => {
+ use crate::core::text::Paragraph as _;
+
+ let Some(Allocation::Paragraph(paragraph)) = allocation
+ else {
+ return None;
+ };
+
+ (
+ paragraph.buffer(),
+ Rectangle::new(*position, paragraph.min_bounds()),
+ paragraph.horizontal_alignment(),
+ paragraph.vertical_alignment(),
+ *color,
+ )
+ }
+ Text::Cached(text) => {
+ let Some(Allocation::Cache(key)) = allocation else {
+ return None;
+ };
+
+ let buffer = cache.get(key).expect("Get cached buffer");
+
+ (
+ buffer,
+ text.bounds,
+ text.horizontal_alignment,
+ text.vertical_alignment,
+ text.color,
+ )
+ }
+ };
+
+ let x = bounds.x * scale_factor;
+ let y = bounds.y * scale_factor;
+
+ let max_width = bounds.width * scale_factor;
+ let total_height = bounds.height * scale_factor;
+
+ let left = match horizontal_alignment {
+ alignment::Horizontal::Left => x,
+ alignment::Horizontal::Center => x - max_width / 2.0,
+ alignment::Horizontal::Right => x - max_width,
+ };
+
+ let top = match vertical_alignment {
+ alignment::Vertical::Top => y,
+ alignment::Vertical::Center => y - total_height / 2.0,
+ alignment::Vertical::Bottom => y - total_height,
+ };
+
+ let section_bounds = Rectangle {
+ x: left,
+ y: top,
+ width: max_width,
+ height: total_height,
+ };
+
+ let clip_bounds = layer_bounds.intersection(&section_bounds)?;
+
+ Some(glyphon::TextArea {
+ buffer,
+ left,
+ top,
+ scale: scale_factor,
+ bounds: glyphon::TextBounds {
+ left: clip_bounds.x as i32,
+ top: clip_bounds.y as i32,
+ right: (clip_bounds.x + clip_bounds.width) as i32,
+ bottom: (clip_bounds.y + clip_bounds.height) as i32,
+ },
+ default_color: {
+ let [r, g, b, a] = color::pack(color).components();
+
+ glyphon::Color::rgba(
+ (r * 255.0) as u8,
+ (g * 255.0) as u8,
+ (b * 255.0) as u8,
+ (a * 255.0) as u8,
+ )
+ },
+ })
+ },
+ );
let result = renderer.prepare(
device,
@@ -219,287 +255,8 @@ impl Pipeline {
pub fn end_frame(&mut self) {
self.atlas.trim();
+ self.cache.get_mut().trim();
self.prepare_layer = 0;
}
-
- pub fn trim_measurements(&mut self) {
- self.cache.get_mut().trim(Purpose::Measuring);
- }
-
- pub fn measure(
- &self,
- content: &str,
- size: f32,
- line_height: LineHeight,
- font: Font,
- bounds: Size,
- shaping: Shaping,
- ) -> Size {
- let mut cache = self.cache.borrow_mut();
-
- let line_height = f32::from(line_height.to_absolute(Pixels(size)));
-
- let (_, entry) = cache.allocate(
- &mut self.font_system.borrow_mut(),
- Key {
- content,
- size,
- line_height,
- font,
- bounds,
- shaping,
- },
- Purpose::Measuring,
- );
-
- entry.bounds
- }
-
- pub fn hit_test(
- &self,
- content: &str,
- size: f32,
- line_height: LineHeight,
- font: Font,
- bounds: Size,
- shaping: Shaping,
- point: Point,
- _nearest_only: bool,
- ) -> Option<Hit> {
- let mut cache = self.cache.borrow_mut();
-
- let line_height = f32::from(line_height.to_absolute(Pixels(size)));
-
- let (_, entry) = cache.allocate(
- &mut self.font_system.borrow_mut(),
- Key {
- content,
- size,
- line_height,
- font,
- bounds,
- shaping,
- },
- Purpose::Measuring,
- );
-
- let cursor = entry.buffer.hit(point.x, point.y)?;
-
- Some(Hit::CharOffset(cursor.index))
- }
}
-
-fn measure(buffer: &glyphon::Buffer) -> Size {
- let (width, total_lines) = buffer
- .layout_runs()
- .fold((0.0, 0usize), |(width, total_lines), run| {
- (run.line_w.max(width), total_lines + 1)
- });
-
- Size::new(width, total_lines as f32 * buffer.metrics().line_height)
-}
-
-fn to_family(family: font::Family) -> glyphon::Family<'static> {
- match family {
- font::Family::Name(name) => glyphon::Family::Name(name),
- font::Family::SansSerif => glyphon::Family::SansSerif,
- font::Family::Serif => glyphon::Family::Serif,
- font::Family::Cursive => glyphon::Family::Cursive,
- font::Family::Fantasy => glyphon::Family::Fantasy,
- font::Family::Monospace => glyphon::Family::Monospace,
- }
-}
-
-fn to_weight(weight: font::Weight) -> glyphon::Weight {
- match weight {
- font::Weight::Thin => glyphon::Weight::THIN,
- font::Weight::ExtraLight => glyphon::Weight::EXTRA_LIGHT,
- font::Weight::Light => glyphon::Weight::LIGHT,
- font::Weight::Normal => glyphon::Weight::NORMAL,
- font::Weight::Medium => glyphon::Weight::MEDIUM,
- font::Weight::Semibold => glyphon::Weight::SEMIBOLD,
- font::Weight::Bold => glyphon::Weight::BOLD,
- font::Weight::ExtraBold => glyphon::Weight::EXTRA_BOLD,
- font::Weight::Black => glyphon::Weight::BLACK,
- }
-}
-
-fn to_stretch(stretch: font::Stretch) -> glyphon::Stretch {
- match stretch {
- font::Stretch::UltraCondensed => glyphon::Stretch::UltraCondensed,
- font::Stretch::ExtraCondensed => glyphon::Stretch::ExtraCondensed,
- font::Stretch::Condensed => glyphon::Stretch::Condensed,
- font::Stretch::SemiCondensed => glyphon::Stretch::SemiCondensed,
- font::Stretch::Normal => glyphon::Stretch::Normal,
- font::Stretch::SemiExpanded => glyphon::Stretch::SemiExpanded,
- font::Stretch::Expanded => glyphon::Stretch::Expanded,
- font::Stretch::ExtraExpanded => glyphon::Stretch::ExtraExpanded,
- font::Stretch::UltraExpanded => glyphon::Stretch::UltraExpanded,
- }
-}
-
-fn to_style(style: font::Style) -> glyphon::Style {
- match style {
- font::Style::Normal => glyphon::Style::Normal,
- font::Style::Italic => glyphon::Style::Italic,
- font::Style::Oblique => glyphon::Style::Oblique,
- }
-}
-
-fn to_shaping(shaping: Shaping) -> glyphon::Shaping {
- match shaping {
- Shaping::Basic => glyphon::Shaping::Basic,
- Shaping::Advanced => glyphon::Shaping::Advanced,
- }
-}
-
-struct Cache {
- entries: FxHashMap<KeyHash, Entry>,
- aliases: FxHashMap<KeyHash, KeyHash>,
- recently_measured: FxHashSet<KeyHash>,
- recently_drawn: FxHashSet<KeyHash>,
- hasher: HashBuilder,
-}
-
-struct Entry {
- buffer: glyphon::Buffer,
- bounds: Size,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum Purpose {
- Measuring,
- Drawing,
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-type HashBuilder = twox_hash::RandomXxHashBuilder64;
-
-#[cfg(target_arch = "wasm32")]
-type HashBuilder = std::hash::BuildHasherDefault<twox_hash::XxHash64>;
-
-impl Cache {
- fn new() -> Self {
- Self {
- entries: FxHashMap::default(),
- aliases: FxHashMap::default(),
- recently_measured: FxHashSet::default(),
- recently_drawn: FxHashSet::default(),
- hasher: HashBuilder::default(),
- }
- }
-
- fn get(&self, key: &KeyHash) -> Option<&Entry> {
- self.entries.get(key)
- }
-
- fn allocate(
- &mut self,
- font_system: &mut glyphon::FontSystem,
- key: Key<'_>,
- purpose: Purpose,
- ) -> (KeyHash, &mut Entry) {
- let hash = key.hash(self.hasher.build_hasher());
-
- let recently_used = match purpose {
- Purpose::Measuring => &mut self.recently_measured,
- Purpose::Drawing => &mut self.recently_drawn,
- };
-
- if let Some(hash) = self.aliases.get(&hash) {
- let _ = recently_used.insert(*hash);
-
- return (*hash, self.entries.get_mut(hash).unwrap());
- }
-
- if let hash_map::Entry::Vacant(entry) = self.entries.entry(hash) {
- let metrics = glyphon::Metrics::new(key.size, key.line_height);
- let mut buffer = glyphon::Buffer::new(font_system, metrics);
-
- buffer.set_size(
- font_system,
- key.bounds.width,
- key.bounds.height.max(key.line_height),
- );
- buffer.set_text(
- font_system,
- key.content,
- glyphon::Attrs::new()
- .family(to_family(key.font.family))
- .weight(to_weight(key.font.weight))
- .stretch(to_stretch(key.font.stretch))
- .style(to_style(key.font.style)),
- to_shaping(key.shaping),
- );
-
- let bounds = measure(&buffer);
- let _ = entry.insert(Entry { buffer, bounds });
-
- for bounds in [
- bounds,
- Size {
- width: key.bounds.width,
- ..bounds
- },
- ] {
- if key.bounds != bounds {
- let _ = self.aliases.insert(
- Key { bounds, ..key }.hash(self.hasher.build_hasher()),
- hash,
- );
- }
- }
- }
-
- let _ = recently_used.insert(hash);
-
- (hash, self.entries.get_mut(&hash).unwrap())
- }
-
- fn trim(&mut self, purpose: Purpose) {
- self.entries.retain(|key, _| {
- self.recently_measured.contains(key)
- || self.recently_drawn.contains(key)
- });
- self.aliases.retain(|_, value| {
- self.recently_measured.contains(value)
- || self.recently_drawn.contains(value)
- });
-
- match purpose {
- Purpose::Measuring => {
- self.recently_measured.clear();
- }
- Purpose::Drawing => {
- self.recently_drawn.clear();
- }
- }
- }
-}
-
-#[derive(Debug, Clone, Copy)]
-struct Key<'a> {
- content: &'a str,
- size: f32,
- line_height: f32,
- font: Font,
- bounds: Size,
- shaping: Shaping,
-}
-
-impl Key<'_> {
- fn hash<H: Hasher>(self, mut hasher: H) -> KeyHash {
- self.content.hash(&mut hasher);
- self.size.to_bits().hash(&mut hasher);
- self.line_height.to_bits().hash(&mut hasher);
- self.font.hash(&mut hasher);
- self.bounds.width.to_bits().hash(&mut hasher);
- self.bounds.height.to_bits().hash(&mut hasher);
- self.shaping.hash(&mut hasher);
-
- hasher.finish()
- }
-}
-
-type KeyHash = u64;
diff --git a/wgpu/src/window/compositor.rs b/wgpu/src/window/compositor.rs
index cd5b20cc..09e11fdc 100644
--- a/wgpu/src/window/compositor.rs
+++ b/wgpu/src/window/compositor.rs
@@ -216,7 +216,14 @@ impl<Theme> graphics::Compositor for Compositor<Theme> {
) -> Result<(Self, Self::Renderer), Error> {
let (compositor, backend) = new(settings, compatible_window)?;
- Ok((compositor, Renderer::new(backend)))
+ Ok((
+ compositor,
+ Renderer::new(
+ backend,
+ settings.default_font,
+ settings.default_text_size,
+ ),
+ ))
}
fn create_surface<W: HasRawWindowHandle + HasRawDisplayHandle>(
generated by cgit (git 2.34.1) at 2025-04-16 21:00:28 +0000