1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
|
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use api::{ColorF, ColorU, GradientStop, PremultipliedColorF};
use api::units::{LayoutRect, LayoutSize, LayoutVector2D};
use crate::renderer::{GpuBufferAddress, GpuBufferBuilderF};
use std::hash;
mod linear;
mod radial;
mod conic;
pub use linear::MAX_CACHED_SIZE as LINEAR_MAX_CACHED_SIZE;
pub use linear::*;
pub use radial::*;
pub use conic::*;
/// A hashable gradient stop that can be used in primitive keys.
#[cfg_attr(feature = "capture", derive(Serialize))]
#[cfg_attr(feature = "replay", derive(Deserialize))]
#[derive(Debug, Copy, Clone, MallocSizeOf, PartialEq)]
pub struct GradientStopKey {
pub offset: f32,
pub color: ColorU,
}
impl GradientStopKey {
pub fn empty() -> Self {
GradientStopKey {
offset: 0.0,
color: ColorU::new(0, 0, 0, 0),
}
}
}
impl Into<GradientStopKey> for GradientStop {
fn into(self) -> GradientStopKey {
GradientStopKey {
offset: self.offset,
color: self.color.into(),
}
}
}
// Convert `stop_keys` into a vector of `GradientStop`s, which is a more
// convenient representation for the current gradient builder. Compute the
// minimum stop alpha along the way.
fn stops_and_min_alpha(stop_keys: &[GradientStopKey]) -> (Vec<GradientStop>, f32) {
let mut min_alpha: f32 = 1.0;
let stops = stop_keys.iter().map(|stop_key| {
let color: ColorF = stop_key.color.into();
min_alpha = min_alpha.min(color.a);
GradientStop {
offset: stop_key.offset,
color,
}
}).collect();
(stops, min_alpha)
}
impl Eq for GradientStopKey {}
impl hash::Hash for GradientStopKey {
fn hash<H: hash::Hasher>(&self, state: &mut H) {
self.offset.to_bits().hash(state);
self.color.hash(state);
}
}
// The gradient entry index for the first color stop
pub const GRADIENT_DATA_FIRST_STOP: usize = 0;
// The gradient entry index for the last color stop
pub const GRADIENT_DATA_LAST_STOP: usize = GRADIENT_DATA_SIZE - 1;
// The start of the gradient data table
pub const GRADIENT_DATA_TABLE_BEGIN: usize = GRADIENT_DATA_FIRST_STOP + 1;
// The exclusive bound of the gradient data table
pub const GRADIENT_DATA_TABLE_END: usize = GRADIENT_DATA_LAST_STOP;
// The number of entries in the gradient data table.
pub const GRADIENT_DATA_TABLE_SIZE: usize = 128;
// The number of entries in a gradient data: GRADIENT_DATA_TABLE_SIZE + first stop entry + last stop entry
pub const GRADIENT_DATA_SIZE: usize = GRADIENT_DATA_TABLE_SIZE + 2;
/// An entry in a gradient data table representing a segment of the gradient
/// color space.
#[derive(Debug, Copy, Clone)]
#[repr(C)]
struct GradientDataEntry {
start_color: PremultipliedColorF,
end_step: PremultipliedColorF,
}
impl GradientDataEntry {
fn white() -> Self {
Self {
start_color: PremultipliedColorF::WHITE,
end_step: PremultipliedColorF::TRANSPARENT,
}
}
}
// TODO(gw): Tidy this up to be a free function / module?
pub struct GradientGpuBlockBuilder {}
impl GradientGpuBlockBuilder {
/// Generate a color ramp filling the indices in [start_idx, end_idx) and interpolating
/// from start_color to end_color.
fn fill_colors(
start_idx: usize,
end_idx: usize,
start_color: &PremultipliedColorF,
end_color: &PremultipliedColorF,
entries: &mut [GradientDataEntry; GRADIENT_DATA_SIZE],
prev_step: &PremultipliedColorF,
) -> PremultipliedColorF {
// Calculate the color difference for individual steps in the ramp.
let inv_steps = 1.0 / (end_idx - start_idx) as f32;
let mut step = PremultipliedColorF {
r: (end_color.r - start_color.r) * inv_steps,
g: (end_color.g - start_color.g) * inv_steps,
b: (end_color.b - start_color.b) * inv_steps,
a: (end_color.a - start_color.a) * inv_steps,
};
// As a subtle form of compression, we ensure that the step values for
// each stop range are the same if and only if they belong to the same
// stop range. However, if two different stop ranges have the same step,
// we need to modify the steps so they compare unequally between ranges.
// This allows to quickly compare if two adjacent stops belong to the
// same range by comparing their steps.
if step == *prev_step {
// Modify the step alpha value as if by nextafter(). The difference
// here should be so small as to be unnoticeable, but yet allow it
// to compare differently.
step.a = f32::from_bits(if step.a == 0.0 { 1 } else { step.a.to_bits() + 1 });
}
let mut cur_color = *start_color;
// Walk the ramp writing start and end colors for each entry.
for index in start_idx .. end_idx {
let entry = &mut entries[index];
entry.start_color = cur_color;
cur_color.r += step.r;
cur_color.g += step.g;
cur_color.b += step.b;
cur_color.a += step.a;
entry.end_step = step;
}
step
}
/// Compute an index into the gradient entry table based on a gradient stop offset. This
/// function maps offsets from [0, 1] to indices in [GRADIENT_DATA_TABLE_BEGIN, GRADIENT_DATA_TABLE_END].
#[inline]
fn get_index(offset: f32) -> usize {
(offset.max(0.0).min(1.0) * GRADIENT_DATA_TABLE_SIZE as f32 +
GRADIENT_DATA_TABLE_BEGIN as f32)
.round() as usize
}
// Build the gradient data from the supplied stops, reversing them if necessary.
pub fn build(
reverse_stops: bool,
gpu_buffer_builder: &mut GpuBufferBuilderF,
src_stops: &[GradientStop],
) -> GpuBufferAddress {
// Preconditions (should be ensured by DisplayListBuilder):
// * we have at least two stops
// * first stop has offset 0.0
// * last stop has offset 1.0
let mut src_stops = src_stops.into_iter();
let mut cur_color = match src_stops.next() {
Some(stop) => {
debug_assert_eq!(stop.offset, 0.0);
stop.color.premultiplied()
}
None => {
error!("Zero gradient stops found!");
PremultipliedColorF::BLACK
}
};
// A table of gradient entries, with two colors per entry, that specify the start and end color
// within the segment of the gradient space represented by that entry. To lookup a gradient result,
// first the entry index is calculated to determine which two colors to interpolate between, then
// the offset within that entry bucket is used to interpolate between the two colors in that entry.
// This layout is motivated by the fact that if one naively tries to store a single color per entry
// and interpolate directly between entries, then hard stops will become softened because the end
// color of an entry actually differs from the start color of the next entry, even though they fall
// at the same edge offset in the gradient space. Instead, the two-color-per-entry layout preserves
// hard stops, as the end color for a given entry can differ from the start color for the following
// entry.
// Colors are stored in RGBA32F format (in the GPU cache). This table requires the gradient color
// stops to be normalized to the range [0, 1]. The first and last entries hold the first and last
// color stop colors respectively, while the entries in between hold the interpolated color stop
// values for the range [0, 1].
// As a further optimization, rather than directly storing the end color, the difference of the end
// color from the start color is stored instead, so that an entry can be evaluated more cheaply
// with start+diff*offset instead of mix(start,end,offset). Further, the color difference in two
// adjacent entries will always be the same if they were generated from the same set of stops/run.
// To allow fast searching of the table, if two adjacent entries generated from different sets of
// stops (a boundary) have the same difference, the floating-point bits of the stop will be nudged
// so that they compare differently without perceptibly altering the interpolation result. This way,
// one can quickly scan the table and recover runs just by comparing the color differences of the
// current and next entry.
// For example, a table with 2 inside entries (startR,startG,startB):(diffR,diffG,diffB) might look
// like so:
// first | 0.0 | 0.5 | last
// (0,0,0):(0,0,0) | (1,0,0):(-1,1,0) | (0,0,1):(0,1,-1) | (1,1,1):(0,0,0)
// ^ solid black ^ red to green ^ blue to green ^ solid white
let mut entries = [GradientDataEntry::white(); GRADIENT_DATA_SIZE];
let mut prev_step = cur_color;
if reverse_stops {
// Fill in the first entry (for reversed stops) with the first color stop
prev_step = GradientGpuBlockBuilder::fill_colors(
GRADIENT_DATA_LAST_STOP,
GRADIENT_DATA_LAST_STOP + 1,
&cur_color,
&cur_color,
&mut entries,
&prev_step,
);
// Fill in the center of the gradient table, generating a color ramp between each consecutive pair
// of gradient stops. Each iteration of a loop will fill the indices in [next_idx, cur_idx). The
// loop will then fill indices in [GRADIENT_DATA_TABLE_BEGIN, GRADIENT_DATA_TABLE_END).
let mut cur_idx = GRADIENT_DATA_TABLE_END;
for next in src_stops {
let next_color = next.color.premultiplied();
let next_idx = Self::get_index(1.0 - next.offset);
if next_idx < cur_idx {
prev_step = GradientGpuBlockBuilder::fill_colors(
next_idx,
cur_idx,
&next_color,
&cur_color,
&mut entries,
&prev_step,
);
cur_idx = next_idx;
}
cur_color = next_color;
}
if cur_idx != GRADIENT_DATA_TABLE_BEGIN {
error!("Gradient stops abruptly at {}, auto-completing to white", cur_idx);
}
// Fill in the last entry (for reversed stops) with the last color stop
GradientGpuBlockBuilder::fill_colors(
GRADIENT_DATA_FIRST_STOP,
GRADIENT_DATA_FIRST_STOP + 1,
&cur_color,
&cur_color,
&mut entries,
&prev_step,
);
} else {
// Fill in the first entry with the first color stop
prev_step = GradientGpuBlockBuilder::fill_colors(
GRADIENT_DATA_FIRST_STOP,
GRADIENT_DATA_FIRST_STOP + 1,
&cur_color,
&cur_color,
&mut entries,
&prev_step,
);
// Fill in the center of the gradient table, generating a color ramp between each consecutive pair
// of gradient stops. Each iteration of a loop will fill the indices in [cur_idx, next_idx). The
// loop will then fill indices in [GRADIENT_DATA_TABLE_BEGIN, GRADIENT_DATA_TABLE_END).
let mut cur_idx = GRADIENT_DATA_TABLE_BEGIN;
for next in src_stops {
let next_color = next.color.premultiplied();
let next_idx = Self::get_index(next.offset);
if next_idx > cur_idx {
prev_step = GradientGpuBlockBuilder::fill_colors(
cur_idx,
next_idx,
&cur_color,
&next_color,
&mut entries,
&prev_step,
);
cur_idx = next_idx;
}
cur_color = next_color;
}
if cur_idx != GRADIENT_DATA_TABLE_END {
error!("Gradient stops abruptly at {}, auto-completing to white", cur_idx);
}
// Fill in the last entry with the last color stop
GradientGpuBlockBuilder::fill_colors(
GRADIENT_DATA_LAST_STOP,
GRADIENT_DATA_LAST_STOP + 1,
&cur_color,
&cur_color,
&mut entries,
&prev_step,
);
}
let mut writer = gpu_buffer_builder.write_blocks(2 * entries.len());
for entry in entries {
writer.push_one(entry.start_color);
writer.push_one(entry.end_step);
}
writer.finish()
}
}
// If the gradient is not tiled we know that any content outside of the clip will not
// be shown. Applying the clip early reduces how much of the gradient we
// render and cache. We do this optimization separately on each axis.
// Returns the offset between the new and old primitive rect origin, to apply to the
// gradient parameters that are relative to the primitive origin.
pub fn apply_gradient_local_clip(
prim_rect: &mut LayoutRect,
stretch_size: &LayoutSize,
tile_spacing: &LayoutSize,
clip_rect: &LayoutRect,
) -> LayoutVector2D {
let w = prim_rect.max.x.min(clip_rect.max.x) - prim_rect.min.x;
let h = prim_rect.max.y.min(clip_rect.max.y) - prim_rect.min.y;
let is_tiled_x = w > stretch_size.width + tile_spacing.width;
let is_tiled_y = h > stretch_size.height + tile_spacing.height;
let mut offset = LayoutVector2D::new(0.0, 0.0);
if !is_tiled_x {
let diff = (clip_rect.min.x - prim_rect.min.x).min(prim_rect.width());
if diff > 0.0 {
prim_rect.min.x += diff;
offset.x = -diff;
}
let diff = prim_rect.max.x - clip_rect.max.x;
if diff > 0.0 {
prim_rect.max.x -= diff;
}
}
if !is_tiled_y {
let diff = (clip_rect.min.y - prim_rect.min.y).min(prim_rect.height());
if diff > 0.0 {
prim_rect.min.y += diff;
offset.y = -diff;
}
let diff = prim_rect.max.y - clip_rect.max.y;
if diff > 0.0 {
prim_rect.max.y -= diff;
}
}
offset
}
#[test]
#[cfg(target_pointer_width = "64")]
fn test_struct_sizes() {
use std::mem;
// The sizes of these structures are critical for performance on a number of
// talos stress tests. If you get a failure here on CI, there's two possibilities:
// (a) You made a structure smaller than it currently is. Great work! Update the
// test expectations and move on.
// (b) You made a structure larger. This is not necessarily a problem, but should only
// be done with care, and after checking if talos performance regresses badly.
assert_eq!(mem::size_of::<LinearGradient>(), 72, "LinearGradient size changed");
assert_eq!(mem::size_of::<LinearGradientTemplate>(), 144, "LinearGradientTemplate size changed");
assert_eq!(mem::size_of::<LinearGradientKey>(), 88, "LinearGradientKey size changed");
assert_eq!(mem::size_of::<RadialGradient>(), 72, "RadialGradient size changed");
assert_eq!(mem::size_of::<RadialGradientTemplate>(), 144, "RadialGradientTemplate size changed");
assert_eq!(mem::size_of::<RadialGradientKey>(), 96, "RadialGradientKey size changed");
assert_eq!(mem::size_of::<ConicGradient>(), 72, "ConicGradient size changed");
assert_eq!(mem::size_of::<ConicGradientTemplate>(), 144, "ConicGradientTemplate size changed");
assert_eq!(mem::size_of::<ConicGradientKey>(), 96, "ConicGradientKey size changed");
}
|