+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 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 23 + 24 24 + /// A positioned glyph in a shaped text run. 25 25 + #[derive(Debug, Clone)] 26 26 + pub struct ShapedGlyph { 27 27 + /// Glyph ID in the font. 28 28 + pub glyph_id: u16, 29 29 + /// Horizontal position in pixels. 30 30 + pub x_offset: f32, 31 31 + /// Vertical offset in pixels (usually 0 for basic horizontal shaping). 32 32 + pub y_offset: f32, 33 33 + /// Horizontal advance in pixels. 34 34 + pub x_advance: f32, 35 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 222 + } 223 223 + 224 224 + /// Parse the `kern` table, if present. 225 225 + /// 226 226 + /// Returns an empty `KernTable` (zero pairs) if the font has no kern table. 227 227 + pub fn kern(&self) -> Result<KernTable, FontError> { 228 228 + match self.table_data(b"kern") { 229 229 + Some(data) => KernTable::parse(data), 230 230 + None => Ok(KernTable::empty()), 231 231 + } 232 232 + } 233 233 + 234 234 + /// Look up the raw kerning value for a pair of glyph IDs (in font units). 235 235 + /// 236 236 + /// Returns 0 if the font has no kern table or the pair has no adjustment. 237 237 + pub fn kern_pair(&self, left: u16, right: u16) -> i16 { 238 238 + self.kern().map(|k| k.kern_value(left, right)).unwrap_or(0) 239 239 + } 240 240 + 241 241 + /// Shape a text string: map characters to glyphs and compute positions. 242 242 + /// 243 243 + /// Returns a list of positioned glyphs with coordinates in pixels. 244 244 + pub fn shape_text(&self, text: &str, size_px: f32) -> Vec<ShapedGlyph> { 245 245 + let head = match self.head() { 246 246 + Ok(h) => h, 247 247 + Err(_) => return Vec::new(), 248 248 + }; 249 249 + let scale = size_px / head.units_per_em as f32; 250 250 + 251 251 + let cmap = match self.cmap() { 252 252 + Ok(c) => c, 253 253 + Err(_) => return Vec::new(), 254 254 + }; 255 255 + let hmtx = match self.hmtx() { 256 256 + Ok(h) => h, 257 257 + Err(_) => return Vec::new(), 258 258 + }; 259 259 + let kern = self.kern().unwrap_or_else(|_| KernTable::empty()); 260 260 + 261 261 + // Map characters to glyph IDs. 262 262 + let glyph_ids: Vec<u16> = text 263 263 + .chars() 264 264 + .map(|ch| cmap.glyph_index(ch as u32).unwrap_or(0)) 265 265 + .collect(); 266 266 + 267 267 + let mut result = Vec::with_capacity(glyph_ids.len()); 268 268 + let mut cursor_x: f32 = 0.0; 269 269 + 270 270 + for (i, &gid) in glyph_ids.iter().enumerate() { 271 271 + let advance_fu = hmtx.advances.get(gid as usize).copied().unwrap_or(0); 272 272 + let x_advance = advance_fu as f32 * scale; 273 273 + 274 274 + // Apply kerning adjustment with the next glyph. 275 275 + let kern_adjust = if i + 1 < glyph_ids.len() { 276 276 + kern.kern_value(gid, glyph_ids[i + 1]) as f32 * scale 277 277 + } else { 278 278 + 0.0 279 279 + }; 280 280 + 281 281 + result.push(ShapedGlyph { 282 282 + glyph_id: gid, 283 283 + x_offset: cursor_x, 284 284 + y_offset: 0.0, 285 285 + x_advance, 286 286 + }); 287 287 + 288 288 + cursor_x += x_advance + kern_adjust; 289 289 + } 290 290 + 291 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 643 + } 644 644 + 645 645 + #[test] 646 646 + fn kern_table_loads() { 647 647 + let font = test_font(); 648 648 + // kern table is optional — just verify parsing doesn't error. 649 649 + let kern = font.kern(); 650 650 + assert!(kern.is_ok(), "kern() should not error: {:?}", kern.err()); 651 651 + } 652 652 + 653 653 + #[test] 654 654 + fn kern_pair_no_crash() { 655 655 + let font = test_font(); 656 656 + let gid_a = font.glyph_index(0x0041).unwrap().unwrap_or(0); 657 657 + let gid_v = font.glyph_index(0x0056).unwrap().unwrap_or(0); 658 658 + // Just verify no crash; value may be 0 if font has no kern table. 659 659 + let _val = font.kern_pair(gid_a, gid_v); 660 660 + } 661 661 + 662 662 + #[test] 663 663 + fn shape_text_basic() { 664 664 + let font = test_font(); 665 665 + let shaped = font.shape_text("Hello", 16.0); 666 666 + 667 667 + assert_eq!(shaped.len(), 5, "should have 5 glyphs for 'Hello'"); 668 668 + 669 669 + // All glyph IDs should be nonzero (font has Latin glyphs). 670 670 + for (i, g) in shaped.iter().enumerate() { 671 671 + assert!(g.glyph_id > 0, "glyph {} should have nonzero ID", i); 672 672 + } 673 673 + 674 674 + // Positions should be monotonically increasing. 675 675 + for i in 1..shaped.len() { 676 676 + assert!( 677 677 + shaped[i].x_offset > shaped[i - 1].x_offset, 678 678 + "glyph {} x_offset ({}) should be > glyph {} x_offset ({})", 679 679 + i, 680 680 + shaped[i].x_offset, 681 681 + i - 1, 682 682 + shaped[i - 1].x_offset 683 683 + ); 684 684 + } 685 685 + 686 686 + // First glyph should start at 0. 687 687 + assert_eq!(shaped[0].x_offset, 0.0, "first glyph should start at x=0"); 688 688 + 689 689 + // All advances should be positive. 690 690 + for (i, g) in shaped.iter().enumerate() { 691 691 + assert!( 692 692 + g.x_advance > 0.0, 693 693 + "glyph {} advance ({}) should be positive", 694 694 + i, 695 695 + g.x_advance 696 696 + ); 697 697 + } 698 698 + } 699 699 + 700 700 + #[test] 701 701 + fn shape_text_empty() { 702 702 + let font = test_font(); 703 703 + let shaped = font.shape_text("", 16.0); 704 704 + assert!(shaped.is_empty(), "empty text should produce no glyphs"); 705 705 + } 706 706 + 707 707 + #[test] 708 708 + fn shape_text_single_char() { 709 709 + let font = test_font(); 710 710 + let shaped = font.shape_text("A", 16.0); 711 711 + assert_eq!(shaped.len(), 1); 712 712 + assert_eq!(shaped[0].x_offset, 0.0); 713 713 + assert!(shaped[0].x_advance > 0.0); 714 714 + } 715 715 + 716 716 + #[test] 717 717 + fn shape_text_space_has_advance() { 718 718 + let font = test_font(); 719 719 + let shaped = font.shape_text(" ", 16.0); 720 720 + assert_eq!(shaped.len(), 1); 721 721 + // Space should have an advance width (it occupies horizontal space). 722 722 + assert!( 723 723 + shaped[0].x_advance > 0.0, 724 724 + "space should have positive advance: {}", 725 725 + shaped[0].x_advance 726 726 + ); 727 727 + } 728 728 + 729 729 + #[test] 730 730 + fn shape_text_scales_with_size() { 731 731 + let font = test_font(); 732 732 + let small = font.shape_text("A", 12.0); 733 733 + let large = font.shape_text("A", 24.0); 734 734 + 735 735 + // At double the size, the advance should be double. 736 736 + let ratio = large[0].x_advance / small[0].x_advance; 737 737 + assert!( 738 738 + (ratio - 2.0).abs() < 0.01, 739 739 + "advance ratio should be ~2.0, got {}", 740 740 + ratio 741 741 + ); 742 742 + } 743 743 + 744 744 + #[test] 745 745 + fn shape_text_fonts_without_kern_work() { 746 746 + let font = test_font(); 747 747 + // Even if the font has no kern table, shaping should work fine. 748 748 + let shaped = font.shape_text("AV", 16.0); 749 749 + assert_eq!(shaped.len(), 2); 750 750 + assert!(shaped[1].x_offset > 0.0); 559 751 } 560 752 }

+182

crates/text/src/font/tables/kern.rs

··· 1 1 + //! `kern` — Kerning table. 2 2 + //! 3 3 + //! Contains kerning pair adjustments for glyph spacing. 4 4 + //! Supports the classic Microsoft kern table (version 0) with format 0 subtables. 5 5 + //! Reference: <https://learn.microsoft.com/en-us/typography/opentype/spec/kern> 6 6 + 7 7 + use crate::font::parse::Reader; 8 8 + use crate::font::FontError; 9 9 + 10 10 + /// A single kerning pair. 11 11 + #[derive(Debug, Clone, Copy)] 12 12 + struct KernPair { 13 13 + /// Left glyph ID. 14 14 + left: u16, 15 15 + /// Right glyph ID. 16 16 + right: u16, 17 17 + /// Kerning value in font units (positive = move apart, negative = move together). 18 18 + value: i16, 19 19 + } 20 20 + 21 21 + /// Parsed `kern` table. 22 22 + #[derive(Debug)] 23 23 + pub struct KernTable { 24 24 + /// Sorted list of kerning pairs (for binary search). 25 25 + pairs: Vec<KernPair>, 26 26 + } 27 27 + 28 28 + impl KernTable { 29 29 + /// Create an empty kern table (no pairs). 30 30 + pub fn empty() -> KernTable { 31 31 + KernTable { pairs: Vec::new() } 32 32 + } 33 33 + 34 34 + /// Parse the `kern` table from raw bytes. 35 35 + pub fn parse(data: &[u8]) -> Result<KernTable, FontError> { 36 36 + let r = Reader::new(data); 37 37 + if r.len() < 4 { 38 38 + return Err(FontError::MalformedTable("kern")); 39 39 + } 40 40 + 41 41 + let version = r.u16(0)?; 42 42 + 43 43 + match version { 44 44 + 0 => Self::parse_version0(data), 45 45 + _ => { 46 46 + // Version 1 (Apple AAT) or unknown — try parsing as version 0 47 47 + // since some fonts mislabel the version. If that fails, return 48 48 + // an empty table (kerning is optional, not critical). 49 49 + Ok(KernTable { pairs: Vec::new() }) 50 50 + } 51 51 + } 52 52 + } 53 53 + 54 54 + /// Parse a version 0 kern table (Microsoft format). 55 55 + fn parse_version0(data: &[u8]) -> Result<KernTable, FontError> { 56 56 + let r = Reader::new(data); 57 57 + let n_tables = r.u16(2)? as usize; 58 58 + 59 59 + let mut pairs = Vec::new(); 60 60 + let mut offset = 4; // Skip version + nTables 61 61 + 62 62 + for _ in 0..n_tables { 63 63 + if offset + 6 > r.len() { 64 64 + break; 65 65 + } 66 66 + 67 67 + let _subtable_version = r.u16(offset)?; 68 68 + let subtable_length = r.u16(offset + 2)? as usize; 69 69 + let coverage = r.u16(offset + 4)?; 70 70 + 71 71 + // Coverage field: 72 72 + // Bit 0: 1 = horizontal kerning 73 73 + // Bit 1: 1 = minimum values (not kerning values) 74 74 + // Bit 2: 1 = cross-stream 75 75 + // Bits 8-15: format number 76 76 + let is_horizontal = coverage & 0x0001 != 0; 77 77 + let is_minimum = coverage & 0x0002 != 0; 78 78 + let is_cross_stream = coverage & 0x0004 != 0; 79 79 + let format = (coverage >> 8) as u8; 80 80 + 81 81 + // We only support horizontal kerning, format 0, non-minimum, non-cross-stream. 82 82 + if format == 0 && is_horizontal && !is_minimum && !is_cross_stream { 83 83 + Self::parse_format0(data, offset + 6, &mut pairs)?; 84 84 + } 85 85 + 86 86 + // Advance to next subtable. 87 87 + if subtable_length == 0 { 88 88 + break; 89 89 + } 90 90 + offset += subtable_length; 91 91 + } 92 92 + 93 93 + // Sort pairs for binary search. 94 94 + pairs.sort_by(|a, b| a.left.cmp(&b.left).then_with(|| a.right.cmp(&b.right))); 95 95 + 96 96 + Ok(KernTable { pairs }) 97 97 + } 98 98 + 99 99 + /// Parse a format 0 subtable (sorted pairs). 100 100 + fn parse_format0( 101 101 + data: &[u8], 102 102 + offset: usize, 103 103 + pairs: &mut Vec<KernPair>, 104 104 + ) -> Result<(), FontError> { 105 105 + let r = Reader::new(data); 106 106 + if offset + 8 > r.len() { 107 107 + return Err(FontError::MalformedTable("kern")); 108 108 + } 109 109 + 110 110 + let n_pairs = r.u16(offset)? as usize; 111 111 + // Skip searchRange(2), entrySelector(2), rangeShift(2) = 6 bytes. 112 112 + let pair_offset = offset + 8; 113 113 + 114 114 + for i in 0..n_pairs { 115 115 + let base = pair_offset + i * 6; 116 116 + if base + 6 > r.len() { 117 117 + break; 118 118 + } 119 119 + let left = r.u16(base)?; 120 120 + let right = r.u16(base + 2)?; 121 121 + let value = r.i16(base + 4)?; 122 122 + pairs.push(KernPair { left, right, value }); 123 123 + } 124 124 + 125 125 + Ok(()) 126 126 + } 127 127 + 128 128 + /// Look up the kerning value for a pair of glyph IDs. 129 129 + /// 130 130 + /// Returns the kerning adjustment in font units, or 0 if no pair exists. 131 131 + pub fn kern_value(&self, left: u16, right: u16) -> i16 { 132 132 + self.pairs 133 133 + .binary_search_by(|pair| pair.left.cmp(&left).then_with(|| pair.right.cmp(&right))) 134 134 + .map(|idx| self.pairs[idx].value) 135 135 + .unwrap_or(0) 136 136 + } 137 137 + 138 138 + /// Returns the number of kerning pairs. 139 139 + pub fn num_pairs(&self) -> usize { 140 140 + self.pairs.len() 141 141 + } 142 142 + } 143 143 + 144 144 + #[cfg(test)] 145 145 + mod tests { 146 146 + use super::*; 147 147 + 148 148 + #[test] 149 149 + fn empty_kern_table() { 150 150 + // Version 0, 0 subtables. 151 151 + let data = [0u8, 0, 0, 0]; 152 152 + let kern = KernTable::parse(&data).unwrap(); 153 153 + assert_eq!(kern.num_pairs(), 0); 154 154 + assert_eq!(kern.kern_value(1, 2), 0); 155 155 + } 156 156 + 157 157 + #[test] 158 158 + fn kern_value_lookup() { 159 159 + // Build a minimal version 0 kern table with format 0 subtable. 160 160 + let mut data = Vec::new(); 161 161 + 162 162 + // Header: version=0, nTables=1 163 163 + data.extend_from_slice(&[0, 0, 0, 1]); 164 164 + 165 165 + // Subtable header: version=0, length=20, coverage=0x0001 (horizontal, format 0) 166 166 + data.extend_from_slice(&[0, 0, 0, 20, 0, 1]); 167 167 + 168 168 + // Format 0 header: nPairs=1, searchRange=6, entrySelector=0, rangeShift=0 169 169 + data.extend_from_slice(&[0, 1, 0, 6, 0, 0, 0, 0]); 170 170 + 171 171 + // One pair: left=10, right=20, value=-50 172 172 + data.extend_from_slice(&10u16.to_be_bytes()); 173 173 + data.extend_from_slice(&20u16.to_be_bytes()); 174 174 + data.extend_from_slice(&(-50i16).to_be_bytes()); 175 175 + 176 176 + let kern = KernTable::parse(&data).unwrap(); 177 177 + assert_eq!(kern.num_pairs(), 1); 178 178 + assert_eq!(kern.kern_value(10, 20), -50); 179 179 + assert_eq!(kern.kern_value(10, 21), 0); 180 180 + assert_eq!(kern.kern_value(11, 20), 0); 181 181 + } 182 182 + }

+1

crates/text/src/font/tables/mod.rs

··· 5 5 pub mod head; 6 6 pub mod hhea; 7 7 pub mod hmtx; 8 8 + pub mod kern; 8 9 pub mod loca; 9 10 pub mod maxp; 10 11 pub mod name;