pierrelf.com
web engine - experimental web browser
Implement basic text shaping with kern table parsing
- Add kern table parser (version 0, format 0 subtables) with binary
search lookup for kerning pair values
- Add ShapedGlyph type and Font::shape_text() method that maps
Unicode text to positioned glyph runs using cmap, hmtx advances,
and kern pair adjustments
- Add Font::kern() and Font::kern_pair() public API methods
- Fonts without kern tables work correctly (zero kerning)
- Comprehensive tests for kern parsing, shaping pipeline, scaling,
empty input, and space handling
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
+375
+192
crates/text/src/font/mod.rs
+192
crates/text/src/font/mod.rs
···
15
15
pub use tables::head::HeadTable;
16
16
pub use tables::hhea::HheaTable;
17
17
pub use tables::hmtx::HmtxTable;
18
+
pub use tables::kern::KernTable;
18
19
pub use tables::loca::LocaTable;
19
20
pub use tables::maxp::MaxpTable;
20
21
pub use tables::name::NameTable;
21
22
pub use tables::os2::Os2Table;
23
+
24
+
/// A positioned glyph in a shaped text run.
25
+
#[derive(Debug, Clone)]
26
+
pub struct ShapedGlyph {
27
+
/// Glyph ID in the font.
28
+
pub glyph_id: u16,
29
+
/// Horizontal position in pixels.
30
+
pub x_offset: f32,
31
+
/// Vertical offset in pixels (usually 0 for basic horizontal shaping).
32
+
pub y_offset: f32,
33
+
/// Horizontal advance in pixels.
34
+
pub x_advance: f32,
35
+
}
22
36
23
37
/// Errors that can occur during font parsing.
24
38
#[derive(Debug)]
···
205
219
.table_data(b"OS/2")
206
220
.ok_or(FontError::MissingTable("OS/2"))?;
207
221
Os2Table::parse(data)
222
+
}
223
+
224
+
/// Parse the `kern` table, if present.
225
+
///
226
+
/// Returns an empty `KernTable` (zero pairs) if the font has no kern table.
227
+
pub fn kern(&self) -> Result<KernTable, FontError> {
228
+
match self.table_data(b"kern") {
229
+
Some(data) => KernTable::parse(data),
230
+
None => Ok(KernTable::empty()),
231
+
}
232
+
}
233
+
234
+
/// Look up the raw kerning value for a pair of glyph IDs (in font units).
235
+
///
236
+
/// Returns 0 if the font has no kern table or the pair has no adjustment.
237
+
pub fn kern_pair(&self, left: u16, right: u16) -> i16 {
238
+
self.kern().map(|k| k.kern_value(left, right)).unwrap_or(0)
239
+
}
240
+
241
+
/// Shape a text string: map characters to glyphs and compute positions.
242
+
///
243
+
/// Returns a list of positioned glyphs with coordinates in pixels.
244
+
pub fn shape_text(&self, text: &str, size_px: f32) -> Vec<ShapedGlyph> {
245
+
let head = match self.head() {
246
+
Ok(h) => h,
247
+
Err(_) => return Vec::new(),
248
+
};
249
+
let scale = size_px / head.units_per_em as f32;
250
+
251
+
let cmap = match self.cmap() {
252
+
Ok(c) => c,
253
+
Err(_) => return Vec::new(),
254
+
};
255
+
let hmtx = match self.hmtx() {
256
+
Ok(h) => h,
257
+
Err(_) => return Vec::new(),
258
+
};
259
+
let kern = self.kern().unwrap_or_else(|_| KernTable::empty());
260
+
261
+
// Map characters to glyph IDs.
262
+
let glyph_ids: Vec<u16> = text
263
+
.chars()
264
+
.map(|ch| cmap.glyph_index(ch as u32).unwrap_or(0))
265
+
.collect();
266
+
267
+
let mut result = Vec::with_capacity(glyph_ids.len());
268
+
let mut cursor_x: f32 = 0.0;
269
+
270
+
for (i, &gid) in glyph_ids.iter().enumerate() {
271
+
let advance_fu = hmtx.advances.get(gid as usize).copied().unwrap_or(0);
272
+
let x_advance = advance_fu as f32 * scale;
273
+
274
+
// Apply kerning adjustment with the next glyph.
275
+
let kern_adjust = if i + 1 < glyph_ids.len() {
276
+
kern.kern_value(gid, glyph_ids[i + 1]) as f32 * scale
277
+
} else {
278
+
0.0
279
+
};
280
+
281
+
result.push(ShapedGlyph {
282
+
glyph_id: gid,
283
+
x_offset: cursor_x,
284
+
y_offset: 0.0,
285
+
x_advance,
286
+
});
287
+
288
+
cursor_x += x_advance + kern_adjust;
289
+
}
290
+
291
+
result
208
292
}
209
293
210
294
/// Map a Unicode code point to a glyph index using the cmap table.
···
556
640
let result = font.glyph_outline(0);
557
641
assert!(result.is_ok(), ".notdef outline parse should not error");
558
642
// .notdef may or may not have an outline — just verify no crash.
643
+
}
644
+
645
+
#[test]
646
+
fn kern_table_loads() {
647
+
let font = test_font();
648
+
// kern table is optional — just verify parsing doesn't error.
649
+
let kern = font.kern();
650
+
assert!(kern.is_ok(), "kern() should not error: {:?}", kern.err());
651
+
}
652
+
653
+
#[test]
654
+
fn kern_pair_no_crash() {
655
+
let font = test_font();
656
+
let gid_a = font.glyph_index(0x0041).unwrap().unwrap_or(0);
657
+
let gid_v = font.glyph_index(0x0056).unwrap().unwrap_or(0);
658
+
// Just verify no crash; value may be 0 if font has no kern table.
659
+
let _val = font.kern_pair(gid_a, gid_v);
660
+
}
661
+
662
+
#[test]
663
+
fn shape_text_basic() {
664
+
let font = test_font();
665
+
let shaped = font.shape_text("Hello", 16.0);
666
+
667
+
assert_eq!(shaped.len(), 5, "should have 5 glyphs for 'Hello'");
668
+
669
+
// All glyph IDs should be nonzero (font has Latin glyphs).
670
+
for (i, g) in shaped.iter().enumerate() {
671
+
assert!(g.glyph_id > 0, "glyph {} should have nonzero ID", i);
672
+
}
673
+
674
+
// Positions should be monotonically increasing.
675
+
for i in 1..shaped.len() {
676
+
assert!(
677
+
shaped[i].x_offset > shaped[i - 1].x_offset,
678
+
"glyph {} x_offset ({}) should be > glyph {} x_offset ({})",
679
+
i,
680
+
shaped[i].x_offset,
681
+
i - 1,
682
+
shaped[i - 1].x_offset
683
+
);
684
+
}
685
+
686
+
// First glyph should start at 0.
687
+
assert_eq!(shaped[0].x_offset, 0.0, "first glyph should start at x=0");
688
+
689
+
// All advances should be positive.
690
+
for (i, g) in shaped.iter().enumerate() {
691
+
assert!(
692
+
g.x_advance > 0.0,
693
+
"glyph {} advance ({}) should be positive",
694
+
i,
695
+
g.x_advance
696
+
);
697
+
}
698
+
}
699
+
700
+
#[test]
701
+
fn shape_text_empty() {
702
+
let font = test_font();
703
+
let shaped = font.shape_text("", 16.0);
704
+
assert!(shaped.is_empty(), "empty text should produce no glyphs");
705
+
}
706
+
707
+
#[test]
708
+
fn shape_text_single_char() {
709
+
let font = test_font();
710
+
let shaped = font.shape_text("A", 16.0);
711
+
assert_eq!(shaped.len(), 1);
712
+
assert_eq!(shaped[0].x_offset, 0.0);
713
+
assert!(shaped[0].x_advance > 0.0);
714
+
}
715
+
716
+
#[test]
717
+
fn shape_text_space_has_advance() {
718
+
let font = test_font();
719
+
let shaped = font.shape_text(" ", 16.0);
720
+
assert_eq!(shaped.len(), 1);
721
+
// Space should have an advance width (it occupies horizontal space).
722
+
assert!(
723
+
shaped[0].x_advance > 0.0,
724
+
"space should have positive advance: {}",
725
+
shaped[0].x_advance
726
+
);
727
+
}
728
+
729
+
#[test]
730
+
fn shape_text_scales_with_size() {
731
+
let font = test_font();
732
+
let small = font.shape_text("A", 12.0);
733
+
let large = font.shape_text("A", 24.0);
734
+
735
+
// At double the size, the advance should be double.
736
+
let ratio = large[0].x_advance / small[0].x_advance;
737
+
assert!(
738
+
(ratio - 2.0).abs() < 0.01,
739
+
"advance ratio should be ~2.0, got {}",
740
+
ratio
741
+
);
742
+
}
743
+
744
+
#[test]
745
+
fn shape_text_fonts_without_kern_work() {
746
+
let font = test_font();
747
+
// Even if the font has no kern table, shaping should work fine.
748
+
let shaped = font.shape_text("AV", 16.0);
749
+
assert_eq!(shaped.len(), 2);
750
+
assert!(shaped[1].x_offset > 0.0);
559
751
}
560
752
}
+182
crates/text/src/font/tables/kern.rs
+182
crates/text/src/font/tables/kern.rs
···
1
+
//! `kern` — Kerning table.
2
+
//!
3
+
//! Contains kerning pair adjustments for glyph spacing.
4
+
//! Supports the classic Microsoft kern table (version 0) with format 0 subtables.
5
+
//! Reference: <https://learn.microsoft.com/en-us/typography/opentype/spec/kern>
6
+
7
+
use crate::font::parse::Reader;
8
+
use crate::font::FontError;
9
+
10
+
/// A single kerning pair.
11
+
#[derive(Debug, Clone, Copy)]
12
+
struct KernPair {
13
+
/// Left glyph ID.
14
+
left: u16,
15
+
/// Right glyph ID.
16
+
right: u16,
17
+
/// Kerning value in font units (positive = move apart, negative = move together).
18
+
value: i16,
19
+
}
20
+
21
+
/// Parsed `kern` table.
22
+
#[derive(Debug)]
23
+
pub struct KernTable {
24
+
/// Sorted list of kerning pairs (for binary search).
25
+
pairs: Vec<KernPair>,
26
+
}
27
+
28
+
impl KernTable {
29
+
/// Create an empty kern table (no pairs).
30
+
pub fn empty() -> KernTable {
31
+
KernTable { pairs: Vec::new() }
32
+
}
33
+
34
+
/// Parse the `kern` table from raw bytes.
35
+
pub fn parse(data: &[u8]) -> Result<KernTable, FontError> {
36
+
let r = Reader::new(data);
37
+
if r.len() < 4 {
38
+
return Err(FontError::MalformedTable("kern"));
39
+
}
40
+
41
+
let version = r.u16(0)?;
42
+
43
+
match version {
44
+
0 => Self::parse_version0(data),
45
+
_ => {
46
+
// Version 1 (Apple AAT) or unknown — try parsing as version 0
47
+
// since some fonts mislabel the version. If that fails, return
48
+
// an empty table (kerning is optional, not critical).
49
+
Ok(KernTable { pairs: Vec::new() })
50
+
}
51
+
}
52
+
}
53
+
54
+
/// Parse a version 0 kern table (Microsoft format).
55
+
fn parse_version0(data: &[u8]) -> Result<KernTable, FontError> {
56
+
let r = Reader::new(data);
57
+
let n_tables = r.u16(2)? as usize;
58
+
59
+
let mut pairs = Vec::new();
60
+
let mut offset = 4; // Skip version + nTables
61
+
62
+
for _ in 0..n_tables {
63
+
if offset + 6 > r.len() {
64
+
break;
65
+
}
66
+
67
+
let _subtable_version = r.u16(offset)?;
68
+
let subtable_length = r.u16(offset + 2)? as usize;
69
+
let coverage = r.u16(offset + 4)?;
70
+
71
+
// Coverage field:
72
+
// Bit 0: 1 = horizontal kerning
73
+
// Bit 1: 1 = minimum values (not kerning values)
74
+
// Bit 2: 1 = cross-stream
75
+
// Bits 8-15: format number
76
+
let is_horizontal = coverage & 0x0001 != 0;
77
+
let is_minimum = coverage & 0x0002 != 0;
78
+
let is_cross_stream = coverage & 0x0004 != 0;
79
+
let format = (coverage >> 8) as u8;
80
+
81
+
// We only support horizontal kerning, format 0, non-minimum, non-cross-stream.
82
+
if format == 0 && is_horizontal && !is_minimum && !is_cross_stream {
83
+
Self::parse_format0(data, offset + 6, &mut pairs)?;
84
+
}
85
+
86
+
// Advance to next subtable.
87
+
if subtable_length == 0 {
88
+
break;
89
+
}
90
+
offset += subtable_length;
91
+
}
92
+
93
+
// Sort pairs for binary search.
94
+
pairs.sort_by(|a, b| a.left.cmp(&b.left).then_with(|| a.right.cmp(&b.right)));
95
+
96
+
Ok(KernTable { pairs })
97
+
}
98
+
99
+
/// Parse a format 0 subtable (sorted pairs).
100
+
fn parse_format0(
101
+
data: &[u8],
102
+
offset: usize,
103
+
pairs: &mut Vec<KernPair>,
104
+
) -> Result<(), FontError> {
105
+
let r = Reader::new(data);
106
+
if offset + 8 > r.len() {
107
+
return Err(FontError::MalformedTable("kern"));
108
+
}
109
+
110
+
let n_pairs = r.u16(offset)? as usize;
111
+
// Skip searchRange(2), entrySelector(2), rangeShift(2) = 6 bytes.
112
+
let pair_offset = offset + 8;
113
+
114
+
for i in 0..n_pairs {
115
+
let base = pair_offset + i * 6;
116
+
if base + 6 > r.len() {
117
+
break;
118
+
}
119
+
let left = r.u16(base)?;
120
+
let right = r.u16(base + 2)?;
121
+
let value = r.i16(base + 4)?;
122
+
pairs.push(KernPair { left, right, value });
123
+
}
124
+
125
+
Ok(())
126
+
}
127
+
128
+
/// Look up the kerning value for a pair of glyph IDs.
129
+
///
130
+
/// Returns the kerning adjustment in font units, or 0 if no pair exists.
131
+
pub fn kern_value(&self, left: u16, right: u16) -> i16 {
132
+
self.pairs
133
+
.binary_search_by(|pair| pair.left.cmp(&left).then_with(|| pair.right.cmp(&right)))
134
+
.map(|idx| self.pairs[idx].value)
135
+
.unwrap_or(0)
136
+
}
137
+
138
+
/// Returns the number of kerning pairs.
139
+
pub fn num_pairs(&self) -> usize {
140
+
self.pairs.len()
141
+
}
142
+
}
143
+
144
+
#[cfg(test)]
145
+
mod tests {
146
+
use super::*;
147
+
148
+
#[test]
149
+
fn empty_kern_table() {
150
+
// Version 0, 0 subtables.
151
+
let data = [0u8, 0, 0, 0];
152
+
let kern = KernTable::parse(&data).unwrap();
153
+
assert_eq!(kern.num_pairs(), 0);
154
+
assert_eq!(kern.kern_value(1, 2), 0);
155
+
}
156
+
157
+
#[test]
158
+
fn kern_value_lookup() {
159
+
// Build a minimal version 0 kern table with format 0 subtable.
160
+
let mut data = Vec::new();
161
+
162
+
// Header: version=0, nTables=1
163
+
data.extend_from_slice(&[0, 0, 0, 1]);
164
+
165
+
// Subtable header: version=0, length=20, coverage=0x0001 (horizontal, format 0)
166
+
data.extend_from_slice(&[0, 0, 0, 20, 0, 1]);
167
+
168
+
// Format 0 header: nPairs=1, searchRange=6, entrySelector=0, rangeShift=0
169
+
data.extend_from_slice(&[0, 1, 0, 6, 0, 0, 0, 0]);
170
+
171
+
// One pair: left=10, right=20, value=-50
172
+
data.extend_from_slice(&10u16.to_be_bytes());
173
+
data.extend_from_slice(&20u16.to_be_bytes());
174
+
data.extend_from_slice(&(-50i16).to_be_bytes());
175
+
176
+
let kern = KernTable::parse(&data).unwrap();
177
+
assert_eq!(kern.num_pairs(), 1);
178
+
assert_eq!(kern.kern_value(10, 20), -50);
179
+
assert_eq!(kern.kern_value(10, 21), 0);
180
+
assert_eq!(kern.kern_value(11, 20), 0);
181
+
}
182
+
}