Flutter Engine
 
Loading...
Searching...
No Matches
layer_state_stack_unittests.cc
Go to the documentation of this file.
1// Copyright 2013 The Flutter Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "gtest/gtest.h"
6
7#include "flutter/display_list/effects/dl_color_filter.h"
8#include "flutter/display_list/effects/dl_image_filter.h"
9#include "flutter/flow/layers/layer.h"
10#include "flutter/flow/layers/layer_state_stack.h"
11#include "flutter/testing/display_list_testing.h"
12
13namespace flutter {
14namespace testing {
15
16#ifndef NDEBUG
17TEST(LayerStateStack, AccessorsDieWithoutDelegate) {
18 LayerStateStack state_stack;
19
20 EXPECT_DEATH_IF_SUPPORTED(state_stack.device_cull_rect(),
21 "LayerStateStack state queried without a delegate");
22 EXPECT_DEATH_IF_SUPPORTED(state_stack.local_cull_rect(),
23 "LayerStateStack state queried without a delegate");
24 EXPECT_DEATH_IF_SUPPORTED(state_stack.matrix(),
25 "LayerStateStack state queried without a delegate");
26 EXPECT_DEATH_IF_SUPPORTED(state_stack.content_culled({}),
27 "LayerStateStack state queried without a delegate");
28 {
29 // state_stack.set_preroll_delegate(kGiantRect, DlMatrix());
30 auto mutator = state_stack.save();
31 mutator.applyOpacity({}, 0.5);
32 state_stack.clear_delegate();
33 auto restore = state_stack.applyState({}, 0);
34 }
35}
36#endif
37
38TEST(LayerStateStack, Defaults) {
39 LayerStateStack state_stack;
40
41 ASSERT_EQ(state_stack.canvas_delegate(), nullptr);
42 ASSERT_EQ(state_stack.outstanding_opacity(), 1.0f);
43 ASSERT_EQ(state_stack.outstanding_color_filter(), nullptr);
44 ASSERT_EQ(state_stack.outstanding_image_filter(), nullptr);
45 ASSERT_EQ(state_stack.outstanding_bounds(), DlRect());
46
47 state_stack.set_preroll_delegate(kGiantRect, DlMatrix());
48 ASSERT_EQ(state_stack.device_cull_rect(), kGiantRect);
49 ASSERT_EQ(state_stack.local_cull_rect(), kGiantRect);
50 ASSERT_EQ(state_stack.matrix(), DlMatrix());
51
52 DlPaint dl_paint;
53 state_stack.fill(dl_paint);
54 ASSERT_EQ(dl_paint, DlPaint());
55}
56
57TEST(LayerStateStack, SingularDelegate) {
58 LayerStateStack state_stack;
59 ASSERT_EQ(state_stack.canvas_delegate(), nullptr);
60
61 // Two different DlCanvas implementators
62 DisplayListBuilder builder;
63 DisplayListBuilder builder2;
64 DlCanvas& canvas = builder2;
65
66 // no delegate -> builder delegate
67 state_stack.set_delegate(&builder);
68 ASSERT_EQ(state_stack.canvas_delegate(), &builder);
69
70 // builder delegate -> DlCanvas delegate
71 state_stack.set_delegate(&canvas);
72 ASSERT_EQ(state_stack.canvas_delegate(), &canvas);
73
74 // DlCanvas delegate -> builder delegate
75 state_stack.set_delegate(&builder);
76 ASSERT_EQ(state_stack.canvas_delegate(), &builder);
77
78 // builder delegate -> no delegate
79 state_stack.clear_delegate();
80 ASSERT_EQ(state_stack.canvas_delegate(), nullptr);
81
82 // DlCanvas delegate -> no delegate
83 state_stack.set_delegate(&canvas);
84 state_stack.clear_delegate();
85 ASSERT_EQ(state_stack.canvas_delegate(), nullptr);
86}
87
88TEST(LayerStateStack, OldDelegateIsRolledBack) {
89 LayerStateStack state_stack;
90 DisplayListBuilder builder;
91 DisplayListBuilder builder2;
92 DlCanvas& canvas = builder2;
93
94 ASSERT_TRUE(builder.GetMatrix().IsIdentity());
95 ASSERT_TRUE(canvas.GetMatrix().IsIdentity());
96
97 state_stack.set_delegate(&builder);
98
99 ASSERT_TRUE(builder.GetMatrix().IsIdentity());
100 ASSERT_TRUE(canvas.GetMatrix().IsIdentity());
101
102 auto mutator = state_stack.save();
103 mutator.translate({10, 10});
104
105 ASSERT_EQ(builder.GetMatrix(), DlMatrix::MakeTranslation({10, 10}));
106 ASSERT_TRUE(canvas.GetMatrix().IsIdentity());
107
108 state_stack.set_delegate(&canvas);
109
110 ASSERT_TRUE(builder.GetMatrix().IsIdentity());
111 ASSERT_EQ(canvas.GetMatrix(), DlMatrix::MakeTranslation({10, 10}));
112
113 state_stack.set_preroll_delegate(DlRect::MakeWH(100, 100));
114
115 ASSERT_TRUE(builder.GetMatrix().IsIdentity());
116 ASSERT_TRUE(canvas.GetMatrix().IsIdentity());
117
118 state_stack.set_delegate(&builder);
119 state_stack.clear_delegate();
120
121 ASSERT_TRUE(builder.GetMatrix().IsIdentity());
122 ASSERT_TRUE(canvas.GetMatrix().IsIdentity());
123
124 state_stack.set_delegate(&canvas);
125 state_stack.clear_delegate();
126
127 ASSERT_TRUE(builder.GetMatrix().IsIdentity());
128 ASSERT_TRUE(canvas.GetMatrix().IsIdentity());
129}
130
131TEST(LayerStateStack, Opacity) {
132 DlRect rect = DlRect::MakeLTRB(10, 10, 20, 20);
133
134 LayerStateStack state_stack;
135 state_stack.set_preroll_delegate(DlRect::MakeLTRB(0, 0, 50, 50));
136 {
137 auto mutator = state_stack.save();
138 mutator.applyOpacity(rect, 0.5f);
139
140 ASSERT_EQ(state_stack.outstanding_opacity(), 0.5f);
141 ASSERT_EQ(state_stack.outstanding_bounds(), rect);
142
143 // Check nested opacities multiply with each other
144 {
145 auto mutator2 = state_stack.save();
146 mutator.applyOpacity(rect, 0.5f);
147
148 ASSERT_EQ(state_stack.outstanding_opacity(), 0.25f);
149 ASSERT_EQ(state_stack.outstanding_bounds(), rect);
150
151 // Verify output with applyState that does not accept opacity
152 {
153 DisplayListBuilder builder;
154 state_stack.set_delegate(&builder);
155 {
156 auto restore = state_stack.applyState(rect, 0);
157 ASSERT_EQ(state_stack.outstanding_opacity(), 1.0f);
158 ASSERT_EQ(state_stack.outstanding_bounds(), DlRect());
159
160 DlPaint paint;
161 state_stack.fill(paint);
162 builder.DrawRect(rect, paint);
163 }
164 state_stack.clear_delegate();
165
166 DisplayListBuilder expected;
167 DlPaint save_paint =
168 DlPaint().setOpacity(state_stack.outstanding_opacity());
169 expected.SaveLayer(rect, &save_paint);
170 expected.DrawRect(rect, DlPaint());
171 expected.Restore();
172 ASSERT_TRUE(DisplayListsEQ_Verbose(builder.Build(), expected.Build()));
173 }
174
175 // Verify output with applyState that accepts opacity
176 {
177 DisplayListBuilder builder;
178 state_stack.set_delegate(&builder);
179 {
180 auto restore = state_stack.applyState(
181 rect, LayerStateStack::kCallerCanApplyOpacity);
182 ASSERT_EQ(state_stack.outstanding_opacity(), 0.25f);
183 ASSERT_EQ(state_stack.outstanding_bounds(), rect);
184
185 DlPaint paint;
186 state_stack.fill(paint);
187 builder.DrawRect(rect, paint);
188 }
189 state_stack.clear_delegate();
190
191 DisplayListBuilder expected;
192 expected.DrawRect(rect, DlPaint().setOpacity(0.25f));
193 ASSERT_TRUE(DisplayListsEQ_Verbose(builder.Build(), expected.Build()));
194 }
195 }
196
197 ASSERT_EQ(state_stack.outstanding_opacity(), 0.5f);
198 ASSERT_EQ(state_stack.outstanding_bounds(), rect);
199 }
200
201 ASSERT_EQ(state_stack.outstanding_opacity(), 1.0f);
202 ASSERT_EQ(state_stack.outstanding_bounds(), DlRect());
203}
204
205TEST(LayerStateStack, ColorFilter) {
206 DlRect rect = DlRect::MakeLTRB(10, 10, 20, 20);
207 auto outer_filter =
208 DlColorFilter::MakeBlend(DlColor::kYellow(), DlBlendMode::kColorBurn);
209 auto inner_filter =
210 DlColorFilter::MakeBlend(DlColor::kRed(), DlBlendMode::kColorBurn);
211
212 LayerStateStack state_stack;
213 state_stack.set_preroll_delegate(DlRect::MakeLTRB(0, 0, 50, 50));
214 {
215 auto mutator = state_stack.save();
216 mutator.applyColorFilter(rect, outer_filter);
217
218 ASSERT_EQ(state_stack.outstanding_color_filter(), outer_filter);
219
220 // Check nested color filters result in nested saveLayers
221 {
222 auto mutator2 = state_stack.save();
223 mutator.applyColorFilter(rect, inner_filter);
224
225 ASSERT_EQ(state_stack.outstanding_color_filter(), inner_filter);
226
227 // Verify output with applyState that does not accept color filters
228 {
229 DisplayListBuilder builder;
230 state_stack.set_delegate(&builder);
231 {
232 auto restore = state_stack.applyState(rect, 0);
233 ASSERT_EQ(state_stack.outstanding_color_filter(), nullptr);
234
235 DlPaint paint;
236 state_stack.fill(paint);
237 builder.DrawRect(rect, paint);
238 }
239 state_stack.clear_delegate();
240
241 DisplayListBuilder expected;
242 DlPaint outer_save_paint = DlPaint().setColorFilter(outer_filter);
243 DlPaint inner_save_paint = DlPaint().setColorFilter(inner_filter);
244 expected.SaveLayer(rect, &outer_save_paint);
245 expected.SaveLayer(rect, &inner_save_paint);
246 expected.DrawRect(rect, DlPaint());
247 expected.Restore();
248 expected.Restore();
249 ASSERT_TRUE(DisplayListsEQ_Verbose(builder.Build(), expected.Build()));
250 }
251
252 // Verify output with applyState that accepts color filters
253 {
254 DlRect rect = DlRect::MakeLTRB(10, 10, 20, 20);
255 DisplayListBuilder builder;
256 state_stack.set_delegate(&builder);
257 {
258 auto restore = state_stack.applyState(
259 rect, LayerStateStack::kCallerCanApplyColorFilter);
260 ASSERT_EQ(state_stack.outstanding_color_filter(), inner_filter);
261
262 DlPaint paint;
263 state_stack.fill(paint);
264 builder.DrawRect(rect, paint);
265 }
266 state_stack.clear_delegate();
267
268 DisplayListBuilder expected;
269 DlPaint save_paint = DlPaint().setColorFilter(outer_filter);
270 DlPaint draw_paint = DlPaint().setColorFilter(inner_filter);
271 expected.SaveLayer(rect, &save_paint);
272 expected.DrawRect(rect, draw_paint);
273 ASSERT_TRUE(DisplayListsEQ_Verbose(builder.Build(), expected.Build()));
274 }
275 }
276
277 ASSERT_EQ(state_stack.outstanding_color_filter(), outer_filter);
278 }
279
280 ASSERT_EQ(state_stack.outstanding_color_filter(), nullptr);
281}
282
283TEST(LayerStateStack, ImageFilter) {
284 DlRect rect = DlRect::MakeLTRB(10, 10, 20, 20);
285 std::shared_ptr<DlImageFilter> outer_filter =
286 DlImageFilter::MakeBlur(2.0f, 2.0f, DlTileMode::kClamp);
287 std::shared_ptr<DlImageFilter> inner_filter =
288 DlImageFilter::MakeBlur(3.0f, 3.0f, DlTileMode::kClamp);
289 DlRect inner_src_rect = rect;
290 DlRect dl_outer_src_rect;
291 ASSERT_EQ(inner_filter->map_local_bounds(rect, dl_outer_src_rect),
292 &dl_outer_src_rect);
293 DlRect outer_src_rect = dl_outer_src_rect;
294
295 LayerStateStack state_stack;
296 state_stack.set_preroll_delegate(DlRect::MakeLTRB(0, 0, 50, 50));
297 {
298 auto mutator = state_stack.save();
299 mutator.applyImageFilter(outer_src_rect, outer_filter);
300
301 ASSERT_EQ(state_stack.outstanding_image_filter(), outer_filter);
302
303 // Check nested color filters result in nested saveLayers
304 {
305 auto mutator2 = state_stack.save();
306 mutator.applyImageFilter(rect, inner_filter);
307
308 ASSERT_EQ(state_stack.outstanding_image_filter(), inner_filter);
309
310 // Verify output with applyState that does not accept color filters
311 {
312 DisplayListBuilder builder;
313 state_stack.set_delegate(&builder);
314 {
315 auto restore = state_stack.applyState(rect, 0);
316 ASSERT_EQ(state_stack.outstanding_image_filter(), nullptr);
317
318 DlPaint paint;
319 state_stack.fill(paint);
320 builder.DrawRect(rect, paint);
321 }
322 state_stack.clear_delegate();
323
324 DisplayListBuilder expected;
325 DlPaint outer_save_paint = DlPaint().setImageFilter(outer_filter);
326 DlPaint inner_save_paint = DlPaint().setImageFilter(inner_filter);
327 expected.SaveLayer(outer_src_rect, &outer_save_paint);
328 expected.SaveLayer(inner_src_rect, &inner_save_paint);
329 expected.DrawRect(rect, DlPaint());
330 expected.Restore();
331 expected.Restore();
332 ASSERT_TRUE(DisplayListsEQ_Verbose(builder.Build(), expected.Build()));
333 }
334
335 // Verify output with applyState that accepts color filters
336 {
337 DlRect rect = DlRect::MakeLTRB(10, 10, 20, 20);
338 DisplayListBuilder builder;
339 state_stack.set_delegate(&builder);
340 {
341 auto restore = state_stack.applyState(
342 rect, LayerStateStack::kCallerCanApplyImageFilter);
343 ASSERT_EQ(state_stack.outstanding_image_filter(), inner_filter);
344
345 DlPaint paint;
346 state_stack.fill(paint);
347 builder.DrawRect(rect, paint);
348 }
349 state_stack.clear_delegate();
350
351 DisplayListBuilder expected;
352 DlPaint save_paint = DlPaint().setImageFilter(outer_filter);
353 DlPaint draw_paint = DlPaint().setImageFilter(inner_filter);
354 expected.SaveLayer(outer_src_rect, &save_paint);
355 expected.DrawRect(rect, draw_paint);
356 ASSERT_TRUE(DisplayListsEQ_Verbose(builder.Build(), expected.Build()));
357 }
358 }
359
360 ASSERT_EQ(state_stack.outstanding_image_filter(), outer_filter);
361 }
362
363 ASSERT_EQ(state_stack.outstanding_image_filter(), nullptr);
364}
365
366TEST(LayerStateStack, OpacityAndColorFilterInteraction) {
367 DlRect rect = DlRect::MakeLTRB(10, 10, 20, 20);
368 auto color_filter =
369 DlColorFilter::MakeBlend(DlColor::kYellow(), DlBlendMode::kColorBurn);
370
371 DisplayListBuilder builder;
372 LayerStateStack state_stack;
373 state_stack.set_delegate(&builder);
374 ASSERT_EQ(builder.GetSaveCount(), 1);
375
376 {
377 auto mutator1 = state_stack.save();
378 ASSERT_EQ(builder.GetSaveCount(), 1);
379 mutator1.applyOpacity(rect, 0.5f);
380 ASSERT_EQ(builder.GetSaveCount(), 1);
381
382 {
383 auto mutator2 = state_stack.save();
384 ASSERT_EQ(builder.GetSaveCount(), 1);
385 mutator2.applyColorFilter(rect, color_filter);
386
387 // The opacity will have been resolved by a saveLayer
388 ASSERT_EQ(builder.GetSaveCount(), 2);
389 ASSERT_EQ(state_stack.outstanding_color_filter(), color_filter);
390 ASSERT_EQ(state_stack.outstanding_opacity(), 1.0f);
391 }
392 ASSERT_EQ(builder.GetSaveCount(), 1);
393 ASSERT_EQ(state_stack.outstanding_color_filter(), nullptr);
394 ASSERT_EQ(state_stack.outstanding_opacity(), 0.5f);
395 }
396 ASSERT_EQ(builder.GetSaveCount(), 1);
397 ASSERT_EQ(state_stack.outstanding_color_filter(), nullptr);
398 ASSERT_EQ(state_stack.outstanding_opacity(), 1.0f);
399
400 {
401 auto mutator1 = state_stack.save();
402 ASSERT_EQ(builder.GetSaveCount(), 1);
403 mutator1.applyColorFilter(rect, color_filter);
404 ASSERT_EQ(builder.GetSaveCount(), 1);
405
406 {
407 auto mutator2 = state_stack.save();
408 ASSERT_EQ(builder.GetSaveCount(), 1);
409 mutator2.applyOpacity(rect, 0.5f);
410
411 // color filter applied to opacity can be applied together
412 ASSERT_EQ(builder.GetSaveCount(), 1);
413 ASSERT_EQ(state_stack.outstanding_color_filter(), color_filter);
414 ASSERT_EQ(state_stack.outstanding_opacity(), 0.5f);
415 }
416 ASSERT_EQ(builder.GetSaveCount(), 1);
417 ASSERT_EQ(state_stack.outstanding_color_filter(), color_filter);
418 ASSERT_EQ(state_stack.outstanding_opacity(), 1.0f);
419 }
420 ASSERT_EQ(builder.GetSaveCount(), 1);
421 ASSERT_EQ(state_stack.outstanding_color_filter(), nullptr);
422 ASSERT_EQ(state_stack.outstanding_opacity(), 1.0f);
423}
424
425TEST(LayerStateStack, OpacityAndImageFilterInteraction) {
426 DlRect rect = DlRect::MakeLTRB(10, 10, 20, 20);
427 std::shared_ptr<DlImageFilter> image_filter =
428 DlImageFilter::MakeBlur(2.0f, 2.0f, DlTileMode::kClamp);
429
430 DisplayListBuilder builder;
431 LayerStateStack state_stack;
432 state_stack.set_delegate(&builder);
433 ASSERT_EQ(builder.GetSaveCount(), 1);
434
435 {
436 auto mutator1 = state_stack.save();
437 ASSERT_EQ(builder.GetSaveCount(), 1);
438 mutator1.applyOpacity(rect, 0.5f);
439 ASSERT_EQ(builder.GetSaveCount(), 1);
440
441 {
442 auto mutator2 = state_stack.save();
443 ASSERT_EQ(builder.GetSaveCount(), 1);
444 mutator2.applyImageFilter(rect, image_filter);
445
446 // opacity applied to image filter can be applied together
447 ASSERT_EQ(builder.GetSaveCount(), 1);
448 ASSERT_EQ(state_stack.outstanding_image_filter(), image_filter);
449 ASSERT_EQ(state_stack.outstanding_opacity(), 0.5f);
450 }
451 ASSERT_EQ(builder.GetSaveCount(), 1);
452 ASSERT_EQ(state_stack.outstanding_image_filter(), nullptr);
453 ASSERT_EQ(state_stack.outstanding_opacity(), 0.5f);
454 }
455 ASSERT_EQ(builder.GetSaveCount(), 1);
456 ASSERT_EQ(state_stack.outstanding_image_filter(), nullptr);
457 ASSERT_EQ(state_stack.outstanding_opacity(), 1.0f);
458
459 {
460 auto mutator1 = state_stack.save();
461 ASSERT_EQ(builder.GetSaveCount(), 1);
462 mutator1.applyImageFilter(rect, image_filter);
463 ASSERT_EQ(builder.GetSaveCount(), 1);
464
465 {
466 auto mutator2 = state_stack.save();
467 ASSERT_EQ(builder.GetSaveCount(), 1);
468 mutator2.applyOpacity(rect, 0.5f);
469
470 // The image filter will have been resolved by a saveLayer
471 ASSERT_EQ(builder.GetSaveCount(), 2);
472 ASSERT_EQ(state_stack.outstanding_image_filter(), nullptr);
473 ASSERT_EQ(state_stack.outstanding_opacity(), 0.5f);
474 }
475 ASSERT_EQ(builder.GetSaveCount(), 1);
476 ASSERT_EQ(state_stack.outstanding_image_filter(), image_filter);
477 ASSERT_EQ(state_stack.outstanding_opacity(), 1.0f);
478 }
479 ASSERT_EQ(builder.GetSaveCount(), 1);
480 ASSERT_EQ(state_stack.outstanding_image_filter(), nullptr);
481 ASSERT_EQ(state_stack.outstanding_opacity(), 1.0f);
482}
483
484TEST(LayerStateStack, ColorFilterAndImageFilterInteraction) {
485 DlRect rect = DlRect::MakeLTRB(10, 10, 20, 20);
486 auto color_filter =
487 DlColorFilter::MakeBlend(DlColor::kYellow(), DlBlendMode::kColorBurn);
488 auto image_filter = DlImageFilter::MakeBlur(2.0f, 2.0f, DlTileMode::kClamp);
489
490 DisplayListBuilder builder;
491 LayerStateStack state_stack;
492 state_stack.set_delegate(&builder);
493 ASSERT_EQ(builder.GetSaveCount(), 1);
494
495 {
496 auto mutator1 = state_stack.save();
497 ASSERT_EQ(builder.GetSaveCount(), 1);
498 mutator1.applyColorFilter(rect, color_filter);
499 ASSERT_EQ(builder.GetSaveCount(), 1);
500
501 {
502 auto mutator2 = state_stack.save();
503 ASSERT_EQ(builder.GetSaveCount(), 1);
504 mutator2.applyImageFilter(rect, image_filter);
505
506 // color filter applied to image filter can be applied together
507 ASSERT_EQ(builder.GetSaveCount(), 1);
508 ASSERT_EQ(state_stack.outstanding_image_filter(), image_filter);
509 ASSERT_EQ(state_stack.outstanding_color_filter(), color_filter);
510 }
511 ASSERT_EQ(builder.GetSaveCount(), 1);
512 ASSERT_EQ(state_stack.outstanding_image_filter(), nullptr);
513 ASSERT_EQ(state_stack.outstanding_color_filter(), color_filter);
514 }
515 ASSERT_EQ(builder.GetSaveCount(), 1);
516 ASSERT_EQ(state_stack.outstanding_image_filter(), nullptr);
517 ASSERT_EQ(state_stack.outstanding_color_filter(), nullptr);
518
519 {
520 auto mutator1 = state_stack.save();
521 ASSERT_EQ(builder.GetSaveCount(), 1);
522 mutator1.applyImageFilter(rect, image_filter);
523 ASSERT_EQ(builder.GetSaveCount(), 1);
524
525 {
526 auto mutator2 = state_stack.save();
527 ASSERT_EQ(builder.GetSaveCount(), 1);
528 mutator2.applyColorFilter(rect, color_filter);
529
530 // The image filter will have been resolved by a saveLayer
531 ASSERT_EQ(builder.GetSaveCount(), 2);
532 ASSERT_EQ(state_stack.outstanding_image_filter(), nullptr);
533 ASSERT_EQ(state_stack.outstanding_color_filter(), color_filter);
534 }
535 ASSERT_EQ(builder.GetSaveCount(), 1);
536 ASSERT_EQ(state_stack.outstanding_image_filter(), image_filter);
537 ASSERT_EQ(state_stack.outstanding_color_filter(), nullptr);
538 }
539 ASSERT_EQ(builder.GetSaveCount(), 1);
540 ASSERT_EQ(state_stack.outstanding_image_filter(), nullptr);
541 ASSERT_EQ(state_stack.outstanding_color_filter(), nullptr);
542}
543
544} // namespace testing
545} // namespace flutter
flutter::DisplayListBuilder::GetMatrix
DlMatrix GetMatrix() const override
Definition dl_builder.h:102
flutter::DisplayListBuilder::SaveLayer
void SaveLayer(const std::optional< DlRect > &bounds, const DlPaint *paint=nullptr, const DlImageFilter *backdrop=nullptr, std::optional< int64_t > backdrop_id=std::nullopt) override
Definition dl_builder.cc:543
flutter::DisplayListBuilder::Build
sk_sp< DisplayList > Build()
Definition dl_builder.cc:66
flutter::DisplayListBuilder::GetSaveCount
int GetSaveCount() const override
Definition dl_builder.h:62
flutter::DisplayListBuilder::DrawRect
void DrawRect(const DlRect &rect, const DlPaint &paint) override
Definition dl_builder.cc:1182
flutter::DlCanvas
Developer-facing API for rendering anything within the engine.
Definition dl_canvas.h:32
flutter::DlCanvas::GetMatrix
virtual DlMatrix GetMatrix() const =0
flutter::DlColorFilter::MakeBlend
static std::shared_ptr< const DlColorFilter > MakeBlend(DlColor color, DlBlendMode mode)
Definition dl_color_filter.cc:15
flutter::DlImageFilter::MakeBlur
static std::shared_ptr< DlImageFilter > MakeBlur(DlScalar sigma_x, DlScalar sigma_y, DlTileMode tile_mode)
Definition dl_image_filter.cc:12
flutter::DlPaint::setImageFilter
DlPaint & setImageFilter(std::nullptr_t filter)
Definition dl_paint.h:167
flutter::DlPaint::setOpacity
DlPaint & setOpacity(DlScalar opacity)
Definition dl_paint.h:78
flutter::DlPaint::setColorFilter
DlPaint & setColorFilter(std::nullptr_t filter)
Definition dl_paint.h:149
flutter::LayerStateStack::MutatorContext::applyColorFilter
void applyColorFilter(const DlRect &bounds, const std::shared_ptr< const DlColorFilter > &filter)
Definition layer_state_stack.cc:554
flutter::LayerStateStack::MutatorContext::translate
void translate(DlScalar tx, DlScalar ty)
flutter::LayerStateStack::MutatorContext::applyOpacity
void applyOpacity(const DlRect &bounds, DlScalar opacity)
Definition layer_state_stack.cc:540
flutter::LayerStateStack::MutatorContext::applyImageFilter
void applyImageFilter(const DlRect &bounds, const std::shared_ptr< DlImageFilter > &filter)
Definition layer_state_stack.cc:546
flutter::LayerStateStack::outstanding_opacity
DlScalar outstanding_opacity() const
Definition layer_state_stack.h:249
flutter::LayerStateStack::fill
void fill(MutatorsStack *mutators)
Definition layer_state_stack.cc:670
flutter::LayerStateStack::outstanding_image_filter
std::shared_ptr< DlImageFilter > outstanding_image_filter() const
Definition layer_state_stack.h:255
flutter::LayerStateStack::content_culled
bool content_culled(const DlRect &content_bounds) const
Definition layer_state_stack.h:297
flutter::LayerStateStack::kCallerCanApplyColorFilter
static constexpr int kCallerCanApplyColorFilter
Definition layer_state_stack.h:227
flutter::LayerStateStack::set_delegate
void set_delegate(DlCanvas *canvas)
Definition layer_state_stack.cc:630
flutter::LayerStateStack::set_preroll_delegate
void set_preroll_delegate(const DlRect &cull_rect, const DlMatrix &matrix)
Definition layer_state_stack.cc:649
flutter::LayerStateStack::applyState
AutoRestore applyState(const DlRect &bounds, int can_apply_flags)
Definition layer_state_stack.h:244
flutter::LayerStateStack::outstanding_color_filter
std::shared_ptr< const DlColorFilter > outstanding_color_filter() const
Definition layer_state_stack.h:251
flutter::LayerStateStack::kCallerCanApplyImageFilter
static constexpr int kCallerCanApplyImageFilter
Definition layer_state_stack.h:228
flutter::LayerStateStack::matrix
const DlMatrix matrix() const
Definition layer_state_stack.h:285
flutter::LayerStateStack::kCallerCanApplyOpacity
static constexpr int kCallerCanApplyOpacity
Definition layer_state_stack.h:226
display_list_testing.h
dl_color_filter.h
dl_image_filter.h
layer_state_stack.h
flutter::testing::TEST
TEST(NativeAssetsManagerTest, NoAvailableAssets)
Definition native_assets_unittests.cc:68
flutter::testing::DisplayListsEQ_Verbose
bool DisplayListsEQ_Verbose(const DisplayList *a, const DisplayList *b)
Definition display_list_testing.cc:20
flutter::DlMatrix
impeller::Matrix DlMatrix
Definition dl_geometry_types.h:32
flutter::kGiantRect
static constexpr DlRect kGiantRect
Definition layer.h:40
flutter::DlColor::kYellow
static constexpr DlColor kYellow()
Definition dl_color.h:76
flutter::DlColor::kRed
static constexpr DlColor kRed()
Definition dl_color.h:71
impeller::Matrix
A 4x4 matrix using column-major storage.
Definition matrix.h:37
impeller::Matrix::MakeTranslation
static constexpr Matrix MakeTranslation(const Vector3 &t)
Definition matrix.h:95
impeller::Matrix::IsIdentity
constexpr bool IsIdentity() const
Definition matrix.h:467
impeller::TRect< Scalar >::MakeWH
static constexpr TRect MakeWH(Type width, Type height)
Definition rect.h:140
impeller::TRect< Scalar >::MakeLTRB
static constexpr TRect MakeLTRB(Type left, Type top, Type right, Type bottom)
Definition rect.h:129