msdfgen 0.2.1

Safe bindings for msdfgen (multi-channel signed distance field generator)
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use crate::{Contour, EdgeColor, EdgeHolder, FontExt, Point2, Shape};

#[derive(Default)]
struct ContourBuilder {
    contour: Contour,
    point: Point2<f64>,
    start_point: Point2<f64>,
}

impl ContourBuilder {
    pub fn open_at(x: f64, y: f64) -> Self {
        Self {
            contour: Contour::default(),
            point: Point2::new(x, y),
            start_point: Point2::new(x, y),
        }
    }

    pub fn line_to(&mut self, x: f64, y: f64) {
        let point = Point2::new(x, y);
        self.contour.add_edge(&EdgeHolder::new_linear(
            self.point,
            point,
            EdgeColor::default(),
        ));
        self.point = point;
    }

    pub fn quad_to(&mut self, cx: f64, cy: f64, x: f64, y: f64) {
        let cpoint = Point2::new(cx, cy);
        let point = Point2::new(x, y);
        self.contour.add_edge(&EdgeHolder::new_quadratic(
            self.point,
            cpoint,
            point,
            EdgeColor::default(),
        ));
        self.point = point;
    }

    pub fn curve_to(&mut self, c1x: f64, c1y: f64, c2x: f64, c2y: f64, x: f64, y: f64) {
        let c1point = Point2::new(c1x, c1y);
        let c2point = Point2::new(c2x, c2y);
        let point = Point2::new(x, y);
        self.contour.add_edge(&EdgeHolder::new_cubic(
            self.point,
            c1point,
            c2point,
            point,
            EdgeColor::default(),
        ));
        self.point = point;
    }

    pub fn close(self) -> Contour {
        self.contour
    }
}

#[derive(Default)]
struct ShapeBuilder {
    shape: Shape,
    contour: Option<ContourBuilder>,
}

impl ShapeBuilder {
    pub fn build(self) -> Shape {
        self.shape
    }
}

impl ttf_parser::OutlineBuilder for ShapeBuilder {
    fn move_to(&mut self, x: f32, y: f32) {
        if self.contour.is_some() {
            panic!("Unexpected move_to");
        }

        self.contour = ContourBuilder::open_at(x as _, y as _).into();
    }

    fn line_to(&mut self, x: f32, y: f32) {
        self.contour
            .as_mut()
            .expect("Opened contour")
            .line_to(x as _, y as _);
    }

    fn quad_to(&mut self, x1: f32, y1: f32, x: f32, y: f32) {
        self.contour
            .as_mut()
            .expect("Opened contour")
            .quad_to(x1 as _, y1 as _, x as _, y as _);
    }

    fn curve_to(&mut self, x1: f32, y1: f32, x2: f32, y2: f32, x: f32, y: f32) {
        self.contour
            .as_mut()
            .expect("Opened contour")
            .curve_to(x1 as _, y1 as _, x2 as _, y2 as _, x as _, y as _);
    }

    fn close(&mut self) {
        let mut contour = self.contour.take().expect("Opened contour");
        if contour.point != contour.start_point {
            contour.line_to(contour.start_point.x as _, contour.start_point.y as _);
        }
        self.shape.add_contour(&contour.close());
    }
}

impl<'a> FontExt for ttf_parser::Face<'a> {
    type Glyph = ttf_parser::GlyphId;

    fn glyph_shape(&self, glyph: Self::Glyph) -> Option<Shape> {
        let mut builder = ShapeBuilder::default();

        self.outline_glyph(glyph, &mut builder)?;

        Some(builder.build())
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use notosans::REGULAR_TTF;
    use ttf_parser::{Face, GlyphId};

    #[test]
    fn glyph_shape() {
        let font = Face::parse(REGULAR_TTF, 0).unwrap();

        let mut shapes = 0;

        for glyph in 0..font.number_of_glyphs() {
            let glyph = GlyphId(glyph);
            if let Some(_shape) = font.glyph_shape(glyph) {
                shapes += 1;
            }
        }

        assert_eq!(shapes, 2392);
    }
}