packed-font-derive 0.1.0

Compile-time font rasterizer and packer for embedded systems (derive macro)
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

use skrifa::{
    OutlineGlyph,
    outline::{DrawSettings, HintingInstance, OutlinePen},
};
use tiny_skia::{Color, FillRule, Paint, PathBuilder, Pixmap, Transform};

pub struct Bitmap {
    x0: f32,
    y0: f32,
    pixmap: Pixmap,
    path: Option<PathBuilder>,
}

impl Bitmap {
    pub fn new(x0: f32, y0: f32, width: u32, height: u32) -> Self {
        let pixmap = Pixmap::new(width, height).expect("Can't allocate pixmap");
        Self {
            x0,
            y0,
            pixmap,
            path: None,
        }
    }

    pub fn draw_glyph(&mut self, hinter: &HintingInstance, glyph: &OutlineGlyph) {
        let settings = DrawSettings::hinted(hinter, false);
        glyph.draw(settings, self).expect("Can't draw glyph");
        self.draw_path();
    }

    fn path(&mut self) -> &mut PathBuilder {
        self.path.get_or_insert_with(PathBuilder::new)
    }

    fn draw_path(&mut self) {
        if let Some(path) = self.path.take().and_then(PathBuilder::finish) {
            let mut paint = Paint::default();
            paint.set_color(Color::WHITE);
            self.pixmap.fill_path(
                &path,
                &paint,
                FillRule::Winding,
                Transform::identity(),
                None,
            );
        }
    }

    pub fn pixels(&self) -> impl ExactSizeIterator<Item = u8> {
        self.pixmap.pixels().iter().map(|p| p.alpha())
    }
}

impl OutlinePen for Bitmap {
    fn move_to(&mut self, x: f32, y: f32) {
        let x0 = self.x0;
        let y0 = self.y0;
        self.path().move_to(x0 + x, y0 - y)
    }

    fn line_to(&mut self, x: f32, y: f32) {
        let x0 = self.x0;
        let y0 = self.y0;
        self.path().line_to(x0 + x, y0 - y)
    }

    fn quad_to(&mut self, cx0: f32, cy0: f32, x: f32, y: f32) {
        let x0 = self.x0;
        let y0 = self.y0;
        self.path().quad_to(x0 + cx0, y0 - cy0, x0 + x, y0 - y)
    }

    fn curve_to(&mut self, cx0: f32, cy0: f32, cx1: f32, cy1: f32, x: f32, y: f32) {
        let x0 = self.x0;
        let y0 = self.y0;
        self.path()
            .cubic_to(x0 + cx0, y0 - cy0, x0 + cx1, y0 - cy1, x0 + x, y0 - y);
    }

    fn close(&mut self) {
        self.path().close();
    }
}