Implement explicit text caching in the widget state tree

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