use std::collections::HashMap;
use std::rc::Rc;
#[derive(Hash, PartialEq, Eq, Clone, Copy)]
pub(crate) struct WidthKey {
pub font_id: fontdb::ID,
pub glyph_id: u16,
pub size_bits: u16,
}
impl WidthKey {
#[allow(dead_code)]
pub(crate) fn new(font_id: fontdb::ID, glyph_id: u16, size_bits: u16) -> Self {
Self {
font_id,
glyph_id,
size_bits,
}
}
}
#[derive(Clone)]
#[allow(dead_code)]
pub(crate) struct GlyphMetrics {
pub advance_x: f32,
pub x0: f32,
pub y0: f32,
pub x1: f32,
pub y1: f32,
}
#[derive(Hash, PartialEq, Eq, Clone, Copy)]
pub(crate) struct BitmapKey {
pub font_id: fontdb::ID,
pub glyph_id: u16,
pub size_bits: u16,
pub color_rgb: [u8; 3],
}
impl BitmapKey {
pub(crate) fn new(
font_id: fontdb::ID,
glyph_id: u16,
size_bits: u16,
color_rgb: [u8; 3],
) -> Self {
Self {
font_id,
glyph_id,
size_bits,
color_rgb,
}
}
}
pub(crate) struct CachedGlyph {
pub pixmap: Rc<tiny_skia::Pixmap>,
pub left: i32,
pub top: i32,
pub color_rgb: [u8; 3],
}
pub(crate) struct GlyphCache {
#[allow(dead_code)]
width_cache: HashMap<WidthKey, GlyphMetrics>,
bitmap_cache: HashMap<BitmapKey, CachedGlyph>,
bitmap_bytes: u64,
}
impl GlyphCache {
const MAX_BITMAP_BYTES: u64 = 4 * 1024 * 1024;
#[allow(dead_code)]
const TRIM_INTERVAL: u64 = 300;
pub(crate) fn new() -> Self {
Self {
width_cache: HashMap::new(),
bitmap_cache: HashMap::new(),
bitmap_bytes: 0,
}
}
#[allow(dead_code)]
pub(crate) fn measure(
&mut self,
font_id: fontdb::ID,
glyph_id: u16,
font_size: f32,
compute: impl FnOnce() -> Option<GlyphMetrics>,
) -> Option<GlyphMetrics> {
let key = WidthKey::new(font_id, glyph_id, (font_size * 10.0) as u16);
if let Some(m) = self.width_cache.get(&key) {
return Some(m.clone());
}
let m = compute()?;
self.width_cache.insert(key, m.clone());
Some(m)
}
pub(crate) fn rasterize(
&mut self,
font_id: fontdb::ID,
glyph_id: u16,
font_size: f32,
color_rgb: [u8; 3],
render: impl FnOnce() -> Option<CachedGlyph>,
) -> Option<CachedGlyph> {
let key = BitmapKey::new(font_id, glyph_id, (font_size * 10.0) as u16, color_rgb);
if let Some(g) = self.bitmap_cache.get(&key) {
return Some(CachedGlyph {
pixmap: Rc::clone(&g.pixmap),
left: g.left,
top: g.top,
color_rgb: g.color_rgb,
});
}
let g = render()?;
let byte_count = (g.pixmap.width() * g.pixmap.height() * 4) as u64;
if self.bitmap_bytes + byte_count > Self::MAX_BITMAP_BYTES {
self.purge_half();
}
self.bitmap_bytes += byte_count;
let result = CachedGlyph {
pixmap: Rc::clone(&g.pixmap),
left: g.left,
top: g.top,
color_rgb: g.color_rgb,
};
self.bitmap_cache.insert(key, g);
Some(result)
}
fn purge_half(&mut self) {
let target = self.bitmap_cache.len() / 2;
let keys: Vec<BitmapKey> = self.bitmap_cache.keys().take(target).copied().collect();
for k in keys {
self.bitmap_cache.remove(&k);
}
}
pub(crate) fn trim(&mut self, _frame_count: u64) {
if self.bitmap_bytes > Self::MAX_BITMAP_BYTES {
self.purge_half();
}
}
pub(crate) fn clear_bitmaps(&mut self) {
self.bitmap_cache.clear();
self.bitmap_bytes = 0;
}
}