1#[cfg(not(feature = "std"))]
3#[allow(unused_imports)]
4use core_maths::CoreFloat as _;
5
6use read_fonts::tables::trak::TrackTableEntry;
7use read_fonts::types::{BigEndian, Fixed};
8use read_fonts::FontData;
9
10use crate::LayoutData;
11use crate::{buffer::Buffer, plan::ShapePlan, Scale};
12
13pub fn apply(
14 _plan: &ShapePlan,
15 layout: LayoutData<'_>,
16 scale: Scale,
17 point_size: Option<f32>,
18 buffer: &mut Buffer,
19) -> Option<()> {
20 let trak = layout.aat.trak.as_ref()?;
21 let mut ptem = point_size.unwrap_or(0.0);
22 if ptem <= 0.0 {
23 ptem = 12.0; }
25
26 if !buffer.have_positions {
27 buffer.clear_positions();
28 }
29
30 let advance_to_add = if buffer.direction.is_horizontal() {
31 scale.scale_x_f(trak.get_h_tracking(ptem, 0.0))
32 } else {
33 scale.scale_y_f(trak.get_v_tracking(ptem, 0.0))
34 };
35
36 foreach_grapheme!(buffer, start, end, {
37 if let Some(pos) = buffer.pos.get_mut(start) {
38 if buffer.direction.is_horizontal() {
39 pos.x_advance = pos.x_advance.saturating_add(advance_to_add);
40 } else {
41 pos.y_advance = pos.y_advance.saturating_add(advance_to_add);
42 }
43 }
44 });
45
46 Some(())
47}
48
49trait TrakExt {
50 fn get_h_tracking(&self, ptem: f32, track: f32) -> f32;
51 fn get_v_tracking(&self, ptem: f32, track: f32) -> f32;
52}
53
54impl TrakExt for read_fonts::tables::trak::Trak<'_> {
55 fn get_h_tracking(&self, ptem: f32, track: f32) -> f32 {
58 self.horiz()
59 .transpose()
60 .ok()
61 .flatten()
62 .map_or(0.0, |t| t.get_tracking(self.offset_data(), ptem, track))
63 }
64
65 fn get_v_tracking(&self, ptem: f32, track: f32) -> f32 {
66 self.vert()
67 .transpose()
68 .ok()
69 .flatten()
70 .map_or(0.0, |t| t.get_tracking(self.offset_data(), ptem, track))
71 }
72}
73
74trait TrackDataExt {
75 fn get_tracking(&self, offset_data: FontData, ptem: f32, track: f32) -> f32;
76}
77
78impl TrackDataExt for read_fonts::tables::trak::TrackData<'_> {
79 fn get_tracking(&self, offset_data: FontData, ptem: f32, track: f32) -> f32 {
80 let Some(sizes) = self.size_table(offset_data) else {
81 return 0.0;
82 };
83
84 if sizes.is_empty() {
85 return 0.0;
86 }
87
88 let tracks = self.track_table();
89 if tracks.is_empty() {
90 return 0.0;
91 }
92
93 let get_value = |entry: &TrackTableEntry| {
94 let Some(values) = entry.per_size_values(offset_data, sizes.len() as u16) else {
95 return 0.0;
96 };
97 entry.get_value(ptem, sizes, values)
98 };
99
100 if tracks.len() == 1 {
101 return tracks.first().map_or(0.0, get_value);
102 }
103
104 let mut i = 0;
105 let mut j = tracks.len() - 1;
106
107 while i + 1 < tracks.len() && tracks.get(i + 1).map_or(0.0, |t| t.track().to_f32()) <= track
108 {
109 i += 1;
110 }
111 while j > 0 && tracks.get(j - 1).map_or(0.0, |t| t.track().to_f32()) >= track {
112 j -= 1;
113 }
114
115 if i == j {
116 return tracks.get(i).map_or(0.0, get_value);
117 }
118
119 let t0 = tracks.get(i).map_or(0.0, |t| t.track().to_f32());
120 let t1 = tracks.get(j).map_or(0.0, |t| t.track().to_f32());
121 let interp = if (t1 - t0).abs() < f32::EPSILON {
122 0.0
123 } else {
124 (track - t0) / (t1 - t0)
125 };
126
127 let a = tracks.get(i).map_or(0.0, get_value);
128 let b = tracks.get(j).map_or(0.0, get_value);
129 a + interp * (b - a)
130 }
131}
132
133trait TrackEntryExt {
134 fn get_value(&self, ptem: f32, sizes: &[BigEndian<Fixed>], values: &[BigEndian<i16>]) -> f32;
135}
136
137impl TrackEntryExt for TrackTableEntry {
138 fn get_value(&self, ptem: f32, sizes: &[BigEndian<Fixed>], values: &[BigEndian<i16>]) -> f32 {
139 let n = sizes.len().min(values.len());
140 if n == 0 {
141 return 0.0;
142 }
143
144 for i in 0..n {
145 let size_pt = sizes.get(i).map_or(0.0, |f| f.get().to_f32());
146 if size_pt >= ptem {
147 if i == 0 {
148 return values.first().map(|v| v.get() as f32).unwrap_or_default();
149 }
150
151 let s0 = sizes.get(i - 1).map_or(0.0, |f| f.get().to_f32());
152 let s1 = size_pt;
153 let v0 = values
154 .get(i - 1)
155 .map(|v| v.get() as f32)
156 .unwrap_or_default();
157 let v1 = values.get(i).map(|v| v.get() as f32).unwrap_or_default();
158
159 if (s1 - s0).abs() < f32::EPSILON {
160 return f32::midpoint(v0, v1);
161 }
162
163 let t = (ptem - s0) / (s1 - s0);
164 return v0 + t * (v1 - v0);
165 }
166 }
167
168 values
169 .get(n - 1)
170 .map(|v| v.get() as f32)
171 .unwrap_or_default()
172 }
173}