loam_text/

lib.rs

//! Printable ASCII (`0x20..=0x7E`) is pre-baked at a fixed atlas size; per-call
//! sizes scale the quads bilinearly. HUD readouts only, not typographic or
//! non-Latin text.

pub mod glyph;
pub mod pass;

pub use pass::{TextDraw, TextPass};

use std::collections::HashMap;

pub use ab_glyph;
use ab_glyph::{Font, FontRef, Glyph, GlyphId, Point, ScaleFont};
use anyhow::{anyhow, Result};
use bytemuck::{Pod, Zeroable};
use wgpu::*;

const ATLAS_SIZE: u32 = 1024;
const ATLAS_FORMAT: TextureFormat = TextureFormat::R8Unorm;

#[derive(Copy, Clone, Debug)]
struct GlyphEntry {
    uv_min: [f32; 2],
    uv_max: [f32; 2],
    px_width: f32,
    px_height: f32,
    h_advance: f32,
    bearing_x: f32,
    bearing_y: f32,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, Pod, Zeroable)]
struct TextVertex {
    pos: [f32; 2],
    uv: [f32; 2],
    color: [f32; 4],
}

#[repr(C)]
#[derive(Copy, Clone, Debug, Pod, Zeroable)]
struct TextUniforms {
    viewport_size: [f32; 2],
    _pad: [f32; 2],
}

pub struct TextMetrics {
    advances: HashMap<char, f32>,
    bake_size_px: f32,
    line_height_px: f32,
}

impl TextMetrics {
    pub fn new(font_bytes: &[u8], bake_size_px: f32) -> Result<Self> {
        validate_bake_size(bake_size_px)?;
        let font = FontRef::try_from_slice(font_bytes)
            .map_err(|e| anyhow!("loam-text: failed to parse font: {e}"))?;
        Ok(Self::from_font(&font, bake_size_px))
    }

    fn from_font(font: &FontRef<'_>, bake_size_px: f32) -> Self {
        let scaled = font.as_scaled(bake_size_px);
        let advances = (0x20u32..=0x7E)
            .map(|code| {
                let c = code as u8 as char;
                (c, scaled.h_advance(font.glyph_id(c)))
            })
            .collect();
        Self {
            advances,
            bake_size_px,
            line_height_px: scaled.ascent() - scaled.descent() + scaled.line_gap(),
        }
    }

    /// Measures advances and full line boxes, including the final line gap.
    pub fn measure(&self, text: &str, size_px: f32) -> [f32; 2] {
        let mut widest = 0.0_f32;
        let mut line = 0.0_f32;
        let mut lines = 1_u32;
        for c in text.chars() {
            if c == '\n' {
                widest = widest.max(line);
                line = 0.0;
                lines += 1;
                continue;
            }
            line += self.advances.get(&c).copied().unwrap_or(0.0);
        }
        let scale = size_px / self.bake_size_px;
        [
            widest.max(line) * scale,
            lines as f32 * self.line_height_px * scale,
        ]
    }

    pub fn bake_size_px(&self) -> f32 {
        self.bake_size_px
    }

    /// At the bake size.
    pub fn line_height_px(&self) -> f32 {
        self.line_height_px
    }
}

pub struct TextRenderer {
    pipeline: RenderPipeline,
    bind_group: BindGroup,
    uniform_buf: Buffer,
    glyphs: HashMap<char, GlyphEntry>,
    metrics: TextMetrics,
    ascent_px: f32,

    vertex_buf: Buffer,
    vertex_capacity: u64,
    queued: Vec<TextVertex>,
}

impl TextRenderer {
    pub fn new(
        device: &Device,
        queue: &Queue,
        surface_format: TextureFormat,
        font_bytes: &[u8],
        bake_size_px: f32,
    ) -> Result<Self> {
        validate_bake_size(bake_size_px)?;
        let font = FontRef::try_from_slice(font_bytes)
            .map_err(|e| anyhow!("loam-text: failed to parse font: {e}"))?;

        let atlas_tex = device.create_texture(&TextureDescriptor {
            label: Some("loam-text atlas"),
            size: Extent3d {
                width: ATLAS_SIZE,
                height: ATLAS_SIZE,
                depth_or_array_layers: 1,
            },
            mip_level_count: 1,
            sample_count: 1,
            dimension: TextureDimension::D2,
            format: ATLAS_FORMAT,
            usage: TextureUsages::TEXTURE_BINDING | TextureUsages::COPY_DST,
            view_formats: &[],
        });
        let atlas_view = atlas_tex.create_view(&TextureViewDescriptor::default());
        let atlas_sampler = device.create_sampler(&SamplerDescriptor {
            label: Some("loam-text atlas sampler"),
            address_mode_u: AddressMode::ClampToEdge,
            address_mode_v: AddressMode::ClampToEdge,
            address_mode_w: AddressMode::ClampToEdge,
            mag_filter: FilterMode::Linear,
            min_filter: FilterMode::Linear,
            mipmap_filter: FilterMode::Nearest,
            ..Default::default()
        });

        let baked = bake_ascii_atlas(&font, bake_size_px)?;
        queue.write_texture(
            TexelCopyTextureInfo {
                texture: &atlas_tex,
                mip_level: 0,
                origin: Origin3d::ZERO,
                aspect: TextureAspect::All,
            },
            &baked.pixels,
            TexelCopyBufferLayout {
                offset: 0,
                bytes_per_row: Some(ATLAS_SIZE),
                rows_per_image: Some(ATLAS_SIZE),
            },
            Extent3d {
                width: ATLAS_SIZE,
                height: ATLAS_SIZE,
                depth_or_array_layers: 1,
            },
        );

        let uniform_buf = device.create_buffer(&BufferDescriptor {
            label: Some("loam-text uniforms"),
            size: std::mem::size_of::<TextUniforms>() as u64,
            usage: BufferUsages::UNIFORM | BufferUsages::COPY_DST,
            mapped_at_creation: false,
        });

        let bgl = device.create_bind_group_layout(&BindGroupLayoutDescriptor {
            label: Some("loam-text bgl"),
            entries: &[
                BindGroupLayoutEntry {
                    binding: 0,
                    visibility: ShaderStages::VERTEX_FRAGMENT,
                    ty: BindingType::Buffer {
                        ty: BufferBindingType::Uniform,
                        has_dynamic_offset: false,
                        min_binding_size: None,
                    },
                    count: None,
                },
                BindGroupLayoutEntry {
                    binding: 1,
                    visibility: ShaderStages::FRAGMENT,
                    ty: BindingType::Texture {
                        sample_type: TextureSampleType::Float { filterable: true },
                        view_dimension: TextureViewDimension::D2,
                        multisampled: false,
                    },
                    count: None,
                },
                BindGroupLayoutEntry {
                    binding: 2,
                    visibility: ShaderStages::FRAGMENT,
                    ty: BindingType::Sampler(SamplerBindingType::Filtering),
                    count: None,
                },
            ],
        });
        let bind_group = device.create_bind_group(&BindGroupDescriptor {
            label: Some("loam-text bg"),
            layout: &bgl,
            entries: &[
                BindGroupEntry {
                    binding: 0,
                    resource: uniform_buf.as_entire_binding(),
                },
                BindGroupEntry {
                    binding: 1,
                    resource: BindingResource::TextureView(&atlas_view),
                },
                BindGroupEntry {
                    binding: 2,
                    resource: BindingResource::Sampler(&atlas_sampler),
                },
            ],
        });

        let shader = device.create_shader_module(ShaderModuleDescriptor {
            label: Some("loam-text shader"),
            source: ShaderSource::Wgsl(WGSL_SHADER.into()),
        });
        let pipeline_layout = device.create_pipeline_layout(&PipelineLayoutDescriptor {
            label: Some("loam-text pipeline layout"),
            bind_group_layouts: &[&bgl],
            push_constant_ranges: &[],
        });
        let vertex_attrs = wgpu::vertex_attr_array![
            0 => Float32x2,
            1 => Float32x2,
            2 => Float32x4,
        ];
        let pipeline = device.create_render_pipeline(&RenderPipelineDescriptor {
            label: Some("loam-text pipeline"),
            layout: Some(&pipeline_layout),
            vertex: VertexState {
                module: &shader,
                entry_point: Some("vs_main"),
                buffers: &[VertexBufferLayout {
                    array_stride: std::mem::size_of::<TextVertex>() as u64,
                    step_mode: VertexStepMode::Vertex,
                    attributes: &vertex_attrs,
                }],
                compilation_options: Default::default(),
            },
            fragment: Some(FragmentState {
                module: &shader,
                entry_point: Some("fs_main"),
                targets: &[Some(ColorTargetState {
                    format: surface_format,
                    blend: Some(BlendState::ALPHA_BLENDING),
                    write_mask: ColorWrites::ALL,
                })],
                compilation_options: Default::default(),
            }),
            primitive: PrimitiveState {
                topology: PrimitiveTopology::TriangleList,
                ..Default::default()
            },
            depth_stencil: None,
            multisample: MultisampleState {
                count: 1,
                ..Default::default()
            },
            multiview: None,
            cache: None,
        });

        let initial_capacity = 1024_u64;
        let vertex_buf = device.create_buffer(&BufferDescriptor {
            label: Some("loam-text vertices"),
            size: initial_capacity * std::mem::size_of::<TextVertex>() as u64,
            usage: BufferUsages::VERTEX | BufferUsages::COPY_DST,
            mapped_at_creation: false,
        });

        Ok(Self {
            pipeline,
            bind_group,
            uniform_buf,
            glyphs: baked.glyphs,
            metrics: baked.metrics,
            ascent_px: baked.ascent_px,
            vertex_buf,
            vertex_capacity: initial_capacity,
            queued: Vec::new(),
        })
    }

    /// Queues straight-alpha RGBA text at the first line's ascender in viewport pixels.
    pub fn queue(&mut self, text: &str, position: [f32; 2], size_px: f32, color: [f32; 4]) {
        layout_text(
            text,
            position,
            size_px,
            color,
            &self.glyphs,
            self.metrics.bake_size_px,
            self.metrics.line_height_px,
            self.ascent_px,
            &mut self.queued,
        );
    }

    /// Draws and clears the text queue.
    pub fn record(
        &mut self,
        device: &Device,
        queue: &Queue,
        encoder: &mut CommandEncoder,
        view: &TextureView,
        viewport_size: [f32; 2],
    ) {
        if self.queued.is_empty() {
            return;
        }
        self.upload(device, queue, viewport_size);
        let mut rp = encoder.begin_render_pass(&RenderPassDescriptor {
            label: Some("loam-text pass"),
            color_attachments: &[Some(RenderPassColorAttachment {
                view,
                depth_slice: None,
                resolve_target: None,
                ops: Operations {
                    load: LoadOp::Load,
                    store: StoreOp::Store,
                },
            })],
            depth_stencil_attachment: None,
            timestamp_writes: None,
            occlusion_query_set: None,
        });
        rp.set_pipeline(&self.pipeline);
        rp.set_bind_group(0, &self.bind_group, &[]);
        rp.set_vertex_buffer(0, self.vertex_buf.slice(..));
        rp.draw(0..self.queued.len() as u32, 0..1);
        drop(rp);

        self.queued.clear();
    }

    fn upload(&mut self, device: &Device, queue: &Queue, viewport_size: [f32; 2]) {
        let uniforms = TextUniforms {
            viewport_size,
            _pad: [0.0; 2],
        };
        queue.write_buffer(&self.uniform_buf, 0, bytemuck::bytes_of(&uniforms));

        let needed = self.queued.len() as u64;
        if needed > self.vertex_capacity {
            let mut new_cap = self.vertex_capacity.max(1);
            while new_cap < needed {
                new_cap *= 2;
            }
            self.vertex_buf = device.create_buffer(&BufferDescriptor {
                label: Some("loam-text vertices (grown)"),
                size: new_cap * std::mem::size_of::<TextVertex>() as u64,
                usage: BufferUsages::VERTEX | BufferUsages::COPY_DST,
                mapped_at_creation: false,
            });
            self.vertex_capacity = new_cap;
        }
        queue.write_buffer(&self.vertex_buf, 0, bytemuck::cast_slice(&self.queued));
    }

    pub fn metrics(&self) -> &TextMetrics {
        &self.metrics
    }

    pub fn bake_size_px(&self) -> f32 {
        self.metrics.bake_size_px
    }

    pub fn line_height_px(&self) -> f32 {
        self.metrics.line_height_px
    }
}

#[allow(clippy::too_many_arguments)]
fn layout_text(
    text: &str,
    position: [f32; 2],
    size_px: f32,
    color: [f32; 4],
    glyphs: &HashMap<char, GlyphEntry>,
    bake_size_px: f32,
    line_height_px: f32,
    ascent_px: f32,
    out: &mut Vec<TextVertex>,
) {
    let scale = size_px / bake_size_px;
    let line_h = line_height_px * scale;
    let mut cursor_x = position[0];
    let mut cursor_y = position[1];

    for c in text.chars() {
        if c == '\n' {
            cursor_x = position[0];
            cursor_y += line_h;
            continue;
        }
        if !is_printable_ascii(c) {
            continue;
        }
        let Some(g) = glyphs.get(&c) else {
            continue;
        };

        let x0 = cursor_x + g.bearing_x * scale;
        let y0 = cursor_y + (ascent_px + g.bearing_y) * scale;
        let x1 = x0 + g.px_width * scale;
        let y1 = y0 + g.px_height * scale;

        let (u0, v0) = (g.uv_min[0], g.uv_min[1]);
        let (u1, v1) = (g.uv_max[0], g.uv_max[1]);

        out.extend_from_slice(&[
            TextVertex {
                pos: [x0, y0],
                uv: [u0, v0],
                color,
            },
            TextVertex {
                pos: [x1, y0],
                uv: [u1, v0],
                color,
            },
            TextVertex {
                pos: [x0, y1],
                uv: [u0, v1],
                color,
            },
            TextVertex {
                pos: [x1, y0],
                uv: [u1, v0],
                color,
            },
            TextVertex {
                pos: [x1, y1],
                uv: [u1, v1],
                color,
            },
            TextVertex {
                pos: [x0, y1],
                uv: [u0, v1],
                color,
            },
        ]);

        cursor_x += g.h_advance * scale;
    }
}

fn is_printable_ascii(c: char) -> bool {
    ('\u{20}'..='\u{7E}').contains(&c)
}

pub fn is_renderable(text: &str) -> bool {
    text.chars().all(|c| c == '\n' || is_printable_ascii(c))
}

struct BakedAtlas {
    pixels: Vec<u8>,
    glyphs: HashMap<char, GlyphEntry>,
    metrics: TextMetrics,
    ascent_px: f32,
}

fn validate_bake_size(size: f32) -> Result<()> {
    if !size.is_finite() || size <= 0.0 {
        return Err(anyhow!(
            "font bake size must be finite and positive, got {size}"
        ));
    }
    Ok(())
}

fn bake_ascii_atlas(font: &FontRef<'_>, bake_size_px: f32) -> Result<BakedAtlas> {
    let scaled = font.as_scaled(bake_size_px);

    let mut atlas = vec![0u8; (ATLAS_SIZE * ATLAS_SIZE) as usize];
    let mut entries: HashMap<char, GlyphEntry> = HashMap::with_capacity(96);

    let pad = 1u32;
    let mut shelf_y: u32 = pad;
    let mut shelf_x: u32 = pad;
    let mut shelf_h: u32 = 0;

    for code in 0x20u32..=0x7E {
        let c = code as u8 as char;
        let gid: GlyphId = font.glyph_id(c);
        let h_adv = scaled.h_advance(gid);

        let mut glyph: Glyph = scaled.scaled_glyph(c);
        glyph.position = Point { x: 0.0, y: 0.0 };

        let outlined = scaled.outline_glyph(glyph);
        match outlined {
            Some(o) => {
                let bounds = o.px_bounds();
                let gw = bounds.width().ceil() as u32;
                let gh = bounds.height().ceil() as u32;
                if gw == 0 || gh == 0 {
                    entries.insert(
                        c,
                        GlyphEntry {
                            uv_min: [0.0; 2],
                            uv_max: [0.0; 2],
                            px_width: 0.0,
                            px_height: 0.0,
                            h_advance: h_adv,
                            bearing_x: 0.0,
                            bearing_y: 0.0,
                        },
                    );
                    continue;
                }
                if gw > ATLAS_SIZE - 2 * pad || gh > ATLAS_SIZE - 2 * pad {
                    return Err(anyhow!("glyph {c:?} exceeds the {ATLAS_SIZE} pixel atlas"));
                }
                if shelf_x + gw + pad > ATLAS_SIZE {
                    shelf_y += shelf_h + pad;
                    shelf_x = pad;
                    shelf_h = 0;
                }
                if shelf_y + gh + pad > ATLAS_SIZE {
                    return Err(anyhow!(
                        "loam-text: ASCII atlas exceeded {ATLAS_SIZE}x{ATLAS_SIZE} at glyph {c:?}; \
                         reduce bake_size_px or extend the packer"
                    ));
                }

                let dst_x = shelf_x;
                let dst_y = shelf_y;
                o.draw(|gx, gy, cov| {
                    let px_x = dst_x + gx;
                    let px_y = dst_y + gy;
                    if px_x < ATLAS_SIZE && px_y < ATLAS_SIZE {
                        let idx = (px_y * ATLAS_SIZE + px_x) as usize;
                        let v = (cov * 255.0).round().clamp(0.0, 255.0) as u8;
                        atlas[idx] = atlas[idx].max(v);
                    }
                });

                let uv_min = [
                    dst_x as f32 / ATLAS_SIZE as f32,
                    dst_y as f32 / ATLAS_SIZE as f32,
                ];
                let uv_max = [
                    (dst_x + gw) as f32 / ATLAS_SIZE as f32,
                    (dst_y + gh) as f32 / ATLAS_SIZE as f32,
                ];

                entries.insert(
                    c,
                    GlyphEntry {
                        uv_min,
                        uv_max,
                        px_width: gw as f32,
                        px_height: gh as f32,
                        h_advance: h_adv,
                        bearing_x: bounds.min.x,
                        bearing_y: bounds.min.y,
                    },
                );

                shelf_x += gw + pad;
                shelf_h = shelf_h.max(gh);
            }
            None => {
                entries.insert(
                    c,
                    GlyphEntry {
                        uv_min: [0.0; 2],
                        uv_max: [0.0; 2],
                        px_width: 0.0,
                        px_height: 0.0,
                        h_advance: h_adv,
                        bearing_x: 0.0,
                        bearing_y: 0.0,
                    },
                );
            }
        }
    }

    Ok(BakedAtlas {
        pixels: atlas,
        glyphs: entries,
        metrics: TextMetrics::from_font(font, bake_size_px),
        ascent_px: scaled.ascent(),
    })
}

const WGSL_SHADER: &str = r#"
struct Uniforms {
    viewport_size: vec2<f32>,
    _pad: vec2<f32>,
};

@group(0) @binding(0) var<uniform> u: Uniforms;
@group(0) @binding(1) var atlas_tex: texture_2d<f32>;
@group(0) @binding(2) var atlas_sam: sampler;

struct VsOut {
    @builtin(position) clip: vec4<f32>,
    @location(0) uv: vec2<f32>,
    @location(1) color: vec4<f32>,
};

@vertex
fn vs_main(
    @location(0) in_pos: vec2<f32>,
    @location(1) in_uv: vec2<f32>,
    @location(2) in_color: vec4<f32>,
) -> VsOut {
    let ndc_x = (in_pos.x / u.viewport_size.x) * 2.0 - 1.0;
    // pixel y axis points down; NDC y axis points up; flip.
    let ndc_y = 1.0 - (in_pos.y / u.viewport_size.y) * 2.0;
    var out: VsOut;
    out.clip = vec4<f32>(ndc_x, ndc_y, 0.0, 1.0);
    out.uv = in_uv;
    out.color = in_color;
    return out;
}

@fragment
fn fs_main(in: VsOut) -> @location(0) vec4<f32> {
    let alpha = textureSample(atlas_tex, atlas_sam, in.uv).r;
    return vec4<f32>(in.color.rgb, in.color.a * alpha);
}
"#;

#[cfg(test)]
mod tests {
    use super::*;

    const MOCK_ASCENT: f32 = 12.0;

    fn mock_glyph_table(h_advance: f32) -> HashMap<char, GlyphEntry> {
        (0x20u8..=0x7Eu8)
            .map(|c| {
                (
                    c as char,
                    GlyphEntry {
                        uv_min: [0.0, 0.0],
                        uv_max: [1.0, 1.0],
                        bearing_x: 0.0,
                        bearing_y: 0.0,
                        px_width: 1.0,
                        px_height: 1.0,
                        h_advance,
                    },
                )
            })
            .collect()
    }

    fn mock_metrics(h_advance: f32) -> TextMetrics {
        TextMetrics {
            advances: (0x20u8..=0x7Eu8).map(|c| (c as char, h_advance)).collect(),
            bake_size_px: 16.0,
            line_height_px: 16.0,
        }
    }

    #[test]
    fn layout_newline_resets_x_and_advances_y() {
        let glyphs = mock_glyph_table(10.0);
        let mut out = Vec::new();
        layout_text(
            "a\nb",
            [5.0, 0.0],
            16.0,
            [1.0; 4],
            &glyphs,
            16.0,
            16.0,
            MOCK_ASCENT,
            &mut out,
        );
        assert_eq!(out.len(), 12);

        let first = out[0];
        assert_eq!(first.pos[0], 5.0);
        assert!((first.pos[1] - MOCK_ASCENT).abs() < 1e-5);

        let second = out[6];
        assert_eq!(
            second.pos[0], 5.0,
            "newline must reset cursor_x to position[0]"
        );
        assert!(
            (second.pos[1] - (MOCK_ASCENT + 16.0)).abs() < 1e-5,
            "newline must advance cursor_y by line_h, got {}",
            second.pos[1],
        );
    }

    #[test]
    fn position_y_is_the_ascender_line_at_every_scale() {
        let mut glyphs = mock_glyph_table(10.0);
        glyphs.insert(
            'A',
            GlyphEntry {
                uv_min: [0.0, 0.0],
                uv_max: [1.0, 1.0],
                bearing_x: 0.0,
                bearing_y: -MOCK_ASCENT,
                px_width: 8.0,
                px_height: MOCK_ASCENT,
                h_advance: 10.0,
            },
        );
        for size_px in [8.0_f32, 16.0, 40.0] {
            let mut out = Vec::new();
            layout_text(
                "A",
                [3.0, 7.0],
                size_px,
                [1.0; 4],
                &glyphs,
                16.0,
                16.0,
                MOCK_ASCENT,
                &mut out,
            );
            assert!(
                (out[0].pos[1] - 7.0).abs() < 1e-5,
                "at {size_px}px the ascender landed at {} instead of 7.0",
                out[0].pos[1]
            );
        }
    }

    #[test]
    fn layout_cursor_advances_by_h_advance_scaled() {
        let glyphs = mock_glyph_table(10.0);
        let mut out = Vec::new();
        layout_text(
            "ab",
            [0.0, 0.0],
            32.0,
            [1.0; 4],
            &glyphs,
            16.0,
            16.0,
            MOCK_ASCENT,
            &mut out,
        );

        assert_eq!(out[0].pos[0], 0.0);
        assert_eq!(out[6].pos[0], 20.0);
    }

    #[test]
    fn layout_skips_unprintable_and_out_of_range_chars() {
        let glyphs = mock_glyph_table(10.0);
        let mut out = Vec::new();
        layout_text(
            "a\tb\u{80}c😀d",
            [0.0, 0.0],
            16.0,
            [1.0; 4],
            &glyphs,
            16.0,
            16.0,
            MOCK_ASCENT,
            &mut out,
        );
        assert_eq!(out.len(), 24);
    }

    #[test]
    fn layout_skips_missing_glyphs() {
        let mut glyphs = mock_glyph_table(10.0);
        glyphs.remove(&'b');
        let mut out = Vec::new();
        layout_text(
            "ab",
            [0.0, 0.0],
            16.0,
            [1.0; 4],
            &glyphs,
            16.0,
            16.0,
            MOCK_ASCENT,
            &mut out,
        );
        assert_eq!(out.len(), 6);
    }

    #[test]
    fn metrics_keep_advance_widths_separate_from_ink_overhang() {
        let metrics = mock_metrics(10.0);
        let mut glyphs = mock_glyph_table(10.0);
        let glyph = glyphs.get_mut(&'A').unwrap();
        glyph.bearing_x = -2.0;
        glyph.px_width = 15.0;
        let mut vertices = Vec::new();
        layout_text(
            "AA\nA\n",
            [7.0, 11.0],
            32.0,
            [1.0; 4],
            &glyphs,
            16.0,
            16.0,
            MOCK_ASCENT,
            &mut vertices,
        );
        assert_eq!(metrics.measure("AA\nA\n", 32.0), [40.0, 96.0]);
        assert_eq!(vertices[0].pos[0], 3.0);
        assert_eq!(vertices[6].pos[0], 23.0);
        assert_eq!(vertices[12].pos[0], 3.0);
        assert_eq!(vertices[12].pos[1] - vertices[0].pos[1], 32.0);
    }

    #[test]
    fn renderable_charset_excludes_controls_and_non_ascii() {
        assert!(is_renderable(" ~\n"));
        for text in ["\u{1f}", "\u{7f}", "\t", "é", "😀"] {
            assert!(!is_renderable(text), "{text:?}");
        }
    }
}