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