rusttype 0.7.5

A pure Rust alternative to libraries like FreeType. RustType provides an API for loading, querying and rasterising TrueType fonts. It also provides an implementation of a dynamic GPU glyph cache for hardware font rendering.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use image::{DynamicImage, LumaA};
use rusttype::{point, Font, Scale, ScaledGlyph};
use std::io::Cursor;

lazy_static::lazy_static! {
    static ref DEJA_VU_MONO: Font<'static> =
        Font::from_bytes(include_bytes!("../fonts/dejavu/DejaVuSansMono.ttf") as &[u8]).unwrap();
    static ref OPEN_SANS_ITALIC: Font<'static> =
        Font::from_bytes(include_bytes!("../fonts/opensans/OpenSans-Italic.ttf") as &[u8]).unwrap();
}

fn draw_luma_alpha(glyph: ScaledGlyph<'_>) -> image::GrayAlphaImage {
    let glyph = glyph.positioned(point(0.0, 0.0));
    let bounds = glyph.pixel_bounding_box().unwrap();
    let mut glyph_image =
        DynamicImage::new_luma_a8(bounds.width() as _, bounds.height() as _).to_luma_alpha();

    glyph.draw(|x, y, v| {
        glyph_image.put_pixel(
            x,
            y,
            LumaA {
                data: [128, (v * 255.0) as u8],
            },
        )
    });

    glyph_image
}

/// Render a 600px U+2623 character require it to match the reference with
/// 8-bit accuracy
#[test]
fn render_to_reference_big_biohazard() {
    let new_image = draw_luma_alpha(DEJA_VU_MONO.glyph('☣').scaled(Scale::uniform(600.0)));

    // save the new render for manual inspection
    new_image.save("target/big_biohazard.png").unwrap();

    let reference = image::load(
        Cursor::new(include_bytes!("reference_big_biohazard.png") as &[u8]),
        image::PNG,
    )
    .expect("!image::load")
    .to_luma_alpha();

    assert_eq!(reference.dimensions(), new_image.dimensions());

    for y in 0..reference.height() {
        for x in 0..reference.width() {
            assert_eq!(
                reference.get_pixel(x, y),
                new_image.get_pixel(x, y),
                "unexpected alpha difference at ({}, {})",
                x,
                y
            );
        }
    }
}

/// Render a 16px 'w' character require it to match the reference with 8-bit
/// accuracy
#[test]
fn render_to_reference_w() {
    let new_image = draw_luma_alpha(DEJA_VU_MONO.glyph('w').scaled(Scale::uniform(16.0)));

    // save the new render for manual inspection
    new_image.save("target/w.png").unwrap();

    let reference = image::load(
        Cursor::new(include_bytes!("reference_w.png") as &[u8]),
        image::PNG,
    )
    .expect("!image::load")
    .to_luma_alpha();

    assert_eq!(reference.dimensions(), new_image.dimensions());

    for y in 0..reference.height() {
        for x in 0..reference.width() {
            assert_eq!(
                reference.get_pixel(x, y),
                new_image.get_pixel(x, y),
                "unexpected alpha difference at ({}, {})",
                x,
                y
            );
        }
    }
}

/// Render a 60px 'ΐ' character require it to match the reference with 8-bit
/// accuracy
#[test]
fn render_to_reference_iota() {
    let new_image = draw_luma_alpha(OPEN_SANS_ITALIC.glyph('ΐ').scaled(Scale::uniform(60.0)));

    // save the new render for manual inspection
    new_image.save("target/iota.png").unwrap();

    let reference = image::load(
        Cursor::new(include_bytes!("reference_iota.png") as &[u8]),
        image::PNG,
    )
    .expect("!image::load")
    .to_luma_alpha();

    assert_eq!(reference.dimensions(), new_image.dimensions());

    for y in 0..reference.height() {
        for x in 0..reference.width() {
            assert_eq!(
                reference.get_pixel(x, y),
                new_image.get_pixel(x, y),
                "unexpected alpha difference at ({}, {})",
                x,
                y
            );
        }
    }
}