font.rs

use crate::cff::{self, Cff};
use crate::error::Error;
use crate::glyf::{self, Glyf};
use crate::opentype::{self, require};
use crate::outline::{self, Outline};
use std::collections::HashMap;


#[derive(Debug, Clone)]
enum Kind {
    Cff(Cff),
    Glyf(Glyf),
}


#[derive(Debug, Clone)]
pub struct Font {
    data: Vec<u8>,
    family: String,
    units_per_em: f64,
    kind: Kind,
    map: HashMap<char, u16>,
    advance: Vec<f64>,
    extent: Vec<(f64, f64)>,
    bearing: Vec<(f64, f64)>,
    cap_height: f64,
    x_height: f64,
    digit_height: f64,
}


const DEFAULT_CAP_HEIGHT: f64 = 0.7;

const DEFAULT_X_HEIGHT: f64 = 0.45;

const DEFAULT_DIGIT_HEIGHT: f64 = 0.66;


pub fn load(data: Vec<u8>) -> Result<Font, Error> {
    let (head_at, _) = require(&data, "head")?;
    let shape = opentype::head(&data, head_at)?;
    let units_per_em = shape.units_per_em;
    let (maxp_at, _) = require(&data, "maxp")?;
    let count = opentype::glyph_count(&data, maxp_at)?;
    let (hmtx_at, _) = require(&data, "hmtx")?;
    let (hhea_at, _) = require(&data, "hhea")?;
    let (cmap_at, _) = require(&data, "cmap")?;
    let (name_at, _) = require(&data, "name")?;

    let kind = match opentype::find(&data, "CFF ")? {
        Some((cff_at, _)) => Kind::Cff(cff::parse(&data, cff_at, units_per_em)?),
        None => {
            let (glyf_at, _) = require(&data, "glyf")?;
            let (loca_at, _) = require(&data, "loca")?;

            Kind::Glyf(glyf::new(glyf_at, loca_at, shape.long_loca, count))
        }
    };

    let advance = opentype::advances(&data, hmtx_at, hhea_at, count)?
        .into_iter()
        .map(|width| width / units_per_em)
        .collect();
    let mut font = Font {
        family: opentype::family_name(&data, name_at)?,
        map: opentype::character_map(&data, cmap_at)?,
        units_per_em,
        kind,
        advance,
        extent: Vec::new(),
        bearing: Vec::new(),
        cap_height: DEFAULT_CAP_HEIGHT,
        x_height: DEFAULT_X_HEIGHT,
        digit_height: DEFAULT_DIGIT_HEIGHT,
        data,
    };

    let (extent, bearing) = measure_all(&font, count);
    font.extent = extent;
    font.bearing = bearing;
    font.cap_height = height_of(&font, 'H', DEFAULT_CAP_HEIGHT);
    font.x_height = height_of(&font, 'x', DEFAULT_X_HEIGHT);
    font.digit_height = height_of(&font, '0', DEFAULT_DIGIT_HEIGHT);

    Ok(font)
}


pub fn family(font: &Font) -> &str {
    &font.family
}


pub const FALLBACK: &str = "serif";


pub fn units_per_em(font: &Font) -> f64 {
    font.units_per_em
}


pub fn cap_height(font: &Font) -> f64 {
    font.cap_height
}


pub fn x_height(font: &Font) -> f64 {
    font.x_height
}


pub fn digit_height(font: &Font) -> f64 {
    font.digit_height
}


pub fn glyph_of(font: &Font, character: char) -> Option<u16> {
    font.map.get(&character).copied()
}


pub fn advance(font: &Font, glyph: u16) -> f64 {
    font.advance.get(glyph as usize).copied().unwrap_or(0.0)
}


pub fn extent(font: &Font, glyph: u16) -> (f64, f64) {
    font.extent.get(glyph as usize).copied().unwrap_or((0.0, 0.0))
}


pub fn bearing(font: &Font, glyph: u16) -> (f64, f64) {
    font.bearing.get(glyph as usize).copied().unwrap_or((0.0, 0.0))
}


pub fn fallback_metric(character: char) -> (f64, f64, f64) {
    if character as u32 >= 0x2e80 {
        (1.0, 0.88, 0.12)
    } else {
        (0.5, 0.7, 0.0)
    }
}


pub fn outline_of(font: &Font, glyph: u16) -> Outline {
    let found = match &font.kind {
        Kind::Cff(cff) => cff::outline(&font.data, cff, glyph),
        Kind::Glyf(glyf) => glyf::outline(&font.data, glyf, glyph),
    };

    found.unwrap_or_default()
}


#[cfg(test)]
pub fn sample() -> Font {
    let path = "font/latinmodern-math.otf";
    let data = std::fs::read(path).expect("cannot read the test font");

    load(data).expect("cannot load the test font")
}


fn height_of(font: &Font, character: char, default: f64) -> f64 {
    match font.map.get(&character) {
        Some(glyph) => match font.extent.get(*glyph as usize) {
            Some((height, _)) if *height > 0.0 => *height,
            _ => default,
        },
        None => default,
    }
}


type Measured = (Vec<(f64, f64)>, Vec<(f64, f64)>);


fn measure_all(font: &Font, count: usize) -> Measured {
    let mut extent = Vec::with_capacity(count);
    let mut bearing = Vec::with_capacity(count);

    for glyph in 0..count {
        let drawn = outline_of(font, glyph as u16);
        let (left, bottom, right, top) = outline::bounds(&drawn);
        let units = font.units_per_em;
        extent.push((top / units, -bottom / units));

        let advance = font.advance.get(glyph).copied().unwrap_or(0.0);
        bearing.push((left / units, (advance - right / units).max(0.0)));
    }

    (extent, bearing)
}


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

    #[test]
    fn reads_the_name_and_the_unit() {
        let font = sample();
        assert_eq!(family(&font), "Latin Modern Math");
        assert_eq!(units_per_em(&font), 1000.0);
    }

    #[test]
    fn measures_letters() {
        let font = sample();
        let carbon = glyph_of(&font, 'C').unwrap();
        let hydrogen = glyph_of(&font, 'H').unwrap();
        assert!(advance(&font, carbon) > 0.3 && advance(&font, carbon) < 1.0);
        assert!(extent(&font, hydrogen).1.abs() < 1e-9, "H has depth");
        assert!(extent(&font, carbon).1 > 0.0 && extent(&font, carbon).1 < 0.05);
        assert!(extent(&font, carbon).0 > extent(&font, hydrogen).0);
        assert!(extent(&font, hydrogen).0 > 0.5);
    }

    #[test]
    fn the_heights_come_from_the_font() {
        let font = sample();
        assert!(cap_height(&font) > 0.5 && cap_height(&font) < 0.9);
        assert!(x_height(&font) > 0.3 && x_height(&font) < 0.6);
        assert!(x_height(&font) < cap_height(&font));
    }

    #[test]
    fn outlines_come_out_in_font_units() {
        let font = sample();
        let oxygen = glyph_of(&font, 'O').unwrap();
        let drawn = outline_of(&font, oxygen);
        assert!(!drawn.segment.is_empty());
        let (_, _, _, top) = outline::bounds(&drawn);
        assert!((top / units_per_em(&font) - extent(&font, oxygen).0).abs() < 1e-9);
    }

    #[test]
    fn a_broken_file_is_reported_in_bytes() {
        let found = load(vec![0; 8]).unwrap_err();
        assert!(found.in_font);
        assert!(found.to_string().contains("byte"));
    }

    #[test]
    fn a_font_without_math_still_loads() {
        let path = "/System/Library/Fonts/Supplemental/Times New Roman.ttf";
        let Ok(data) = std::fs::read(path) else {
            return;
        };
        let font = load(data).unwrap();
        assert!(cap_height(&font) > 0.5);
        assert!(glyph_of(&font, 'C').is_some());
    }
}