5 #include "flutter/display_list/display_list.h"
6 #include "flutter/display_list/dl_blend_mode.h"
7 #include "flutter/display_list/dl_builder.h"
8 #include "flutter/display_list/dl_color.h"
9 #include "flutter/display_list/dl_paint.h"
10 #include "flutter/display_list/dl_sampling_options.h"
11 #include "flutter/display_list/dl_tile_mode.h"
12 #include "flutter/display_list/effects/dl_color_filter.h"
13 #include "flutter/display_list/effects/dl_color_source.h"
14 #include "flutter/display_list/effects/dl_image_filter.h"
15 #include "flutter/display_list/effects/dl_mask_filter.h"
16 #include "flutter/display_list/geometry/dl_path_builder.h"
19 #include "gmock/gmock.h"
23 #include "impeller/renderer/testing/mocks.h"
24 #include "third_party/imgui/imgui.h"
39 DisplayListBuilder builder;
40 builder.Scale(GetContentScale().
x, GetContentScale().y);
42 std::vector<float> sigmas = {0.0, 0.01, 1.0};
43 std::vector<DlColor> colors = {DlColor::kGreen(), DlColor::kYellow(),
45 for (uint32_t i = 0; i < sigmas.size(); ++i) {
47 paint.setColor(colors[i]);
49 DlBlurMaskFilter::Make(DlBlurStyle::kNormal, sigmas[i]));
52 builder.Translate(100 + (i * 100), 100);
54 DlRoundRect::MakeRectXY(DlRect::MakeXYWH(0, 0, 60.0f, 160.0f), 50, 100);
55 builder.DrawRoundRect(rrect, paint);
59 ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
65 DisplayListBuilder builder;
66 builder.Scale(content_Scale.
x, content_Scale.
y);
68 DlPaint background_paint;
69 background_paint.setColor(DlColor(1, 0.1, 0.1, 0.1, DlColorSpace::kSRGB));
70 builder.DrawPaint(background_paint);
72 std::vector<DlColor> colors = {DlColor::kRed(), DlColor::kBlue()};
73 std::vector<Scalar> stops = {0.0, 1.0};
76 paint.setMaskFilter(DlBlurMaskFilter::Make(style, sigma));
77 auto gradient = DlColorSource::MakeLinear(
78 {0, 0}, {200, 200}, 2, colors.data(), stops.data(), DlTileMode::kClamp);
79 paint.setColorSource(gradient);
80 paint.setColor(DlColor::kWhite());
81 paint.setDrawStyle(DlDrawStyle::kStroke);
82 paint.setStrokeWidth(20);
85 builder.Translate(100, 100);
89 line_paint.setColor(DlColor::kWhite());
95 DlRoundRect::MakeRectXY(DlRect::MakeXYWH(0, 0, 200.0f, 60.0f), 50, 100);
96 builder.DrawRoundRect(rrect, paint);
99 return builder.Build();
105 GetContentScale(), 10, DlBlurStyle::kNormal)));
110 GetContentScale(), 0, DlBlurStyle::kNormal)));
115 GetContentScale(), 10, DlBlurStyle::kOuter)));
120 GetContentScale(), 10, DlBlurStyle::kInner)));
125 GetContentScale(), 10, DlBlurStyle::kSolid)));
129 DisplayListBuilder builder;
130 builder.Scale(GetContentScale().
x, GetContentScale().y);
132 std::vector<float> sigmas = {0.0, 0.01, 1.0};
133 std::vector<DlColor> colors = {DlColor::kGreen(), DlColor::kYellow(),
135 for (uint32_t i = 0; i < sigmas.size(); ++i) {
137 paint.setColor(colors[i]);
139 DlBlurMaskFilter::Make(DlBlurStyle::kNormal, sigmas[i]));
142 builder.Translate(100 + (i * 100), 100);
144 DlRect::MakeXYWH(0, 0, 100.0f, 100.0f), 100, 100);
145 builder.DrawRoundRect(rrect, paint);
149 ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
153 DisplayListBuilder builder;
156 paint.setColor(DlColor::kGreen());
157 paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 99999));
158 builder.DrawCircle(
DlPoint(400, 400), 300, paint);
161 ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
167 DisplayListBuilder builder;
168 builder.ClipRect(DlRect::MakeXYWH(100, 150, 400, 400));
171 paint.setColor(DlColor::kWhite());
175 DlBlurMaskFilter::Make(DlBlurStyle::kNormal, sigma.
sigma));
176 paint.setColorFilter(
177 DlColorFilter::MakeBlend(DlColor::kGreen(), DlBlendMode::kSrc));
178 builder.DrawCircle(
DlPoint(400, 400), 200, paint);
180 ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
186 DisplayListBuilder builder;
187 builder.ClipRect(DlRect::MakeXYWH(100, 150, 400, 400));
191 DlColor::RGBA(128.0f / 255.0f, 128.0f / 255.0f, 128.0f / 255.0f, 1.0f));
195 DlBlurMaskFilter::Make(DlBlurStyle::kNormal, sigma.
sigma));
196 paint.setColorFilter(
197 DlColorFilter::MakeBlend(DlColor::kGreen(), DlBlendMode::kColor));
198 builder.DrawCircle(
DlPoint(400, 400), 200, paint);
201 ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
205 auto callback = [&]() -> sk_sp<DisplayList> {
210 DisplayListBuilder builder;
212 paint.setColor(DlColor::kCornflowerBlue());
213 builder.DrawCircle(
DlPoint(100, 100), 50, paint);
215 paint.setColor(DlColor::kGreenYellow());
216 builder.DrawCircle(
DlPoint(300, 200), 100, paint);
218 paint.setColor(DlColor::kDarkMagenta());
219 builder.DrawCircle(
DlPoint(140, 170), 75, paint);
221 paint.setColor(DlColor::kOrangeRed());
222 builder.DrawCircle(
DlPoint(180, 120), 100, paint);
225 DlRoundRect::MakeRectXY(DlRect::MakeLTRB(a.x, a.y,
b.x,
b.y), 20, 20);
226 builder.ClipRoundRect(rrect);
229 save_paint.setBlendMode(DlBlendMode::kSrc);
231 auto backdrop_filter = DlImageFilter::MakeBlur(20, 20, DlTileMode::kClamp);
232 builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get());
235 return builder.Build();
238 ASSERT_TRUE(OpenPlaygroundHere(callback));
242 DisplayListBuilder builder;
245 paint.setColor(DlColor::kCornflowerBlue());
246 builder.DrawCircle(
DlPoint(100, 100), 50, paint);
248 paint.setColor(DlColor::kGreenYellow());
249 builder.DrawCircle(
DlPoint(300, 200), 100, paint);
251 paint.setColor(DlColor::kDarkMagenta());
252 builder.DrawCircle(
DlPoint(140, 170), 75, paint);
254 paint.setColor(DlColor::kOrangeRed());
255 builder.DrawCircle(
DlPoint(180, 120), 100, paint);
258 DlRoundRect::MakeRectXY(DlRect::MakeLTRB(75, 50, 375, 275), 20, 20);
259 builder.ClipRoundRect(rrect);
262 save_paint.setBlendMode(DlBlendMode::kSrc);
263 auto backdrop_filter = DlImageFilter::MakeBlur(30, 30, DlTileMode::kClamp);
264 builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get());
267 ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
273 DisplayListBuilder builder;
276 builder.DrawImage(image,
DlPoint(50.0, 50.0),
277 DlImageSampling::kNearestNeighbor, &paint);
280 DlRoundRect::MakeRectXY(DlRect::MakeXYWH(50, 250, 100, 100), 20, 20);
282 builder.ClipRoundRect(rrect);
285 save_paint.setBlendMode(DlBlendMode::kSrc);
286 auto backdrop_filter = DlImageFilter::MakeBlur(30, 30, DlTileMode::kClamp);
287 builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get(),
292 ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
298 DisplayListBuilder builder;
301 builder.DrawImage(image,
DlPoint(50.0, 50.0),
302 DlImageSampling::kNearestNeighbor, &paint);
304 for (
int i = 0; i < 6; i++) {
306 DlRect::MakeXYWH(50 + (i * 100), 250, 100, 100), 20, 20);
308 builder.ClipRoundRect(rrect);
311 save_paint.setBlendMode(DlBlendMode::kSrc);
312 auto backdrop_filter = DlImageFilter::MakeBlur(30, 30, DlTileMode::kClamp);
313 builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get(),
319 ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
323 CanRenderMultipleBackdropBlurWithSingleBackdropIdAndDistinctFilters) {
326 DisplayListBuilder builder;
329 builder.DrawImage(image,
DlPoint(50.0, 50.0),
330 DlImageSampling::kNearestNeighbor, &paint);
332 for (
int i = 0; i < 6; i++) {
334 DlRect::MakeXYWH(50 + (i * 100), 250, 100, 100), 20, 20);
336 builder.ClipRoundRect(rrect);
339 save_paint.setBlendMode(DlBlendMode::kSrc);
340 auto backdrop_filter =
341 DlImageFilter::MakeBlur(30 + i, 30, DlTileMode::kClamp);
342 builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get(),
348 ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
352 DisplayListBuilder builder;
355 paint.setColor(DlColor::kGreen());
356 builder.DrawCircle(
DlPoint(400, 400), 300, paint);
359 save_paint.setBlendMode(DlBlendMode::kSrc);
361 auto backdrop_filter =
362 DlImageFilter::MakeBlur(999999, 999999, DlTileMode::kClamp);
363 builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get());
366 ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
370 DisplayListBuilder builder;
371 builder.ClipRect(DlRect::MakeXYWH(100, 150, 400, 400));
374 paint.setColor(DlColor::kGreen());
375 paint.setImageFilter(DlImageFilter::MakeBlur(20, 20, DlTileMode::kDecal));
376 builder.DrawCircle(
DlPoint(400, 400), 200, paint);
379 ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
383 auto callback = [&]() -> sk_sp<DisplayList> {
388 DisplayListBuilder builder;
389 auto location = point -
Point(400, 400);
390 builder.Translate(location.x, location.y);
395 DlBlurMaskFilter::Make(DlBlurStyle::kNormal, sigma.
sigma));
396 paint.setColor(DlColor::kRed());
398 DlPath path = DlPath::MakeRect(DlRect::MakeLTRB(0, 0, 800, 800));
399 path = path + DlPath::MakeCircle(
DlPoint(0, 0), 0.5);
400 builder.DrawPath(path, paint);
401 return builder.Build();
403 ASSERT_TRUE(OpenPlaygroundHere(callback));
407 DisplayListBuilder builder;
408 builder.Translate(0, -400);
413 DlBlurMaskFilter::Make(DlBlurStyle::kNormal, sigma.
sigma));
414 paint.setColor(DlColor::kRed());
416 DlPath path = DlPath::MakeRect(DlRect::MakeLTRB(0, 0, 800, 800));
417 path = path + DlPath::MakeCircle(
DlPoint(0, 0), 0.5);
418 builder.DrawPath(path, paint);
420 ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
424 DisplayListBuilder builder;
426 paint.setColor(DlColor::kBlue());
427 builder.DrawRect(DlRect::MakeXYWH(0, 0, 600.0, 600.0), paint);
430 clear.setBlendMode(DlBlendMode::kClear);
431 clear.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 20));
433 builder.DrawCircle(
DlPoint(300.0, 300.0), 200.0, clear);
435 ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
440 auto callback = [&]() -> sk_sp<DisplayList> {
442 ImGuiWindowFlags_AlwaysAutoResize)) {
443 ImGui::SliderFloat(
"Sigma", &sigma, 0, 50);
446 DisplayListBuilder builder;
447 builder.Scale(GetContentScale().
x, GetContentScale().y);
448 builder.DrawPaint({});
451 paint.setColor(DlColor::kGreen());
452 paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, sigma));
454 builder.DrawRect(DlRect::MakeXYWH(300, 300, 200, 200), paint);
455 return builder.Build();
458 ASSERT_TRUE(OpenPlaygroundHere(callback));
462 DisplayListBuilder builder;
465 paint.setColor(DlColor::kBlue());
466 paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 0));
468 builder.DrawCircle(
DlPoint(300, 300), 200, paint);
469 builder.DrawRect(DlRect::MakeLTRB(100, 300, 500, 600), paint);
471 ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
476 EXPECT_EQ(GetContext()->GetCapabilities()->GetDefaultColorFormat(),
479 DisplayListBuilder builder;
480 builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
483 paint.setColor(DlColor::kBlue());
484 paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 10));
487 builder.DrawRect(DlRect::MakeLTRB(100, 250, 500, 250), paint);
489 builder.DrawRect(DlRect::MakeLTRB(100, 300, 500, 600), paint);
491 builder.DrawRect(DlRect::MakeLTRB(550, 300, 550, 600), paint);
493 ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
497 DlBlurStyle style = DlBlurStyle::kNormal;
501 bool invert_colors =
false;
502 DlBlendMode blend_mode = DlBlendMode::kSrcOver;
508 DisplayListBuilder builder;
511 builder.Scale(0.8f, 0.8f);
512 builder.Translate(50.f, 50.f);
518 builder.DrawPaint(draw_paint);
521 paint.setMaskFilter(DlBlurMaskFilter::Make(config.
style, config.
sigma));
527 const Scalar radius = 20.0f;
528 const Scalar y_spacing = 100.0f;
532 paint.setColor(DlColor::kCrimson().withAlpha(alpha));
533 builder.DrawRect(DlRect::MakeXYWH(
x + 25 - radius / 2, y + radius / 2,
534 radius, 60.0f - radius),
538 paint.setColor(DlColor::kBlue().withAlpha(alpha));
539 builder.DrawCircle(
DlPoint{
x + 25, y + 25}, radius, paint);
542 paint.setColor(DlColor::kGreen().withAlpha(alpha));
543 builder.DrawOval(DlRect::MakeXYWH(
x + 25 - radius / 2, y + radius / 2,
544 radius, 60.0f - radius),
548 paint.setColor(DlColor::kPurple().withAlpha(alpha));
550 DlRect::MakeXYWH(
x, y, 60.0f, 60.0f), radius, radius);
551 builder.DrawRoundRect(rrect, paint);
554 paint.setColor(DlColor::kOrange().withAlpha(alpha));
556 rrect = DlRoundRect::MakeRectXY(DlRect::MakeXYWH(
x, y, 60.0f, 60.0f),
558 builder.DrawRoundRect(rrect, paint);
561 paint.setColor(DlColor::kMaroon().withAlpha(alpha));
564 DlPathBuilder path_builder;
565 path_builder.MoveTo(
DlPoint(
x + 0, y + 60));
566 path_builder.LineTo(
DlPoint(
x + 30, y + 0));
567 path_builder.LineTo(
DlPoint(
x + 60, y + 60));
568 path_builder.Close();
570 builder.DrawPath(path_builder.TakePath(), paint);
574 paint.setColor(DlColor::kMaroon().withAlpha(alpha));
580 builder.DrawPath(path, paint);
583 return builder.Build();
588 {
"NormalTranslucentZeroSigma",
589 {.style = DlBlurStyle::kNormal, .sigma = 0.0f, .alpha = 0.5f}},
591 {
"NormalTranslucent",
592 {.style = DlBlurStyle::kNormal, .sigma = 8.0f, .alpha = 0.5f}},
595 {.style = DlBlurStyle::kSolid, .sigma = 8.0f, .alpha = 0.5f}},
597 {
"SolidOpaque", {.style = DlBlurStyle::kSolid, .sigma = 8.0f}},
599 {
"SolidTranslucentWithFilters",
600 {.style = DlBlurStyle::kSolid,
603 .image_filter = DlImageFilter::MakeBlur(3, 3, DlTileMode::kClamp),
604 .invert_colors =
true}},
606 {
"SolidTranslucentExclusionBlend",
607 {.style = DlBlurStyle::kSolid,
610 .blend_mode = DlBlendMode::kExclusion}},
613 {.style = DlBlurStyle::kInner, .sigma = 8.0f, .alpha = 0.5f}},
615 {
"InnerTranslucentWithBlurImageFilter",
616 {.style = DlBlurStyle::kInner,
619 .image_filter = DlImageFilter::MakeBlur(3, 3, DlTileMode::kClamp)}},
622 {.style = DlBlurStyle::kOuter, .sigma = 8.0f, .alpha = 0.5f}},
624 {
"OuterOpaqueWithBlurImageFilter",
625 {.style = DlBlurStyle::kOuter,
627 .image_filter = DlImageFilter::MakeBlur(3, 3, DlTileMode::kClamp)}},
630 #define MASK_BLUR_VARIANT_TEST(config) \
631 TEST_P(AiksTest, MaskBlurVariantTest##config) { \
632 ASSERT_TRUE(OpenPlaygroundHere( \
633 MaskBlurVariantTest(*this, kPaintVariations.at(#config)))); \
647 #undef MASK_BLUR_VARIANT_TEST
650 DisplayListBuilder builder;
651 builder.Scale(GetContentScale().
x, GetContentScale().y);
654 paint.setColor(DlColor::RGBA(0.1, 0.1, 0.1, 1));
655 builder.DrawPaint(paint);
657 paint.setColor(DlColor::kGreen());
658 paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kInner, 30));
660 DlPathBuilder path_builder;
661 path_builder.MoveTo(
DlPoint(200, 200));
662 path_builder.LineTo(
DlPoint(300, 400));
663 path_builder.LineTo(
DlPoint(100, 400));
664 path_builder.Close();
666 builder.DrawPath(path_builder.TakePath(), paint);
670 red.setColor(DlColor::kRed());
671 builder.DrawRect(DlRect::MakeXYWH(0, 0, 200, 200), red);
673 ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
677 DisplayListBuilder builder;
678 builder.Scale(GetContentScale().
x, GetContentScale().y);
681 paint.setColor(DlColor::RGBA(0.1, 0.1, 0.1, 1.0));
682 builder.DrawPaint(paint);
684 paint.setColor(DlColor::kGreen());
685 paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kOuter, 30));
687 DlPathBuilder path_builder;
688 path_builder.MoveTo(
DlPoint(200, 200));
689 path_builder.LineTo(
DlPoint(300, 400));
690 path_builder.LineTo(
DlPoint(100, 400));
691 path_builder.Close();
693 builder.DrawPath(path_builder.TakePath(), paint);
697 red.setColor(DlColor::kRed());
698 builder.DrawRect(DlRect::MakeXYWH(0, 0, 200, 200), red);
700 ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
704 DisplayListBuilder builder;
705 builder.Scale(GetContentScale().
x, GetContentScale().y);
708 paint.setColor(DlColor::RGBA(0.1, 0.1, 0.1, 1.0));
709 builder.DrawPaint(paint);
711 paint.setColor(DlColor::kGreen());
712 paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kSolid, 30));
714 DlPathBuilder path_builder;
715 path_builder.MoveTo(
DlPoint(200, 200));
716 path_builder.LineTo(
DlPoint(300, 400));
717 path_builder.LineTo(
DlPoint(100, 400));
718 path_builder.Close();
720 builder.DrawPath(path_builder.TakePath(), paint);
724 red.setColor(DlColor::kRed());
725 builder.DrawRect(DlRect::MakeXYWH(0, 0, 200, 200), red);
727 ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
732 auto callback = [&]() -> sk_sp<DisplayList> {
734 ImGuiWindowFlags_AlwaysAutoResize)) {
735 ImGui::SliderFloat(
"Sigma", &sigma, 0, 500);
739 DisplayListBuilder builder;
740 builder.Scale(GetContentScale().
x, GetContentScale().y);
743 paint.setColor(DlColor::kGreen());
744 paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, sigma));
748 DlPoint(200, 200), DlImageSampling::kNearestNeighbor, &paint);
751 red.setColor(DlColor::kRed());
752 builder.DrawRect(DlRect::MakeXYWH(0, 0, 200, 200), red);
754 return builder.Build();
756 ASSERT_TRUE(OpenPlaygroundHere(callback));
761 auto callback = [&]() -> sk_sp<DisplayList> {
763 ImGuiWindowFlags_AlwaysAutoResize)) {
764 ImGui::SliderFloat(
"Sigma", &sigma, 0, 500);
768 DisplayListBuilder builder;
769 builder.Scale(GetContentScale().
x, GetContentScale().y);
772 paint.setColor(DlColor::RGBA(0.1, 0.1, 0.1, 1.0));
773 builder.DrawPaint(paint);
775 std::shared_ptr<Texture> boston = CreateTextureForFixture(
"boston.jpg");
780 paint.setColorSource(DlColorSource::MakeImage(
782 DlImageSampling::kMipmapLinear));
783 paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, sigma));
785 builder.DrawRect(DlRect::MakeXYWH(0, 0, boston->GetSize().width,
786 boston->GetSize().height),
789 return builder.Build();
791 ASSERT_TRUE(OpenPlaygroundHere(callback));
795 DisplayListBuilder builder;
798 builder.Scale(GetContentScale().
x, GetContentScale().y);
800 paint.setColor(DlColor::kLimeGreen());
802 DlRect::MakeLTRB(0, 0, GetWindowSize().width, 100), 10, 10);
803 builder.DrawRoundRect(rrect, paint);
805 paint.setColor(DlColor::kMagenta());
806 rrect = DlRoundRect::MakeRectXY(
807 DlRect::MakeLTRB(0, 110, GetWindowSize().width, 210), 10, 10);
808 builder.DrawRoundRect(rrect, paint);
809 builder.ClipRect(DlRect::MakeLTRB(100, 0, 200, GetWindowSize().height));
812 save_paint.setBlendMode(DlBlendMode::kSrc);
814 auto backdrop_filter = DlImageFilter::MakeBlur(20, 20, DlTileMode::kClamp);
816 builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get());
819 ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
823 DisplayListBuilder builder;
825 builder.Scale(GetContentScale().
x, GetContentScale().y);
826 std::shared_ptr<Texture> boston = CreateTextureForFixture(
"boston.jpg");
827 builder.DrawImageRect(
829 DlRect::MakeXYWH(0, 0, boston->GetSize().width, boston->GetSize().height),
830 DlRect::MakeLTRB(0, 0, GetWindowSize().width, 100),
831 DlImageSampling::kNearestNeighbor);
834 paint.setColor(DlColor::kMagenta());
837 DlRect::MakeLTRB(0, 110, GetWindowSize().width, 210), 10, 10);
838 builder.DrawRoundRect(rrect, paint);
839 builder.ClipRect(DlRect::MakeLTRB(0, 50, GetWindowSize().width, 150));
842 save_paint.setBlendMode(DlBlendMode::kSrc);
844 auto backdrop_filter = DlImageFilter::MakeBlur(20, 20, DlTileMode::kClamp);
845 builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get());
848 ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
857 CreateTextureForFixture(
"boston.jpg",
true);
863 auto callback = [&]() -> sk_sp<DisplayList> {
865 ImGuiWindowFlags_AlwaysAutoResize)) {
866 ImGui::SliderFloat(
"Sigma", &sigma, 0, 200);
867 ImGui::SliderFloat(
"Frequency", &freq, 0.01, 2.0);
868 ImGui::SliderFloat(
"Amplitude", &, 1, 100);
872 DisplayListBuilder builder;
873 builder.Scale(GetContentScale().
x, GetContentScale().y);
874 Scalar y = amp * sin(freq * 2.0 * M_PI * count / 60);
876 DlPoint(1024 / 2 - boston->GetSize().width / 2,
877 (768 / 2 - boston->GetSize().height / 2) + y),
878 DlImageSampling::kMipmapLinear);
884 DlRect::MakeLTRB(handle_a.x, handle_a.y, handle_b.x, handle_b.y));
885 builder.ClipRect(DlRect::MakeLTRB(100, 100, 900, 700));
888 paint.setBlendMode(DlBlendMode::kSrc);
890 auto backdrop_filter =
891 DlImageFilter::MakeBlur(sigma, sigma, DlTileMode::kClamp);
892 builder.SaveLayer(std::nullopt, &paint, backdrop_filter.get());
894 return builder.Build();
896 ASSERT_TRUE(OpenPlaygroundHere(callback));
900 DisplayListBuilder builder;
902 builder.Scale(GetContentScale().
x, GetContentScale().y);
905 paint.setColor(DlColor::RGBA(0.1, 0.1, 0.1, 1.0));
906 builder.DrawPaint(paint);
908 std::vector<DlColor> colors = {DlColor::RGBA(0.9568, 0.2627, 0.2118, 1.0),
909 DlColor::RGBA(0.7568, 0.2627, 0.2118, 1.0)};
910 std::vector<Scalar> stops = {0.0, 1.0};
913 paint.setColorSource(DlColorSource::MakeLinear(
919 DlTileMode::kMirror));
920 paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kInner, 30));
922 DlPathBuilder path_builder;
923 path_builder.MoveTo(
DlPoint(200, 200));
924 path_builder.LineTo(
DlPoint(300, 400));
925 path_builder.LineTo(
DlPoint(100, 400));
926 path_builder.Close();
927 builder.DrawPath(path_builder.TakePath(), paint);
931 red.setColor(DlColor::kRed());
932 builder.DrawRect(DlRect::MakeXYWH(0, 0, 200, 200), red);
934 ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
938 DisplayListBuilder builder;
939 builder.Scale(GetContentScale().
x, GetContentScale().y);
942 paint.setColor(DlColor::RGBA(0.1, 0.1, 0.1, 1.0));
943 builder.DrawPaint(paint);
945 std::vector<DlColor> colors = {DlColor::RGBA(0.9568, 0.2627, 0.2118, 1.0),
946 DlColor::RGBA(0.7568, 0.2627, 0.2118, 1.0)};
947 std::vector<Scalar> stops = {0.0, 1.0};
950 paint.setColorSource(DlColorSource::MakeLinear(
956 DlTileMode::kMirror));
957 paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kSolid, 30));
959 DlPathBuilder path_builder;
960 path_builder.MoveTo(
DlPoint(200, 200));
961 path_builder.LineTo(
DlPoint(300, 400));
962 path_builder.LineTo(
DlPoint(100, 400));
963 path_builder.Close();
964 builder.DrawPath(path_builder.TakePath(), paint);
968 red.setColor(DlColor::kRed());
969 builder.DrawRect(DlRect::MakeXYWH(0, 0, 200, 200), red);
970 ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
974 DisplayListBuilder builder;
975 builder.Scale(GetContentScale().
x, GetContentScale().y);
978 paint.setColor(DlColor::RGBA(0.1, 0.1, 0.1, 1.0));
979 builder.DrawPaint(paint);
981 std::vector<DlColor> colors = {DlColor::RGBA(0.9568, 0.2627, 0.2118, 1.0),
982 DlColor::RGBA(0.7568, 0.2627, 0.2118, 1.0)};
983 std::vector<Scalar> stops = {0.0, 1.0};
986 paint.setColorSource(DlColorSource::MakeLinear(
992 DlTileMode::kMirror));
993 paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kOuter, 30));
995 DlPathBuilder path_builder;
996 path_builder.MoveTo(
DlPoint(200, 200));
997 path_builder.LineTo(
DlPoint(300, 400));
998 path_builder.LineTo(
DlPoint(100, 400));
999 path_builder.Close();
1000 builder.DrawPath(path_builder.TakePath(), paint);
1004 red.setColor(DlColor::kRed());
1005 builder.DrawRect(DlRect::MakeXYWH(0, 0, 200, 200), red);
1006 ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
1010 DisplayListBuilder builder;
1011 std::shared_ptr<Texture> boston = CreateTextureForFixture(
"boston.jpg");
1013 Rect::MakeXYWH(0, 0, boston->GetSize().width, boston->GetSize().height);
1017 paint.setImageFilter(DlImageFilter::MakeBlur(20, 20, DlTileMode::kDecal));
1019 Vector2 clip_size = {150, 75};
1021 builder.Scale(GetContentScale().
x, GetContentScale().y);
1025 builder.ClipRect(DlRect::MakeLTRB(rect.GetLeft(), rect.GetTop(),
1026 rect.GetRight(), rect.GetBottom()));
1027 builder.Translate(center.
x, center.
y);
1028 builder.Scale(0.6, 0.6);
1032 Rect dest = bounds.
Shift(-image_center);
1036 sk_dst, DlImageSampling::kNearestNeighbor,
1039 ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
1043 std::shared_ptr<Texture> boston = CreateTextureForFixture(
"boston.jpg");
1045 auto callback = [&]() -> sk_sp<DisplayList> {
1046 const char* tile_mode_names[] = {
"Clamp",
"Repeat",
"Mirror",
"Decal"};
1047 const DlTileMode tile_modes[] = {DlTileMode::kClamp, DlTileMode::kRepeat,
1048 DlTileMode::kMirror, DlTileMode::kDecal};
1050 static float rotation = 0;
1051 static float scale = 0.6;
1052 static int selected_tile_mode = 3;
1055 ImGuiWindowFlags_AlwaysAutoResize)) {
1056 ImGui::SliderFloat(
"Rotation (degrees)", &rotation, -180, 180);
1057 ImGui::SliderFloat(
"Scale", &scale, 0, 2.0);
1058 ImGui::Combo(
"Tile mode", &selected_tile_mode, tile_mode_names,
1059 sizeof(tile_mode_names) /
sizeof(
char*));
1063 DisplayListBuilder builder;
1065 Rect::MakeXYWH(0, 0, boston->GetSize().width, boston->GetSize().height);
1068 paint.setImageFilter(
1069 DlImageFilter::MakeBlur(20, 20, tile_modes[selected_tile_mode]));
1076 builder.Scale(GetContentScale().
x, GetContentScale().y);
1078 DlRect::MakeLTRB(handle_a.x, handle_a.y, handle_b.x, handle_b.y));
1079 builder.Translate(center.
x, center.
y);
1080 builder.Scale(scale, scale);
1081 builder.
Rotate(rotation);
1085 Rect dest = bounds.
Shift(-image_center);
1089 sk_dst, DlImageSampling::kNearestNeighbor,
1091 return builder.Build();
1094 ASSERT_TRUE(OpenPlaygroundHere(callback));
1098 DisplayListBuilder builder;
1100 builder.Scale(GetContentScale().
x, GetContentScale().y);
1101 builder.Scale(0.5, 0.5);
1103 std::shared_ptr<Texture> boston = CreateTextureForFixture(
"boston.jpg");
1107 paint.setBlendMode(DlBlendMode::kSrc);
1109 auto backdrop_filter = DlImageFilter::MakeBlur(50, 0, DlTileMode::kClamp);
1110 builder.SaveLayer(std::nullopt, &paint, backdrop_filter.get());
1112 ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
1120 DisplayListBuilder builder;
1122 std::shared_ptr<Texture> boston = CreateTextureForFixture(
"boston.jpg");
1124 Rect::MakeXYWH(0, 0, boston->GetSize().width, boston->GetSize().height);
1127 paint.setImageFilter(DlImageFilter::MakeBlur(20, 20, DlTileMode::kDecal));
1130 Vector2 clip_size = {150, 75};
1132 builder.Scale(GetContentScale().
x, GetContentScale().y);
1136 builder.ClipRect(DlRect::MakeLTRB(clip_bounds.GetLeft(), clip_bounds.GetTop(),
1137 clip_bounds.GetRight(),
1138 clip_bounds.GetBottom()));
1139 builder.Translate(center.
x, center.
y);
1140 builder.Scale(0.6, 0.6);
1143 auto dst_rect = bounds.
Shift(-image_center);
1144 builder.DrawImageRect(
1149 DlRect::MakeLTRB(dst_rect.GetLeft(), dst_rect.GetTop(),
1150 dst_rect.GetRight(), dst_rect.GetBottom()),
1151 DlImageSampling::kMipmapLinear, &paint);
1153 ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
1157 auto callback = [&]() -> sk_sp<DisplayList> {
1158 const char* tile_mode_names[] = {
"Clamp",
"Repeat",
"Mirror",
"Decal"};
1159 const DlTileMode tile_modes[] = {DlTileMode::kClamp, DlTileMode::kRepeat,
1160 DlTileMode::kMirror, DlTileMode::kDecal};
1162 static float rotation = 45;
1163 static float scale = 0.6;
1164 static int selected_tile_mode = 3;
1167 ImGuiWindowFlags_AlwaysAutoResize)) {
1168 ImGui::SliderFloat(
"Rotation (degrees)", &rotation, -180, 180);
1169 ImGui::SliderFloat(
"Scale", &scale, 0, 2.0);
1170 ImGui::Combo(
"Tile mode", &selected_tile_mode, tile_mode_names,
1171 sizeof(tile_mode_names) /
sizeof(
char*));
1175 DisplayListBuilder builder;
1178 paint.setColor(DlColor::kGreen());
1179 paint.setImageFilter(
1180 DlImageFilter::MakeBlur(50, 0, tile_modes[selected_tile_mode]));
1183 builder.Scale(GetContentScale().
x, GetContentScale().y);
1184 builder.Translate(center.
x, center.
y);
1185 builder.Scale(scale, scale);
1186 builder.
Rotate(rotation);
1189 DlRoundRect::MakeRectXY(DlRect::MakeXYWH(-100, -100, 200, 200), 10, 10);
1190 builder.DrawRoundRect(rrect, paint);
1191 return builder.Build();
1194 ASSERT_TRUE(OpenPlaygroundHere(callback));
1198 DisplayListBuilder builder;
1199 builder.Scale(GetContentScale().
x, GetContentScale().y);
1201 auto paint_lines = [&builder](
Scalar dx,
Scalar dy, DlPaint paint) {
1203 DlPath line = DlPath::MakeLine(a,
b);
1204 builder.DrawPath(line, paint);
1206 paint.setStrokeWidth(5);
1207 paint.setDrawStyle(DlDrawStyle::kStroke);
1208 draw_line(
DlPoint(dx + 100, dy + 100),
DlPoint(dx + 200, dy + 200));
1209 draw_line(
DlPoint(dx + 100, dy + 200),
DlPoint(dx + 200, dy + 100));
1210 draw_line(
DlPoint(dx + 150, dy + 100),
DlPoint(dx + 200, dy + 150));
1211 draw_line(
DlPoint(dx + 100, dy + 150),
DlPoint(dx + 150, dy + 200));
1215 DisplayListBuilder recorder_builder;
1216 for (
int x = 0;
x < 5; ++
x) {
1217 for (
int y = 0; y < 5; ++y) {
1218 DlRect rect = DlRect::MakeXYWH(
x * 20, y * 20, 20, 20);
1220 paint.setColor(((
x + y) & 1) == 0 ? DlColor::kYellow()
1221 : DlColor::kBlue());
1223 recorder_builder.DrawRect(rect, paint);
1229 auto image_source = DlColorSource::MakeImage(
1231 auto blur_filter = DlImageFilter::MakeBlur(5, 5, DlTileMode::kDecal);
1234 paint.setColor(DlColor::kDarkGreen());
1235 builder.DrawRect(DlRect::MakeLTRB(0, 0, 300, 600), paint);
1237 paint.setColorSource(image_source);
1238 builder.DrawRect(DlRect::MakeLTRB(100, 100, 200, 200), paint);
1240 paint.setColorSource(
nullptr);
1241 paint.setColor(DlColor::kRed());
1242 builder.DrawRect(DlRect::MakeLTRB(300, 0, 600, 600), paint);
1244 paint.setColorSource(image_source);
1245 paint.setImageFilter(blur_filter);
1246 builder.DrawRect(DlRect::MakeLTRB(400, 100, 500, 200), paint);
1248 paint.setImageFilter(
nullptr);
1249 paint_lines(0, 300, paint);
1251 paint.setImageFilter(blur_filter);
1252 paint_lines(300, 300, paint);
1254 ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
1263 for (int32_t i = 1; i < 5; ++i) {
1264 DisplayListBuilder builder;
1266 DlPathBuilder path_builder;
1267 path_builder.MoveTo(
DlPoint(100, 100));
1268 path_builder.LineTo(
DlPoint(100 + fi, 100 + fi));
1271 paint.setColor(DlColor::kChartreuse());
1272 auto blur_filter = DlImageFilter::MakeBlur(0.1, 0.1, DlTileMode::kClamp);
1273 paint.setImageFilter(blur_filter);
1275 builder.DrawPath(path_builder.TakePath(), paint);
1278 EXPECT_TRUE(image) <<
" length " << i;
1287 for (int32_t i = 1; i < 5; ++i) {
1288 DisplayListBuilder builder;
1293 DlRect::MakeXYWH(400, 400, clip_size.
width, clip_size.
height));
1296 paint.setColor(DlColor::kGreen());
1297 auto blur_filter = DlImageFilter::MakeBlur(0.1, 0.1, DlTileMode::kDecal);
1298 paint.setImageFilter(blur_filter);
1300 builder.DrawCircle(
DlPoint(400, 400), 200, paint);
1304 EXPECT_TRUE(image) <<
" length " << i;
1309 CanRenderMultipleBackdropBlurWithSingleBackdropIdDifferentLayers) {
1312 DisplayListBuilder builder;
1315 builder.DrawImage(image,
DlPoint(50.0, 50.0),
1316 DlImageSampling::kNearestNeighbor, &paint);
1318 for (
int i = 0; i < 6; i++) {
1321 paint.setColor(DlColor::kWhite().withAlphaF(0.95));
1322 builder.SaveLayer(std::nullopt, &paint);
1325 DlRect::MakeXYWH(50 + (i * 100), 250, 100, 100), 20, 20);
1327 builder.ClipRoundRect(rrect);
1330 save_paint.setBlendMode(DlBlendMode::kSrc);
1331 auto backdrop_filter = DlImageFilter::MakeBlur(30, 30, DlTileMode::kClamp);
1332 builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get(),
1341 ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
1345 DisplayListBuilder builder;
1346 builder.Scale(GetContentScale().
x, GetContentScale().y);
1348 std::vector<DlColor> colors = {DlColor(0xFFFF0000), DlColor(0xFF00FF00)};
1349 std::vector<Scalar> stops = {0.0, 1.0};
1351 auto gradient = DlColorSource::MakeLinear(
1352 {0, 0}, {400, 400}, 2, colors.data(), stops.data(), DlTileMode::kClamp);
1355 save_paint.setOpacity(0.5);
1356 builder.SaveLayer(std::nullopt, &save_paint);
1359 paint.setColorSource(gradient);
1360 paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 1));
1361 builder.DrawRect(DlRect::MakeXYWH(100, 100, 200, 200), paint);
1365 ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
#define MASK_BLUR_VARIANT_TEST(config)
static bool ImGuiBegin(const char *name, bool *p_open, ImGuiWindowFlags flags)
static sk_sp< DlImageImpeller > Make(std::shared_ptr< Texture > texture, OwningContext owning_context=OwningContext::kIO)
Point GetContentScale() const
sk_sp< flutter::DisplayList > DoGradientOvalStrokeMaskBlur(Vector2 content_Scale, Scalar sigma, DlBlurStyle style)
static sk_sp< DisplayList > MaskBlurVariantTest(const AiksTest &test_context, const MaskBlurTestConfig &config)
TEST_P(AiksTest, DrawAtlasNoColor)
static const std::map< std::string, MaskBlurTestConfig > kPaintVariations
std::shared_ptr< Texture > DisplayListToTexture(const sk_sp< flutter::DisplayList > &display_list, ISize size, AiksContext &context, bool reset_host_buffer, bool generate_mips)
Render the provided display list to a texture with the given size.
Point DrawPlaygroundPoint(PlaygroundPoint &point)
std::tuple< Point, Point > DrawPlaygroundLine(PlaygroundPoint &point_a, PlaygroundPoint &point_b)
flutter::DlRoundRect DlRoundRect
static constexpr Color White()
static constexpr Color Red()
static constexpr Color AntiqueWhite()
static constexpr Color Green()
static constexpr Matrix MakeTranslation(const Vector3 &t)
static constexpr Matrix MakeScale(const Vector3 &s)
For convolution filters, the "radius" is the size of the convolution kernel to use on the local space...
In filters that use Gaussian distributions, "sigma" is a size of one standard deviation in terms of t...
constexpr TPoint Rotate(const Radians &angle) const
constexpr TRect< T > Expand(T left, T top, T right, T bottom) const
Returns a rectangle with expanded edges. Negative expansion results in shrinking.
constexpr auto GetBottom() const
constexpr auto GetTop() const
constexpr auto GetLeft() const
constexpr TSize< Type > GetSize() const
Returns the size of the rectangle which may be negative in either width or height and may have been c...
constexpr auto GetRight() const
constexpr static TRect MakeXYWH(Type x, Type y, Type width, Type height)
constexpr TRect< T > Shift(T dx, T dy) const
Returns a new rectangle translated by the given offset.
constexpr static TRect MakeLTRB(Type left, Type top, Type right, Type bottom)
std::shared_ptr< DlImageFilter > image_filter