Skip to main content

harfrust/aat/
trak.rs

1// libm used for f32::round() method
2#[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; // CoreText fallback
24    }
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    // Keep tracking fractional; scale_x_f rounds once, matching HarfBuzz's
56    // em_scalef (the interpolated value is generally not a whole font unit).
57    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}