Struct Rasterizer 

pub struct Rasterizer { /* private fields */ }

Rasterizer converts font glyphs into CPU bitmap or distance-field images.

Valo’s renderer owns one internally. Hosts need this type only when building a custom glyph cache or text renderer. Reuse an instance to retain scaling and stroking scratch state; its methods require mutable access.

Implementations

impl Rasterizer

pub fn new() -> Self

new creates an empty CPU glyph rasterizer.

Examples found in repository

examples/raster_bench.rs (line 45)

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 alpha( &mut self, font: &Font, glyph: u32, px: f32, dx: f32, ) -> Option<GlyphImage>

alpha rasterizes a glyph into one-byte alpha coverage.

px is the font size in raster pixels. dx shifts the outline horizontally for subpixel positioning and is usually one of 0.0, 0.25, 0.5, or 0.75. It returns None when the glyph has no rasterizable monochrome outline.

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");
        }
    }
}

pub fn stroked( &mut self, font: &Font, glyph: u32, px: f32, dx: f32, stroke: &GlyphStroke, ) -> Option<GlyphImage>

stroked rasterizes a stroked glyph outline into one-byte alpha coverage.

px, dx, and stroke dimensions are in raster pixels. It returns None when the glyph has no outline or the stroked path cannot be built.

pub fn sdf(&mut self, font: &Font, glyph: u32, px: f32) -> Option<GlyphImage>

sdf rasterizes a glyph into a one-byte signed distance field.

px is the font size in raster pixels. A value near 128 marks the edge; larger values are inside and smaller values are outside. The image is padded by SDF_PAD pixels. It returns None when no monochrome outline can be rasterized.

Examples found in repository

examples/raster_bench.rs (line 53)

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 color(&mut self, font: &Font, glyph: u32, px: f32) -> Option<GlyphImage>

color rasterizes a color glyph into premultiplied RGBA8 pixels.

px is the font size in raster pixels. It supports color outlines and embedded color bitmaps. It returns None when the glyph has no supported color representation, allowing callers to fall back to alpha rendering.

Trait Implementations

impl Default for Rasterizer

fn default() -> Rasterizer

Returns the “default value” for a type.