migrations/egui
1
0
Fork 0
mirror of https://github.com/emilk/egui.git synced 2026-06-26 22:53:14 -04:00
Code Activity

Fix glyph caching on font variations (#8189)

Browse Source 
* Closes https://github.com/emilk/egui/pull/8029

---------

Co-authored-by: lucasmerlin <hi@lucasmerlin.me>
This commit is contained in:
Emil Ernerfeldt
2026-05-22 15:30:21 +02:00
committed by GitHub
parent 3888087dc5
commit e925a41419
7 changed files with 402 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

275
crates/epaint/src/text/font.rs
View File

@@ -58,6 +58,41 @@ impl GlyphInfo {
};
}
/// Result of resolving a `char` to a [`GlyphId`] within a single [`FontFace`].
///
/// Location-independent: only depends on the font's charmap and `FontTweak`,
/// not on variable-font variation coordinates.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub(super) enum GlyphIdResolution {
/// A real, visible glyph.
Glyph(GlyphId),
/// A valid char, but rendered as zero-width (control chars, joiners, …).
Invisible,
}
/// A precomputed hash of a [`skrifa::instance::Location`].
///
/// Used as a cache key so that we don't have to re-hash the coordinate list
/// for every glyph lookup. Compute once per text run and reuse for every glyph
/// in the run.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub(crate) struct LocationHash(u64);
impl nohash_hasher::IsEnabled for LocationHash {}
impl LocationHash {
#[inline]
pub fn new(location: &skrifa::instance::Location) -> Self {
if location.coords().is_empty() {
// Fast path for the (common) default-coords case.
Self(0)
} else {
Self(crate::util::hash(location))
}
}
}
// Subpixel binning, taken from cosmic-text:
// https://github.com/pop-os/cosmic-text/blob/974ddaed96b334f560b606ebe5d2ca2d2f9f23ef/src/glyph_cache.rs
@@ -131,10 +166,12 @@ struct GlyphCacheKey(u64);
impl nohash_hasher::IsEnabled for GlyphCacheKey {}
impl GlyphCacheKey {
#[inline]
fn new(glyph_id: GlyphId, metrics: &StyledMetrics, bin: SubpixelBin) -> Self {
let StyledMetrics {
pixels_per_point,
px_scale_factor,
location_hash,
..
} = *metrics;
debug_assert!(
@@ -150,6 +187,7 @@ impl GlyphCacheKey {
pixels_per_point.to_bits(),
px_scale_factor.to_bits(),
bin,
location_hash,
)))
}
}
@@ -161,7 +199,6 @@ struct DependentFontData<'a> {
charmap: skrifa::charmap::Charmap<'a>,
outline_glyphs: skrifa::outline::OutlineGlyphCollection<'a>,
metrics: skrifa::metrics::Metrics,
glyph_metrics: skrifa::metrics::GlyphMetrics<'a>,
hinting_instance: Option<skrifa::outline::HintingInstance>,
}
@@ -204,7 +241,9 @@ impl FontCell {
if let Some(hinting_instance) = &mut font_data.hinting_instance {
let size = skrifa::instance::Size::new(metrics.scale);
if hinting_instance.size() != size {
if hinting_instance.size() != size
|| hinting_instance.location().coords() != location.coords()
{
hinting_instance
.reconfigure(
&font_data.outline_glyphs,
@@ -323,7 +362,18 @@ pub struct FontFace {
/// `ShaperData` is `Copy` — lives outside the `self_cell`.
shaper_data: harfrust::ShaperData,
glyph_info_cache: ahash::HashMap<char, GlyphInfo>,
/// Location-independent: `char → GlyphId | Invisible`.
///
/// Only depends on the font's charmap + `FontTweak`. A miss means the char
/// is not in this face's repertoire and the fallback chain should be tried.
glyph_id_cache: ahash::HashMap<char, GlyphIdResolution>,
/// Location-dependent: `(char, LocationHash) → unscaled advance width`.
///
/// Variable fonts can vary advance widths per axis (HVAR table), so this
/// must be re-keyed per resolved [`skrifa::instance::Location`].
advance_width_cache: ahash::HashMap<(char, LocationHash), OrderedFloat<f32>>,
glyph_alloc_cache: ahash::HashMap<GlyphCacheKey, GlyphAllocation>,
}
@@ -345,14 +395,11 @@ impl FontFace {
// Note: We use default location here during initialization because
// the actual weight will be applied via the stored location during rendering.
// The metrics won't be significantly different at this unscaled size.
// TODO(emilk): heed location for vertical metrics too (HVAR/MVAR).
let metrics = skrifa_font.metrics(
skrifa::instance::Size::unscaled(),
skrifa::instance::LocationRef::default(),
);
let glyph_metrics = skrifa_font.glyph_metrics(
skrifa::instance::Size::unscaled(),
skrifa::instance::LocationRef::default(),
);
let hinting_enabled = tweak.hinting.unwrap_or(options.font_hinting);
let hinting_instance = hinting_enabled
@@ -374,7 +421,6 @@ impl FontFace {
charmap,
outline_glyphs: glyphs,
metrics,
glyph_metrics,
hinting_instance,
})
})?;
@@ -389,7 +435,8 @@ impl FontFace {
tweak,
subpixel_binning,
shaper_data,
glyph_info_cache: Default::default(),
glyph_id_cache: Default::default(),
advance_width_cache: Default::default(),
glyph_alloc_cache: Default::default(),
})
}
@@ -423,65 +470,86 @@ impl FontFace {
.filter_map(|(chr, _)| char::from_u32(chr).filter(|c| !self.ignore_character(*c)))
}
/// `\n` will result in `None`
pub(super) fn glyph_info(&mut self, c: char) -> Option<GlyphInfo> {
if let Some(glyph_info) = self.glyph_info_cache.get(&c) {
return Some(*glyph_info);
/// Resolve a `char` to a [`GlyphId`] within this face.
///
/// Location-independent. Returns `None` when this face cannot represent
/// the char (the caller should try the fallback chain).
///
/// `\t` and thin spaces share `' '`s glyph id (they just have a custom advance).
pub(super) fn glyph_id_resolution(&mut self, c: char) -> Option<GlyphIdResolution> {
if let Some(resolution) = self.glyph_id_cache.get(&c) {
return Some(*resolution);
}
if self.ignore_character(c) {
return None; // these will result in the replacement character when rendering
}
if c == '\t'
&& let Some(space) = self.glyph_info(' ')
{
let glyph_info = GlyphInfo {
advance_width_unscaled: (self.tweak.tab_size * space.advance_width_unscaled.0)
.into(),
..space
};
self.glyph_info_cache.insert(c, glyph_info);
return Some(glyph_info);
}
if (c == '\u{2009}' || c == '\u{202F}')
&& let Some(space) = self.glyph_info(' ')
{
// Thin space (U+2009) and narrow no-break space (U+202F),
// often used as thousands separator: 1 234 567 890
let advance_width = self.tweak.thin_space_width * space.advance_width_unscaled.0;
let glyph_info = GlyphInfo {
advance_width_unscaled: advance_width.into(),
..space
};
self.glyph_info_cache.insert(c, glyph_info);
return Some(glyph_info);
}
if invisible_char(c) {
let glyph_info = GlyphInfo::INVISIBLE;
self.glyph_info_cache.insert(c, glyph_info);
return Some(glyph_info);
}
let font_data = self.font.borrow_dependent();
// Add new character:
let glyph_id = font_data
.charmap
.map(c)
.filter(|id| *id != GlyphId::NOTDEF)?;
let glyph_info = GlyphInfo {
id: Some(glyph_id),
advance_width_unscaled: font_data
.glyph_metrics
.advance_width(glyph_id)
.unwrap_or_default()
.into(),
let resolution = if c == '\t' || c == '\u{2009}' || c == '\u{202F}' {
// `\t` and thin spaces are rendered as a space glyph with a custom advance.
self.glyph_id_resolution(' ')?
} else if invisible_char(c) {
GlyphIdResolution::Invisible
} else {
let glyph_id = self
.font
.borrow_dependent()
.charmap
.map(c)
.filter(|id| *id != GlyphId::NOTDEF)?;
GlyphIdResolution::Glyph(glyph_id)
};
self.glyph_id_cache.insert(c, resolution);
Some(resolution)
}
/// Unscaled advance width for `c` at the given variation location.
///
/// Location-dependent (variable fonts can vary advances via HVAR).
/// Cached per `(char, LocationHash)`.
fn advance_width_unscaled(&mut self, c: char, metrics: &StyledMetrics) -> f32 {
let cache_key = (c, metrics.location_hash);
if let Some(advance) = self.advance_width_cache.get(&cache_key) {
return advance.0;
}
let advance = match c {
'\t' => self.tweak.tab_size * self.advance_width_unscaled(' ', metrics),
'\u{2009}' | '\u{202F}' => {
// Thin space (U+2009) and narrow no-break space (U+202F),
// often used as thousands separator.
self.tweak.thin_space_width * self.advance_width_unscaled(' ', metrics)
}
_ => {
let Some(GlyphIdResolution::Glyph(glyph_id)) = self.glyph_id_resolution(c) else {
return 0.0;
};
let font_data = self.font.borrow_dependent();
let glyph_metrics = font_data
.skrifa
.glyph_metrics(skrifa::instance::Size::unscaled(), &metrics.location);
glyph_metrics.advance_width(glyph_id).unwrap_or_default()
}
};
self.advance_width_cache.insert(cache_key, advance.into());
advance
}
/// `\n` will result in `None`.
///
/// Caller must pass [`StyledMetrics`] resolved against *this* face so that
/// variable-font advance widths are looked up at the correct location.
pub(super) fn glyph_info(&mut self, c: char, metrics: &StyledMetrics) -> Option<GlyphInfo> {
let resolution = self.glyph_id_resolution(c)?;
let glyph_info = match resolution {
GlyphIdResolution::Invisible => GlyphInfo::INVISIBLE,
GlyphIdResolution::Glyph(glyph_id) => GlyphInfo {
id: Some(glyph_id),
advance_width_unscaled: self.advance_width_unscaled(c, metrics).into(),
},
};
self.glyph_info_cache.insert(c, glyph_info);
Some(glyph_info)
}
@@ -510,6 +578,7 @@ impl FontFace {
// argument (probably from TextFormat).
let settings = std::iter::chain(self.tweak.coords.as_ref(), coords.as_ref());
let location = axes.location(settings);
let location_hash = LocationHash::new(&location);
StyledMetrics {
pixels_per_point,
@@ -519,6 +588,7 @@ impl FontFace {
ascent,
row_height: ascent - descent + line_gap,
location,
location_hash,
}
}
@@ -594,7 +664,7 @@ pub struct Font<'a> {
impl Font<'_> {
pub fn preload_characters(&mut self, s: &str) {
for c in s.chars() {
self.glyph_info(c);
self.resolve_face(c);
}
}
@@ -626,19 +696,23 @@ impl Font<'_> {
.unwrap_or_default()
}
/// Width of this character in points.
/// Width of this character in points, at the font's default variation location.
pub fn glyph_width(&mut self, c: char, font_size: f32) -> f32 {
let (key, glyph_info) = self.glyph_info(c);
if let Some(font) = &self.fonts_by_id.get(&key) {
glyph_info.advance_width_unscaled.0 * font.font.px_scale_factor(font_size)
} else {
0.0
}
let face_key = self.resolve_face(c);
let Some(font_face) = self.fonts_by_id.get_mut(&face_key) else {
return 0.0;
};
let metrics = font_face.styled_metrics(1.0, font_size, &VariationCoords::default());
let Some(glyph_info) = font_face.glyph_info(c, &metrics) else {
return 0.0;
};
glyph_info.advance_width_unscaled.0 * font_face.font.px_scale_factor(font_size)
}
/// Can we display this glyph?
pub fn has_glyph(&mut self, c: char) -> bool {
self.glyph_info(c) != self.cached_family.replacement_glyph // TODO(emilk): this is a false negative if the user asks about the replacement character itself 🤦‍♂️
// TODO(emilk): this is a false negative if the user asks about the replacement character itself 🤦‍♂️
self.resolve_face(c) != self.cached_family.replacement_face_key
}
/// Can we display all the glyphs in this text?
@@ -646,21 +720,52 @@ impl Font<'_> {
s.chars().all(|c| self.has_glyph(c))
}
/// `\n` will (intentionally) show up as the replacement character.
pub(crate) fn glyph_info(&mut self, c: char) -> (FontFaceKey, GlyphInfo) {
if let Some(font_index_glyph_info) = self.cached_family.glyph_info_cache.get(&c) {
return *font_index_glyph_info;
/// Find which face in the fallback chain owns `c`.
///
/// Location-independent — fallback choice depends only on charmap support.
/// Falls back to the replacement-glyph face when no fallback face has `c`.
#[inline]
pub(crate) fn resolve_face(&mut self, c: char) -> FontFaceKey {
if let Some(font_key) = self.cached_family.face_cache.get(&c) {
return *font_key;
}
self.resolve_face_slow(c)
}
let font_index_glyph_info = self
#[cold]
fn resolve_face_slow(&mut self, c: char) -> FontFaceKey {
let font_key = self
.cached_family
.glyph_info_no_cache_or_fallback(c, self.fonts_by_id);
let font_index_glyph_info =
font_index_glyph_info.unwrap_or(self.cached_family.replacement_glyph);
self.cached_family
.glyph_info_cache
.insert(c, font_index_glyph_info);
font_index_glyph_info
.find_face_for_char(c, self.fonts_by_id)
.unwrap_or(self.cached_family.replacement_face_key);
self.cached_family.face_cache.insert(c, font_key);
font_key
}
/// Resolve `c` to its (face, [`GlyphInfo`]) at the given face's location.
///
/// `\n` will (intentionally) show up as the replacement character.
///
/// `metrics` must be the resolved [`StyledMetrics`] for the face that ends
/// up owning `c`. Most callers pass the metrics of their text run's primary
/// face — that is correct as long as `c` is in that face. For correct
/// fallback-face advances, resolve the face first with [`Self::resolve_face`]
/// and build metrics for that face.
pub(crate) fn glyph_info(
&mut self,
c: char,
metrics: &StyledMetrics,
) -> (FontFaceKey, GlyphInfo) {
let face_key = self.resolve_face(c);
let Some(face) = self.fonts_by_id.get_mut(&face_key) else {
return (face_key, GlyphInfo::INVISIBLE);
};
let glyph_info = face.glyph_info(c, metrics).unwrap_or_else(|| {
// `c` is in no face — render the replacement character instead.
face.glyph_info(self.cached_family.replacement_char, metrics)
.unwrap_or(GlyphInfo::INVISIBLE)
});
(face_key, glyph_info)
}
}
@@ -693,6 +798,12 @@ pub struct StyledMetrics {
/// Resolved variation coordinates.
pub location: skrifa::instance::Location,
/// Precomputed hash of [`Self::location`].
///
/// Hashed once per run of text so per-glyph cache lookups don't have to
/// re-hash the full coordinate list.
pub(crate) location_hash: LocationHash,
}
/// Code points that will always be invisible (zero width).

63
crates/epaint/src/text/fonts.rs
View File

@@ -11,7 +11,7 @@ use crate::{
TextureAtlas,
text::{
Galley, LayoutJob, LayoutSection, TextOptions, VariationCoords,
font::{Font, FontFace, GlyphInfo},
font::{Font, FontFace},
},
};
use emath::{NumExt as _, OrderedFloat};
@@ -457,9 +457,20 @@ pub(super) struct CachedFamily {
/// Lazily calculated.
pub characters: Option<BTreeMap<char, Vec<String>>>,
pub replacement_glyph: (FontFaceKey, GlyphInfo),
/// The face used when no face in [`Self::fonts`] supports a char.
pub replacement_face_key: FontFaceKey,
pub glyph_info_cache: ahash::HashMap<char, (FontFaceKey, GlyphInfo)>,
/// The char that [`Self::replacement_face_key`] actually contains.
///
/// When the user asks about a char that no fallback face supports we
/// render this char in its place.
pub replacement_char: char,
/// Cache: `char → which face in the fallback chain owns this char`.
///
/// Location-independent (fallback choice depends only on charmap support,
/// not on variation coordinates).
pub face_cache: ahash::HashMap<char, FontFaceKey>,
}
impl CachedFamily {
@@ -467,49 +478,59 @@ impl CachedFamily {
fonts: Vec<FontFaceKey>,
fonts_by_id: &mut nohash_hasher::IntMap<FontFaceKey, FontFace>,
) -> Self {
const PRIMARY_REPLACEMENT_CHAR: char = '◻'; // white medium square
const FALLBACK_REPLACEMENT_CHAR: char = '?'; // fallback for the fallback
if fonts.is_empty() {
return Self {
fonts,
characters: None,
replacement_glyph: (FontFaceKey::INVALID, GlyphInfo::INVISIBLE),
glyph_info_cache: Default::default(),
replacement_face_key: FontFaceKey::INVALID,
replacement_char: PRIMARY_REPLACEMENT_CHAR,
face_cache: Default::default(),
};
}
let mut slf = Self {
fonts,
characters: None,
replacement_glyph: (FontFaceKey::INVALID, GlyphInfo::INVISIBLE),
glyph_info_cache: Default::default(),
replacement_face_key: FontFaceKey::INVALID,
replacement_char: PRIMARY_REPLACEMENT_CHAR,
face_cache: Default::default(),
};
const PRIMARY_REPLACEMENT_CHAR: char = '◻'; // white medium square
const FALLBACK_REPLACEMENT_CHAR: char = '?'; // fallback for the fallback
let replacement_glyph = slf
.glyph_info_no_cache_or_fallback(PRIMARY_REPLACEMENT_CHAR, fonts_by_id)
.or_else(|| slf.glyph_info_no_cache_or_fallback(FALLBACK_REPLACEMENT_CHAR, fonts_by_id))
let (replacement_face_key, replacement_char) = slf
.find_face_for_char(PRIMARY_REPLACEMENT_CHAR, fonts_by_id)
.map(|key| (key, PRIMARY_REPLACEMENT_CHAR))
.or_else(|| {
slf.find_face_for_char(FALLBACK_REPLACEMENT_CHAR, fonts_by_id)
.map(|key| (key, FALLBACK_REPLACEMENT_CHAR))
})
.unwrap_or_else(|| {
log::warn!(
"Failed to find replacement characters {PRIMARY_REPLACEMENT_CHAR:?} or {FALLBACK_REPLACEMENT_CHAR:?}. Will use empty glyph."
);
(FontFaceKey::INVALID, GlyphInfo::INVISIBLE)
(FontFaceKey::INVALID, PRIMARY_REPLACEMENT_CHAR)
});
slf.replacement_glyph = replacement_glyph;
slf.replacement_face_key = replacement_face_key;
slf.replacement_char = replacement_char;
slf
}
pub(crate) fn glyph_info_no_cache_or_fallback(
&mut self,
/// Walk the fallback chain and return the first face whose charmap supports `c`.
///
/// Pure — does not touch any cache. Callers that want memoisation should
/// insert into [`Self::face_cache`] themselves.
pub(crate) fn find_face_for_char(
&self,
c: char,
fonts_by_id: &mut nohash_hasher::IntMap<FontFaceKey, FontFace>,
) -> Option<(FontFaceKey, GlyphInfo)> {
) -> Option<FontFaceKey> {
for font_key in &self.fonts {
let font_face = fonts_by_id.get_mut(font_key).expect("Nonexistent font ID");
if let Some(glyph_info) = font_face.glyph_info(c) {
self.glyph_info_cache.insert(c, (*font_key, glyph_info));
return Some((*font_key, glyph_info));
if font_face.glyph_id_resolution(c).is_some() {
return Some(*font_key);
}
}
None

19
crates/epaint/src/text/text_layout.rs
View File

@@ -261,7 +261,7 @@ fn layout_shaped_run(
if chr == '\t' {
let tweak = font.fonts_by_id.get(&run.font_key).map(|ff| ff.tweak());
let tab_size = tweak.map_or(4.0, |t| t.tab_size);
let (_, space_info) = font.glyph_info(' ');
let (_, space_info) = font.glyph_info(' ', face_metrics);
let space_width_px = space_info.advance_width_unscaled.0 * px_scale;
advance_width_px = tab_size * space_width_px;
}
@@ -271,7 +271,7 @@ fn layout_shaped_run(
if chr == '\u{2009}' || chr == '\u{202F}' {
let tweak = font.fonts_by_id.get(&run.font_key).map(|ff| ff.tweak());
let thin_space_width = tweak.map_or(0.5, |t| t.thin_space_width);
let (_, space_info) = font.glyph_info(' ');
let (_, space_info) = font.glyph_info(' ', face_metrics);
let space_width_px = space_info.advance_width_unscaled.0 * px_scale;
advance_width_px = thin_space_width * space_width_px;
}
@@ -308,7 +308,7 @@ fn layout_shaped_run(
}
// Use the fallback font face (not run.font_key which returned NOTDEF).
let (fallback_key, glyph_info) = font.glyph_info(chr);
let fallback_key = font.resolve_face(chr);
let fallback_metrics = font
.fonts_by_id
.get(&fallback_key)
@@ -316,6 +316,7 @@ fn layout_shaped_run(
ff.styled_metrics(ctx.pixels_per_point, ctx.font_size, &Default::default())
})
.unwrap_or_default();
let (_, glyph_info) = font.glyph_info(chr, &fallback_metrics);
let advance_width_px =
glyph_info.advance_width_unscaled.0 * fallback_metrics.px_scale_factor;
let (glyph_alloc, physical_x) =
@@ -774,12 +775,14 @@ fn replace_last_glyph_with_overflow_character(
let mut font = fonts.font(&section.format.font_id.family);
let font_size = section.format.font_id.size;
let (font_id, glyph_info) = font.glyph_info(overflow_character);
let mut font_face = font.fonts_by_id.get_mut(&font_id);
let font_face_metrics = font_face
.as_mut()
let font_id = font.resolve_face(overflow_character);
let font_face_metrics = font
.fonts_by_id
.get(&font_id)
.map(|f| f.styled_metrics(pixels_per_point, font_size, &section.format.coords))
.unwrap_or_default();
let (_, glyph_info) = font.glyph_info(overflow_character, &font_face_metrics);
let mut font_face = font.fonts_by_id.get_mut(&font_id);
let overflow_glyph_x = if let Some(prev_glyph) = row.glyphs.last() {
prev_glyph.max_x() + extra_letter_spacing
@@ -1371,7 +1374,7 @@ fn segment_into_runs(font: &mut Font<'_>, text: &str, out: &mut Vec<TextRun>) {
let byte_end = byte_offset + grapheme_str.len();
let base_char = grapheme_str.chars().next().unwrap_or(' ');
let (font_key, _) = font.glyph_info(base_char);
let font_key = font.resolve_face(base_char);
if let Some(last_run) = out.last_mut()
&& last_run.font_key == font_key