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 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
199pub(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#[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 ((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}