Skip to main content

sui_render_wgpu/
text_policy.rs

1use sui_core::Color;
2
3#[derive(Debug, Clone, Copy, PartialEq)]
4pub struct FeatheringOptions {
5    pub enabled: bool,
6    pub width: f32,
7}
8
9impl Default for FeatheringOptions {
10    fn default() -> Self {
11        Self::new(false, crate::resources::DEFAULT_FEATHER_WIDTH)
12    }
13}
14
15impl FeatheringOptions {
16    pub const fn new(enabled: bool, width: f32) -> Self {
17        Self { enabled, width }
18    }
19
20    pub fn clamped(self) -> Self {
21        Self {
22            enabled: self.enabled,
23            width: self.width.max(0.0),
24        }
25    }
26
27    pub fn effective_width(self) -> f32 {
28        if self.enabled {
29            self.width.max(0.0)
30        } else {
31            0.0
32        }
33    }
34}
35
36#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
37pub enum TextRenderMode {
38    #[default]
39    Grayscale,
40    LcdSubpixel,
41}
42
43#[derive(Debug, Clone, Copy, PartialEq)]
44pub enum TextHinting {
45    None,
46    Slight { max_ppem: f32 },
47}
48
49pub(crate) const DEFAULT_TEXT_HINTING_MAX_PPEM: f32 = 96.0;
50
51impl Default for TextHinting {
52    fn default() -> Self {
53        Self::Slight {
54            max_ppem: DEFAULT_TEXT_HINTING_MAX_PPEM,
55        }
56    }
57}
58
59impl TextHinting {
60    pub fn normalized(self) -> Self {
61        match self {
62            Self::None => Self::None,
63            Self::Slight { max_ppem } if max_ppem.is_finite() && max_ppem > 0.0 => {
64                Self::Slight { max_ppem }
65            }
66            Self::Slight { .. } => Self::None,
67        }
68    }
69
70    pub fn should_hint(self, ppem: f32) -> bool {
71        match self.normalized() {
72            Self::None => false,
73            Self::Slight { max_ppem } => ppem.is_finite() && ppem <= max_ppem,
74        }
75    }
76}
77
78#[derive(Debug, Clone, Copy, PartialEq, Default)]
79pub enum StemDarkening {
80    #[default]
81    None,
82    Enabled {
83        max_ppem: f32,
84        amount: f32,
85    },
86}
87
88impl StemDarkening {
89    pub fn normalized(self) -> Self {
90        match self {
91            Self::None => Self::None,
92            Self::Enabled { max_ppem, amount }
93                if max_ppem.is_finite() && max_ppem > 0.0 && amount.is_finite() && amount > 0.0 =>
94            {
95                Self::Enabled {
96                    max_ppem,
97                    amount: amount.clamp(0.0, 1.0),
98                }
99            }
100            Self::Enabled { .. } => Self::None,
101        }
102    }
103
104    pub fn effective_amount(self, ppem: f32) -> f32 {
105        match self.normalized() {
106            Self::None => 0.0,
107            Self::Enabled { max_ppem, amount } if ppem.is_finite() && ppem <= max_ppem => amount,
108            Self::Enabled { .. } => 0.0,
109        }
110    }
111}
112
113#[derive(Debug, Clone, Copy, PartialEq, Default)]
114pub enum TextCoveragePolicy {
115    #[default]
116    Perceptual,
117    /// Resolved luminances for the perceptual curve. Prefer `Perceptual` to
118    /// let the renderer resolve these from the text and its solid backdrop.
119    PerceptualLuminance {
120        text: f32,
121        background: f32,
122    },
123    Linear,
124    Gamma(f32),
125    CoverageBoost(f32),
126    TwoCoverageMinusCoverageSq,
127}
128
129impl TextCoveragePolicy {
130    pub fn normalized(self) -> Self {
131        match self {
132            Self::Perceptual => Self::Perceptual,
133            Self::PerceptualLuminance { text, background }
134                if text.is_finite() && background.is_finite() =>
135            {
136                Self::PerceptualLuminance {
137                    text: text.clamp(0.0, 1.0),
138                    background: background.clamp(0.0, 1.0),
139                }
140            }
141            Self::PerceptualLuminance { .. } => Self::Linear,
142            Self::Linear => Self::Linear,
143            Self::Gamma(gamma) if gamma.is_finite() && gamma > 0.0 => Self::Gamma(gamma),
144            Self::Gamma(_) => Self::Linear,
145            Self::CoverageBoost(amount) if amount.is_finite() && amount > 0.0 => {
146                Self::CoverageBoost(amount.clamp(0.0, 1.0))
147            }
148            Self::CoverageBoost(_) => Self::Linear,
149            Self::TwoCoverageMinusCoverageSq => Self::TwoCoverageMinusCoverageSq,
150        }
151    }
152
153    pub fn resolved_for_text_color(self, color: Color) -> Self {
154        self.resolved_for_text_background(color, None)
155    }
156
157    pub(crate) fn resolved_for_text_background(
158        self,
159        color: Color,
160        background: Option<Color>,
161    ) -> Self {
162        match self.normalized() {
163            Self::Perceptual => {
164                if !is_sdr_color(color) || background.is_some_and(|c| !is_sdr_color(c)) {
165                    return Self::Linear;
166                }
167                let text = encoded_srgb_luminance(color);
168                Self::PerceptualLuminance {
169                    text,
170                    background: background.map(encoded_srgb_luminance).unwrap_or(1.0 - text),
171                }
172            }
173            policy => policy,
174        }
175    }
176
177    pub fn apply(self, coverage: f32) -> f32 {
178        let coverage = coverage.clamp(0.0, 1.0);
179        match self.normalized() {
180            Self::Perceptual => perceptual_text_coverage(coverage, 0.0, 1.0),
181            Self::PerceptualLuminance { text, background } => {
182                perceptual_text_coverage(coverage, text, background)
183            }
184            Self::Linear => coverage,
185            Self::Gamma(gamma) => coverage.powf(gamma),
186            Self::CoverageBoost(amount) => apply_coverage_boost(coverage, amount),
187            Self::TwoCoverageMinusCoverageSq => (2.0 * coverage) - (coverage * coverage),
188        }
189    }
190}
191
192pub(crate) fn is_sdr_color(color: Color) -> bool {
193    let c = color.to_linear_srgb();
194    [c.red, c.green, c.blue]
195        .iter()
196        .all(|v| v.is_finite() && (0.0..=1.0).contains(v))
197}
198
199/// Contrast/gamma compensation modeled on Skia's mask-gamma construction,
200/// converted back to coverage for our linear-light framebuffer. The 1.8
201/// perceptual exponent is calibrated against Chrome's light/dark UI text;
202/// it is not the framebuffer transfer function. Keep in sync with both text
203/// atlas shaders. Endpoint preservation also keeps glyph padding transparent.
204pub(crate) fn perceptual_text_coverage(coverage: f32, text: f32, background: f32) -> f32 {
205    let c = coverage.clamp(0.0, 1.0);
206    if c == 0.0 || c == 1.0 {
207        return c;
208    }
209    let gamma = 1.8;
210    let a = apply_coverage_boost(c, 0.5 * background.powf(gamma));
211    let fg = encoded_srgb_to_linear_unit(text);
212    let bg = encoded_srgb_to_linear_unit(background);
213    if (fg - bg).abs() < 1e-4 {
214        return a;
215    }
216    let perceptual = (text.powf(gamma) * a + background.powf(gamma) * (1.0 - a)).powf(1.0 / gamma);
217    ((encoded_srgb_to_linear_unit(perceptual) - bg) / (fg - bg)).clamp(0.0, 1.0)
218}
219
220fn encoded_srgb_to_linear_unit(value: f32) -> f32 {
221    if value <= 0.04045 {
222        value / 12.92
223    } else {
224        ((value + 0.055) / 1.055).powf(2.4)
225    }
226}
227
228/// Chrome/Skia's per-channel sRGB mask correction, followed by conversion of
229/// the resulting encoded-space composite into coverage for our linear target.
230/// Uses the Windows reference contrast of 1.0. This is LCD-only; the portable
231/// grayscale policy keeps its separately calibrated luminance curve.
232#[cfg(test)]
233pub(crate) fn lcd_text_coverage(coverage: f32, text: f32, background: f32) -> f32 {
234    let c = coverage.clamp(0.0, 1.0);
235    if c == 0.0 || c == 1.0 {
236        return c;
237    }
238    let guessed_bg = 1.0 - text;
239    let guessed_linear = encoded_srgb_to_linear_unit(guessed_bg);
240    let foreground_linear = encoded_srgb_to_linear_unit(text);
241    let a = apply_coverage_boost(c, guessed_linear);
242    let encoded_alpha = if (text - guessed_bg).abs() < 1.0 / 256.0 {
243        a
244    } else {
245        (linear_srgb_to_encoded_unit(foreground_linear * a + guessed_linear * (1.0 - a))
246            - guessed_bg)
247            / (text - guessed_bg)
248    }
249    .clamp(0.0, 1.0);
250    let bg = encoded_srgb_to_linear_unit(background);
251    if (foreground_linear - bg).abs() < 1e-4 {
252        return c;
253    }
254    let desired = encoded_srgb_to_linear_unit(background + (text - background) * encoded_alpha);
255    ((desired - bg) / (foreground_linear - bg)).clamp(0.0, 1.0)
256}
257
258pub(crate) fn pack_lcd_background(color: Color) -> f32 {
259    let c = color.to_linear_srgb();
260    let [r, g, b] =
261        [c.red, c.green, c.blue].map(|v| (linear_srgb_to_encoded_unit(v) * 255.0).round() as u32);
262    // Exactly representable as an f32 integer and interpolated flat.
263    ((r << 16) | (g << 8) | b) as f32
264}
265
266pub(crate) fn apply_coverage_boost(coverage: f32, amount: f32) -> f32 {
267    coverage + (coverage * (1.0 - coverage) * amount.clamp(0.0, 1.0))
268}
269
270pub(crate) fn encoded_srgb_luminance(color: Color) -> f32 {
271    let linear = color.to_linear_srgb();
272    let red = linear_srgb_to_encoded_unit(linear.red);
273    let green = linear_srgb_to_encoded_unit(linear.green);
274    let blue = linear_srgb_to_encoded_unit(linear.blue);
275    ((0.2126 * red) + (0.7152 * green) + (0.0722 * blue)).clamp(0.0, 1.0)
276}
277
278pub(crate) fn linear_srgb_to_encoded_unit(channel: f32) -> f32 {
279    let value = channel.clamp(0.0, 1.0);
280    if value <= 0.003_130_8 {
281        value * 12.92
282    } else {
283        (1.055 * value.powf(1.0 / 2.4)) - 0.055
284    }
285}