Struct FaceSet 

pub struct FaceSet { /* private fields */ }

FaceSet stores registered fonts and their global fallback order.

Cloning a face set shares parsed fonts, allowing callers to grow a snapshot without modifying existing holders.

Implementations

impl FaceSet

pub fn new() -> Self

new creates an empty face set.

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

register adds font bytes under a family using default attributes.

It returns None when face zero cannot be parsed.

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_with adds font bytes under a family with explicit attributes.

It returns None when face zero cannot be parsed.

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

add registers an already parsed font under its embedded names and attributes.

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

with_font returns a cloned face set containing one additional font.

Existing fonts remain shared and are not reparsed.

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

with_fallbacks returns a clone with its global fallback order replaced.

Every identifier must belong to this face set.

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

add_fallback appends a registered font to the global fallback order.

Requested families are searched before this chain. id must belong to this face set.

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

grown_by returns a clone extended with answers from a font source.

Requested families are also registered under the requested name. Uncovered codepoints add matching faces to the fallback chain. It returns None when the source supplies nothing new.

pub fn is_empty(&self) -> bool

is_empty reports whether no fonts are registered.

pub fn len(&self) -> usize

len returns the number of registered fonts.

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

get_arc returns a shared handle to a registered font.

Panics

Panics if id does not belong to this face set.

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

get returns a registered font by identifier.

Panics

Panics if id does not belong to this face set.

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>

family returns the first registered font matching a family name or alias.

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

faces iterates over every font matching a family name or alias.

Results follow registration order and include separate subset faces.

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

family_variant returns the family face nearest to requested attributes.

Width is matched first, then italic style and weight. Registration order breaks ties.

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

resolve selects a font for a character and requested style.

It searches requested families in order, then global fallbacks. If no font covers the character, it returns a font suitable for rendering .notdef.

Panics

Panics when the face set is empty.

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

resolve_covered selects a font and reports whether it covers the character.

A false flag means the returned font will render .notdef.

Panics

Panics when the face set is empty.

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.