jitter 0.1.0

Add natural handwriting-like variation to digital text
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

use skrifa::instance::Size;
use skrifa::raw::FileRef;
use skrifa::raw::TableProvider;
use skrifa::MetadataProvider;
use std::path::Path;

/// A single path command extracted from a glyph outline.
#[derive(Debug, Clone)]
pub enum PathCommand {
    MoveTo(f32, f32),
    LineTo(f32, f32),
    QuadTo(f32, f32, f32, f32),
    CurveTo(f32, f32, f32, f32, f32, f32),
    Close,
}

/// A glyph with its outline path commands and advance width.
#[derive(Debug, Clone)]
pub struct GlyphData {
    pub commands: Vec<PathCommand>,
    pub advance_width: f32,
}

/// Pen that collects path commands from skrifa's outline API.
struct CollectPen {
    commands: Vec<PathCommand>,
}

impl CollectPen {
    fn new() -> Self {
        Self {
            commands: Vec::new(),
        }
    }
}

impl skrifa::outline::OutlinePen for CollectPen {
    fn move_to(&mut self, x: f32, y: f32) {
        self.commands.push(PathCommand::MoveTo(x, y));
    }

    fn line_to(&mut self, x: f32, y: f32) {
        self.commands.push(PathCommand::LineTo(x, y));
    }

    fn quad_to(&mut self, cx0: f32, cy0: f32, x: f32, y: f32) {
        self.commands.push(PathCommand::QuadTo(cx0, cy0, x, y));
    }

    fn curve_to(&mut self, cx0: f32, cy0: f32, cx1: f32, cy1: f32, x: f32, y: f32) {
        self.commands
            .push(PathCommand::CurveTo(cx0, cy0, cx1, cy1, x, y));
    }

    fn close(&mut self) {
        self.commands.push(PathCommand::Close);
    }
}

/// Load a font file and extract glyph data for each character in the text.
///
/// Returns a vector of `GlyphData` (one per character) and the units per em value.
pub fn load_glyphs(font_path: &Path, text: &str) -> Result<(Vec<GlyphData>, u16), String> {
    let font_data =
        std::fs::read(font_path).map_err(|e| format!("Failed to read font file: {e}"))?;

    let font_ref = match FileRef::new(&font_data) {
        Ok(FileRef::Font(f)) => f,
        Ok(FileRef::Collection(c)) => c
            .get(0)
            .map_err(|e| format!("Failed to get font from collection: {e}"))?,
        Err(e) => return Err(format!("Failed to parse font: {e}")),
    };

    let units_per_em = font_ref.head().map_err(|e| format!("{e}"))?.units_per_em();
    let charmap = font_ref.charmap();
    let outlines = font_ref.outline_glyphs();
    let location = font_ref.axes().location::<&[(&str, f32)]>(&[]);
    let glyph_metrics = font_ref.glyph_metrics(Size::unscaled(), &location);

    let mut glyphs = Vec::new();

    for ch in text.chars() {
        let glyph_id = charmap
            .map(ch)
            .ok_or_else(|| format!("Character '{ch}' not found in font"))?;

        let advance_width = glyph_metrics.advance_width(glyph_id).unwrap_or(0.0);

        let outline_glyph = outlines.get(glyph_id);

        let mut pen = CollectPen::new();
        if let Some(glyph) = outline_glyph {
            glyph
                .draw(Size::unscaled(), &mut pen)
                .map_err(|e| format!("Failed to draw glyph for '{ch}': {e}"))?;
        }

        glyphs.push(GlyphData {
            commands: pen.commands,
            advance_width,
        });
    }

    Ok((glyphs, units_per_em))
}