Add font hinting API

valadaptive · valadaptive · commit 6ef0c7453ada · 2025-03-27T17:55:32.000-04:00
diff --git a/crates/egui/src/context.rs b/crates/egui/src/context.rs
@@ -612,6 +612,10 @@ impl ContextImpl {
                 .expect("new_font_definitions is borrowed, but we had nowhere to borrow it from")
         };
 
+        if let Some(new_font_hinting) = self.memory.new_font_hinting.take() {
+            fonts.set_hinting_enabled(new_font_hinting);
+        }
+
         {
             profiling::scope!("FontStore::begin_pass");
             fonts.begin_pass(max_texture_side);
@@ -1801,15 +1805,12 @@ impl Context {
     pub fn set_fonts(&self, font_definitions: FontDefinitions) {
         profiling::function_scope!();
 
-        let mut update_fonts = true;
-
-        self.read(|ctx| {
-            if let Some(current_fonts) = ctx.fonts.as_ref() {
-                // NOTE: this comparison is expensive since it checks TTF data for equality
-                if current_fonts.definitions() == &font_definitions {
-                    update_fonts = false; // no need to update
-                }
-            }
+        let update_fonts = self.read(|ctx| {
+            // NOTE: this comparison is expensive since it checks TTF data for equality
+            // TODO(valadaptive): add_font only checks the *names* for equality. Change this?
+            ctx.fonts
+                .as_ref()
+                .is_none_or(|fonts| fonts.definitions() != &font_definitions)
         });
 
         if update_fonts {
@@ -1827,25 +1828,37 @@ impl Context {
     pub fn add_font(&self, new_font: FontInsert) {
         profiling::function_scope!();
 
-        let mut update_fonts = true;
-
-        self.read(|ctx| {
-            if let Some(current_fonts) = ctx.fonts.as_ref() {
-                if current_fonts
-                    .definitions()
-                    .font_data
-                    .contains_key(&new_font.name)
-                {
-                    update_fonts = false; // no need to update
-                }
-            }
+        let update_fonts = self.read(|ctx| {
+            ctx.fonts
+                .as_ref()
+                .is_none_or(|fonts| !fonts.definitions().font_data.contains_key(&new_font.name))
         });
 
         if update_fonts {
             self.memory_mut(|mem| mem.add_fonts.push(new_font));
         }
     }
 
+    /// Set whether font hinting (pixel snapping for clearer fonts) is enabled.
+    ///
+    /// By default, hinting is enabled. You can override this per-font with
+    /// [`crate::FontTweak::hinting_enabled`].
+    ///
+    /// The new font hinting setting will become active at the start of the next pass.
+    pub fn set_font_hinting_enabled(&self, hinting_enabled: bool) {
+        profiling::function_scope!();
+
+        let update_hinting = self.read(|ctx| {
+            ctx.fonts
+                .as_ref()
+                .is_none_or(|fonts| fonts.hinting_enabled() != hinting_enabled)
+        });
+
+        if update_hinting {
+            self.memory_mut(|mem| mem.new_font_hinting = Some(hinting_enabled));
+        }
+    }
+
     /// Does the OS use dark or light mode?
     /// This is used when the theme preference is set to [`crate::ThemePreference::System`].
     pub fn system_theme(&self) -> Option<Theme> {
diff --git a/crates/egui/src/memory/mod.rs b/crates/egui/src/memory/mod.rs
@@ -79,6 +79,10 @@ pub struct Memory {
     #[cfg_attr(feature = "persistence", serde(skip))]
     pub(crate) new_font_definitions: Option<epaint::text::FontDefinitions>,
 
+    /// new font hinting setting that will be applied at the start of the next frame
+    #[cfg_attr(feature = "persistence", serde(skip))]
+    pub(crate) new_font_hinting: Option<bool>,
+
     /// add new font that will be applied at the start of the next frame
     #[cfg_attr(feature = "persistence", serde(skip))]
     pub(crate) add_fonts: Vec<epaint::text::FontInsert>,
@@ -125,6 +129,7 @@ impl Default for Memory {
             data: Default::default(),
             caches: Default::default(),
             new_font_definitions: Default::default(),
+            new_font_hinting: Default::default(),
             interactions: Default::default(),
             focus: Default::default(),
             viewport_id: Default::default(),
diff --git a/crates/egui/src/style.rs b/crates/egui/src/style.rs
@@ -2626,6 +2626,7 @@ impl Widget for &mut FontTweak {
                     y_offset_factor,
                     y_offset,
                     baseline_offset_factor,
+                    hinting_override,
                 } = self;
 
                 ui.label("Scale");
@@ -2645,6 +2646,19 @@ impl Widget for &mut FontTweak {
                 ui.add(DragValue::new(baseline_offset_factor).speed(-0.0025));
                 ui.end_row();
 
+                ui.label("hinting_override");
+                ComboBox::from_id_salt("hinting_override")
+                    .selected_text(match hinting_override {
+                        None => "None",
+                        Some(true) => "Enable",
+                        Some(false) => "Disable",
+                    })
+                    .show_ui(ui, |ui| {
+                        ui.selectable_value(hinting_override, None, "None");
+                        ui.selectable_value(hinting_override, Some(true), "Enable");
+                        ui.selectable_value(hinting_override, Some(false), "Disable");
+                    });
+
                 if ui.button("Reset").clicked() {
                     *self = Default::default();
                 }
diff --git a/crates/epaint/src/text/fonts.rs b/crates/epaint/src/text/fonts.rs
@@ -103,6 +103,11 @@ pub struct FontTweak {
     /// A positive value shifts the text downwards.
     /// A negative value shifts it upwards.
     pub baseline_offset_factor: f32,
+
+    /// Override the global font hinting setting for this specific font.
+    ///
+    /// `None` means use the global setting.
+    pub hinting_override: Option<bool>,
 }
 
 impl Default for FontTweak {
@@ -112,6 +117,7 @@ impl Default for FontTweak {
             y_offset_factor: 0.0,
             y_offset: 0.0,
             baseline_offset_factor: 0.0,
+            hinting_override: None,
         }
     }
 }
@@ -345,6 +351,7 @@ pub(super) struct FontsLayoutView<'a> {
     pub texture_atlas: &'a mut TextureAtlas,
     pub glyph_atlas: &'a mut GlyphAtlas,
     pub font_tweaks: &'a mut ahash::HashMap<u64, FontTweak>,
+    pub hinting_enabled: bool,
     pub pixels_per_point: f32,
 }
 
@@ -363,6 +370,7 @@ pub struct FontStore {
     max_texture_side: usize,
     definitions: FontDefinitions,
     font_tweaks: ahash::HashMap<u64, FontTweak>,
+    hinting_enabled: bool,
     atlas: TextureAtlas,
     galley_cache: GalleyCache,
 
@@ -399,6 +407,7 @@ impl FontStore {
             max_texture_side,
             definitions,
             font_tweaks: Default::default(),
+            hinting_enabled: true,
             glyph_atlas: GlyphAtlas::new(),
             atlas,
             galley_cache: Default::default(),
@@ -500,6 +509,15 @@ impl FontStore {
         self.load_fonts_from_definitions();
     }
 
+    pub fn hinting_enabled(&self) -> bool {
+        self.hinting_enabled
+    }
+
+    pub fn set_hinting_enabled(&mut self, enabled: bool) {
+        self.hinting_enabled = enabled;
+        self.clear_cache(self.max_texture_side);
+    }
+
     /// Width of this character in points.
     pub fn glyph_width(&mut self, font_id: &FontId, c: char) -> f32 {
         *self.glyph_width_cache.entry(c).or_insert_with(|| {
@@ -559,6 +577,7 @@ impl FontStore {
                             &mut self.atlas,
                             &run,
                             vec2(x_offset, 0.0),
+                            self.hinting_enabled,
                             pixels_per_point,
                             &self.font_tweaks,
                         )
@@ -730,12 +749,19 @@ impl Fonts<'_> {
         self.fonts.definitions()
     }
 
+    #[inline]
+    pub fn hinting_enabled(&self) -> bool {
+        self.fonts.hinting_enabled()
+    }
+
     /// Width of this character in points.
+    #[inline]
     pub fn glyph_width(&mut self, font_id: &FontId, c: char) -> f32 {
         self.fonts.glyph_width(font_id, c)
     }
 
     /// Can we display all the glyphs in this text?
+    #[inline]
     pub fn has_glyphs_for(&mut self, font_id: &FontId, s: &str) -> bool {
         self.fonts.has_glyphs_for(font_id, s)
     }
@@ -746,13 +772,15 @@ impl Fonts<'_> {
     /// Height of one row of text in points.
     ///
     /// Returns a value rounded to [`emath::GUI_ROUNDING`].
+    #[inline]
     pub fn row_height(&mut self, font_id: &FontId) -> f32 {
         self.fonts
             .row_height(font_id)
             .round_to_pixels(self.pixels_per_point)
     }
 
     /// Call at the end of each frame (before painting) to get the change to the font texture since last call.
+    #[inline]
     pub fn font_image_delta(&mut self) -> Option<crate::ImageDelta> {
         self.fonts.font_image_delta()
     }
@@ -764,21 +792,25 @@ impl Fonts<'_> {
 
     /// The font atlas.
     /// Pass this to [`crate::Tessellator`].
+    #[inline]
     pub fn texture_atlas(&self) -> &TextureAtlas {
         self.fonts.texture_atlas()
     }
 
     /// Current size of the font image.
     /// Pass this to [`crate::Tessellator`].
+    #[inline]
     pub fn font_image_size(&self) -> [usize; 2] {
         self.fonts.font_image_size()
     }
 
     /// List of all loaded font families.
+    #[inline]
     pub fn families(&mut self) -> &[FontFamily] {
         self.fonts.families()
     }
 
+    #[inline]
     pub fn num_galleys_in_cache(&self) -> usize {
         self.fonts.num_galleys_in_cache()
     }
@@ -787,6 +819,7 @@ impl Fonts<'_> {
     ///
     /// This increases as new fonts and/or glyphs are used,
     /// but can also decrease in a call to [`Self::begin_pass`].
+    #[inline]
     pub fn font_atlas_fill_ratio(&self) -> f32 {
         self.fonts.font_atlas_fill_ratio()
     }
@@ -807,6 +840,7 @@ impl Fonts<'_> {
                 texture_atlas: &mut self.fonts.atlas,
                 glyph_atlas: &mut self.fonts.glyph_atlas,
                 font_tweaks: &mut self.fonts.font_tweaks,
+                hinting_enabled: self.fonts.hinting_enabled,
                 pixels_per_point: self.pixels_per_point,
             },
             job,
@@ -827,6 +861,7 @@ impl Fonts<'_> {
                 texture_atlas: &mut self.fonts.atlas,
                 glyph_atlas: &mut self.fonts.glyph_atlas,
                 font_tweaks: &mut self.fonts.font_tweaks,
+                hinting_enabled: self.fonts.hinting_enabled,
                 pixels_per_point: self.pixels_per_point,
             },
             job,
@@ -836,6 +871,7 @@ impl Fonts<'_> {
     /// Will wrap text at the given width and line break at `\n`.
     ///
     /// The implementation uses memoization so repeated calls are cheap.
+    #[inline]
     pub fn layout(
         &mut self,
         text: String,
@@ -850,6 +886,7 @@ impl Fonts<'_> {
     /// Will line break at `\n`.
     ///
     /// The implementation uses memoization so repeated calls are cheap.
+    #[inline]
     pub fn layout_no_wrap(
         &mut self,
         text: String,
@@ -863,6 +900,7 @@ impl Fonts<'_> {
     /// Like [`Self::layout`], made for when you want to pick a color for the text later.
     ///
     /// The implementation uses memoization so repeated calls are cheap.
+    #[inline]
     pub fn layout_delayed_color(
         &mut self,
         text: String,
diff --git a/crates/epaint/src/text/glyph_atlas.rs b/crates/epaint/src/text/glyph_atlas.rs
@@ -115,27 +115,33 @@ struct StyleKey<'a> {
     font_id: u64,
     font_size: OrderedFloat<f32>,
     skew: i8,
+    hinting_enabled: bool,
     /// We want to avoid doing a bunch of allocations. When looking up this key in a map, this can be a borrowed slice.
     /// We only need to convert it to an owned [`Vec<i16>`] the first time we insert it into the map.
     normalized_coords: Cow<'a, [i16]>,
 }
 
 impl<'a> StyleKey<'a> {
-    fn new(font_id: u64, font_size: f32, skew: i8, normalized_coords: &'a [i16]) -> Self {
+    fn new(
+        font_id: u64,
+        font_size: f32,
+        skew: i8,
+        hinting_enabled: bool,
+        normalized_coords: &'a [i16],
+    ) -> Self {
         Self {
             font_id,
             font_size: font_size.into(),
             skew,
+            hinting_enabled,
             normalized_coords: Cow::Borrowed(normalized_coords),
         }
     }
 
     fn to_static(&self) -> StyleKey<'static> {
         StyleKey {
-            font_id: self.font_id,
-            font_size: self.font_size,
-            skew: self.skew,
             normalized_coords: self.normalized_coords.clone().into_owned().into(),
+            ..*self
         }
     }
 }
@@ -184,6 +190,7 @@ impl GlyphAtlas {
         atlas: &'c mut TextureAtlas,
         glyph_run: &'b GlyphRun<'b, Color32>,
         offset: Vec2,
+        hinting_enabled: bool,
         pixels_per_point: f32,
         font_tweaks: &ahash::HashMap<u64, FontTweak>,
     ) -> impl Iterator<Item = (Glyph, Option<UvRect>, (i32, i32), Color32)> + use<'a, 'b, 'c> {
@@ -209,12 +216,20 @@ impl GlyphAtlas {
         let size = font_size * pixels_per_point;
         let normalized_coords = run.normalized_coords();
 
+        let font_tweak = font_tweaks.get(&font_id);
+        let tweak_offset = font_tweak.map_or(0.0, |tweak| {
+            (font_size * tweak.y_offset_factor) + tweak.y_offset
+        });
+        let hinting_enabled = font_tweak
+            .and_then(|tweak| tweak.hinting_override)
+            .unwrap_or(hinting_enabled);
+
         let mut scaler: swash::scale::Scaler<'b> = self
             .scale_context
             .builder(font_ref)
             .size(size)
             .normalized_coords(normalized_coords)
-            .hint(true)
+            .hint(hinting_enabled)
             .build();
         let rendered_glyphs = &mut self.rendered_glyphs;
         let color = glyph_run.style().brush;
@@ -227,6 +242,7 @@ impl GlyphAtlas {
             font_id,
             size,
             skew.unwrap_or_default() as i8,
+            hinting_enabled,
             normalized_coords,
         );
 
@@ -242,10 +258,6 @@ impl GlyphAtlas {
                 }),
         };
 
-        let tweak_offset = font_tweaks.get(&font_id).map_or(0.0, |tweak| {
-            (font_size * tweak.y_offset_factor) + tweak.y_offset
-        });
-
         glyph_run.positioned_glyphs().map(move |mut glyph| {
             // The Y-position transform applies to the font *after* it's been hinted, making it blurry. (So does the
             // X-position transform, but the hinter doesn't change the X coordinates anymore.)
diff --git a/crates/epaint/src/text/parley_layout.rs b/crates/epaint/src/text/parley_layout.rs
diff --git a/parley-todo.md b/parley-todo.md
