use std::collections::HashMap;
use std::path::{Path, PathBuf};
use crate::assets::{Assets, Handle, Texture};
use crate::canvas::atlas::{PADDING, ShelfPacker};
use crate::canvas::draw::{DrawList, Rect, SpriteInstance};
use sgl_core::math::Vec2;
pub const GLYPH_PAGE_SIZE: u32 = 512;
pub const MAX_GLYPH_PAGE_SIZE: u32 = 8192;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TextChannel {
World,
Screen,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum HAlign {
Left,
Center,
Right,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum VAlign {
Top,
Center,
Bottom,
}
#[derive(Debug, Clone, Copy)]
pub struct Outline {
pub width: f32,
pub color: [f32; 4],
}
#[derive(Debug, Clone, Copy)]
pub struct Shadow {
pub offset: Vec2,
pub spread: f32,
pub color: [f32; 4],
}
#[derive(Debug, Clone, Copy)]
pub struct TextStyle {
pub px: f32,
pub color: [f32; 4],
pub outline: Option<Outline>,
pub shadow: Option<Shadow>,
}
impl TextStyle {
pub fn new(px: f32, color: [f32; 4]) -> Self {
Self {
px,
color,
outline: None,
shadow: None,
}
}
#[must_use]
pub fn with_outline(mut self, width: f32) -> Self {
self.outline = Some(Outline {
width,
color: [0.0, 0.0, 0.0, 1.0],
});
self
}
#[must_use]
pub fn with_shadow(mut self, offset: Vec2, spread: f32) -> Self {
self.shadow = Some(Shadow {
offset,
spread,
color: [0.0, 0.0, 0.0, 1.0],
});
self
}
}
#[derive(Debug)]
pub enum TextError {
Io {
path: PathBuf,
source: std::io::Error,
},
Font(&'static str),
}
impl std::fmt::Display for TextError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Io { path, source } => write!(f, "font read {}: {source}", path.display()),
Self::Font(msg) => write!(f, "font parse: {msg}"),
}
}
}
impl std::error::Error for TextError {}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
struct GlyphKey {
c: char,
px_bits: u32,
}
#[derive(Debug, Clone, Copy)]
struct GlyphBitmap {
page: usize,
x: u32,
y: u32,
w: u32,
h: u32,
xmin: f32,
ymin: f32,
}
#[derive(Debug, Clone, Copy)]
struct GlyphSlot {
bitmap: Option<GlyphBitmap>,
advance: f32,
}
struct GlyphPage {
side: u32,
dedicated: bool,
packer: ShelfPacker,
pixels: Vec<u8>,
dirty: bool,
handle: Option<Handle<Texture>>,
last_used: u64,
}
impl GlyphPage {
fn new(side: u32, dedicated: bool, frame: u64) -> Self {
Self {
side,
dedicated,
packer: ShelfPacker::new(side, side),
pixels: vec![0; page_bytes(side)],
dirty: false,
handle: None,
last_used: frame,
}
}
fn reset(&mut self, side: u32, frame: u64) {
if side == self.side {
self.pixels.fill(0);
} else {
self.pixels = vec![0; page_bytes(side)];
self.side = side;
}
self.packer = ShelfPacker::new(side, side);
self.last_used = frame;
}
}
fn page_bytes(side: u32) -> usize {
usize::try_from(u64::from(side) * u64::from(side) * 4)
.expect("a page within MAX_GLYPH_PAGE_SIZE is addressable")
}
struct Quad {
page: usize,
src: Rect,
center: Vec2,
scale: f32,
color: [f32; 4],
z: f32,
screen: bool,
clip: Option<Rect>,
}
pub struct TextRenderer {
font: fontdue::Font,
instance: u64,
pages: Vec<GlyphPage>,
glyphs: HashMap<GlyphKey, GlyphSlot>,
queued: Vec<Quad>,
clip: Option<Rect>,
pixel_scale: f32,
frame: u64,
}
impl TextRenderer {
pub fn new(font_bytes: &[u8]) -> Result<Self, TextError> {
let settings = fontdue::FontSettings {
scale: 84.0,
..fontdue::FontSettings::default()
};
let font = fontdue::Font::from_bytes(font_bytes, settings).map_err(TextError::Font)?;
static NEXT_INSTANCE: std::sync::atomic::AtomicUsize =
std::sync::atomic::AtomicUsize::new(0);
let instance = NEXT_INSTANCE.fetch_add(1, std::sync::atomic::Ordering::Relaxed) as u64;
Ok(Self {
font,
instance,
pages: Vec::new(),
glyphs: HashMap::new(),
queued: Vec::new(),
clip: None,
pixel_scale: 1.0,
frame: 0,
})
}
pub fn set_pixel_scale(&mut self, scale: f32) {
self.pixel_scale = scale.max(0.25);
}
pub fn set_clip(&mut self, clip: Option<Rect>) {
self.clip = clip;
}
pub fn load(path: &Path) -> Result<Self, TextError> {
let bytes = std::fs::read(path).map_err(|source| TextError::Io {
path: path.to_owned(),
source,
})?;
Self::new(&bytes)
}
pub fn page_count(&self) -> usize {
self.pages.len()
}
pub fn measure(&self, text: &str, px: f32) -> Vec2 {
if !drawable_px(px * self.pixel_scale) {
return Vec2::ZERO;
}
let mut width = 0.0;
let mut prev: Option<char> = None;
for c in text.chars() {
if let Some(p) = prev
&& let Some(kern) = self.font.horizontal_kern(p, c, px)
{
width += kern;
}
width += self.font.metrics(c, px).advance_width;
prev = Some(c);
}
Vec2::new(width, self.line_height(px))
}
pub fn line_height(&self, px: f32) -> f32 {
self.font
.horizontal_line_metrics(px)
.map_or(px, |m| m.ascent - m.descent)
}
pub fn ascent(&self, px: f32) -> f32 {
self.font
.horizontal_line_metrics(px)
.map_or(px * 0.8, |m| m.ascent)
}
pub fn draw(
&mut self,
text: &str,
top_left: Vec2,
style: &TextStyle,
z: f32,
channel: TextChannel,
) {
let s = self.pixel_scale;
let raster_px = style.px * s;
if !drawable_px(raster_px) {
return;
}
let snap = |v: f32| (v * s).round() / s;
let baseline = top_left.y + self.ascent(raster_px) / s;
let mut placed: Vec<(GlyphBitmap, Vec2)> = Vec::new();
let mut pen = top_left.x;
let mut prev: Option<char> = None;
for c in text.chars() {
if let Some(p) = prev
&& let Some(kern) = self.font.horizontal_kern(p, c, raster_px)
{
pen += kern / s;
}
let slot = self.glyph(c, raster_px);
if let Some(b) = slot.bitmap {
self.pages[b.page].last_used = self.frame;
let gx = snap(pen + b.xmin / s);
let gy = snap(baseline - b.ymin / s - b.h as f32 / s);
placed.push((b, Vec2::new(gx, gy)));
}
pen += slot.advance / s;
prev = Some(c);
}
let screen = channel == TextChannel::Screen;
let clip = self.clip;
let queued = &mut self.queued;
let mut emit = |offset: Vec2, color: [f32; 4]| {
for (b, pos) in &placed {
let size = Vec2::new(b.w as f32, b.h as f32) / s;
queued.push(Quad {
page: b.page,
src: Rect::new(b.x as f32, b.y as f32, b.w as f32, b.h as f32),
center: *pos + offset + size * 0.5,
scale: 1.0 / s,
color,
z,
screen,
clip,
});
}
};
if let Some(shadow) = style.shadow {
for o in ring_offsets(shadow.spread) {
emit(shadow.offset + o, shadow.color);
}
emit(shadow.offset, shadow.color);
}
if let Some(outline) = style.outline {
for o in ring_offsets(outline.width) {
emit(o, outline.color);
}
}
emit(Vec2::ZERO, style.color);
}
#[allow(clippy::too_many_arguments)]
pub fn draw_in_rect(
&mut self,
text: &str,
rect: Rect,
h_align: HAlign,
v_align: VAlign,
style: &TextStyle,
z: f32,
channel: TextChannel,
) {
let size = self.measure(text, style.px);
let space = rect.size();
let x = match h_align {
HAlign::Left => rect.min.x,
HAlign::Center => rect.min.x + (space.x - size.x) * 0.5,
HAlign::Right => rect.max.x - size.x,
};
let y = match v_align {
VAlign::Top => rect.min.y,
VAlign::Center => rect.min.y + (space.y - size.y) * 0.5,
VAlign::Bottom => rect.max.y - size.y,
};
self.draw(text, Vec2::new(x, y), style, z, channel);
}
pub fn end_frame(
&mut self,
assets: &mut Assets<Texture>,
list: &mut DrawList,
) -> Vec<Handle<Texture>> {
let mut changed = Vec::new();
for (i, page) in self.pages.iter_mut().enumerate() {
if !page.dirty {
continue;
}
let path = PathBuf::from(format!("sgl://glyph-page/{}/{i}", self.instance));
let handle = assets.insert(
path,
Texture {
width: page.side,
height: page.side,
rgba: page.pixels.clone(),
},
);
page.handle = Some(handle);
page.dirty = false;
changed.push(handle);
}
for quad in self.queued.drain(..) {
let Some(handle) = self.pages[quad.page].handle else {
continue; };
let instance = SpriteInstance {
src: Some(quad.src),
scale: Vec2::splat(quad.scale),
color: quad.color,
z: quad.z,
clip: quad.clip,
..SpriteInstance::new(handle, quad.center)
};
if quad.screen {
list.push_screen(instance);
} else {
list.push(instance);
}
}
self.frame += 1;
changed
}
fn glyph(&mut self, c: char, px: f32) -> GlyphSlot {
let key = GlyphKey {
c,
px_bits: px.to_bits(),
};
if let Some(slot) = self.glyphs.get(&key) {
return *slot;
}
let metrics = self.font.metrics(c, px);
let dims = u32::try_from(metrics.width)
.ok()
.zip(u32::try_from(metrics.height).ok())
.filter(|&(w, h)| {
w != 0
&& h != 0
&& u64::from(w.max(h)) + u64::from(PADDING) <= u64::from(MAX_GLYPH_PAGE_SIZE)
});
let bitmap = if dims.is_none() {
None
} else {
let (metrics, coverage) = self.font.rasterize(c, px);
let (w, h) = (metrics.width as u32, metrics.height as u32);
let (page, x, y) = self.place(w, h);
let stride = self.pages[page].side as usize;
let pixels = &mut self.pages[page].pixels;
for row in 0..metrics.height {
for col in 0..metrics.width {
let a = coverage[row * metrics.width + col];
let at = ((y as usize + row) * stride + x as usize + col) * 4;
pixels[at..at + 4].copy_from_slice(&[255, 255, 255, a]);
}
}
self.pages[page].dirty = true;
Some(GlyphBitmap {
page,
x,
y,
w,
h,
xmin: metrics.xmin as f32,
ymin: metrics.ymin as f32,
})
};
let slot = GlyphSlot {
bitmap,
advance: metrics.advance_width,
};
if slot.bitmap.is_some() {
self.glyphs.insert(key, slot);
}
slot
}
fn place(&mut self, w: u32, h: u32) -> (usize, u32, u32) {
let frame = self.frame;
let need = w.max(h) + PADDING;
let dedicated = need > GLYPH_PAGE_SIZE;
let found = if dedicated {
None
} else {
self.pages
.iter_mut()
.enumerate()
.filter(|(_, page)| !page.dedicated)
.find_map(|(i, page)| page.packer.insert(w, h).map(|(x, y)| (i, x, y)))
};
let (i, x, y) = found.unwrap_or_else(|| {
let stale = self
.pages
.iter()
.enumerate()
.filter(|(_, page)| page.last_used < frame && page.dedicated == dedicated)
.min_by_key(|(_, page)| page.last_used)
.map(|(i, _)| i);
let side = need.max(GLYPH_PAGE_SIZE);
let i = if let Some(i) = stale {
self.glyphs
.retain(|_, slot| slot.bitmap.is_none_or(|b| b.page != i));
self.pages[i].reset(side, frame);
i
} else {
self.pages.push(GlyphPage::new(side, dedicated, frame));
self.pages.len() - 1
};
let (x, y) = self.pages[i]
.packer
.insert(w, h)
.expect("an empty page one padding wider than the glyph fits it");
(i, x, y)
});
self.pages[i].last_used = frame;
(i, x, y)
}
}
pub const MAX_RING_WIDTH: f32 = 64.0;
fn ring_offsets(width: f32) -> Vec<Vec2> {
let mut out = Vec::new();
if !width.is_finite() {
return out;
}
let mut r = width.min(MAX_RING_WIDTH);
while r > 0.25 {
let samples = ((std::f32::consts::TAU * r) / 2.0).ceil().max(8.0) as usize;
for i in 0..samples {
let a = std::f32::consts::TAU * i as f32 / samples as f32;
out.push(Vec2::new(a.cos(), a.sin()) * r);
}
r -= 2.0;
}
out
}
fn drawable_px(px: f32) -> bool {
px > 0.0 && px.is_finite()
}
#[cfg(test)]
mod tests {
use super::*;
use wasm_bindgen_test::wasm_bindgen_test;
#[wasm_bindgen_test(unsupported = test)]
fn alignment_and_the_unit_outline_ring_are_exact() {
let mut r = renderer();
let style = TextStyle::new(16.0, [1.0; 4]);
let text = "Hg";
let size = r.measure(text, 16.0);
let rect = Rect::new(100.0, 100.0, 200.0, 80.0);
let mut assets: Assets<Texture> = Assets::new();
let mut anchors = Vec::new();
for (h, v, expected) in [
(HAlign::Left, VAlign::Top, Vec2::new(100.0, 100.0)),
(
HAlign::Right,
VAlign::Bottom,
Vec2::new(300.0 - size.x, 180.0 - size.y),
),
(
HAlign::Center,
VAlign::Center,
Vec2::new(
100.0 + (200.0 - size.x) * 0.5,
100.0 + (80.0 - size.y) * 0.5,
),
),
] {
let mut list = DrawList::new();
r.draw_in_rect(text, rect, h, v, &style, 0.0, TextChannel::Screen);
r.end_frame(&mut assets, &mut list);
let mut direct = DrawList::new();
r.draw(text, expected, &style, 0.0, TextChannel::Screen);
r.end_frame(&mut assets, &mut direct);
let centers = |l: &DrawList| l.screen.iter().map(|q| q.pos).collect::<Vec<_>>();
assert_eq!(centers(&list), centers(&direct), "{h:?} {v:?}");
anchors.push(centers(&list));
}
assert_ne!(anchors[0], anchors[1]);
let ring = ring_offsets(1.0);
assert_eq!(ring.len(), 8);
for o in &ring {
assert!((o.length() - 1.0).abs() < 1e-5, "{o}");
}
assert!(ring_offsets(0.25).is_empty());
assert_eq!(ring_offsets(3.0).len(), ring_offsets(1.0).len() + 10);
}
fn renderer() -> TextRenderer {
TextRenderer::new(include_bytes!(
"../../tests/fixtures/IBMPlexSans-Regular.ttf"
))
.expect("test font should parse")
}
#[wasm_bindgen_test(unsupported = test)]
fn measure_is_monotone_over_prefixes() {
let tr = renderer();
let text = "ELEMENTAL CHAOS";
let mut last = 0.0;
for end in 1..=text.len() {
let w = tr.measure(&text[..end], 48.0).x;
assert!(w >= last, "width shrank at prefix {end}: {w} < {last}");
if !text[end - 1..end].trim().is_empty() {
assert!(w > last, "inked char did not widen at prefix {end}");
}
last = w;
}
assert!(tr.measure(text, 48.0).y > tr.measure(text, 24.0).y);
}
#[wasm_bindgen_test(unsupported = test)]
fn measure_scales_with_size() {
let tr = renderer();
let w8 = tr.measure("99", 8.0).x;
let w24 = tr.measure("99", 24.0).x;
let w84 = tr.measure("99", 84.0).x;
assert!(w8 < w24 && w24 < w84);
}
#[wasm_bindgen_test(unsupported = test)]
fn glyph_atlas_grows_new_pages() {
let mut tr = renderer();
for px in [84.0, 72.0, 48.0] {
for c in ('A'..='Z').chain('a'..='z').chain('0'..='9') {
let slot = tr.glyph(c, px);
if let Some(b) = slot.bitmap {
assert!(b.x + b.w <= GLYPH_PAGE_SIZE, "{c}@{px} escapes page x");
assert!(b.y + b.h <= GLYPH_PAGE_SIZE, "{c}@{px} escapes page y");
}
}
}
assert!(
tr.page_count() >= 2,
"expected atlas growth past one page, got {}",
tr.page_count()
);
let a = tr.glyph('A', 84.0).bitmap.unwrap();
let b = tr.glyph('A', 84.0).bitmap.unwrap();
assert_eq!((a.page, a.x, a.y), (b.page, b.x, b.y));
}
#[wasm_bindgen_test(unsupported = test)]
fn space_has_advance_but_no_bitmap() {
let mut tr = renderer();
let slot = tr.glyph(' ', 24.0);
assert!(slot.bitmap.is_none());
assert!(slot.advance > 0.0);
}
#[wasm_bindgen_test(unsupported = test)]
fn end_frame_republishes_dirty_pages_and_flushes_quads() {
let mut tr = renderer();
let mut assets: Assets<Texture> = Assets::new();
let mut list = DrawList::new();
let style = TextStyle::new(24.0, [1.0; 4]);
tr.draw("Hello", Vec2::ZERO, &style, 5.0, TextChannel::Screen);
let first = tr.end_frame(&mut assets, &mut list);
assert_eq!(first.len(), 1, "one dirty page after first draw");
assert_eq!(list.screen.len(), 5, "one quad per inked glyph");
assert!(list.world.is_empty());
assert!(list.screen.iter().all(|i| i.z == 5.0));
assert!(assets.get(first[0]).is_some(), "published page resolves");
list.clear();
tr.draw("Hello", Vec2::ZERO, &style, 0.0, TextChannel::World);
let again = tr.end_frame(&mut assets, &mut list);
assert!(again.is_empty(), "clean page must not republish");
assert_eq!(list.world.len(), 5, "world channel supported");
list.clear();
tr.draw("xyz!", Vec2::ZERO, &style, 0.0, TextChannel::Screen);
let third = tr.end_frame(&mut assets, &mut list);
assert_eq!(third, first, "a page keeps its handle");
}
#[wasm_bindgen_test(unsupported = test)]
fn outline_and_shadow_add_ring_copies() {
let mut tr = renderer();
let mut assets: Assets<Texture> = Assets::new();
let mut list = DrawList::new();
let plain = TextStyle::new(24.0, [1.0, 1.0, 0.0, 1.0]);
tr.draw("AB", Vec2::ZERO, &plain, 0.0, TextChannel::Screen);
tr.end_frame(&mut assets, &mut list);
let plain_count = list.screen.len();
assert_eq!(plain_count, 2);
list.clear();
let fancy = plain
.with_outline(1.0)
.with_shadow(Vec2::new(5.0, 5.0), 0.0);
tr.draw("AB", Vec2::ZERO, &fancy, 0.0, TextChannel::Screen);
tr.end_frame(&mut assets, &mut list);
assert_eq!(list.screen.len(), 2 * (8 + 1 + 1));
assert_eq!(list.screen.first().unwrap().color, [0.0, 0.0, 0.0, 1.0]);
assert_eq!(list.screen.last().unwrap().color, [1.0, 1.0, 0.0, 1.0]);
}
#[wasm_bindgen_test(unsupported = test)]
fn draw_in_rect_centers_within_the_rect() {
let mut tr = renderer();
let mut assets: Assets<Texture> = Assets::new();
let mut list = DrawList::new();
let style = TextStyle::new(84.0, [1.0, 1.0, 0.0, 1.0]);
let band = Rect::new(0.0, 0.0, 960.0, 216.0);
tr.draw_in_rect(
"ELEMENTAL CHAOS",
band,
HAlign::Center,
VAlign::Center,
&style,
0.0,
TextChannel::Screen,
);
tr.end_frame(&mut assets, &mut list);
assert!(!list.screen.is_empty());
let (mut min_x, mut max_x) = (f32::MAX, f32::MIN);
let (mut min_y, mut max_y) = (f32::MAX, f32::MIN);
for i in &list.screen {
let half = i.src.unwrap().size() * 0.5;
min_x = min_x.min(i.pos.x - half.x);
max_x = max_x.max(i.pos.x + half.x);
min_y = min_y.min(i.pos.y - half.y);
max_y = max_y.max(i.pos.y + half.y);
}
let center_x = (min_x + max_x) * 0.5;
assert!(
(center_x - 480.0).abs() < 4.0,
"title not horizontally centered: {center_x}"
);
assert!(min_y > 0.0 && max_y < 216.0, "title escapes the top band");
assert!(max_y - min_y > 50.0, "title glyphs suspiciously small");
}
#[wasm_bindgen_test(unsupported = test)]
fn pixel_scale_one_is_bit_identical() {
let mut assets: Assets<Texture> = Assets::new();
let style = TextStyle::new(24.0, [1.0; 4]);
let mut base = renderer();
let mut base_list = DrawList::new();
base.draw(
"Zoom 100%",
Vec2::new(3.7, 9.2),
&style,
1.0,
TextChannel::Screen,
);
base.end_frame(&mut assets, &mut base_list);
let mut scaled = renderer();
scaled.set_pixel_scale(1.0);
let mut scaled_list = DrawList::new();
scaled.draw(
"Zoom 100%",
Vec2::new(3.7, 9.2),
&style,
1.0,
TextChannel::Screen,
);
scaled.end_frame(&mut assets, &mut scaled_list);
assert_eq!(base_list.screen.len(), scaled_list.screen.len());
for (a, b) in base_list.screen.iter().zip(&scaled_list.screen) {
assert_eq!(a.pos, b.pos, "positions must match bit-for-bit");
assert_eq!(a.src, b.src);
assert_eq!(a.scale, b.scale);
}
}
#[wasm_bindgen_test(unsupported = test)]
fn pixel_scale_two_rasterizes_double_and_snaps_half_grid() {
let mut assets: Assets<Texture> = Assets::new();
let style = TextStyle::new(24.0, [1.0; 4]);
let mut one = renderer();
let mut one_list = DrawList::new();
one.draw(
"Hg",
Vec2::new(10.0, 10.0),
&style,
0.0,
TextChannel::Screen,
);
one.end_frame(&mut assets, &mut one_list);
let mut two = renderer();
two.set_pixel_scale(2.0);
let mut two_list = DrawList::new();
two.draw(
"Hg",
Vec2::new(10.0, 10.0),
&style,
0.0,
TextChannel::Screen,
);
two.end_frame(&mut assets, &mut two_list);
assert_eq!(one_list.screen.len(), two_list.screen.len());
for (a, b) in one_list.screen.iter().zip(&two_list.screen) {
let (sa, sb) = (a.src.unwrap(), b.src.unwrap());
assert!(
(sb.size().x - sa.size().x * 2.0).abs() <= 2.0,
"raster width should double: {} vs {}",
sa.size().x,
sb.size().x
);
let quad = sb.size() * b.scale;
assert!(
(quad.x - sa.size().x).abs() <= 1.5 && (quad.y - sa.size().y).abs() <= 1.5,
"quad size should stay in layout units: {quad:?} vs {sa:?}"
);
let corner = b.pos - quad * 0.5;
for v in [corner.x, corner.y] {
let doubled = v * 2.0;
assert!(
(doubled - doubled.round()).abs() < 1e-3,
"corner {v} is off the 1/2-point grid"
);
}
}
}
#[wasm_bindgen_test(unsupported = test)]
fn an_oversized_high_dpi_glyph_gets_its_own_page() {
let mut tr = renderer();
let mut assets: Assets<Texture> = Assets::new();
let mut list = DrawList::new();
tr.set_pixel_scale(4.0);
tr.draw(
"W",
Vec2::ZERO,
&TextStyle::new(160.0, [1.0; 4]),
0.0,
TextChannel::Screen,
);
tr.end_frame(&mut assets, &mut list);
let (metrics, coverage) = renderer().font.rasterize('W', 640.0);
assert!(metrics.width.max(metrics.height) > GLYPH_PAGE_SIZE as usize);
let [quad] = list.screen.as_slice() else {
panic!("one quad for one glyph, got {}", list.screen.len());
};
let page = assets.get(quad.texture).expect("published page");
let src = quad.src.expect("glyph quads have a src rect");
assert_eq!(
(src.size().x as usize, src.size().y as usize),
(metrics.width, metrics.height)
);
let (x0, y0) = (src.min.x as usize, src.min.y as usize);
let stride = page.width as usize;
let alpha: Vec<u8> = (0..metrics.height)
.flat_map(|row| {
(0..metrics.width).map(move |col| ((y0 + row) * stride + x0 + col) * 4 + 3)
})
.map(|at| page.rgba[at])
.collect();
assert_eq!(alpha, coverage);
}
#[wasm_bindgen_test(unsupported = test)]
fn standard_glyphs_never_share_an_oversized_page() {
let mut tr = renderer();
let mut assets: Assets<Texture> = Assets::new();
let mut list = DrawList::new();
tr.set_pixel_scale(4.0);
let big = TextStyle::new(160.0, [1.0; 4]);
tr.draw("W", Vec2::ZERO, &big, 0.0, TextChannel::Screen);
tr.end_frame(&mut assets, &mut list);
list.clear();
tr.set_pixel_scale(1.0);
let alphabet: String = ('A'..='Z').chain('a'..='z').chain('0'..='9').collect();
for px in [84.0, 72.0, 48.0] {
let style = TextStyle::new(px, [1.0; 4]);
tr.draw(&alphabet, Vec2::ZERO, &style, 0.0, TextChannel::Screen);
}
tr.end_frame(&mut assets, &mut list);
assert!(tr.page_count() >= 3, "standard glyphs needed a second page");
for quad in &list.screen {
let page = assets.get(quad.texture).expect("published page");
assert_eq!(page.width, GLYPH_PAGE_SIZE);
}
}
#[wasm_bindgen_test(unsupported = test)]
fn animated_oversized_text_reuses_dedicated_pages() {
let mut tr = renderer();
let mut assets: Assets<Texture> = Assets::new();
let mut list = DrawList::new();
tr.set_pixel_scale(4.0);
for frame in 0..80u8 {
let px = 200.0 - f32::from(frame.min(80 - frame));
let style = TextStyle::new(px, [1.0; 4]);
tr.draw("W", Vec2::ZERO, &style, 0.0, TextChannel::Screen);
tr.end_frame(&mut assets, &mut list);
for quad in &list.screen {
let page = assets.get(quad.texture).expect("published page");
let src = quad.src.expect("glyph quads have a src rect");
assert!(page.width > GLYPH_PAGE_SIZE, "a dedicated page");
let glyph_side = src.size().x.max(src.size().y) as u32;
assert_eq!(page.width, glyph_side + PADDING);
}
list.clear();
assert!(
tr.page_count() <= 2,
"{} pages at frame {frame}",
tr.page_count()
);
}
}
#[wasm_bindgen_test(unsupported = test)]
fn growing_oversized_text_keeps_a_bounded_page_count() {
let mut tr = renderer();
let mut assets: Assets<Texture> = Assets::new();
let mut list = DrawList::new();
tr.set_pixel_scale(4.0);
for frame in 0..40u8 {
let style = TextStyle::new(160.0 + f32::from(frame), [1.0; 4]);
tr.draw("W", Vec2::ZERO, &style, 0.0, TextChannel::Screen);
tr.end_frame(&mut assets, &mut list);
list.clear();
assert!(
tr.page_count() <= 2,
"{} pages at frame {frame}",
tr.page_count()
);
}
}
#[wasm_bindgen_test(unsupported = test)]
fn a_glyph_beyond_the_page_cap_is_skipped() {
let mut tr = renderer();
let slot = tr.glyph('W', 40_000.0);
assert!(slot.bitmap.is_none());
assert!(slot.advance > 0.0);
assert_eq!(tr.page_count(), 0);
}
#[wasm_bindgen_test(unsupported = test)]
fn a_glyph_past_the_default_texture_limit_is_skipped() {
let mut tr = renderer();
let limit = wgpu::Limits::default().max_texture_dimension_2d;
let px = 10_400.0;
let m = tr.font.metrics('W', px);
assert!(m.width.max(m.height) as u32 + PADDING > limit);
let slot = tr.glyph('W', px);
assert!(slot.bitmap.is_none());
assert!(slot.advance > 0.0);
assert_eq!(tr.page_count(), 0);
}
#[wasm_bindgen_test(unsupported = test)]
fn warm_cache_layout_matches_cold_and_measure() {
let text = "W".repeat(40);
let style = TextStyle::new(16.1, [1.0; 4]);
let centers = |tr: &mut TextRenderer| {
let mut assets: Assets<Texture> = Assets::new();
let mut list = DrawList::new();
tr.draw(&text, Vec2::ZERO, &style, 0.0, TextChannel::Screen);
tr.end_frame(&mut assets, &mut list);
list.screen.iter().map(|q| q.pos.x).collect::<Vec<_>>()
};
let mut cold = renderer();
let cold_x = centers(&mut cold);
let mut warm = renderer();
let mut assets: Assets<Texture> = Assets::new();
warm.draw(
&text,
Vec2::ZERO,
&TextStyle::new(16.0, [1.0; 4]),
0.0,
TextChannel::Screen,
);
warm.end_frame(&mut assets, &mut DrawList::new());
assert_eq!(centers(&mut warm), cold_x);
let expected = cold_x[0] + cold.measure(&text[..39], 16.1).x;
let last = cold_x[39];
assert!((last - expected).abs() <= 1.0, "{last} vs {expected}");
}
#[wasm_bindgen_test(unsupported = test)]
fn negative_and_non_finite_sizes_draw_nothing() {
let mut tr = renderer();
let mut assets: Assets<Texture> = Assets::new();
for px in [-16.0, f32::NEG_INFINITY, f32::INFINITY, f32::NAN] {
let mut list = DrawList::new();
let style = TextStyle::new(px, [1.0; 4]);
tr.draw("Hello", Vec2::ZERO, &style, 0.0, TextChannel::Screen);
tr.end_frame(&mut assets, &mut list);
assert!(list.screen.is_empty(), "{px} drew glyphs");
assert_eq!(tr.measure("Hello", px), Vec2::ZERO, "{px}");
}
tr.set_pixel_scale(2.0);
assert_eq!(tr.measure("Hello", f32::MAX), Vec2::ZERO);
assert_eq!(tr.page_count(), 0);
}
fn sampled_glyphs(assets: &Assets<Texture>, list: &DrawList) -> Vec<Vec<u8>> {
list.screen
.iter()
.map(|quad| {
let page = assets.get(quad.texture).expect("published page");
let src = quad.src.expect("glyph quads have a src rect");
let (x0, y0) = (src.min.x as usize, src.min.y as usize);
let (x1, y1) = (src.max.x as usize, src.max.y as usize);
let stride = GLYPH_PAGE_SIZE as usize * 4;
(y0..y1)
.flat_map(|y| page.rgba[y * stride + x0 * 4..y * stride + x1 * 4].to_vec())
.collect()
})
.collect()
}
#[wasm_bindgen_test(unsupported = test)]
fn animated_text_sizes_keep_a_bounded_page_count() {
let mut tr = renderer();
let mut assets: Assets<Texture> = Assets::new();
let mut list = DrawList::new();
for frame in 0..1000u16 {
let style = TextStyle::new(16.0 + f32::from(frame) * 0.25, [1.0; 4]);
tr.draw("Hi", Vec2::ZERO, &style, 0.0, TextChannel::Screen);
tr.end_frame(&mut assets, &mut list);
list.clear();
assert!(
tr.page_count() <= 3,
"{} pages at frame {frame}",
tr.page_count()
);
}
let style = TextStyle::new(16.0, [1.0; 4]);
tr.draw("Hi", Vec2::ZERO, &style, 0.0, TextChannel::Screen);
tr.end_frame(&mut assets, &mut list);
let mut fresh = renderer();
let mut fresh_assets: Assets<Texture> = Assets::new();
let mut fresh_list = DrawList::new();
fresh.draw("Hi", Vec2::ZERO, &style, 0.0, TextChannel::Screen);
fresh.end_frame(&mut fresh_assets, &mut fresh_list);
assert_eq!(
sampled_glyphs(&assets, &list),
sampled_glyphs(&fresh_assets, &fresh_list)
);
}
#[wasm_bindgen_test(unsupported = test)]
fn animated_inkless_glyphs_keep_a_bounded_cache() {
let mut tr = renderer();
let mut assets: Assets<Texture> = Assets::new();
let mut list = DrawList::new();
for frame in 0..1000u16 {
let style = TextStyle::new(16.0 + f32::from(frame) * 0.001, [1.0; 4]);
tr.draw(" ", Vec2::ZERO, &style, 0.0, TextChannel::Screen);
tr.end_frame(&mut assets, &mut list);
list.clear();
}
assert!(tr.glyphs.len() <= 1, "{} cached slots", tr.glyphs.len());
}
#[wasm_bindgen_test(unsupported = test)]
fn non_finite_and_huge_ring_widths_are_bounded() {
assert!(ring_offsets(f32::INFINITY).is_empty());
assert!(ring_offsets(f32::NAN).is_empty());
assert_eq!(ring_offsets(1e9).len(), ring_offsets(MAX_RING_WIDTH).len());
}
#[wasm_bindgen_test(unsupported = test)]
fn ring_offsets_scale_with_width() {
assert_eq!(ring_offsets(1.0).len(), 8);
assert!(ring_offsets(0.0).is_empty());
let big = ring_offsets(10.0);
assert!(big.len() > 40, "10 px ring too sparse: {}", big.len());
assert!(big.iter().all(|o| o.length() <= 10.001));
assert!(big.iter().any(|o| o.length() < 5.0), "no inner ring");
}
}