Struct FaceSet 

pub struct FaceSet { /* private fields */ }

The host’s registered fonts: families for styles to name, plus a global fallback chain consulted per character. Immutable once built — register everything, then Arc it for builders and the renderer.

Implementations

impl FaceSet

pub fn new() -> Self

pub fn register(&mut self, family: &str, bytes: Vec<u8>) -> Option<FontId>

Register font bytes under a family name (regular weight/style). Returns None when the bytes don’t parse as a font.

Examples found in repository

examples/raster_bench.rs (lines 23-26)

fn main() {
    let dir = concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/fonts");
    // A CJK face is 20k+ glyphs and too big to vendor: point VALO_CJK_FONT
    // at one to get the CJK column, otherwise the bench runs latin only.
    let cjk_file = std::env::var("VALO_CJK_FONT").unwrap_or_default();
    let mut fonts = FaceSet::default();
    let latin = fonts
        .register(
            "Latin",
            std::fs::read(format!("{dir}/fira_sans.ttf")).unwrap(),
        )
        .unwrap();
    let cjk = std::fs::read(cjk_file)
        .ok()
        .and_then(|bytes| fonts.register("CJK", bytes));

    let mut sets = vec![("latin", latin, glyphs(&fonts, latin, LATIN))];
    if let Some(id) = cjk {
        sets.push(("cjk", id, glyphs(&fonts, id, CJK)));
    }

    println!(
        "{:>6} {:>6}  {:>12} {:>12}  (µs/glyph, n={})",
        "set",
        "px",
        "alpha",
        "sdf",
        LATIN.len()
    );
    let mut raster = Rasterizer::new();
    for (label, font, ids) in &sets {
        for px in SIZES {
            let alpha = time_per_glyph(ids, |g| {
                raster.alpha(fonts.get(*font), g, px, 0.0);
            });
            let mut raster2 = Rasterizer::new();
            let sdf = time_per_glyph(ids, |g| {
                raster2.sdf(fonts.get(*font), g, px);
            });
            println!("{label:>6} {px:>6.0}  {alpha:>10.1}µs {sdf:>10.1}µs");
        }
    }
}

pub fn register_with( &mut self, family: &str, attrs: FontAttrs, bytes: Vec<u8>, ) -> Option<FontId>

Register one variant of a family — resolve picks the nearest weight with a matching style (CSS §5.2, simplified: style first, then minimal weight distance, ties to the first registered).

pub fn add(&mut self, font: Font) -> FontId

Add an already-parsed Font under ITS OWN name/attrs — the SkTypeface → registerTypeface shape.

pub fn with_font(&self, font: Font) -> (FaceSet, FontId)

A new collection = this one + font. Faces are shared by Arc, so this is O(faces) pointer clones — no re-parsing, and every existing holder of the old collection is untouched.

pub fn with_fallbacks(&self, fallbacks: Vec<FontId>) -> FaceSet

A new collection with the fallback chain REPLACED (order matters).

pub fn add_fallback(&mut self, id: FontId)

Append to the global fallback chain (consulted after a style’s own families: nearest attrs among the faces covering the character, ties in chain order).

pub fn grown_by( &self, source: &mut dyn FontSource, demand: &FontDemand, ) -> Option<FaceSet>

Grow this collection to answer demand from source: demanded families register under their own names PLUS the demanded name as an alias (a localized or differently-spelled request must match on the next layout, or a loop around this call could demand forever); codepoints still uncovered afterwards extend the fallback chain with a face matching the demanding span’s attrs. Some(grown) only when something new was found — the caller’s signal to re-register the collection and lay out again. Grow a COPY of this face set to answer demand from source — the out-of-band path (a host that already knows what it wants). Live resolution goes through FontCollection, which owns its sources.

pub fn is_empty(&self) -> bool

True until the first add/register — building paragraphs against an empty collection is a contract violation (resolve asserts).

pub fn len(&self) -> usize

Faces registered so far. Ids are append-only, so a holder of an older collection can name the faces added since: old.len()..new.len().

pub fn get_arc(&self, id: FontId) -> Arc<Font>

The shared instance behind id — what glyph runs carry to the renderer (Skia: blobs hold sk_sp<SkTypeface>).

pub fn get(&self, id: FontId) -> &Font

Examples found in repository

examples/raster_bench.rs (line 49)

fn main() {
    let dir = concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/fonts");
    // A CJK face is 20k+ glyphs and too big to vendor: point VALO_CJK_FONT
    // at one to get the CJK column, otherwise the bench runs latin only.
    let cjk_file = std::env::var("VALO_CJK_FONT").unwrap_or_default();
    let mut fonts = FaceSet::default();
    let latin = fonts
        .register(
            "Latin",
            std::fs::read(format!("{dir}/fira_sans.ttf")).unwrap(),
        )
        .unwrap();
    let cjk = std::fs::read(cjk_file)
        .ok()
        .and_then(|bytes| fonts.register("CJK", bytes));

    let mut sets = vec![("latin", latin, glyphs(&fonts, latin, LATIN))];
    if let Some(id) = cjk {
        sets.push(("cjk", id, glyphs(&fonts, id, CJK)));
    }

    println!(
        "{:>6} {:>6}  {:>12} {:>12}  (µs/glyph, n={})",
        "set",
        "px",
        "alpha",
        "sdf",
        LATIN.len()
    );
    let mut raster = Rasterizer::new();
    for (label, font, ids) in &sets {
        for px in SIZES {
            let alpha = time_per_glyph(ids, |g| {
                raster.alpha(fonts.get(*font), g, px, 0.0);
            });
            let mut raster2 = Rasterizer::new();
            let sdf = time_per_glyph(ids, |g| {
                raster2.sdf(fonts.get(*font), g, px);
            });
            println!("{label:>6} {px:>6.0}  {alpha:>10.1}µs {sdf:>10.1}µs");
        }
    }
}

fn glyphs(fonts: &FaceSet, id: FontId, text: &str) -> Vec<u32> {
    let font = fonts.get(id);
    text.chars().filter_map(|ch| font.glyph_for(ch)).collect()
}

pub fn family(&self, name: &str) -> Option<FontId>

pub fn faces<'a>(&'a self, name: &'a str) -> impl Iterator<Item = FontId> + 'a

Ids of EVERY face answering to name, in registration order. Subset families (css2/cn-font-split unicode-range chunks) register many faces under one name with disjoint coverage — a fallback chain built from Self::family alone reaches only the first-loaded chunk, so hosts expand fallback names with this.

pub fn family_variant(&self, name: &str, attrs: FontAttrs) -> Option<FontId>

The family variant nearest attrs: matching style wins, then the smallest weight distance (ties to the first registered).

pub fn resolve(&self, families: &[String], attrs: FontAttrs, ch: char) -> FontId

The font that renders ch for a style: per requested family, the nearest variant that COVERS ch — subset families (cn-font-split chunks) carry one unicode range per face, so coverage must look past the best-attrs face. Then the fallback chain, else the first candidate.

pub fn resolve_covered( &self, families: &[String], attrs: FontAttrs, ch: char, ) -> (FontId, bool)

Self::resolve plus whether ANYTHING actually covers ch — false means the returned face will shape .notdef. The demand signal: callers report uncovered chars to the host, which decides where fonts come from — valo only detects.

Trait Implementations

impl Clone for FaceSet

fn clone(&self) -> FaceSet

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for FaceSet

fn default() -> FaceSet

Returns the “default value” for a type.