Flutter Impeller
aiks_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 "flutter/impeller/aiks/aiks_unittests.h"
6 
7 #include <array>
8 #include <cmath>
9 #include <cstdlib>
10 #include <memory>
11 #include <tuple>
12 #include <utility>
13 #include <vector>
14 
15 #include "flutter/testing/testing.h"
16 #include "impeller/aiks/canvas.h"
17 #include "impeller/aiks/color_filter.h"
18 #include "impeller/aiks/image.h"
19 #include "impeller/aiks/image_filter.h"
20 #include "impeller/aiks/paint_pass_delegate.h"
21 #include "impeller/aiks/testing/context_spy.h"
22 #include "impeller/core/capture.h"
23 #include "impeller/entity/contents/conical_gradient_contents.h"
24 #include "impeller/entity/contents/filters/inputs/filter_input.h"
25 #include "impeller/entity/contents/linear_gradient_contents.h"
26 #include "impeller/entity/contents/radial_gradient_contents.h"
27 #include "impeller/entity/contents/solid_color_contents.h"
28 #include "impeller/entity/contents/sweep_gradient_contents.h"
29 #include "impeller/geometry/color.h"
30 #include "impeller/geometry/constants.h"
31 #include "impeller/geometry/geometry_asserts.h"
32 #include "impeller/geometry/matrix.h"
33 #include "impeller/geometry/path.h"
34 #include "impeller/geometry/path_builder.h"
35 #include "impeller/playground/widgets.h"
36 #include "impeller/renderer/command_buffer.h"
37 #include "impeller/renderer/snapshot.h"
38 #include "impeller/renderer/testing/mocks.h"
39 #include "impeller/scene/material.h"
40 #include "impeller/scene/node.h"
41 #include "impeller/typographer/backends/skia/text_frame_skia.h"
42 #include "impeller/typographer/backends/skia/typographer_context_skia.h"
43 #include "impeller/typographer/backends/stb/text_frame_stb.h"
44 #include "impeller/typographer/backends/stb/typeface_stb.h"
45 #include "impeller/typographer/backends/stb/typographer_context_stb.h"
46 #include "third_party/imgui/imgui.h"
47 #include "third_party/skia/include/core/SkFontMgr.h"
48 #include "third_party/skia/include/core/SkTypeface.h"
49 #include "txt/platform.h"
50 
51 namespace impeller {
52 namespace testing {
53 
54 INSTANTIATE_PLAYGROUND_SUITE(AiksTest);
55 
56 TEST_P(AiksTest, CanvasCTMCanBeUpdated) {
57  Canvas canvas;
58  Matrix identity;
59  ASSERT_MATRIX_NEAR(canvas.GetCurrentTransform(), identity);
60  canvas.Translate(Size{100, 100});
61  ASSERT_MATRIX_NEAR(canvas.GetCurrentTransform(),
62  Matrix::MakeTranslation({100.0, 100.0, 0.0}));
63 }
64 
65 TEST_P(AiksTest, CanvasCanPushPopCTM) {
66  Canvas canvas;
67  ASSERT_EQ(canvas.GetSaveCount(), 1u);
68  ASSERT_EQ(canvas.Restore(), false);
69 
70  canvas.Translate(Size{100, 100});
71  canvas.Save();
72  ASSERT_EQ(canvas.GetSaveCount(), 2u);
73  ASSERT_MATRIX_NEAR(canvas.GetCurrentTransform(),
74  Matrix::MakeTranslation({100.0, 100.0, 0.0}));
75  ASSERT_TRUE(canvas.Restore());
76  ASSERT_EQ(canvas.GetSaveCount(), 1u);
77  ASSERT_MATRIX_NEAR(canvas.GetCurrentTransform(),
78  Matrix::MakeTranslation({100.0, 100.0, 0.0}));
79 }
80 
81 TEST_P(AiksTest, CanRenderColoredRect) {
82  Canvas canvas;
83  Paint paint;
84  paint.color = Color::Blue();
85  canvas.DrawPath(PathBuilder{}
86  .AddRect(Rect::MakeXYWH(100.0, 100.0, 100.0, 100.0))
87  .TakePath(),
88  paint);
89  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
90 }
91 
92 TEST_P(AiksTest, CanRenderImage) {
93  Canvas canvas;
94  Paint paint;
95  auto image = std::make_shared<Image>(CreateTextureForFixture("kalimba.jpg"));
96  paint.color = Color::Red();
97  canvas.DrawImage(image, Point::MakeXY(100.0, 100.0), paint);
98  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
99 }
100 
101 TEST_P(AiksTest, CanRenderInvertedImageWithColorFilter) {
102  Canvas canvas;
103  Paint paint;
104  auto image = std::make_shared<Image>(CreateTextureForFixture("kalimba.jpg"));
105  paint.color = Color::Red();
106  paint.color_filter =
107  ColorFilter::MakeBlend(BlendMode::kSourceOver, Color::Yellow());
108  paint.invert_colors = true;
109 
110  canvas.DrawImage(image, Point::MakeXY(100.0, 100.0), paint);
111  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
112 }
113 
114 TEST_P(AiksTest, CanRenderColorFilterWithInvertColors) {
115  Canvas canvas;
116  Paint paint;
117  paint.color = Color::Red();
118  paint.color_filter =
119  ColorFilter::MakeBlend(BlendMode::kSourceOver, Color::Yellow());
120  paint.invert_colors = true;
121 
122  canvas.DrawRect(Rect::MakeLTRB(0, 0, 100, 100), paint);
123  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
124 }
125 
126 TEST_P(AiksTest, CanRenderColorFilterWithInvertColorsDrawPaint) {
127  Canvas canvas;
128  Paint paint;
129  paint.color = Color::Red();
130  paint.color_filter =
131  ColorFilter::MakeBlend(BlendMode::kSourceOver, Color::Yellow());
132  paint.invert_colors = true;
133 
134  canvas.DrawPaint(paint);
135  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
136 }
137 
138 namespace {
139 bool GenerateMipmap(const std::shared_ptr<Context>& context,
140  std::shared_ptr<Texture> texture,
141  std::string label,
142  bool async_submit) {
143  auto buffer = context->CreateCommandBuffer();
144  if (!buffer) {
145  return false;
146  }
147  auto pass = buffer->CreateBlitPass();
148  if (!pass) {
149  return false;
150  }
151  pass->GenerateMipmap(std::move(texture), std::move(label));
152  if (async_submit) {
153  return buffer->EncodeAndSubmit(pass, context->GetResourceAllocator());
154  }
155 
156  pass->EncodeCommands(context->GetResourceAllocator());
157  return buffer->SubmitCommands();
158 }
159 
160 void CanRenderTiledTexture(AiksTest* aiks_test,
161  Entity::TileMode tile_mode,
162  bool async_submit = false,
163  Matrix local_matrix = {}) {
164  auto context = aiks_test->GetContext();
165  ASSERT_TRUE(context);
166  auto texture = aiks_test->CreateTextureForFixture("table_mountain_nx.png",
167  /*enable_mipmapping=*/true);
168  GenerateMipmap(context, texture, "table_mountain_nx", async_submit);
169  Canvas canvas;
170  canvas.Scale(aiks_test->GetContentScale());
171  canvas.Translate({100.0f, 100.0f, 0});
172  Paint paint;
173  paint.color_source =
174  ColorSource::MakeImage(texture, tile_mode, tile_mode, {}, local_matrix);
175  paint.color = Color(1, 1, 1, 1);
176  canvas.DrawRect(Rect::MakeXYWH(0, 0, 600, 600), paint);
177 
178  // Should not change the image.
179  constexpr auto stroke_width = 64;
180  paint.style = Paint::Style::kStroke;
181  paint.stroke_width = stroke_width;
182  if (tile_mode == Entity::TileMode::kDecal) {
183  canvas.DrawRect(Rect::MakeXYWH(stroke_width, stroke_width, 600, 600),
184  paint);
185  } else {
186  canvas.DrawRect(Rect::MakeXYWH(0, 0, 600, 600), paint);
187  }
188 
189  {
190  // Should not change the image.
191  PathBuilder path_builder;
192  path_builder.AddCircle({150, 150}, 150);
193  path_builder.AddRoundedRect(Rect::MakeLTRB(300, 300, 600, 600), 10);
194  paint.style = Paint::Style::kFill;
195  canvas.DrawPath(path_builder.TakePath(), paint);
196  }
197 
198  {
199  // Should not change the image. Tests the Convex short-cut code.
200  PathBuilder path_builder;
201  path_builder.AddCircle({150, 450}, 150);
202  path_builder.SetConvexity(Convexity::kConvex);
203  paint.style = Paint::Style::kFill;
204  canvas.DrawPath(path_builder.TakePath(), paint);
205  }
206 
207  ASSERT_TRUE(aiks_test->OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
208 }
209 } // namespace
210 
211 TEST_P(AiksTest, CanRenderTiledTextureClamp) {
212  CanRenderTiledTexture(this, Entity::TileMode::kClamp);
213 }
214 
215 TEST_P(AiksTest, CanRenderTiledTextureClampAsync) {
216  CanRenderTiledTexture(this, Entity::TileMode::kClamp, /*async_submit=*/true);
217 }
218 
219 TEST_P(AiksTest, CanRenderTiledTextureRepeat) {
220  CanRenderTiledTexture(this, Entity::TileMode::kRepeat);
221 }
222 
223 TEST_P(AiksTest, CanRenderTiledTextureMirror) {
224  CanRenderTiledTexture(this, Entity::TileMode::kMirror);
225 }
226 
227 TEST_P(AiksTest, CanRenderTiledTextureDecal) {
228  CanRenderTiledTexture(this, Entity::TileMode::kDecal);
229 }
230 
231 TEST_P(AiksTest, CanRenderTiledTextureClampWithTranslate) {
232  CanRenderTiledTexture(this, Entity::TileMode::kClamp, /*async_submit=*/false,
233  Matrix::MakeTranslation({172.f, 172.f, 0.f}));
234 }
235 
236 TEST_P(AiksTest, CanRenderImageRect) {
237  Canvas canvas;
238  Paint paint;
239  auto image = std::make_shared<Image>(CreateTextureForFixture("kalimba.jpg"));
240  Size image_half_size = Size(image->GetSize()) * 0.5;
241 
242  // Render the bottom right quarter of the source image in a stretched rect.
243  auto source_rect = Rect::MakeSize(image_half_size);
244  source_rect = source_rect.Shift(Point(image_half_size));
245 
246  canvas.DrawImageRect(image, source_rect, Rect::MakeXYWH(100, 100, 600, 600),
247  paint);
248  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
249 }
250 
251 TEST_P(AiksTest, CanRenderSimpleClips) {
252  Canvas canvas;
253  canvas.Scale(GetContentScale());
254  Paint paint;
255 
256  paint.color = Color::White();
257  canvas.DrawPaint(paint);
258 
259  auto draw = [&canvas](const Paint& paint, Scalar x, Scalar y) {
260  canvas.Save();
261  canvas.Translate({x, y});
262  {
263  canvas.Save();
264  canvas.ClipRect(Rect::MakeLTRB(50, 50, 150, 150));
265  canvas.DrawPaint(paint);
266  canvas.Restore();
267  }
268  {
269  canvas.Save();
270  canvas.ClipOval(Rect::MakeLTRB(200, 50, 300, 150));
271  canvas.DrawPaint(paint);
272  canvas.Restore();
273  }
274  {
275  canvas.Save();
276  canvas.ClipRRect(Rect::MakeLTRB(50, 200, 150, 300), {20, 20});
277  canvas.DrawPaint(paint);
278  canvas.Restore();
279  }
280  {
281  canvas.Save();
282  canvas.ClipRRect(Rect::MakeLTRB(200, 230, 300, 270), {20, 20});
283  canvas.DrawPaint(paint);
284  canvas.Restore();
285  }
286  {
287  canvas.Save();
288  canvas.ClipRRect(Rect::MakeLTRB(230, 200, 270, 300), {20, 20});
289  canvas.DrawPaint(paint);
290  canvas.Restore();
291  }
292  canvas.Restore();
293  };
294 
295  paint.color = Color::Blue();
296  draw(paint, 0, 0);
297 
298  std::vector<Color> gradient_colors = {
299  Color{0x1f / 255.0, 0.0, 0x5c / 255.0, 1.0},
300  Color{0x5b / 255.0, 0.0, 0x60 / 255.0, 1.0},
301  Color{0x87 / 255.0, 0x01 / 255.0, 0x60 / 255.0, 1.0},
302  Color{0xac / 255.0, 0x25 / 255.0, 0x53 / 255.0, 1.0},
303  Color{0xe1 / 255.0, 0x6b / 255.0, 0x5c / 255.0, 1.0},
304  Color{0xf3 / 255.0, 0x90 / 255.0, 0x60 / 255.0, 1.0},
305  Color{0xff / 255.0, 0xb5 / 255.0, 0x6b / 250.0, 1.0}};
306  std::vector<Scalar> stops = {
307  0.0,
308  (1.0 / 6.0) * 1,
309  (1.0 / 6.0) * 2,
310  (1.0 / 6.0) * 3,
311  (1.0 / 6.0) * 4,
312  (1.0 / 6.0) * 5,
313  1.0,
314  };
315  auto texture = CreateTextureForFixture("airplane.jpg",
316  /*enable_mipmapping=*/true);
317 
318  paint.color_source = ColorSource::MakeRadialGradient(
319  {500, 600}, 75, std::move(gradient_colors), std::move(stops),
320  Entity::TileMode::kMirror, {});
321  draw(paint, 0, 300);
322 
323  paint.color_source = ColorSource::MakeImage(
324  texture, Entity::TileMode::kRepeat, Entity::TileMode::kRepeat, {},
325  Matrix::MakeTranslation({0, 0}));
326  draw(paint, 300, 0);
327 
328  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
329 }
330 
331 TEST_P(AiksTest, CanRenderNestedClips) {
332  Canvas canvas;
333  Paint paint;
334  paint.color = Color::Fuchsia();
335  canvas.Save();
336  canvas.ClipPath(PathBuilder{}.AddCircle({200, 400}, 300).TakePath());
337  canvas.Restore();
338  canvas.ClipPath(PathBuilder{}.AddCircle({600, 400}, 300).TakePath());
339  canvas.ClipPath(PathBuilder{}.AddCircle({400, 600}, 300).TakePath());
340  canvas.DrawRect(Rect::MakeXYWH(200, 200, 400, 400), paint);
341  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
342 }
343 
344 TEST_P(AiksTest, CanRenderDifferenceClips) {
345  Paint paint;
346  Canvas canvas;
347  canvas.Translate({400, 400});
348 
349  // Limit drawing to face circle with a clip.
350  canvas.ClipPath(PathBuilder{}.AddCircle(Point(), 200).TakePath());
351  canvas.Save();
352 
353  // Cut away eyes/mouth using difference clips.
354  canvas.ClipPath(PathBuilder{}.AddCircle({-100, -50}, 30).TakePath(),
355  Entity::ClipOperation::kDifference);
356  canvas.ClipPath(PathBuilder{}.AddCircle({100, -50}, 30).TakePath(),
357  Entity::ClipOperation::kDifference);
358  canvas.ClipPath(PathBuilder{}
359  .AddQuadraticCurve({-100, 50}, {0, 150}, {100, 50})
360  .TakePath(),
361  Entity::ClipOperation::kDifference);
362 
363  // Draw a huge yellow rectangle to prove the clipping works.
364  paint.color = Color::Yellow();
365  canvas.DrawRect(Rect::MakeXYWH(-1000, -1000, 2000, 2000), paint);
366 
367  // Remove the difference clips and draw hair that partially covers the eyes.
368  canvas.Restore();
369  paint.color = Color::Maroon();
370  canvas.DrawPath(PathBuilder{}
371  .MoveTo({200, -200})
372  .HorizontalLineTo(-200)
373  .VerticalLineTo(-40)
374  .CubicCurveTo({0, -40}, {0, -80}, {200, -80})
375  .TakePath(),
376  paint);
377 
378  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
379 }
380 
381 TEST_P(AiksTest, CanRenderWithContiguousClipRestores) {
382  Canvas canvas;
383 
384  // Cover the whole canvas with red.
385  canvas.DrawPaint({.color = Color::Red()});
386 
387  canvas.Save();
388 
389  // Append two clips, the second resulting in empty coverage.
390  canvas.ClipPath(
391  PathBuilder{}.AddRect(Rect::MakeXYWH(100, 100, 100, 100)).TakePath());
392  canvas.ClipPath(
393  PathBuilder{}.AddRect(Rect::MakeXYWH(300, 300, 100, 100)).TakePath());
394 
395  // Restore to no clips.
396  canvas.Restore();
397 
398  // Replace the whole canvas with green.
399  canvas.DrawPaint({.color = Color::Green()});
400 
401  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
402 }
403 
404 TEST_P(AiksTest, ClipsUseCurrentTransform) {
405  std::array<Color, 5> colors = {Color::White(), Color::Black(),
406  Color::SkyBlue(), Color::Red(),
407  Color::Yellow()};
408  Canvas canvas;
409  Paint paint;
410 
411  canvas.Translate(Vector3(300, 300));
412  for (int i = 0; i < 15; i++) {
413  canvas.Scale(Vector3(0.8, 0.8));
414 
415  paint.color = colors[i % colors.size()];
416  canvas.ClipPath(PathBuilder{}.AddCircle({0, 0}, 300).TakePath());
417  canvas.DrawRect(Rect::MakeXYWH(-300, -300, 600, 600), paint);
418  }
419  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
420 }
421 
422 TEST_P(AiksTest, CanSaveLayerStandalone) {
423  Canvas canvas;
424 
425  Paint red;
426  red.color = Color::Red();
427 
428  Paint alpha;
429  alpha.color = Color::Red().WithAlpha(0.5);
430 
431  canvas.SaveLayer(alpha);
432 
433  canvas.DrawCircle({125, 125}, 125, red);
434 
435  canvas.Restore();
436 
437  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
438 }
439 
440 TEST_P(AiksTest, CanRenderDifferentShapesWithSameColorSource) {
441  Canvas canvas;
442  Paint paint;
443 
444  std::vector<Color> colors = {Color{0.9568, 0.2627, 0.2118, 1.0},
445  Color{0.1294, 0.5882, 0.9529, 1.0}};
446  std::vector<Scalar> stops = {
447  0.0,
448  1.0,
449  };
450 
451  paint.color_source = ColorSource::MakeLinearGradient(
452  {0, 0}, {100, 100}, std::move(colors), std::move(stops),
453  Entity::TileMode::kRepeat, {});
454 
455  canvas.Save();
456  canvas.Translate({100, 100, 0});
457  canvas.DrawRect(Rect::MakeXYWH(0, 0, 200, 200), paint);
458  canvas.Restore();
459 
460  canvas.Save();
461  canvas.Translate({100, 400, 0});
462  canvas.DrawCircle({100, 100}, 100, paint);
463  canvas.Restore();
464  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
465 }
466 
467 TEST_P(AiksTest, CanPictureConvertToImage) {
468  Canvas recorder_canvas;
469  Paint paint;
470  paint.color = Color{0.9568, 0.2627, 0.2118, 1.0};
471  recorder_canvas.DrawRect(Rect::MakeXYWH(100.0, 100.0, 600, 600), paint);
472  paint.color = Color{0.1294, 0.5882, 0.9529, 1.0};
473  recorder_canvas.DrawRect(Rect::MakeXYWH(200.0, 200.0, 600, 600), paint);
474 
475  Canvas canvas;
476  AiksContext renderer(GetContext(), nullptr);
477  paint.color = Color::BlackTransparent();
478  canvas.DrawPaint(paint);
479  Picture picture = recorder_canvas.EndRecordingAsPicture();
480  auto image = picture.ToImage(renderer, ISize{1000, 1000});
481  if (image) {
482  canvas.DrawImage(image, Point(), Paint());
483  paint.color = Color{0.1, 0.1, 0.1, 0.2};
484  canvas.DrawRect(Rect::MakeSize(ISize{1000, 1000}), paint);
485  }
486 
487  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
488 }
489 
490 TEST_P(AiksTest, BlendModeShouldCoverWholeScreen) {
491  Canvas canvas;
492  Paint paint;
493 
494  paint.color = Color::Red();
495  canvas.DrawPaint(paint);
496 
497  paint.blend_mode = BlendMode::kSourceOver;
498  canvas.SaveLayer(paint);
499 
500  paint.color = Color::White();
501  canvas.DrawRect(Rect::MakeXYWH(100, 100, 400, 400), paint);
502 
503  paint.blend_mode = BlendMode::kSource;
504  canvas.SaveLayer(paint);
505 
506  paint.color = Color::Blue();
507  canvas.DrawRect(Rect::MakeXYWH(200, 200, 200, 200), paint);
508 
509  canvas.Restore();
510  canvas.Restore();
511 
512  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
513 }
514 
515 TEST_P(AiksTest, CanRenderGroupOpacity) {
516  Canvas canvas;
517 
518  Paint red;
519  red.color = Color::Red();
520  Paint green;
521  green.color = Color::Green().WithAlpha(0.5);
522  Paint blue;
523  blue.color = Color::Blue();
524 
525  Paint alpha;
526  alpha.color = Color::Red().WithAlpha(0.5);
527 
528  canvas.SaveLayer(alpha);
529 
530  canvas.DrawRect(Rect::MakeXYWH(000, 000, 100, 100), red);
531  canvas.DrawRect(Rect::MakeXYWH(020, 020, 100, 100), green);
532  canvas.DrawRect(Rect::MakeXYWH(040, 040, 100, 100), blue);
533 
534  canvas.Restore();
535 
536  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
537 }
538 
539 TEST_P(AiksTest, CoordinateConversionsAreCorrect) {
540  Canvas canvas;
541 
542  // Render a texture directly.
543  {
544  Paint paint;
545  auto image =
546  std::make_shared<Image>(CreateTextureForFixture("kalimba.jpg"));
547  paint.color = Color::Red();
548 
549  canvas.Save();
550  canvas.Translate({100, 200, 0});
551  canvas.Scale(Vector2{0.5, 0.5});
552  canvas.DrawImage(image, Point::MakeXY(100.0, 100.0), paint);
553  canvas.Restore();
554  }
555 
556  // Render an offscreen rendered texture.
557  {
558  Paint red;
559  red.color = Color::Red();
560  Paint green;
561  green.color = Color::Green();
562  Paint blue;
563  blue.color = Color::Blue();
564 
565  Paint alpha;
566  alpha.color = Color::Red().WithAlpha(0.5);
567 
568  canvas.SaveLayer(alpha);
569 
570  canvas.DrawRect(Rect::MakeXYWH(000, 000, 100, 100), red);
571  canvas.DrawRect(Rect::MakeXYWH(020, 020, 100, 100), green);
572  canvas.DrawRect(Rect::MakeXYWH(040, 040, 100, 100), blue);
573 
574  canvas.Restore();
575  }
576 
577  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
578 }
579 
580 TEST_P(AiksTest, CanPerformFullScreenMSAA) {
581  Canvas canvas;
582 
583  Paint red;
584  red.color = Color::Red();
585 
586  canvas.DrawCircle({250, 250}, 125, red);
587 
588  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
589 }
590 
591 TEST_P(AiksTest, CanPerformSkew) {
592  Canvas canvas;
593 
594  Paint red;
595  red.color = Color::Red();
596 
597  canvas.Skew(2, 5);
598  canvas.DrawRect(Rect::MakeXYWH(0, 0, 100, 100), red);
599 
600  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
601 }
602 
603 TEST_P(AiksTest, CanPerformSaveLayerWithBounds) {
604  Canvas canvas;
605 
606  Paint red;
607  red.color = Color::Red();
608 
609  Paint green;
610  green.color = Color::Green();
611 
612  Paint blue;
613  blue.color = Color::Blue();
614 
615  Paint save;
616  save.color = Color::Black();
617 
618  canvas.SaveLayer(save, Rect::MakeXYWH(0, 0, 50, 50));
619 
620  canvas.DrawRect(Rect::MakeXYWH(0, 0, 100, 100), red);
621  canvas.DrawRect(Rect::MakeXYWH(10, 10, 100, 100), green);
622  canvas.DrawRect(Rect::MakeXYWH(20, 20, 100, 100), blue);
623 
624  canvas.Restore();
625 
626  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
627 }
628 
629 TEST_P(AiksTest,
630  CanPerformSaveLayerWithBoundsAndLargerIntermediateIsNotAllocated) {
631  Canvas canvas;
632 
633  Paint red;
634  red.color = Color::Red();
635 
636  Paint green;
637  green.color = Color::Green();
638 
639  Paint blue;
640  blue.color = Color::Blue();
641 
642  Paint save;
643  save.color = Color::Black().WithAlpha(0.5);
644 
645  canvas.SaveLayer(save, Rect::MakeXYWH(0, 0, 100000, 100000));
646 
647  canvas.DrawRect(Rect::MakeXYWH(0, 0, 100, 100), red);
648  canvas.DrawRect(Rect::MakeXYWH(10, 10, 100, 100), green);
649  canvas.DrawRect(Rect::MakeXYWH(20, 20, 100, 100), blue);
650 
651  canvas.Restore();
652 
653  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
654 }
655 
656 TEST_P(AiksTest, CanRenderRoundedRectWithNonUniformRadii) {
657  Canvas canvas;
658 
659  Paint paint;
660  paint.color = Color::Red();
661 
662  PathBuilder::RoundingRadii radii;
663  radii.top_left = {50, 25};
664  radii.top_right = {25, 50};
665  radii.bottom_right = {50, 25};
666  radii.bottom_left = {25, 50};
667 
668  auto path = PathBuilder{}
669  .AddRoundedRect(Rect::MakeXYWH(100, 100, 500, 500), radii)
670  .TakePath();
671 
672  canvas.DrawPath(std::move(path), paint);
673 
674  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
675 }
676 
677 struct TextRenderOptions {
678  Scalar font_size = 50;
679  Color color = Color::Yellow();
680  Point position = Vector2(100, 200);
681  std::optional<Paint::MaskBlurDescriptor> mask_blur_descriptor;
682 };
683 
684 bool RenderTextInCanvasSkia(const std::shared_ptr<Context>& context,
685  Canvas& canvas,
686  const std::string& text,
687  const std::string_view& font_fixture,
688  TextRenderOptions options = {}) {
689  // Draw the baseline.
690  canvas.DrawRect(
691  Rect::MakeXYWH(options.position.x - 50, options.position.y, 900, 10),
692  Paint{.color = Color::Aqua().WithAlpha(0.25)});
693 
694  // Mark the point at which the text is drawn.
695  canvas.DrawCircle(options.position, 5.0,
696  Paint{.color = Color::Red().WithAlpha(0.25)});
697 
698  // Construct the text blob.
699  auto c_font_fixture = std::string(font_fixture);
700  auto mapping = flutter::testing::OpenFixtureAsSkData(c_font_fixture.c_str());
701  if (!mapping) {
702  return false;
703  }
704  sk_sp<SkFontMgr> font_mgr = txt::GetDefaultFontManager();
705  SkFont sk_font(font_mgr->makeFromData(mapping), options.font_size);
706  auto blob = SkTextBlob::MakeFromString(text.c_str(), sk_font);
707  if (!blob) {
708  return false;
709  }
710 
711  // Create the Impeller text frame and draw it at the designated baseline.
712  auto frame = MakeTextFrameFromTextBlobSkia(blob);
713 
714  Paint text_paint;
715  text_paint.color = options.color;
716  text_paint.mask_blur_descriptor = options.mask_blur_descriptor;
717  canvas.DrawTextFrame(frame, options.position, text_paint);
718  return true;
719 }
720 
721 bool RenderTextInCanvasSTB(const std::shared_ptr<Context>& context,
722  Canvas& canvas,
723  const std::string& text,
724  const std::string& font_fixture,
725  TextRenderOptions options = {}) {
726  // Draw the baseline.
727  canvas.DrawRect(
728  Rect::MakeXYWH(options.position.x - 50, options.position.y, 900, 10),
729  Paint{.color = Color::Aqua().WithAlpha(0.25)});
730 
731  // Mark the point at which the text is drawn.
732  canvas.DrawCircle(options.position, 5.0,
733  Paint{.color = Color::Red().WithAlpha(0.25)});
734 
735  // Construct the text blob.
736  auto mapping = flutter::testing::OpenFixtureAsMapping(font_fixture.c_str());
737  if (!mapping) {
738  return false;
739  }
740  auto typeface_stb = std::make_shared<TypefaceSTB>(std::move(mapping));
741 
742  auto frame = MakeTextFrameSTB(
743  typeface_stb, Font::Metrics{.point_size = options.font_size}, text);
744 
745  Paint text_paint;
746  text_paint.color = options.color;
747  canvas.DrawTextFrame(frame, options.position, text_paint);
748  return true;
749 }
750 
751 TEST_P(AiksTest, CanRenderTextFrame) {
752  Canvas canvas;
753  canvas.DrawPaint({.color = Color(0.1, 0.1, 0.1, 1.0)});
754  ASSERT_TRUE(RenderTextInCanvasSkia(
755  GetContext(), canvas, "the quick brown fox jumped over the lazy dog!.?",
756  "Roboto-Regular.ttf"));
757  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
758 }
759 
760 TEST_P(AiksTest, CanRenderTextFrameSTB) {
761  Canvas canvas;
762  canvas.DrawPaint({.color = Color(0.1, 0.1, 0.1, 1.0)});
763  ASSERT_TRUE(RenderTextInCanvasSTB(
764  GetContext(), canvas, "the quick brown fox jumped over the lazy dog!.?",
765  "Roboto-Regular.ttf"));
766 
767  SetTypographerContext(TypographerContextSTB::Make());
768  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
769 }
770 
771 TEST_P(AiksTest, TextFrameSubpixelAlignment) {
772  std::array<Scalar, 20> phase_offsets;
773  for (Scalar& offset : phase_offsets) {
774  auto rand = std::rand(); // NOLINT
775  offset = (static_cast<float>(rand) / static_cast<float>(RAND_MAX)) * k2Pi;
776  }
777 
778  auto callback = [&](AiksContext& renderer) -> std::optional<Picture> {
779  static float font_size = 20;
780  static float phase_variation = 0.2;
781  static float speed = 0.5;
782  static float magnitude = 100;
783  ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
784  ImGui::SliderFloat("Font size", &font_size, 5, 50);
785  ImGui::SliderFloat("Phase variation", &phase_variation, 0, 1);
786  ImGui::SliderFloat("Oscillation speed", &speed, 0, 2);
787  ImGui::SliderFloat("Oscillation magnitude", &magnitude, 0, 300);
788  ImGui::End();
789 
790  Canvas canvas;
791  canvas.Scale(GetContentScale());
792 
793  for (size_t i = 0; i < phase_offsets.size(); i++) {
794  auto position = Point(
795  200 + magnitude * std::sin((-phase_offsets[i] * phase_variation +
796  GetSecondsElapsed() * speed)), //
797  200 + i * font_size * 1.1 //
798  );
799  if (!RenderTextInCanvasSkia(
800  GetContext(), canvas,
801  "the quick brown fox jumped over "
802  "the lazy dog!.?",
803  "Roboto-Regular.ttf",
804  {.font_size = font_size, .position = position})) {
805  return std::nullopt;
806  }
807  }
808  return canvas.EndRecordingAsPicture();
809  };
810 
811  ASSERT_TRUE(OpenPlaygroundHere(callback));
812 }
813 
814 TEST_P(AiksTest, CanRenderItalicizedText) {
815  Canvas canvas;
816  canvas.DrawPaint({.color = Color(0.1, 0.1, 0.1, 1.0)});
817 
818  ASSERT_TRUE(RenderTextInCanvasSkia(
819  GetContext(), canvas, "the quick brown fox jumped over the lazy dog!.?",
820  "HomemadeApple.ttf"));
821  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
822 }
823 
824 static constexpr std::string_view kFontFixture =
825 #if FML_OS_MACOSX
826  "Apple Color Emoji.ttc";
827 #else
828  "NotoColorEmoji.ttf";
829 #endif
830 
831 TEST_P(AiksTest, CanRenderEmojiTextFrame) {
832  Canvas canvas;
833  canvas.DrawPaint({.color = Color(0.1, 0.1, 0.1, 1.0)});
834 
835  ASSERT_TRUE(RenderTextInCanvasSkia(
836  GetContext(), canvas, "😀 😃 😄 😁 😆 😅 😂 🤣 🥲 😊", kFontFixture));
837  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
838 }
839 
840 TEST_P(AiksTest, CanRenderEmojiTextFrameWithBlur) {
841  Canvas canvas;
842  canvas.DrawPaint({.color = Color(0.1, 0.1, 0.1, 1.0)});
843 
844  ASSERT_TRUE(RenderTextInCanvasSkia(
845  GetContext(), canvas, "😀 😃 😄 😁 😆 😅 😂 🤣 🥲 😊", kFontFixture,
846  TextRenderOptions{.color = Color::Blue(),
847  .mask_blur_descriptor = Paint::MaskBlurDescriptor{
848  .style = FilterContents::BlurStyle::kNormal,
849  .sigma = Sigma(4)}}));
850  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
851 }
852 
853 TEST_P(AiksTest, CanRenderEmojiTextFrameWithAlpha) {
854  Canvas canvas;
855  canvas.DrawPaint({.color = Color(0.1, 0.1, 0.1, 1.0)});
856 
857  ASSERT_TRUE(RenderTextInCanvasSkia(
858  GetContext(), canvas, "😀 😃 😄 😁 😆 😅 😂 🤣 🥲 😊", kFontFixture,
859  {.color = Color::Black().WithAlpha(0.5)}));
860  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
861 }
862 
863 TEST_P(AiksTest, CanRenderTextInSaveLayer) {
864  Canvas canvas;
865  canvas.DrawPaint({.color = Color(0.1, 0.1, 0.1, 1.0)});
866 
867  canvas.Translate({100, 100});
868  canvas.Scale(Vector2{0.5, 0.5});
869 
870  // Blend the layer with the parent pass using kClear to expose the coverage.
871  canvas.SaveLayer({.blend_mode = BlendMode::kClear});
872  ASSERT_TRUE(RenderTextInCanvasSkia(
873  GetContext(), canvas, "the quick brown fox jumped over the lazy dog!.?",
874  "Roboto-Regular.ttf"));
875  canvas.Restore();
876 
877  // Render the text again over the cleared coverage rect.
878  ASSERT_TRUE(RenderTextInCanvasSkia(
879  GetContext(), canvas, "the quick brown fox jumped over the lazy dog!.?",
880  "Roboto-Regular.ttf"));
881 
882  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
883 }
884 
885 TEST_P(AiksTest, CanRenderTextOutsideBoundaries) {
886  Canvas canvas;
887  canvas.Translate({200, 150});
888 
889  // Construct the text blob.
890  auto mapping = flutter::testing::OpenFixtureAsSkData("wtf.otf");
891  ASSERT_NE(mapping, nullptr);
892 
893  Scalar font_size = 80;
894  sk_sp<SkFontMgr> font_mgr = txt::GetDefaultFontManager();
895  SkFont sk_font(font_mgr->makeFromData(mapping), font_size);
896 
897  Paint text_paint;
898  text_paint.color = Color::Blue().WithAlpha(0.8);
899 
900  struct {
901  Point position;
902  const char* text;
903  } text[] = {{Point(0, 0), "0F0F0F0"},
904  {Point(1, 2), "789"},
905  {Point(1, 3), "456"},
906  {Point(1, 4), "123"},
907  {Point(0, 6), "0F0F0F0"}};
908  for (auto& t : text) {
909  canvas.Save();
910  canvas.Translate(t.position * Point(font_size * 2, font_size * 1.1));
911  {
912  auto blob = SkTextBlob::MakeFromString(t.text, sk_font);
913  ASSERT_NE(blob, nullptr);
914  auto frame = MakeTextFrameFromTextBlobSkia(blob);
915  canvas.DrawTextFrame(frame, Point(), text_paint);
916  }
917  canvas.Restore();
918  }
919 
920  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
921 }
922 
923 TEST_P(AiksTest, TextRotated) {
924  Canvas canvas;
925  canvas.Scale(GetContentScale());
926  canvas.DrawPaint({.color = Color(0.1, 0.1, 0.1, 1.0)});
927 
928  canvas.Transform(Matrix(0.25, -0.3, 0, -0.002, //
929  0, 0.5, 0, 0, //
930  0, 0, 0.3, 0, //
931  100, 100, 0, 1.3));
932  ASSERT_TRUE(RenderTextInCanvasSkia(
933  GetContext(), canvas, "the quick brown fox jumped over the lazy dog!.?",
934  "Roboto-Regular.ttf"));
935 
936  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
937 }
938 
939 TEST_P(AiksTest, CanDrawPaint) {
940  Canvas canvas;
941  canvas.Scale(Vector2(0.2, 0.2));
942  canvas.DrawPaint({.color = Color::MediumTurquoise()});
943  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
944 }
945 
946 TEST_P(AiksTest, CanDrawPaintMultipleTimes) {
947  Canvas canvas;
948  canvas.Scale(Vector2(0.2, 0.2));
949  canvas.DrawPaint({.color = Color::MediumTurquoise()});
950  canvas.DrawPaint({.color = Color::Color::OrangeRed().WithAlpha(0.5)});
951  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
952 }
953 
954 TEST_P(AiksTest, CanDrawPaintWithAdvancedBlend) {
955  Canvas canvas;
956  canvas.Scale(Vector2(0.2, 0.2));
957  canvas.DrawPaint({.color = Color::MediumTurquoise()});
958  canvas.DrawPaint({.color = Color::Color::OrangeRed().WithAlpha(0.5),
959  .blend_mode = BlendMode::kHue});
960  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
961 }
962 
963 TEST_P(AiksTest, DrawPaintWithAdvancedBlendOverFilter) {
964  Paint filtered = {
965  .color = Color::Black(),
966  .mask_blur_descriptor =
967  Paint::MaskBlurDescriptor{
968  .style = FilterContents::BlurStyle::kNormal,
969  .sigma = Sigma(60),
970  },
971  };
972 
973  Canvas canvas;
974  canvas.DrawPaint({.color = Color::White()});
975  canvas.DrawCircle({300, 300}, 200, filtered);
976  canvas.DrawPaint({.color = Color::Green(), .blend_mode = BlendMode::kScreen});
977  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
978 }
979 
980 TEST_P(AiksTest, DrawAdvancedBlendPartlyOffscreen) {
981  std::vector<Color> colors = {Color{0.9568, 0.2627, 0.2118, 1.0},
982  Color{0.1294, 0.5882, 0.9529, 1.0}};
983  std::vector<Scalar> stops = {0.0, 1.0};
984 
985  Paint paint = {
986  .color_source = ColorSource::MakeLinearGradient(
987  {0, 0}, {100, 100}, std::move(colors), std::move(stops),
988  Entity::TileMode::kRepeat, Matrix::MakeScale(Vector3(0.3, 0.3, 0.3))),
989  .blend_mode = BlendMode::kLighten,
990  };
991 
992  Canvas canvas;
993  canvas.DrawPaint({.color = Color::Blue()});
994  canvas.Scale(Vector2(2, 2));
995  canvas.ClipRect(Rect::MakeLTRB(0, 0, 200, 200));
996  canvas.DrawCircle({100, 100}, 100, paint);
997  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
998 }
999 
1000 #define BLEND_MODE_TUPLE(blend_mode) {#blend_mode, BlendMode::k##blend_mode},
1001 
1002 struct BlendModeSelection {
1003  std::vector<const char*> blend_mode_names;
1004  std::vector<BlendMode> blend_mode_values;
1005 };
1006 
1007 static BlendModeSelection GetBlendModeSelection() {
1008  std::vector<const char*> blend_mode_names;
1009  std::vector<BlendMode> blend_mode_values;
1010  {
1011  const std::vector<std::tuple<const char*, BlendMode>> blends = {
1012  IMPELLER_FOR_EACH_BLEND_MODE(BLEND_MODE_TUPLE)};
1013  assert(blends.size() ==
1014  static_cast<size_t>(Entity::kLastAdvancedBlendMode) + 1);
1015  for (const auto& [name, mode] : blends) {
1016  blend_mode_names.push_back(name);
1017  blend_mode_values.push_back(mode);
1018  }
1019  }
1020 
1021  return {blend_mode_names, blend_mode_values};
1022 }
1023 
1024 TEST_P(AiksTest, CanDrawPaintMultipleTimesInteractive) {
1025  auto modes = GetBlendModeSelection();
1026 
1027  auto callback = [&](AiksContext& renderer) -> std::optional<Picture> {
1028  static Color background = Color::MediumTurquoise();
1029  static Color foreground = Color::Color::OrangeRed().WithAlpha(0.5);
1030  static int current_blend_index = 3;
1031 
1032  ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
1033  {
1034  ImGui::ColorEdit4("Background", reinterpret_cast<float*>(&background));
1035  ImGui::ColorEdit4("Foreground", reinterpret_cast<float*>(&foreground));
1036  ImGui::ListBox("Blend mode", &current_blend_index,
1037  modes.blend_mode_names.data(),
1038  modes.blend_mode_names.size());
1039  }
1040  ImGui::End();
1041 
1042  Canvas canvas;
1043  canvas.Scale(Vector2(0.2, 0.2));
1044  canvas.DrawPaint({.color = background});
1045  canvas.DrawPaint(
1046  {.color = foreground,
1047  .blend_mode = static_cast<BlendMode>(current_blend_index)});
1048  return canvas.EndRecordingAsPicture();
1049  };
1050  ASSERT_TRUE(OpenPlaygroundHere(callback));
1051 }
1052 
1053 TEST_P(AiksTest, PaintBlendModeIsRespected) {
1054  Paint paint;
1055  Canvas canvas;
1056  // Default is kSourceOver.
1057  paint.color = Color(1, 0, 0, 0.5);
1058  canvas.DrawCircle(Point(150, 200), 100, paint);
1059  paint.color = Color(0, 1, 0, 0.5);
1060  canvas.DrawCircle(Point(250, 200), 100, paint);
1061 
1062  paint.blend_mode = BlendMode::kPlus;
1063  paint.color = Color::Red();
1064  canvas.DrawCircle(Point(450, 250), 100, paint);
1065  paint.color = Color::Green();
1066  canvas.DrawCircle(Point(550, 250), 100, paint);
1067  paint.color = Color::Blue();
1068  canvas.DrawCircle(Point(500, 150), 100, paint);
1069  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
1070 }
1071 
1072 TEST_P(AiksTest, ColorWheel) {
1073  // Compare with https://fiddle.skia.org/c/@BlendModes
1074 
1075  BlendModeSelection blend_modes = GetBlendModeSelection();
1076 
1077  auto draw_color_wheel = [](Canvas& canvas) {
1078  /// color_wheel_sampler: r=0 -> fuchsia, r=2pi/3 -> yellow, r=4pi/3 ->
1079  /// cyan domain: r >= 0 (because modulo used is non euclidean)
1080  auto color_wheel_sampler = [](Radians r) {
1081  Scalar x = r.radians / k2Pi + 1;
1082 
1083  // https://www.desmos.com/calculator/6nhjelyoaj
1084  auto color_cycle = [](Scalar x) {
1085  Scalar cycle = std::fmod(x, 6.0f);
1086  return std::max(0.0f, std::min(1.0f, 2 - std::abs(2 - cycle)));
1087  };
1088  return Color(color_cycle(6 * x + 1), //
1089  color_cycle(6 * x - 1), //
1090  color_cycle(6 * x - 3), //
1091  1);
1092  };
1093 
1094  Paint paint;
1095  paint.blend_mode = BlendMode::kSourceOver;
1096 
1097  // Draw a fancy color wheel for the backdrop.
1098  // https://www.desmos.com/calculator/xw7kafthwd
1099  const int max_dist = 900;
1100  for (int i = 0; i <= 900; i++) {
1101  Radians r(kPhi / k2Pi * i);
1102  Scalar distance = r.radians / std::powf(4.12, 0.0026 * r.radians);
1103  Scalar normalized_distance = static_cast<Scalar>(i) / max_dist;
1104 
1105  paint.color =
1106  color_wheel_sampler(r).WithAlpha(1.0f - normalized_distance);
1107  Point position(distance * std::sin(r.radians),
1108  -distance * std::cos(r.radians));
1109 
1110  canvas.DrawCircle(position, 9 + normalized_distance * 3, paint);
1111  }
1112  };
1113 
1114  std::shared_ptr<Image> color_wheel_image;
1115  Matrix color_wheel_transform;
1116 
1117  auto callback = [&](AiksContext& renderer) -> std::optional<Picture> {
1118  // UI state.
1119  static bool cache_the_wheel = true;
1120  static int current_blend_index = 3;
1121  static float dst_alpha = 1;
1122  static float src_alpha = 1;
1123  static Color color0 = Color::Red();
1124  static Color color1 = Color::Green();
1125  static Color color2 = Color::Blue();
1126 
1127  ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
1128  {
1129  ImGui::Checkbox("Cache the wheel", &cache_the_wheel);
1130  ImGui::ListBox("Blending mode", &current_blend_index,
1131  blend_modes.blend_mode_names.data(),
1132  blend_modes.blend_mode_names.size());
1133  ImGui::SliderFloat("Source alpha", &src_alpha, 0, 1);
1134  ImGui::ColorEdit4("Color A", reinterpret_cast<float*>(&color0));
1135  ImGui::ColorEdit4("Color B", reinterpret_cast<float*>(&color1));
1136  ImGui::ColorEdit4("Color C", reinterpret_cast<float*>(&color2));
1137  ImGui::SliderFloat("Destination alpha", &dst_alpha, 0, 1);
1138  }
1139  ImGui::End();
1140 
1141  static Point content_scale;
1142  Point new_content_scale = GetContentScale();
1143 
1144  if (!cache_the_wheel || new_content_scale != content_scale) {
1145  content_scale = new_content_scale;
1146 
1147  // Render the color wheel to an image.
1148 
1149  Canvas canvas;
1150  canvas.Scale(content_scale);
1151 
1152  canvas.Translate(Vector2(500, 400));
1153  canvas.Scale(Vector2(3, 3));
1154 
1155  draw_color_wheel(canvas);
1156  auto color_wheel_picture = canvas.EndRecordingAsPicture();
1157  auto snapshot = color_wheel_picture.Snapshot(renderer);
1158  if (!snapshot.has_value() || !snapshot->texture) {
1159  return std::nullopt;
1160  }
1161  color_wheel_image = std::make_shared<Image>(snapshot->texture);
1162  color_wheel_transform = snapshot->transform;
1163  }
1164 
1165  Canvas canvas;
1166 
1167  // Blit the color wheel backdrop to the screen with managed alpha.
1168  canvas.SaveLayer({.color = Color::White().WithAlpha(dst_alpha),
1169  .blend_mode = BlendMode::kSource});
1170  {
1171  canvas.DrawPaint({.color = Color::White()});
1172 
1173  canvas.Save();
1174  canvas.Transform(color_wheel_transform);
1175  canvas.DrawImage(color_wheel_image, Point(), Paint());
1176  canvas.Restore();
1177  }
1178  canvas.Restore();
1179 
1180  canvas.Scale(content_scale);
1181  canvas.Translate(Vector2(500, 400));
1182  canvas.Scale(Vector2(3, 3));
1183 
1184  // Draw 3 circles to a subpass and blend it in.
1185  canvas.SaveLayer(
1186  {.color = Color::White().WithAlpha(src_alpha),
1187  .blend_mode = blend_modes.blend_mode_values[current_blend_index]});
1188  {
1189  Paint paint;
1190  paint.blend_mode = BlendMode::kPlus;
1191  const Scalar x = std::sin(k2Pi / 3);
1192  const Scalar y = -std::cos(k2Pi / 3);
1193  paint.color = color0;
1194  canvas.DrawCircle(Point(-x, y) * 45, 65, paint);
1195  paint.color = color1;
1196  canvas.DrawCircle(Point(0, -1) * 45, 65, paint);
1197  paint.color = color2;
1198  canvas.DrawCircle(Point(x, y) * 45, 65, paint);
1199  }
1200  canvas.Restore();
1201 
1202  return canvas.EndRecordingAsPicture();
1203  };
1204 
1205  ASSERT_TRUE(OpenPlaygroundHere(callback));
1206 }
1207 
1208 TEST_P(AiksTest, TransformMultipliesCorrectly) {
1209  Canvas canvas;
1210  ASSERT_MATRIX_NEAR(canvas.GetCurrentTransform(), Matrix());
1211 
1212  // clang-format off
1213  canvas.Translate(Vector3(100, 200));
1214  ASSERT_MATRIX_NEAR(
1215  canvas.GetCurrentTransform(),
1216  Matrix( 1, 0, 0, 0,
1217  0, 1, 0, 0,
1218  0, 0, 1, 0,
1219  100, 200, 0, 1));
1220 
1221  canvas.Rotate(Radians(kPiOver2));
1222  ASSERT_MATRIX_NEAR(
1223  canvas.GetCurrentTransform(),
1224  Matrix( 0, 1, 0, 0,
1225  -1, 0, 0, 0,
1226  0, 0, 1, 0,
1227  100, 200, 0, 1));
1228 
1229  canvas.Scale(Vector3(2, 3));
1230  ASSERT_MATRIX_NEAR(
1231  canvas.GetCurrentTransform(),
1232  Matrix( 0, 2, 0, 0,
1233  -3, 0, 0, 0,
1234  0, 0, 0, 0,
1235  100, 200, 0, 1));
1236 
1237  canvas.Translate(Vector3(100, 200));
1238  ASSERT_MATRIX_NEAR(
1239  canvas.GetCurrentTransform(),
1240  Matrix( 0, 2, 0, 0,
1241  -3, 0, 0, 0,
1242  0, 0, 0, 0,
1243  -500, 400, 0, 1));
1244  // clang-format on
1245 }
1246 
1247 TEST_P(AiksTest, FilledCirclesRenderCorrectly) {
1248  Canvas canvas;
1249  canvas.Scale(GetContentScale());
1250  Paint paint;
1251  const int color_count = 3;
1252  Color colors[color_count] = {
1253  Color::Blue(),
1254  Color::Green(),
1255  Color::Crimson(),
1256  };
1257 
1258  paint.color = Color::White();
1259  canvas.DrawPaint(paint);
1260 
1261  int c_index = 0;
1262  int radius = 600;
1263  while (radius > 0) {
1264  paint.color = colors[(c_index++) % color_count];
1265  canvas.DrawCircle({10, 10}, radius, paint);
1266  if (radius > 30) {
1267  radius -= 10;
1268  } else {
1269  radius -= 2;
1270  }
1271  }
1272 
1273  std::vector<Color> gradient_colors = {
1274  Color{0x1f / 255.0, 0.0, 0x5c / 255.0, 1.0},
1275  Color{0x5b / 255.0, 0.0, 0x60 / 255.0, 1.0},
1276  Color{0x87 / 255.0, 0x01 / 255.0, 0x60 / 255.0, 1.0},
1277  Color{0xac / 255.0, 0x25 / 255.0, 0x53 / 255.0, 1.0},
1278  Color{0xe1 / 255.0, 0x6b / 255.0, 0x5c / 255.0, 1.0},
1279  Color{0xf3 / 255.0, 0x90 / 255.0, 0x60 / 255.0, 1.0},
1280  Color{0xff / 255.0, 0xb5 / 255.0, 0x6b / 250.0, 1.0}};
1281  std::vector<Scalar> stops = {
1282  0.0,
1283  (1.0 / 6.0) * 1,
1284  (1.0 / 6.0) * 2,
1285  (1.0 / 6.0) * 3,
1286  (1.0 / 6.0) * 4,
1287  (1.0 / 6.0) * 5,
1288  1.0,
1289  };
1290  auto texture = CreateTextureForFixture("airplane.jpg",
1291  /*enable_mipmapping=*/true);
1292 
1293  paint.color_source = ColorSource::MakeRadialGradient(
1294  {500, 600}, 75, std::move(gradient_colors), std::move(stops),
1295  Entity::TileMode::kMirror, {});
1296  canvas.DrawCircle({500, 600}, 100, paint);
1297 
1298  paint.color_source = ColorSource::MakeImage(
1299  texture, Entity::TileMode::kRepeat, Entity::TileMode::kRepeat, {},
1300  Matrix::MakeTranslation({700, 200}));
1301  canvas.DrawCircle({800, 300}, 100, paint);
1302 
1303  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
1304 }
1305 
1306 TEST_P(AiksTest, StrokedCirclesRenderCorrectly) {
1307  Canvas canvas;
1308  canvas.Scale(GetContentScale());
1309  Paint paint;
1310  const int color_count = 3;
1311  Color colors[color_count] = {
1312  Color::Blue(),
1313  Color::Green(),
1314  Color::Crimson(),
1315  };
1316 
1317  paint.color = Color::White();
1318  canvas.DrawPaint(paint);
1319 
1320  int c_index = 0;
1321 
1322  auto draw = [&paint, &colors, &c_index](Canvas& canvas, Point center,
1323  Scalar r, Scalar dr, int n) {
1324  for (int i = 0; i < n; i++) {
1325  paint.color = colors[(c_index++) % color_count];
1326  canvas.DrawCircle(center, r, paint);
1327  r += dr;
1328  }
1329  };
1330 
1331  paint.style = Paint::Style::kStroke;
1332  paint.stroke_width = 1;
1333  draw(canvas, {10, 10}, 2, 2, 14); // r = [2, 28], covers [1,29]
1334  paint.stroke_width = 5;
1335  draw(canvas, {10, 10}, 35, 10, 56); // r = [35, 585], covers [30,590]
1336 
1337  std::vector<Color> gradient_colors = {
1338  Color{0x1f / 255.0, 0.0, 0x5c / 255.0, 1.0},
1339  Color{0x5b / 255.0, 0.0, 0x60 / 255.0, 1.0},
1340  Color{0x87 / 255.0, 0x01 / 255.0, 0x60 / 255.0, 1.0},
1341  Color{0xac / 255.0, 0x25 / 255.0, 0x53 / 255.0, 1.0},
1342  Color{0xe1 / 255.0, 0x6b / 255.0, 0x5c / 255.0, 1.0},
1343  Color{0xf3 / 255.0, 0x90 / 255.0, 0x60 / 255.0, 1.0},
1344  Color{0xff / 255.0, 0xb5 / 255.0, 0x6b / 250.0, 1.0}};
1345  std::vector<Scalar> stops = {
1346  0.0,
1347  (1.0 / 6.0) * 1,
1348  (1.0 / 6.0) * 2,
1349  (1.0 / 6.0) * 3,
1350  (1.0 / 6.0) * 4,
1351  (1.0 / 6.0) * 5,
1352  1.0,
1353  };
1354  auto texture = CreateTextureForFixture("airplane.jpg",
1355  /*enable_mipmapping=*/true);
1356 
1357  paint.color_source = ColorSource::MakeRadialGradient(
1358  {500, 600}, 75, std::move(gradient_colors), std::move(stops),
1359  Entity::TileMode::kMirror, {});
1360  draw(canvas, {500, 600}, 5, 10, 10);
1361 
1362  paint.color_source = ColorSource::MakeImage(
1363  texture, Entity::TileMode::kRepeat, Entity::TileMode::kRepeat, {},
1364  Matrix::MakeTranslation({700, 200}));
1365  draw(canvas, {800, 300}, 5, 10, 10);
1366 
1367  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
1368 }
1369 
1370 TEST_P(AiksTest, FilledEllipsesRenderCorrectly) {
1371  Canvas canvas;
1372  canvas.Scale(GetContentScale());
1373  Paint paint;
1374  const int color_count = 3;
1375  Color colors[color_count] = {
1376  Color::Blue(),
1377  Color::Green(),
1378  Color::Crimson(),
1379  };
1380 
1381  paint.color = Color::White();
1382  canvas.DrawPaint(paint);
1383 
1384  int c_index = 0;
1385  int long_radius = 600;
1386  int short_radius = 600;
1387  while (long_radius > 0 && short_radius > 0) {
1388  paint.color = colors[(c_index++) % color_count];
1389  canvas.DrawOval(Rect::MakeXYWH(10 - long_radius, 10 - short_radius,
1390  long_radius * 2, short_radius * 2),
1391  paint);
1392  canvas.DrawOval(Rect::MakeXYWH(1000 - short_radius, 750 - long_radius,
1393  short_radius * 2, long_radius * 2),
1394  paint);
1395  if (short_radius > 30) {
1396  short_radius -= 10;
1397  long_radius -= 5;
1398  } else {
1399  short_radius -= 2;
1400  long_radius -= 1;
1401  }
1402  }
1403 
1404  std::vector<Color> gradient_colors = {
1405  Color{0x1f / 255.0, 0.0, 0x5c / 255.0, 1.0},
1406  Color{0x5b / 255.0, 0.0, 0x60 / 255.0, 1.0},
1407  Color{0x87 / 255.0, 0x01 / 255.0, 0x60 / 255.0, 1.0},
1408  Color{0xac / 255.0, 0x25 / 255.0, 0x53 / 255.0, 1.0},
1409  Color{0xe1 / 255.0, 0x6b / 255.0, 0x5c / 255.0, 1.0},
1410  Color{0xf3 / 255.0, 0x90 / 255.0, 0x60 / 255.0, 1.0},
1411  Color{0xff / 255.0, 0xb5 / 255.0, 0x6b / 250.0, 1.0}};
1412  std::vector<Scalar> stops = {
1413  0.0,
1414  (1.0 / 6.0) * 1,
1415  (1.0 / 6.0) * 2,
1416  (1.0 / 6.0) * 3,
1417  (1.0 / 6.0) * 4,
1418  (1.0 / 6.0) * 5,
1419  1.0,
1420  };
1421  auto texture = CreateTextureForFixture("airplane.jpg",
1422  /*enable_mipmapping=*/true);
1423 
1424  paint.color = Color::White().WithAlpha(0.5);
1425 
1426  paint.color_source = ColorSource::MakeRadialGradient(
1427  {300, 650}, 75, std::move(gradient_colors), std::move(stops),
1428  Entity::TileMode::kMirror, {});
1429  canvas.DrawOval(Rect::MakeXYWH(200, 625, 200, 50), paint);
1430  canvas.DrawOval(Rect::MakeXYWH(275, 550, 50, 200), paint);
1431 
1432  paint.color_source = ColorSource::MakeImage(
1433  texture, Entity::TileMode::kRepeat, Entity::TileMode::kRepeat, {},
1434  Matrix::MakeTranslation({610, 15}));
1435  canvas.DrawOval(Rect::MakeXYWH(610, 90, 200, 50), paint);
1436  canvas.DrawOval(Rect::MakeXYWH(685, 15, 50, 200), paint);
1437 
1438  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
1439 }
1440 
1441 TEST_P(AiksTest, FilledRoundRectsRenderCorrectly) {
1442  Canvas canvas;
1443  canvas.Scale(GetContentScale());
1444  Paint paint;
1445  const int color_count = 3;
1446  Color colors[color_count] = {
1447  Color::Blue(),
1448  Color::Green(),
1449  Color::Crimson(),
1450  };
1451 
1452  paint.color = Color::White();
1453  canvas.DrawPaint(paint);
1454 
1455  int c_index = 0;
1456  for (int i = 0; i < 4; i++) {
1457  for (int j = 0; j < 4; j++) {
1458  paint.color = colors[(c_index++) % color_count];
1459  canvas.DrawRRect(Rect::MakeXYWH(i * 100 + 10, j * 100 + 20, 80, 80),
1460  Size(i * 5 + 10, j * 5 + 10), paint);
1461  }
1462  }
1463  paint.color = colors[(c_index++) % color_count];
1464  canvas.DrawRRect(Rect::MakeXYWH(10, 420, 380, 80), Size(40, 40), paint);
1465  paint.color = colors[(c_index++) % color_count];
1466  canvas.DrawRRect(Rect::MakeXYWH(410, 20, 80, 380), Size(40, 40), paint);
1467 
1468  std::vector<Color> gradient_colors = {
1469  Color{0x1f / 255.0, 0.0, 0x5c / 255.0, 1.0},
1470  Color{0x5b / 255.0, 0.0, 0x60 / 255.0, 1.0},
1471  Color{0x87 / 255.0, 0x01 / 255.0, 0x60 / 255.0, 1.0},
1472  Color{0xac / 255.0, 0x25 / 255.0, 0x53 / 255.0, 1.0},
1473  Color{0xe1 / 255.0, 0x6b / 255.0, 0x5c / 255.0, 1.0},
1474  Color{0xf3 / 255.0, 0x90 / 255.0, 0x60 / 255.0, 1.0},
1475  Color{0xff / 255.0, 0xb5 / 255.0, 0x6b / 250.0, 1.0}};
1476  std::vector<Scalar> stops = {
1477  0.0,
1478  (1.0 / 6.0) * 1,
1479  (1.0 / 6.0) * 2,
1480  (1.0 / 6.0) * 3,
1481  (1.0 / 6.0) * 4,
1482  (1.0 / 6.0) * 5,
1483  1.0,
1484  };
1485  auto texture = CreateTextureForFixture("airplane.jpg",
1486  /*enable_mipmapping=*/true);
1487 
1488  paint.color = Color::White().WithAlpha(0.1);
1489  paint.color_source = ColorSource::MakeRadialGradient(
1490  {550, 550}, 75, gradient_colors, stops, Entity::TileMode::kMirror, {});
1491  for (int i = 1; i <= 10; i++) {
1492  int j = 11 - i;
1493  canvas.DrawRRect(Rect::MakeLTRB(550 - i * 20, 550 - j * 20, //
1494  550 + i * 20, 550 + j * 20),
1495  Size(i * 10, j * 10), paint);
1496  }
1497  paint.color = Color::White().WithAlpha(0.5);
1498  paint.color_source = ColorSource::MakeRadialGradient(
1499  {200, 650}, 75, std::move(gradient_colors), std::move(stops),
1500  Entity::TileMode::kMirror, {});
1501  canvas.DrawRRect(Rect::MakeLTRB(100, 610, 300, 690), Size(40, 40), paint);
1502  canvas.DrawRRect(Rect::MakeLTRB(160, 550, 240, 750), Size(40, 40), paint);
1503 
1504  paint.color = Color::White().WithAlpha(0.1);
1505  paint.color_source = ColorSource::MakeImage(
1506  texture, Entity::TileMode::kRepeat, Entity::TileMode::kRepeat, {},
1507  Matrix::MakeTranslation({520, 20}));
1508  for (int i = 1; i <= 10; i++) {
1509  int j = 11 - i;
1510  canvas.DrawRRect(Rect::MakeLTRB(720 - i * 20, 220 - j * 20, //
1511  720 + i * 20, 220 + j * 20),
1512  Size(i * 10, j * 10), paint);
1513  }
1514  paint.color = Color::White().WithAlpha(0.5);
1515  paint.color_source = ColorSource::MakeImage(
1516  texture, Entity::TileMode::kRepeat, Entity::TileMode::kRepeat, {},
1517  Matrix::MakeTranslation({800, 300}));
1518  canvas.DrawRRect(Rect::MakeLTRB(800, 410, 1000, 490), Size(40, 40), paint);
1519  canvas.DrawRRect(Rect::MakeLTRB(860, 350, 940, 550), Size(40, 40), paint);
1520 
1521  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
1522 }
1523 
1524 TEST_P(AiksTest, SolidColorCirclesOvalsRRectsMaskBlurCorrectly) {
1525  Canvas canvas;
1526  canvas.Scale(GetContentScale());
1527  Paint paint;
1528  paint.mask_blur_descriptor = Paint::MaskBlurDescriptor{
1529  .style = FilterContents::BlurStyle::kNormal,
1530  .sigma = Sigma{1},
1531  };
1532 
1533  canvas.DrawPaint({.color = Color::White()});
1534 
1535  paint.color = Color::Crimson();
1536  Scalar y = 100.0f;
1537  for (int i = 0; i < 5; i++) {
1538  Scalar x = (i + 1) * 100;
1539  Scalar radius = x / 10.0f;
1540  canvas.DrawRect(Rect::MakeXYWH(x + 25 - radius / 2, y + radius / 2, //
1541  radius, 60.0f - radius),
1542  paint);
1543  }
1544 
1545  paint.color = Color::Blue();
1546  y += 100.0f;
1547  for (int i = 0; i < 5; i++) {
1548  Scalar x = (i + 1) * 100;
1549  Scalar radius = x / 10.0f;
1550  canvas.DrawCircle({x + 25, y + 25}, radius, paint);
1551  }
1552 
1553  paint.color = Color::Green();
1554  y += 100.0f;
1555  for (int i = 0; i < 5; i++) {
1556  Scalar x = (i + 1) * 100;
1557  Scalar radius = x / 10.0f;
1558  canvas.DrawOval(Rect::MakeXYWH(x + 25 - radius / 2, y + radius / 2, //
1559  radius, 60.0f - radius),
1560  paint);
1561  }
1562 
1563  paint.color = Color::Purple();
1564  y += 100.0f;
1565  for (int i = 0; i < 5; i++) {
1566  Scalar x = (i + 1) * 100;
1567  Scalar radius = x / 20.0f;
1568  canvas.DrawRRect(Rect::MakeXYWH(x, y, 60.0f, 60.0f), //
1569  {radius, radius}, //
1570  paint);
1571  }
1572 
1573  paint.color = Color::Orange();
1574  y += 100.0f;
1575  for (int i = 0; i < 5; i++) {
1576  Scalar x = (i + 1) * 100;
1577  Scalar radius = x / 20.0f;
1578  canvas.DrawRRect(Rect::MakeXYWH(x, y, 60.0f, 60.0f), //
1579  {radius, 5.0f}, paint);
1580  }
1581 
1582  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
1583 }
1584 
1585 TEST_P(AiksTest, FilledRoundRectPathsRenderCorrectly) {
1586  Canvas canvas;
1587  canvas.Scale(GetContentScale());
1588  Paint paint;
1589  const int color_count = 3;
1590  Color colors[color_count] = {
1591  Color::Blue(),
1592  Color::Green(),
1593  Color::Crimson(),
1594  };
1595 
1596  paint.color = Color::White();
1597  canvas.DrawPaint(paint);
1598 
1599  auto draw_rrect_as_path = [&canvas](const Rect& rect, const Size& radii,
1600  const Paint& paint) {
1601  PathBuilder builder = PathBuilder();
1602  builder.AddRoundedRect(rect, radii);
1603  canvas.DrawPath(builder.TakePath(), paint);
1604  };
1605 
1606  int c_index = 0;
1607  for (int i = 0; i < 4; i++) {
1608  for (int j = 0; j < 4; j++) {
1609  paint.color = colors[(c_index++) % color_count];
1610  draw_rrect_as_path(Rect::MakeXYWH(i * 100 + 10, j * 100 + 20, 80, 80),
1611  Size(i * 5 + 10, j * 5 + 10), paint);
1612  }
1613  }
1614  paint.color = colors[(c_index++) % color_count];
1615  draw_rrect_as_path(Rect::MakeXYWH(10, 420, 380, 80), Size(40, 40), paint);
1616  paint.color = colors[(c_index++) % color_count];
1617  draw_rrect_as_path(Rect::MakeXYWH(410, 20, 80, 380), Size(40, 40), paint);
1618 
1619  std::vector<Color> gradient_colors = {
1620  Color{0x1f / 255.0, 0.0, 0x5c / 255.0, 1.0},
1621  Color{0x5b / 255.0, 0.0, 0x60 / 255.0, 1.0},
1622  Color{0x87 / 255.0, 0x01 / 255.0, 0x60 / 255.0, 1.0},
1623  Color{0xac / 255.0, 0x25 / 255.0, 0x53 / 255.0, 1.0},
1624  Color{0xe1 / 255.0, 0x6b / 255.0, 0x5c / 255.0, 1.0},
1625  Color{0xf3 / 255.0, 0x90 / 255.0, 0x60 / 255.0, 1.0},
1626  Color{0xff / 255.0, 0xb5 / 255.0, 0x6b / 250.0, 1.0}};
1627  std::vector<Scalar> stops = {
1628  0.0,
1629  (1.0 / 6.0) * 1,
1630  (1.0 / 6.0) * 2,
1631  (1.0 / 6.0) * 3,
1632  (1.0 / 6.0) * 4,
1633  (1.0 / 6.0) * 5,
1634  1.0,
1635  };
1636  auto texture = CreateTextureForFixture("airplane.jpg",
1637  /*enable_mipmapping=*/true);
1638 
1639  paint.color = Color::White().WithAlpha(0.1);
1640  paint.color_source = ColorSource::MakeRadialGradient(
1641  {550, 550}, 75, gradient_colors, stops, Entity::TileMode::kMirror, {});
1642  for (int i = 1; i <= 10; i++) {
1643  int j = 11 - i;
1644  draw_rrect_as_path(Rect::MakeLTRB(550 - i * 20, 550 - j * 20, //
1645  550 + i * 20, 550 + j * 20),
1646  Size(i * 10, j * 10), paint);
1647  }
1648  paint.color = Color::White().WithAlpha(0.5);
1649  paint.color_source = ColorSource::MakeRadialGradient(
1650  {200, 650}, 75, std::move(gradient_colors), std::move(stops),
1651  Entity::TileMode::kMirror, {});
1652  draw_rrect_as_path(Rect::MakeLTRB(100, 610, 300, 690), Size(40, 40), paint);
1653  draw_rrect_as_path(Rect::MakeLTRB(160, 550, 240, 750), Size(40, 40), paint);
1654 
1655  paint.color = Color::White().WithAlpha(0.1);
1656  paint.color_source = ColorSource::MakeImage(
1657  texture, Entity::TileMode::kRepeat, Entity::TileMode::kRepeat, {},
1658  Matrix::MakeTranslation({520, 20}));
1659  for (int i = 1; i <= 10; i++) {
1660  int j = 11 - i;
1661  draw_rrect_as_path(Rect::MakeLTRB(720 - i * 20, 220 - j * 20, //
1662  720 + i * 20, 220 + j * 20),
1663  Size(i * 10, j * 10), paint);
1664  }
1665  paint.color = Color::White().WithAlpha(0.5);
1666  paint.color_source = ColorSource::MakeImage(
1667  texture, Entity::TileMode::kRepeat, Entity::TileMode::kRepeat, {},
1668  Matrix::MakeTranslation({800, 300}));
1669  draw_rrect_as_path(Rect::MakeLTRB(800, 410, 1000, 490), Size(40, 40), paint);
1670  draw_rrect_as_path(Rect::MakeLTRB(860, 350, 940, 550), Size(40, 40), paint);
1671 
1672  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
1673 }
1674 
1675 TEST_P(AiksTest, CoverageOriginShouldBeAccountedForInSubpasses) {
1676  auto callback = [&](AiksContext& renderer) -> std::optional<Picture> {
1677  Canvas canvas;
1678  canvas.Scale(GetContentScale());
1679 
1680  Paint alpha;
1681  alpha.color = Color::Red().WithAlpha(0.5);
1682 
1683  auto current = Point{25, 25};
1684  const auto offset = Point{25, 25};
1685  const auto size = Size(100, 100);
1686 
1687  auto [b0, b1] = IMPELLER_PLAYGROUND_LINE(Point(40, 40), Point(160, 160), 10,
1688  Color::White(), Color::White());
1689  auto bounds = Rect::MakeLTRB(b0.x, b0.y, b1.x, b1.y);
1690 
1691  canvas.DrawRect(bounds, Paint{.color = Color::Yellow(),
1692  .stroke_width = 5.0f,
1693  .style = Paint::Style::kStroke});
1694 
1695  canvas.SaveLayer(alpha, bounds);
1696 
1697  canvas.DrawRect(Rect::MakeOriginSize(current, size),
1698  Paint{.color = Color::Red()});
1699  canvas.DrawRect(Rect::MakeOriginSize(current += offset, size),
1700  Paint{.color = Color::Green()});
1701  canvas.DrawRect(Rect::MakeOriginSize(current += offset, size),
1702  Paint{.color = Color::Blue()});
1703 
1704  canvas.Restore();
1705 
1706  return canvas.EndRecordingAsPicture();
1707  };
1708 
1709  ASSERT_TRUE(OpenPlaygroundHere(callback));
1710 }
1711 
1712 TEST_P(AiksTest, SaveLayerDrawsBehindSubsequentEntities) {
1713  // Compare with https://fiddle.skia.org/c/9e03de8567ffb49e7e83f53b64bcf636
1714  Canvas canvas;
1715  Paint paint;
1716 
1717  paint.color = Color::Black();
1718  Rect rect = Rect::MakeXYWH(25, 25, 25, 25);
1719  canvas.DrawRect(rect, paint);
1720 
1721  canvas.Translate({10, 10});
1722  canvas.SaveLayer({});
1723 
1724  paint.color = Color::Green();
1725  canvas.DrawRect(rect, paint);
1726 
1727  canvas.Restore();
1728 
1729  canvas.Translate({10, 10});
1730  paint.color = Color::Red();
1731  canvas.DrawRect(rect, paint);
1732 
1733  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
1734 }
1735 
1736 TEST_P(AiksTest, SiblingSaveLayerBoundsAreRespected) {
1737  Canvas canvas;
1738  Paint paint;
1739  Rect rect = Rect::MakeXYWH(0, 0, 1000, 1000);
1740 
1741  // Black, green, and red squares offset by [10, 10].
1742  {
1743  canvas.SaveLayer({}, Rect::MakeXYWH(25, 25, 25, 25));
1744  paint.color = Color::Black();
1745  canvas.DrawRect(rect, paint);
1746  canvas.Restore();
1747  }
1748 
1749  {
1750  canvas.SaveLayer({}, Rect::MakeXYWH(35, 35, 25, 25));
1751  paint.color = Color::Green();
1752  canvas.DrawRect(rect, paint);
1753  canvas.Restore();
1754  }
1755 
1756  {
1757  canvas.SaveLayer({}, Rect::MakeXYWH(45, 45, 25, 25));
1758  paint.color = Color::Red();
1759  canvas.DrawRect(rect, paint);
1760  canvas.Restore();
1761  }
1762 
1763  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
1764 }
1765 
1766 TEST_P(AiksTest, CanRenderClippedLayers) {
1767  Canvas canvas;
1768 
1769  canvas.DrawPaint({.color = Color::White()});
1770 
1771  // Draw a green circle on the screen.
1772  {
1773  // Increase the clip depth for the savelayer to contend with.
1774  canvas.ClipPath(PathBuilder{}.AddCircle({100, 100}, 50).TakePath());
1775 
1776  canvas.SaveLayer({}, Rect::MakeXYWH(50, 50, 100, 100));
1777 
1778  // Fill the layer with white.
1779  canvas.DrawRect(Rect::MakeSize(Size{400, 400}), {.color = Color::White()});
1780  // Fill the layer with green, but do so with a color blend that can't be
1781  // collapsed into the parent pass.
1782  // TODO(jonahwilliams): this blend mode was changed from color burn to
1783  // hardlight to work around https://github.com/flutter/flutter/issues/136554
1784  // .
1785  canvas.DrawRect(
1786  Rect::MakeSize(Size{400, 400}),
1787  {.color = Color::Green(), .blend_mode = BlendMode::kHardLight});
1788  }
1789 
1790  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
1791 }
1792 
1793 TEST_P(AiksTest, SaveLayerFiltersScaleWithTransform) {
1794  Canvas canvas;
1795  canvas.Scale(GetContentScale());
1796  canvas.Translate(Vector2(100, 100));
1797 
1798  auto texture = std::make_shared<Image>(CreateTextureForFixture("boston.jpg"));
1799  auto draw_image_layer = [&canvas, &texture](const Paint& paint) {
1800  canvas.SaveLayer(paint);
1801  canvas.DrawImage(texture, {}, Paint{});
1802  canvas.Restore();
1803  };
1804 
1805  Paint effect_paint;
1806  effect_paint.mask_blur_descriptor = Paint::MaskBlurDescriptor{
1807  .style = FilterContents::BlurStyle::kNormal,
1808  .sigma = Sigma{6},
1809  };
1810  draw_image_layer(effect_paint);
1811 
1812  canvas.Translate(Vector2(300, 300));
1813  canvas.Scale(Vector2(3, 3));
1814  draw_image_layer(effect_paint);
1815 
1816  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
1817 }
1818 
1819 #if IMPELLER_ENABLE_3D
1820 TEST_P(AiksTest, SceneColorSource) {
1821  // Load up the scene.
1822  auto mapping =
1823  flutter::testing::OpenFixtureAsMapping("flutter_logo_baked.glb.ipscene");
1824  ASSERT_NE(mapping, nullptr);
1825 
1826  std::shared_ptr<scene::Node> gltf_scene = scene::Node::MakeFromFlatbuffer(
1827  *mapping, *GetContext()->GetResourceAllocator());
1828  ASSERT_NE(gltf_scene, nullptr);
1829 
1830  auto callback = [&](AiksContext& renderer) -> std::optional<Picture> {
1831  Paint paint;
1832 
1833  ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
1834  static Scalar distance = 2;
1835  ImGui::SliderFloat("Distance", &distance, 0, 4);
1836  static Scalar y_pos = 0;
1837  ImGui::SliderFloat("Y", &y_pos, -3, 3);
1838  static Scalar fov = 45;
1839  ImGui::SliderFloat("FOV", &fov, 1, 180);
1840  ImGui::End();
1841 
1842  Scalar angle = GetSecondsElapsed();
1843  auto camera_position =
1844  Vector3(distance * std::sin(angle), y_pos, -distance * std::cos(angle));
1845 
1846  paint.color_source = ColorSource::MakeScene(
1847  gltf_scene,
1848  Matrix::MakePerspective(Degrees(fov), GetWindowSize(), 0.1, 1000) *
1849  Matrix::MakeLookAt(camera_position, {0, 0, 0}, {0, 1, 0}));
1850 
1851  Canvas canvas;
1852  canvas.DrawPaint(Paint{.color = Color::MakeRGBA8(0xf9, 0xf9, 0xf9, 0xff)});
1853  canvas.Scale(GetContentScale());
1854  canvas.DrawPaint(paint);
1855  return canvas.EndRecordingAsPicture();
1856  };
1857 
1858  ASSERT_TRUE(OpenPlaygroundHere(callback));
1859 }
1860 #endif // IMPELLER_ENABLE_3D
1861 
1862 TEST_P(AiksTest, PaintWithFilters) {
1863  // validate that a paint with a color filter "HasFilters", no other filters
1864  // impact this setting.
1865  Paint paint;
1866 
1867  ASSERT_FALSE(paint.HasColorFilter());
1868 
1869  paint.color_filter =
1870  ColorFilter::MakeBlend(BlendMode::kSourceOver, Color::Blue());
1871 
1872  ASSERT_TRUE(paint.HasColorFilter());
1873 
1874  paint.image_filter = ImageFilter::MakeBlur(Sigma(1.0), Sigma(1.0),
1875  FilterContents::BlurStyle::kNormal,
1876  Entity::TileMode::kClamp);
1877 
1878  ASSERT_TRUE(paint.HasColorFilter());
1879 
1880  paint.mask_blur_descriptor = {};
1881 
1882  ASSERT_TRUE(paint.HasColorFilter());
1883 
1884  paint.color_filter = nullptr;
1885 
1886  ASSERT_FALSE(paint.HasColorFilter());
1887 }
1888 
1889 TEST_P(AiksTest, OpacityPeepHoleApplicationTest) {
1890  auto entity_pass = std::make_shared<EntityPass>();
1891  auto rect = Rect::MakeLTRB(0, 0, 100, 100);
1892  Paint paint;
1893  paint.color = Color::White().WithAlpha(0.5);
1894  paint.color_filter =
1895  ColorFilter::MakeBlend(BlendMode::kSourceOver, Color::Blue());
1896 
1897  // Paint has color filter, can't elide.
1898  auto delegate = std::make_shared<OpacityPeepholePassDelegate>(paint);
1899  ASSERT_FALSE(delegate->CanCollapseIntoParentPass(entity_pass.get()));
1900 
1901  paint.color_filter = nullptr;
1902  paint.image_filter = ImageFilter::MakeBlur(Sigma(1.0), Sigma(1.0),
1903  FilterContents::BlurStyle::kNormal,
1904  Entity::TileMode::kClamp);
1905 
1906  // Paint has image filter, can't elide.
1907  delegate = std::make_shared<OpacityPeepholePassDelegate>(paint);
1908  ASSERT_FALSE(delegate->CanCollapseIntoParentPass(entity_pass.get()));
1909 
1910  paint.image_filter = nullptr;
1911  paint.color = Color::Red();
1912 
1913  // Paint has no alpha, can't elide;
1914  delegate = std::make_shared<OpacityPeepholePassDelegate>(paint);
1915  ASSERT_FALSE(delegate->CanCollapseIntoParentPass(entity_pass.get()));
1916 
1917  // Positive test.
1918  Entity entity;
1919  entity.SetContents(SolidColorContents::Make(
1920  PathBuilder{}.AddRect(rect).TakePath(), Color::Red()));
1921  entity_pass->AddEntity(std::move(entity));
1922  paint.color = Color::Red().WithAlpha(0.5);
1923 
1924  delegate = std::make_shared<OpacityPeepholePassDelegate>(paint);
1925  ASSERT_TRUE(delegate->CanCollapseIntoParentPass(entity_pass.get()));
1926 }
1927 
1928 TEST_P(AiksTest, DrawPaintAbsorbsClears) {
1929  Canvas canvas;
1930  canvas.DrawPaint({.color = Color::Red(), .blend_mode = BlendMode::kSource});
1931  canvas.DrawPaint({.color = Color::CornflowerBlue().WithAlpha(0.75),
1932  .blend_mode = BlendMode::kSourceOver});
1933 
1934  Picture picture = canvas.EndRecordingAsPicture();
1935  auto expected = Color::Red().Blend(Color::CornflowerBlue().WithAlpha(0.75),
1936  BlendMode::kSourceOver);
1937  ASSERT_EQ(picture.pass->GetClearColor(), expected);
1938 
1939  std::shared_ptr<ContextSpy> spy = ContextSpy::Make();
1940  std::shared_ptr<Context> real_context = GetContext();
1941  std::shared_ptr<ContextMock> mock_context = spy->MakeContext(real_context);
1942  AiksContext renderer(mock_context, nullptr);
1943  std::shared_ptr<Image> image = picture.ToImage(renderer, {300, 300});
1944 
1945  ASSERT_EQ(spy->render_passes_.size(), 1llu);
1946  std::shared_ptr<RenderPass> render_pass = spy->render_passes_[0];
1947  ASSERT_EQ(render_pass->GetCommands().size(), 0llu);
1948 }
1949 
1950 // This is important to enforce with texture reuse, since cached textures need
1951 // to be cleared before reuse.
1952 TEST_P(AiksTest,
1953  ParentSaveLayerCreatesRenderPassWhenChildBackdropFilterIsPresent) {
1954  Canvas canvas;
1955  canvas.SaveLayer({}, std::nullopt, ImageFilter::MakeMatrix(Matrix(), {}));
1956  canvas.DrawPaint({.color = Color::Red(), .blend_mode = BlendMode::kSource});
1957  canvas.DrawPaint({.color = Color::CornflowerBlue().WithAlpha(0.75),
1958  .blend_mode = BlendMode::kSourceOver});
1959  canvas.Restore();
1960 
1961  Picture picture = canvas.EndRecordingAsPicture();
1962 
1963  std::shared_ptr<ContextSpy> spy = ContextSpy::Make();
1964  std::shared_ptr<Context> real_context = GetContext();
1965  std::shared_ptr<ContextMock> mock_context = spy->MakeContext(real_context);
1966  AiksContext renderer(mock_context, nullptr);
1967  std::shared_ptr<Image> image = picture.ToImage(renderer, {300, 300});
1968 
1969  ASSERT_EQ(spy->render_passes_.size(), 3llu);
1970  std::shared_ptr<RenderPass> render_pass = spy->render_passes_[0];
1971  ASSERT_EQ(render_pass->GetCommands().size(), 0llu);
1972 }
1973 
1974 TEST_P(AiksTest, DrawRectAbsorbsClears) {
1975  Canvas canvas;
1976  canvas.DrawRect(Rect::MakeXYWH(0, 0, 300, 300),
1977  {.color = Color::Red(), .blend_mode = BlendMode::kSource});
1978  canvas.DrawRect(Rect::MakeXYWH(0, 0, 300, 300),
1979  {.color = Color::CornflowerBlue().WithAlpha(0.75),
1980  .blend_mode = BlendMode::kSourceOver});
1981 
1982  std::shared_ptr<ContextSpy> spy = ContextSpy::Make();
1983  Picture picture = canvas.EndRecordingAsPicture();
1984  std::shared_ptr<Context> real_context = GetContext();
1985  std::shared_ptr<ContextMock> mock_context = spy->MakeContext(real_context);
1986  AiksContext renderer(mock_context, nullptr);
1987  std::shared_ptr<Image> image = picture.ToImage(renderer, {300, 300});
1988 
1989  ASSERT_EQ(spy->render_passes_.size(), 1llu);
1990  std::shared_ptr<RenderPass> render_pass = spy->render_passes_[0];
1991  ASSERT_EQ(render_pass->GetCommands().size(), 0llu);
1992 }
1993 
1994 TEST_P(AiksTest, DrawRectAbsorbsClearsNegativeRRect) {
1995  Canvas canvas;
1996  canvas.DrawRRect(Rect::MakeXYWH(0, 0, 300, 300), {5.0, 5.0},
1997  {.color = Color::Red(), .blend_mode = BlendMode::kSource});
1998  canvas.DrawRRect(Rect::MakeXYWH(0, 0, 300, 300), {5.0, 5.0},
1999  {.color = Color::CornflowerBlue().WithAlpha(0.75),
2000  .blend_mode = BlendMode::kSourceOver});
2001 
2002  std::shared_ptr<ContextSpy> spy = ContextSpy::Make();
2003  Picture picture = canvas.EndRecordingAsPicture();
2004  std::shared_ptr<Context> real_context = GetContext();
2005  std::shared_ptr<ContextMock> mock_context = spy->MakeContext(real_context);
2006  AiksContext renderer(mock_context, nullptr);
2007  std::shared_ptr<Image> image = picture.ToImage(renderer, {300, 300});
2008 
2009  ASSERT_EQ(spy->render_passes_.size(), 1llu);
2010  std::shared_ptr<RenderPass> render_pass = spy->render_passes_[0];
2011  ASSERT_EQ(render_pass->GetCommands().size(), 2llu);
2012 }
2013 
2014 TEST_P(AiksTest, DrawRectAbsorbsClearsNegativeRotation) {
2015  Canvas canvas;
2016  canvas.Translate(Vector3(150.0, 150.0, 0.0));
2017  canvas.Rotate(Degrees(45.0));
2018  canvas.Translate(Vector3(-150.0, -150.0, 0.0));
2019  canvas.DrawRect(Rect::MakeXYWH(0, 0, 300, 300),
2020  {.color = Color::Red(), .blend_mode = BlendMode::kSource});
2021 
2022  std::shared_ptr<ContextSpy> spy = ContextSpy::Make();
2023  Picture picture = canvas.EndRecordingAsPicture();
2024  std::shared_ptr<Context> real_context = GetContext();
2025  std::shared_ptr<ContextMock> mock_context = spy->MakeContext(real_context);
2026  AiksContext renderer(mock_context, nullptr);
2027  std::shared_ptr<Image> image = picture.ToImage(renderer, {300, 300});
2028 
2029  ASSERT_EQ(spy->render_passes_.size(), 1llu);
2030  std::shared_ptr<RenderPass> render_pass = spy->render_passes_[0];
2031  ASSERT_EQ(render_pass->GetCommands().size(), 1llu);
2032 }
2033 
2034 TEST_P(AiksTest, DrawRectAbsorbsClearsNegative) {
2035  Canvas canvas;
2036  canvas.DrawRect(Rect::MakeXYWH(0, 0, 300, 300),
2037  {.color = Color::Red(), .blend_mode = BlendMode::kSource});
2038  canvas.DrawRect(Rect::MakeXYWH(0, 0, 300, 300),
2039  {.color = Color::CornflowerBlue().WithAlpha(0.75),
2040  .blend_mode = BlendMode::kSourceOver});
2041 
2042  std::shared_ptr<ContextSpy> spy = ContextSpy::Make();
2043  Picture picture = canvas.EndRecordingAsPicture();
2044  std::shared_ptr<Context> real_context = GetContext();
2045  std::shared_ptr<ContextMock> mock_context = spy->MakeContext(real_context);
2046  AiksContext renderer(mock_context, nullptr);
2047  std::shared_ptr<Image> image = picture.ToImage(renderer, {301, 301});
2048 
2049  ASSERT_EQ(spy->render_passes_.size(), 1llu);
2050  std::shared_ptr<RenderPass> render_pass = spy->render_passes_[0];
2051  ASSERT_EQ(render_pass->GetCommands().size(), 2llu);
2052 }
2053 
2054 TEST_P(AiksTest, ClipRectElidesNoOpClips) {
2055  Canvas canvas(Rect::MakeXYWH(0, 0, 100, 100));
2056  canvas.ClipRect(Rect::MakeXYWH(0, 0, 100, 100));
2057  canvas.ClipRect(Rect::MakeXYWH(-100, -100, 300, 300));
2058  canvas.DrawPaint({.color = Color::Red(), .blend_mode = BlendMode::kSource});
2059  canvas.DrawPaint({.color = Color::CornflowerBlue().WithAlpha(0.75),
2060  .blend_mode = BlendMode::kSourceOver});
2061 
2062  Picture picture = canvas.EndRecordingAsPicture();
2063  auto expected = Color::Red().Blend(Color::CornflowerBlue().WithAlpha(0.75),
2064  BlendMode::kSourceOver);
2065  ASSERT_EQ(picture.pass->GetClearColor(), expected);
2066 
2067  std::shared_ptr<ContextSpy> spy = ContextSpy::Make();
2068  std::shared_ptr<Context> real_context = GetContext();
2069  std::shared_ptr<ContextMock> mock_context = spy->MakeContext(real_context);
2070  AiksContext renderer(mock_context, nullptr);
2071  std::shared_ptr<Image> image = picture.ToImage(renderer, {300, 300});
2072 
2073  ASSERT_EQ(spy->render_passes_.size(), 1llu);
2074  std::shared_ptr<RenderPass> render_pass = spy->render_passes_[0];
2075  ASSERT_EQ(render_pass->GetCommands().size(), 0llu);
2076 }
2077 
2078 TEST_P(AiksTest, ClearColorOptimizationDoesNotApplyForBackdropFilters) {
2079  Canvas canvas;
2080  canvas.SaveLayer({}, std::nullopt,
2081  ImageFilter::MakeBlur(Sigma(3), Sigma(3),
2082  FilterContents::BlurStyle::kNormal,
2083  Entity::TileMode::kClamp));
2084  canvas.DrawPaint({.color = Color::Red(), .blend_mode = BlendMode::kSource});
2085  canvas.DrawPaint({.color = Color::CornflowerBlue().WithAlpha(0.75),
2086  .blend_mode = BlendMode::kSourceOver});
2087  canvas.Restore();
2088 
2089  Picture picture = canvas.EndRecordingAsPicture();
2090 
2091  std::optional<Color> actual_color;
2092  bool found_subpass = false;
2093  picture.pass->IterateAllElements([&](EntityPass::Element& element) -> bool {
2094  if (auto subpass = std::get_if<std::unique_ptr<EntityPass>>(&element)) {
2095  actual_color = subpass->get()->GetClearColor();
2096  found_subpass = true;
2097  }
2098  // Fail if the first element isn't a subpass.
2099  return true;
2100  });
2101 
2102  EXPECT_TRUE(found_subpass);
2103  EXPECT_FALSE(actual_color.has_value());
2104 }
2105 
2106 TEST_P(AiksTest, CollapsedDrawPaintInSubpass) {
2107  Canvas canvas;
2108  canvas.DrawPaint(
2109  {.color = Color::Yellow(), .blend_mode = BlendMode::kSource});
2110  canvas.SaveLayer({.blend_mode = BlendMode::kMultiply});
2111  canvas.DrawPaint({.color = Color::CornflowerBlue().WithAlpha(0.75),
2112  .blend_mode = BlendMode::kSourceOver});
2113 
2114  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2115 }
2116 
2117 TEST_P(AiksTest, CollapsedDrawPaintInSubpassBackdropFilter) {
2118  // Bug: https://github.com/flutter/flutter/issues/131576
2119  Canvas canvas;
2120  canvas.DrawPaint(
2121  {.color = Color::Yellow(), .blend_mode = BlendMode::kSource});
2122  canvas.SaveLayer({}, {},
2123  ImageFilter::MakeBlur(Sigma(20.0), Sigma(20.0),
2124  FilterContents::BlurStyle::kNormal,
2125  Entity::TileMode::kDecal));
2126  canvas.DrawPaint(
2127  {.color = Color::CornflowerBlue(), .blend_mode = BlendMode::kSourceOver});
2128 
2129  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2130 }
2131 
2132 TEST_P(AiksTest, ForegroundBlendSubpassCollapseOptimization) {
2133  Canvas canvas;
2134 
2135  canvas.SaveLayer({
2136  .color_filter =
2137  ColorFilter::MakeBlend(BlendMode::kColorDodge, Color::Red()),
2138  });
2139 
2140  canvas.Translate({500, 300, 0});
2141  canvas.Rotate(Radians(2 * kPi / 3));
2142  canvas.DrawRect(Rect::MakeXYWH(100, 100, 200, 200), {.color = Color::Blue()});
2143 
2144  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2145 }
2146 
2147 TEST_P(AiksTest, ColorMatrixFilterSubpassCollapseOptimization) {
2148  Canvas canvas;
2149 
2150  canvas.SaveLayer({
2151  .color_filter =
2152  ColorFilter::MakeMatrix({.array =
2153  {
2154  -1.0, 0, 0, 1.0, 0, //
2155  0, -1.0, 0, 1.0, 0, //
2156  0, 0, -1.0, 1.0, 0, //
2157  1.0, 1.0, 1.0, 1.0, 0 //
2158  }}),
2159  });
2160 
2161  canvas.Translate({500, 300, 0});
2162  canvas.Rotate(Radians(2 * kPi / 3));
2163  canvas.DrawRect(Rect::MakeXYWH(100, 100, 200, 200), {.color = Color::Blue()});
2164 
2165  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2166 }
2167 
2168 TEST_P(AiksTest, LinearToSrgbFilterSubpassCollapseOptimization) {
2169  Canvas canvas;
2170 
2171  canvas.SaveLayer({
2172  .color_filter = ColorFilter::MakeLinearToSrgb(),
2173  });
2174 
2175  canvas.Translate({500, 300, 0});
2176  canvas.Rotate(Radians(2 * kPi / 3));
2177  canvas.DrawRect(Rect::MakeXYWH(100, 100, 200, 200), {.color = Color::Blue()});
2178 
2179  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2180 }
2181 
2182 TEST_P(AiksTest, SrgbToLinearFilterSubpassCollapseOptimization) {
2183  Canvas canvas;
2184 
2185  canvas.SaveLayer({
2186  .color_filter = ColorFilter::MakeSrgbToLinear(),
2187  });
2188 
2189  canvas.Translate({500, 300, 0});
2190  canvas.Rotate(Radians(2 * kPi / 3));
2191  canvas.DrawRect(Rect::MakeXYWH(100, 100, 200, 200), {.color = Color::Blue()});
2192 
2193  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2194 }
2195 
2196 static Picture BlendModeTest(BlendMode blend_mode,
2197  const std::shared_ptr<Image>& src_image,
2198  const std::shared_ptr<Image>& dst_image) {
2199  Color destination_color = Color::CornflowerBlue().WithAlpha(0.75);
2200  auto source_colors = std::vector<Color>({Color::White().WithAlpha(0.75),
2201  Color::LimeGreen().WithAlpha(0.75),
2202  Color::Black().WithAlpha(0.75)});
2203 
2204  Canvas canvas;
2205 
2206  canvas.DrawPaint({.color = Color::Black()});
2207 
2208  //----------------------------------------------------------------------------
2209  /// 1. Save layer blending (top squares).
2210  ///
2211 
2212  canvas.Save();
2213  for (const auto& color : source_colors) {
2214  canvas.Save();
2215  {
2216  canvas.ClipRect(Rect::MakeXYWH(50, 50, 100, 100));
2217  // Perform the blend in a SaveLayer so that the initial backdrop color is
2218  // fully transparent black. SourceOver blend the result onto the parent
2219  // pass.
2220  canvas.SaveLayer({});
2221  {
2222  canvas.DrawPaint({.color = destination_color});
2223  // Draw the source color in an offscreen pass and blend it to the parent
2224  // pass.
2225  canvas.SaveLayer({.blend_mode = blend_mode});
2226  { //
2227  canvas.DrawRect(Rect::MakeXYWH(50, 50, 100, 100), {.color = color});
2228  }
2229  canvas.Restore();
2230  }
2231  canvas.Restore();
2232  }
2233  canvas.Restore();
2234  canvas.Translate(Vector2(100, 0));
2235  }
2236  canvas.RestoreToCount(0);
2237 
2238  //----------------------------------------------------------------------------
2239  /// 2. CPU blend modes (bottom squares).
2240  ///
2241 
2242  canvas.Save();
2243  canvas.Translate({0, 100});
2244 
2245  // Perform the blend in a SaveLayer so that the initial backdrop color is
2246  // fully transparent black. SourceOver blend the result onto the parent pass.
2247  canvas.SaveLayer({});
2248  // canvas.DrawPaint({.color = destination_color});
2249  for (const auto& color : source_colors) {
2250  // Simply write the CPU blended color to the pass.
2251  canvas.DrawRect(Rect::MakeXYWH(50, 50, 100, 100),
2252  {.color = destination_color.Blend(color, blend_mode),
2253  .blend_mode = BlendMode::kSourceOver});
2254  canvas.Translate(Vector2(100, 0));
2255  }
2256  canvas.RestoreToCount(0);
2257 
2258  //----------------------------------------------------------------------------
2259  /// 3. Image blending (top right).
2260  ///
2261  /// Compare these results with the images in the Flutter blend mode
2262  /// documentation: https://api.flutter.dev/flutter/dart-ui/BlendMode.html
2263  ///
2264 
2265  canvas.Save();
2266  // canvas.ClipRect(Rect::MakeXYWH(500, 0, 500, 500));
2267  canvas.SaveLayer({.blend_mode = BlendMode::kSourceOver});
2268  {
2269  canvas.DrawImage(dst_image, {400, 50}, {.blend_mode = BlendMode::kSource});
2270  canvas.DrawImage(src_image, {400, 50}, {.blend_mode = blend_mode});
2271  }
2272  canvas.RestoreToCount(0);
2273 
2274  return canvas.EndRecordingAsPicture();
2275 }
2276 
2277 #define BLEND_MODE_TEST(blend_mode) \
2278  TEST_P(AiksTest, BlendMode##blend_mode) { \
2279  auto src_image = std::make_shared<Image>( \
2280  CreateTextureForFixture("blend_mode_src.png")); \
2281  auto dst_image = std::make_shared<Image>( \
2282  CreateTextureForFixture("blend_mode_dst.png")); \
2283  OpenPlaygroundHere( \
2284  BlendModeTest(BlendMode::k##blend_mode, src_image, dst_image)); \
2285  }
2286 IMPELLER_FOR_EACH_BLEND_MODE(BLEND_MODE_TEST)
2287 
2288 TEST_P(AiksTest, TranslucentSaveLayerDrawsCorrectly) {
2289  Canvas canvas;
2290 
2291  canvas.DrawRect(Rect::MakeXYWH(100, 100, 300, 300), {.color = Color::Blue()});
2292 
2293  canvas.SaveLayer({.color = Color::Black().WithAlpha(0.5)});
2294  canvas.DrawRect(Rect::MakeXYWH(100, 500, 300, 300), {.color = Color::Blue()});
2295  canvas.Restore();
2296 
2297  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2298 }
2299 
2300 TEST_P(AiksTest, TranslucentSaveLayerWithBlendColorFilterDrawsCorrectly) {
2301  Canvas canvas;
2302 
2303  canvas.DrawRect(Rect::MakeXYWH(100, 100, 300, 300), {.color = Color::Blue()});
2304 
2305  canvas.SaveLayer({
2306  .color = Color::Black().WithAlpha(0.5),
2307  .color_filter =
2308  ColorFilter::MakeBlend(BlendMode::kDestinationOver, Color::Red()),
2309  });
2310  canvas.DrawRect(Rect::MakeXYWH(100, 500, 300, 300), {.color = Color::Blue()});
2311  canvas.Restore();
2312 
2313  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2314 }
2315 
2316 TEST_P(AiksTest, TranslucentSaveLayerWithBlendImageFilterDrawsCorrectly) {
2317  Canvas canvas;
2318 
2319  canvas.DrawRect(Rect::MakeXYWH(100, 100, 300, 300), {.color = Color::Blue()});
2320 
2321  canvas.SaveLayer({
2322  .color = Color::Black().WithAlpha(0.5),
2323  .image_filter = ImageFilter::MakeFromColorFilter(
2324  *ColorFilter::MakeBlend(BlendMode::kDestinationOver, Color::Red())),
2325  });
2326 
2327  canvas.DrawRect(Rect::MakeXYWH(100, 500, 300, 300), {.color = Color::Blue()});
2328  canvas.Restore();
2329 
2330  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2331 }
2332 
2333 TEST_P(AiksTest, TranslucentSaveLayerWithColorAndImageFilterDrawsCorrectly) {
2334  Canvas canvas;
2335 
2336  canvas.DrawRect(Rect::MakeXYWH(100, 100, 300, 300), {.color = Color::Blue()});
2337 
2338  canvas.SaveLayer({
2339  .color = Color::Black().WithAlpha(0.5),
2340  .color_filter =
2341  ColorFilter::MakeBlend(BlendMode::kDestinationOver, Color::Red()),
2342  });
2343 
2344  canvas.DrawRect(Rect::MakeXYWH(100, 500, 300, 300), {.color = Color::Blue()});
2345  canvas.Restore();
2346 
2347  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2348 }
2349 
2350 TEST_P(AiksTest, ImageFilteredSaveLayerWithUnboundedContents) {
2351  Canvas canvas;
2352  canvas.Scale(GetContentScale());
2353 
2354  auto test = [&canvas](const std::shared_ptr<ImageFilter>& filter) {
2355  auto DrawLine = [&canvas](const Point& p0, const Point& p1,
2356  const Paint& p) {
2357  auto path = PathBuilder{}
2358  .AddLine(p0, p1)
2359  .SetConvexity(Convexity::kConvex)
2360  .TakePath();
2361  Paint paint = p;
2362  paint.style = Paint::Style::kStroke;
2363  canvas.DrawPath(std::move(path), paint);
2364  };
2365  // Registration marks for the edge of the SaveLayer
2366  DrawLine(Point(75, 100), Point(225, 100), {.color = Color::White()});
2367  DrawLine(Point(75, 200), Point(225, 200), {.color = Color::White()});
2368  DrawLine(Point(100, 75), Point(100, 225), {.color = Color::White()});
2369  DrawLine(Point(200, 75), Point(200, 225), {.color = Color::White()});
2370 
2371  canvas.SaveLayer({.image_filter = filter},
2372  Rect::MakeLTRB(100, 100, 200, 200));
2373  {
2374  // DrawPaint to verify correct behavior when the contents are unbounded.
2375  canvas.DrawPaint({.color = Color::Yellow()});
2376 
2377  // Contrasting rectangle to see interior blurring
2378  canvas.DrawRect(Rect::MakeLTRB(125, 125, 175, 175),
2379  {.color = Color::Blue()});
2380  }
2381  canvas.Restore();
2382  };
2383 
2384  test(ImageFilter::MakeBlur(Sigma{10.0}, Sigma{10.0},
2385  FilterContents::BlurStyle::kNormal,
2386  Entity::TileMode::kDecal));
2387 
2388  canvas.Translate({200.0, 0.0});
2389 
2390  test(ImageFilter::MakeDilate(Radius{10.0}, Radius{10.0}));
2391 
2392  canvas.Translate({200.0, 0.0});
2393 
2394  test(ImageFilter::MakeErode(Radius{10.0}, Radius{10.0}));
2395 
2396  canvas.Translate({-400.0, 200.0});
2397 
2398  auto rotate_filter =
2399  ImageFilter::MakeMatrix(Matrix::MakeTranslation({150, 150}) *
2400  Matrix::MakeRotationZ(Degrees{10.0}) *
2401  Matrix::MakeTranslation({-150, -150}),
2402  SamplerDescriptor{});
2403  test(rotate_filter);
2404 
2405  canvas.Translate({200.0, 0.0});
2406 
2407  auto rgb_swap_filter = ImageFilter::MakeFromColorFilter(
2408  *ColorFilter::MakeMatrix({.array = {
2409  0, 1, 0, 0, 0, //
2410  0, 0, 1, 0, 0, //
2411  1, 0, 0, 0, 0, //
2412  0, 0, 0, 1, 0 //
2413  }}));
2414  test(rgb_swap_filter);
2415 
2416  canvas.Translate({200.0, 0.0});
2417 
2418  test(ImageFilter::MakeCompose(*rotate_filter, *rgb_swap_filter));
2419 
2420  canvas.Translate({-400.0, 200.0});
2421 
2422  test(ImageFilter::MakeLocalMatrix(Matrix::MakeTranslation({25.0, 25.0}),
2423  *rotate_filter));
2424 
2425  canvas.Translate({200.0, 0.0});
2426 
2427  test(ImageFilter::MakeLocalMatrix(Matrix::MakeTranslation({25.0, 25.0}),
2428  *rgb_swap_filter));
2429 
2430  canvas.Translate({200.0, 0.0});
2431 
2432  test(ImageFilter::MakeLocalMatrix(
2433  Matrix::MakeTranslation({25.0, 25.0}),
2434  *ImageFilter::MakeCompose(*rotate_filter, *rgb_swap_filter)));
2435 
2436  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2437 }
2438 
2439 TEST_P(AiksTest, ImageFilteredUnboundedSaveLayerWithUnboundedContents) {
2440  Canvas canvas;
2441  canvas.Scale(GetContentScale());
2442 
2443  auto blur_filter = ImageFilter::MakeBlur(Sigma{10.0}, Sigma{10.0},
2444  FilterContents::BlurStyle::kNormal,
2445  Entity::TileMode::kDecal);
2446 
2447  canvas.SaveLayer({.image_filter = blur_filter}, std::nullopt);
2448  {
2449  // DrawPaint to verify correct behavior when the contents are unbounded.
2450  canvas.DrawPaint({.color = Color::Yellow()});
2451 
2452  // Contrasting rectangle to see interior blurring
2453  canvas.DrawRect(Rect::MakeLTRB(125, 125, 175, 175),
2454  {.color = Color::Blue()});
2455  }
2456  canvas.Restore();
2457 
2458  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2459 }
2460 
2461 TEST_P(AiksTest, TranslucentSaveLayerImageDrawsCorrectly) {
2462  Canvas canvas;
2463 
2464  auto image = std::make_shared<Image>(CreateTextureForFixture("airplane.jpg"));
2465  canvas.DrawImage(image, {100, 100}, {});
2466 
2467  canvas.SaveLayer({.color = Color::Black().WithAlpha(0.5)});
2468  canvas.DrawImage(image, {100, 500}, {});
2469  canvas.Restore();
2470 
2471  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2472 }
2473 
2474 TEST_P(AiksTest, TranslucentSaveLayerWithColorMatrixColorFilterDrawsCorrectly) {
2475  Canvas canvas;
2476 
2477  auto image = std::make_shared<Image>(CreateTextureForFixture("airplane.jpg"));
2478  canvas.DrawImage(image, {100, 100}, {});
2479 
2480  canvas.SaveLayer({
2481  .color = Color::Black().WithAlpha(0.5),
2482  .color_filter = ColorFilter::MakeMatrix({.array =
2483  {
2484  1, 0, 0, 0, 0, //
2485  0, 1, 0, 0, 0, //
2486  0, 0, 1, 0, 0, //
2487  0, 0, 0, 2, 0 //
2488  }}),
2489  });
2490  canvas.DrawImage(image, {100, 500}, {});
2491  canvas.Restore();
2492 
2493  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2494 }
2495 
2496 TEST_P(AiksTest, TranslucentSaveLayerWithColorMatrixImageFilterDrawsCorrectly) {
2497  Canvas canvas;
2498 
2499  auto image = std::make_shared<Image>(CreateTextureForFixture("airplane.jpg"));
2500  canvas.DrawImage(image, {100, 100}, {});
2501 
2502  canvas.SaveLayer({
2503  .color = Color::Black().WithAlpha(0.5),
2504  .image_filter = ImageFilter::MakeFromColorFilter(
2505  *ColorFilter::MakeMatrix({.array =
2506  {
2507  1, 0, 0, 0, 0, //
2508  0, 1, 0, 0, 0, //
2509  0, 0, 1, 0, 0, //
2510  0, 0, 0, 2, 0 //
2511  }})),
2512  });
2513  canvas.DrawImage(image, {100, 500}, {});
2514  canvas.Restore();
2515 
2516  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2517 }
2518 
2519 TEST_P(AiksTest,
2520  TranslucentSaveLayerWithColorFilterAndImageFilterDrawsCorrectly) {
2521  Canvas canvas;
2522 
2523  auto image = std::make_shared<Image>(CreateTextureForFixture("airplane.jpg"));
2524  canvas.DrawImage(image, {100, 100}, {});
2525 
2526  canvas.SaveLayer({
2527  .color = Color::Black().WithAlpha(0.5),
2528  .image_filter = ImageFilter::MakeFromColorFilter(
2529  *ColorFilter::MakeMatrix({.array =
2530  {
2531  1, 0, 0, 0, 0, //
2532  0, 1, 0, 0, 0, //
2533  0, 0.2, 1, 0, 0, //
2534  0, 0, 0, 0.5, 0 //
2535  }})),
2536  .color_filter =
2537  ColorFilter::MakeBlend(BlendMode::kModulate, Color::Green()),
2538  });
2539  canvas.DrawImage(image, {100, 500}, {});
2540  canvas.Restore();
2541 
2542  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2543 }
2544 
2545 TEST_P(AiksTest, TranslucentSaveLayerWithAdvancedBlendModeDrawsCorrectly) {
2546  Canvas canvas;
2547  canvas.DrawRect(Rect::MakeXYWH(0, 0, 400, 400), {.color = Color::Red()});
2548  canvas.SaveLayer({
2549  .color = Color::Black().WithAlpha(0.5),
2550  .blend_mode = BlendMode::kLighten,
2551  });
2552  canvas.DrawCircle({200, 200}, 100, {.color = Color::Green()});
2553  canvas.Restore();
2554  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2555 }
2556 
2557 /// This is a regression check for https://github.com/flutter/engine/pull/41129
2558 /// The entire screen is green if successful. If failing, no frames will render,
2559 /// or the entire screen will be transparent black.
2560 TEST_P(AiksTest, CanRenderTinyOverlappingSubpasses) {
2561  Canvas canvas;
2562  canvas.DrawPaint({.color = Color::Red()});
2563 
2564  // Draw two overlapping subpixel circles.
2565  canvas.SaveLayer({});
2566  canvas.DrawCircle({100, 100}, 0.1, {.color = Color::Yellow()});
2567  canvas.Restore();
2568  canvas.SaveLayer({});
2569  canvas.DrawCircle({100, 100}, 0.1, {.color = Color::Yellow()});
2570  canvas.Restore();
2571 
2572  canvas.DrawPaint({.color = Color::Green()});
2573 
2574  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2575 }
2576 
2577 /// Tests that the debug checkerboard displays for offscreen textures when
2578 /// enabled. Most of the complexity here is just to future proof by making pass
2579 /// collapsing hard.
2580 TEST_P(AiksTest, CanRenderOffscreenCheckerboard) {
2581  Canvas canvas;
2582  canvas.debug_options.offscreen_texture_checkerboard = true;
2583 
2584  canvas.DrawPaint({.color = Color::AntiqueWhite()});
2585  canvas.DrawCircle({400, 300}, 200,
2586  {.color = Color::CornflowerBlue().WithAlpha(0.75)});
2587 
2588  canvas.SaveLayer({.blend_mode = BlendMode::kMultiply});
2589  {
2590  canvas.DrawCircle({500, 400}, 200,
2591  {.color = Color::DarkBlue().WithAlpha(0.75)});
2592  canvas.DrawCircle({550, 450}, 200,
2593  {.color = Color::LightCoral().WithAlpha(0.75),
2594  .blend_mode = BlendMode::kLuminosity});
2595  }
2596  canvas.Restore();
2597 
2598  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2599 }
2600 
2601 TEST_P(AiksTest, OpaqueEntitiesGetCoercedToSource) {
2602  Canvas canvas;
2603  canvas.Scale(Vector2(1.618, 1.618));
2604  canvas.DrawCircle(Point(), 10,
2605  {
2606  .color = Color::CornflowerBlue(),
2607  .blend_mode = BlendMode::kSourceOver,
2608  });
2609  Picture picture = canvas.EndRecordingAsPicture();
2610 
2611  // Extract the SolidColorSource.
2612  // Entity entity;
2613  std::vector<Entity> entity;
2614  std::shared_ptr<SolidColorContents> contents;
2615  picture.pass->IterateAllEntities([e = &entity, &contents](Entity& entity) {
2616  if (ScalarNearlyEqual(entity.GetTransform().GetScale().x, 1.618f)) {
2617  contents =
2618  std::static_pointer_cast<SolidColorContents>(entity.GetContents());
2619  e->emplace_back(entity.Clone());
2620  return false;
2621  }
2622  return true;
2623  });
2624 
2625  ASSERT_TRUE(entity.size() >= 1);
2626  ASSERT_TRUE(contents->IsOpaque());
2627  ASSERT_EQ(entity[0].GetBlendMode(), BlendMode::kSource);
2628 }
2629 
2630 TEST_P(AiksTest, CanRenderDestructiveSaveLayer) {
2631  Canvas canvas;
2632 
2633  canvas.DrawPaint({.color = Color::Red()});
2634  // Draw an empty savelayer with a destructive blend mode, which will replace
2635  // the entire red screen with fully transparent black, except for the green
2636  // circle drawn within the layer.
2637  canvas.SaveLayer({.blend_mode = BlendMode::kSource});
2638  canvas.DrawCircle({300, 300}, 100, {.color = Color::Green()});
2639  canvas.Restore();
2640 
2641  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2642 }
2643 
2644 TEST_P(AiksTest, CanRenderMaskBlurHugeSigma) {
2645  Canvas canvas;
2646  canvas.DrawCircle({400, 400}, 300,
2647  {.color = Color::Green(),
2648  .mask_blur_descriptor = Paint::MaskBlurDescriptor{
2649  .style = FilterContents::BlurStyle::kNormal,
2650  .sigma = Sigma(99999),
2651  }});
2652  canvas.Restore();
2653 
2654  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2655 }
2656 
2657 TEST_P(AiksTest, CanRenderBackdropBlurInteractive) {
2658  auto callback = [&](AiksContext& renderer) -> std::optional<Picture> {
2659  auto [a, b] = IMPELLER_PLAYGROUND_LINE(Point(50, 50), Point(300, 200), 30,
2660  Color::White(), Color::White());
2661 
2662  Canvas canvas;
2663  canvas.DrawCircle({100, 100}, 50, {.color = Color::CornflowerBlue()});
2664  canvas.DrawCircle({300, 200}, 100, {.color = Color::GreenYellow()});
2665  canvas.DrawCircle({140, 170}, 75, {.color = Color::DarkMagenta()});
2666  canvas.DrawCircle({180, 120}, 100, {.color = Color::OrangeRed()});
2667  canvas.ClipRRect(Rect::MakeLTRB(a.x, a.y, b.x, b.y), {20, 20});
2668  canvas.SaveLayer({.blend_mode = BlendMode::kSource}, std::nullopt,
2669  ImageFilter::MakeBlur(Sigma(20.0), Sigma(20.0),
2670  FilterContents::BlurStyle::kNormal,
2671  Entity::TileMode::kClamp));
2672  canvas.Restore();
2673 
2674  return canvas.EndRecordingAsPicture();
2675  };
2676 
2677  ASSERT_TRUE(OpenPlaygroundHere(callback));
2678 }
2679 
2680 TEST_P(AiksTest, CanRenderBackdropBlur) {
2681  Canvas canvas;
2682  canvas.DrawCircle({100, 100}, 50, {.color = Color::CornflowerBlue()});
2683  canvas.DrawCircle({300, 200}, 100, {.color = Color::GreenYellow()});
2684  canvas.DrawCircle({140, 170}, 75, {.color = Color::DarkMagenta()});
2685  canvas.DrawCircle({180, 120}, 100, {.color = Color::OrangeRed()});
2686  canvas.ClipRRect(Rect::MakeLTRB(75, 50, 375, 275), {20, 20});
2687  canvas.SaveLayer({.blend_mode = BlendMode::kSource}, std::nullopt,
2688  ImageFilter::MakeBlur(Sigma(30.0), Sigma(30.0),
2689  FilterContents::BlurStyle::kNormal,
2690  Entity::TileMode::kClamp));
2691  canvas.Restore();
2692 
2693  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2694 }
2695 
2696 TEST_P(AiksTest, CanRenderBackdropBlurHugeSigma) {
2697  Canvas canvas;
2698  canvas.DrawCircle({400, 400}, 300, {.color = Color::Green()});
2699  canvas.SaveLayer({.blend_mode = BlendMode::kSource}, std::nullopt,
2700  ImageFilter::MakeBlur(Sigma(999999), Sigma(999999),
2701  FilterContents::BlurStyle::kNormal,
2702  Entity::TileMode::kClamp));
2703  canvas.Restore();
2704 
2705  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2706 }
2707 
2708 TEST_P(AiksTest, CanRenderClippedBlur) {
2709  Canvas canvas;
2710  canvas.ClipRect(Rect::MakeXYWH(100, 150, 400, 400));
2711  canvas.DrawCircle(
2712  {400, 400}, 200,
2713  {
2714  .color = Color::Green(),
2715  .image_filter = ImageFilter::MakeBlur(
2716  Sigma(20.0), Sigma(20.0), FilterContents::BlurStyle::kNormal,
2717  Entity::TileMode::kClamp),
2718  });
2719  canvas.Restore();
2720 
2721  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2722 }
2723 
2724 TEST_P(AiksTest, CanRenderForegroundBlendWithMaskBlur) {
2725  // This case triggers the ForegroundPorterDuffBlend path. The color filter
2726  // should apply to the color only, and respect the alpha mask.
2727  Canvas canvas;
2728  canvas.ClipRect(Rect::MakeXYWH(100, 150, 400, 400));
2729  canvas.DrawCircle({400, 400}, 200,
2730  {
2731  .color = Color::White(),
2732  .color_filter = ColorFilter::MakeBlend(
2733  BlendMode::kSource, Color::Green()),
2734  .mask_blur_descriptor =
2735  Paint::MaskBlurDescriptor{
2736  .style = FilterContents::BlurStyle::kNormal,
2737  .sigma = Radius(20),
2738  },
2739  });
2740  canvas.Restore();
2741 
2742  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2743 }
2744 
2745 TEST_P(AiksTest, CanRenderForegroundAdvancedBlendWithMaskBlur) {
2746  // This case triggers the ForegroundAdvancedBlend path. The color filter
2747  // should apply to the color only, and respect the alpha mask.
2748  Canvas canvas;
2749  canvas.ClipRect(Rect::MakeXYWH(100, 150, 400, 400));
2750  canvas.DrawCircle({400, 400}, 200,
2751  {
2752  .color = Color::Grey(),
2753  .color_filter = ColorFilter::MakeBlend(
2754  BlendMode::kColor, Color::Green()),
2755  .mask_blur_descriptor =
2756  Paint::MaskBlurDescriptor{
2757  .style = FilterContents::BlurStyle::kNormal,
2758  .sigma = Radius(20),
2759  },
2760  });
2761  canvas.Restore();
2762 
2763  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2764 }
2765 
2766 // Regression test for https://github.com/flutter/flutter/issues/126701 .
2767 TEST_P(AiksTest, CanRenderClippedRuntimeEffects) {
2768  if (!BackendSupportsFragmentProgram()) {
2769  GTEST_SKIP_("This backend doesn't support runtime effects.");
2770  }
2771 
2772  auto runtime_stages =
2773  OpenAssetAsRuntimeStage("runtime_stage_example.frag.iplr");
2774 
2775  auto runtime_stage =
2776  runtime_stages[PlaygroundBackendToRuntimeStageBackend(GetBackend())];
2777  ASSERT_TRUE(runtime_stage);
2778  ASSERT_TRUE(runtime_stage->IsDirty());
2779 
2780  struct FragUniforms {
2781  Vector2 iResolution;
2782  Scalar iTime;
2783  } frag_uniforms = {.iResolution = Vector2(400, 400), .iTime = 100.0};
2784  auto uniform_data = std::make_shared<std::vector<uint8_t>>();
2785  uniform_data->resize(sizeof(FragUniforms));
2786  memcpy(uniform_data->data(), &frag_uniforms, sizeof(FragUniforms));
2787 
2788  std::vector<RuntimeEffectContents::TextureInput> texture_inputs;
2789 
2790  Paint paint;
2791  paint.color_source = ColorSource::MakeRuntimeEffect(
2792  runtime_stage, uniform_data, texture_inputs);
2793 
2794  Canvas canvas;
2795  canvas.Save();
2796  canvas.ClipRRect(Rect::MakeXYWH(0, 0, 400, 400), {10.0, 10.0},
2797  Entity::ClipOperation::kIntersect);
2798  canvas.DrawRect(Rect::MakeXYWH(0, 0, 400, 400), paint);
2799  canvas.Restore();
2800 
2801  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2802 }
2803 
2804 TEST_P(AiksTest, DrawPaintTransformsBounds) {
2805  if (!BackendSupportsFragmentProgram()) {
2806  GTEST_SKIP_("This backend doesn't support runtime effects.");
2807  }
2808 
2809  auto runtime_stages = OpenAssetAsRuntimeStage("gradient.frag.iplr");
2810  auto runtime_stage = runtime_stages[RuntimeStageBackend::kMetal];
2811  ASSERT_TRUE(runtime_stage);
2812  ASSERT_TRUE(runtime_stage->IsDirty());
2813 
2814  struct FragUniforms {
2815  Size size;
2816  } frag_uniforms = {.size = Size::MakeWH(400, 400)};
2817  auto uniform_data = std::make_shared<std::vector<uint8_t>>();
2818  uniform_data->resize(sizeof(FragUniforms));
2819  memcpy(uniform_data->data(), &frag_uniforms, sizeof(FragUniforms));
2820 
2821  std::vector<RuntimeEffectContents::TextureInput> texture_inputs;
2822 
2823  Paint paint;
2824  paint.color_source = ColorSource::MakeRuntimeEffect(
2825  runtime_stage, uniform_data, texture_inputs);
2826 
2827  Canvas canvas;
2828  canvas.Save();
2829  canvas.Scale(GetContentScale());
2830  canvas.DrawPaint(paint);
2831  canvas.Restore();
2832 
2833  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2834 }
2835 
2836 TEST_P(AiksTest, CanDrawPoints) {
2837  std::vector<Point> points = {
2838  {0, 0}, //
2839  {100, 100}, //
2840  {100, 0}, //
2841  {0, 100}, //
2842  {0, 0}, //
2843  {48, 48}, //
2844  {52, 52}, //
2845  };
2846  std::vector<PointStyle> caps = {
2847  PointStyle::kRound,
2848  PointStyle::kSquare,
2849  };
2850  Paint paint;
2851  paint.color = Color::Yellow().WithAlpha(0.5);
2852 
2853  Paint background;
2854  background.color = Color::Black();
2855 
2856  Canvas canvas;
2857  canvas.DrawPaint(background);
2858  canvas.Translate({200, 200});
2859  canvas.DrawPoints(points, 10, paint, PointStyle::kRound);
2860  canvas.Translate({150, 0});
2861  canvas.DrawPoints(points, 10, paint, PointStyle::kSquare);
2862 
2863  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2864 }
2865 
2866 // Regression test for https://github.com/flutter/flutter/issues/127374.
2867 TEST_P(AiksTest, DrawAtlasWithColorAdvancedAndTransform) {
2868  // Draws the image as four squares stiched together.
2869  auto atlas = CreateTextureForFixture("bay_bridge.jpg");
2870  auto size = atlas->GetSize();
2871  auto image = std::make_shared<Image>(atlas);
2872  // Divide image into four quadrants.
2873  Scalar half_width = size.width / 2;
2874  Scalar half_height = size.height / 2;
2875  std::vector<Rect> texture_coordinates = {
2876  Rect::MakeLTRB(0, 0, half_width, half_height),
2877  Rect::MakeLTRB(half_width, 0, size.width, half_height),
2878  Rect::MakeLTRB(0, half_height, half_width, size.height),
2879  Rect::MakeLTRB(half_width, half_height, size.width, size.height)};
2880  // Position quadrants adjacent to eachother.
2881  std::vector<Matrix> transforms = {
2882  Matrix::MakeTranslation({0, 0, 0}),
2883  Matrix::MakeTranslation({half_width, 0, 0}),
2884  Matrix::MakeTranslation({0, half_height, 0}),
2885  Matrix::MakeTranslation({half_width, half_height, 0})};
2886  std::vector<Color> colors = {Color::Red(), Color::Green(), Color::Blue(),
2887  Color::Yellow()};
2888 
2889  Paint paint;
2890 
2891  Canvas canvas;
2892  canvas.Scale({0.25, 0.25, 1.0});
2893  canvas.DrawAtlas(image, transforms, texture_coordinates, colors,
2894  BlendMode::kModulate, {}, std::nullopt, paint);
2895 
2896  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2897 }
2898 
2899 // Regression test for https://github.com/flutter/flutter/issues/127374.
2900 TEST_P(AiksTest, DrawAtlasAdvancedAndTransform) {
2901  // Draws the image as four squares stiched together.
2902  auto atlas = CreateTextureForFixture("bay_bridge.jpg");
2903  auto size = atlas->GetSize();
2904  auto image = std::make_shared<Image>(atlas);
2905  // Divide image into four quadrants.
2906  Scalar half_width = size.width / 2;
2907  Scalar half_height = size.height / 2;
2908  std::vector<Rect> texture_coordinates = {
2909  Rect::MakeLTRB(0, 0, half_width, half_height),
2910  Rect::MakeLTRB(half_width, 0, size.width, half_height),
2911  Rect::MakeLTRB(0, half_height, half_width, size.height),
2912  Rect::MakeLTRB(half_width, half_height, size.width, size.height)};
2913  // Position quadrants adjacent to eachother.
2914  std::vector<Matrix> transforms = {
2915  Matrix::MakeTranslation({0, 0, 0}),
2916  Matrix::MakeTranslation({half_width, 0, 0}),
2917  Matrix::MakeTranslation({0, half_height, 0}),
2918  Matrix::MakeTranslation({half_width, half_height, 0})};
2919 
2920  Paint paint;
2921 
2922  Canvas canvas;
2923  canvas.Scale({0.25, 0.25, 1.0});
2924  canvas.DrawAtlas(image, transforms, texture_coordinates, {},
2925  BlendMode::kModulate, {}, std::nullopt, paint);
2926 
2927  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2928 }
2929 
2930 TEST_P(AiksTest, CanDrawPointsWithTextureMap) {
2931  auto texture = CreateTextureForFixture("table_mountain_nx.png",
2932  /*enable_mipmapping=*/true);
2933 
2934  std::vector<Point> points = {
2935  {0, 0}, //
2936  {100, 100}, //
2937  {100, 0}, //
2938  {0, 100}, //
2939  {0, 0}, //
2940  {48, 48}, //
2941  {52, 52}, //
2942  };
2943  std::vector<PointStyle> caps = {
2944  PointStyle::kRound,
2945  PointStyle::kSquare,
2946  };
2947  Paint paint;
2948  paint.color_source = ColorSource::MakeImage(texture, Entity::TileMode::kClamp,
2949  Entity::TileMode::kClamp, {}, {});
2950 
2951  Canvas canvas;
2952  canvas.Translate({200, 200});
2953  canvas.DrawPoints(points, 100, paint, PointStyle::kRound);
2954  canvas.Translate({150, 0});
2955  canvas.DrawPoints(points, 100, paint, PointStyle::kSquare);
2956 
2957  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2958 }
2959 
2960 // This currently renders solid blue, as the support for text color sources was
2961 // moved into DLDispatching. Path data requires the SkTextBlobs which are not
2962 // used in impeller::TextFrames.
2963 TEST_P(AiksTest, TextForegroundShaderWithTransform) {
2964  auto mapping = flutter::testing::OpenFixtureAsSkData("Roboto-Regular.ttf");
2965  ASSERT_NE(mapping, nullptr);
2966 
2967  Scalar font_size = 100;
2968  sk_sp<SkFontMgr> font_mgr = txt::GetDefaultFontManager();
2969  SkFont sk_font(font_mgr->makeFromData(mapping), font_size);
2970 
2971  Paint text_paint;
2972  text_paint.color = Color::Blue();
2973 
2974  std::vector<Color> colors = {Color{0.9568, 0.2627, 0.2118, 1.0},
2975  Color{0.1294, 0.5882, 0.9529, 1.0}};
2976  std::vector<Scalar> stops = {
2977  0.0,
2978  1.0,
2979  };
2980  text_paint.color_source = ColorSource::MakeLinearGradient(
2981  {0, 0}, {100, 100}, std::move(colors), std::move(stops),
2982  Entity::TileMode::kRepeat, {});
2983 
2984  Canvas canvas;
2985  canvas.Translate({100, 100});
2986  canvas.Rotate(Radians(kPi / 4));
2987 
2988  auto blob = SkTextBlob::MakeFromString("Hello", sk_font);
2989  ASSERT_NE(blob, nullptr);
2990  auto frame = MakeTextFrameFromTextBlobSkia(blob);
2991  canvas.DrawTextFrame(frame, Point(), text_paint);
2992 
2993  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
2994 }
2995 
2996 TEST_P(AiksTest, CanCanvasDrawPicture) {
2997  Canvas subcanvas;
2998  subcanvas.DrawRect(Rect::MakeLTRB(-100, -50, 100, 50),
2999  {.color = Color::CornflowerBlue()});
3000  auto picture = subcanvas.EndRecordingAsPicture();
3001 
3002  Canvas canvas;
3003  canvas.Translate({200, 200});
3004  canvas.Rotate(Radians(kPi / 4));
3005  canvas.DrawPicture(picture);
3006 
3007  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
3008 }
3009 
3010 TEST_P(AiksTest, CanCanvasDrawPictureWithAdvancedBlend) {
3011  Canvas subcanvas;
3012  subcanvas.DrawRect(
3013  Rect::MakeLTRB(-100, -50, 100, 50),
3014  {.color = Color::CornflowerBlue(), .blend_mode = BlendMode::kColorDodge});
3015  auto picture = subcanvas.EndRecordingAsPicture();
3016 
3017  Canvas canvas;
3018  canvas.DrawPaint({.color = Color::Black()});
3019  canvas.DrawCircle(Point::MakeXY(150, 150), 25, {.color = Color::Red()});
3020  canvas.DrawPicture(picture);
3021 
3022  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
3023 }
3024 
3025 TEST_P(AiksTest, CanCanvasDrawPictureWithBackdropFilter) {
3026  Canvas subcanvas;
3027  subcanvas.SaveLayer({}, {},
3028  ImageFilter::MakeBlur(Sigma(20.0), Sigma(20.0),
3029  FilterContents::BlurStyle::kNormal,
3030  Entity::TileMode::kDecal));
3031  auto image = std::make_shared<Image>(CreateTextureForFixture("kalimba.jpg"));
3032  Paint paint;
3033  paint.color = Color::Red().WithAlpha(0.5);
3034  subcanvas.DrawImage(image, Point::MakeXY(100.0, 100.0), paint);
3035 
3036  auto picture = subcanvas.EndRecordingAsPicture();
3037 
3038  Canvas canvas;
3039  canvas.DrawPaint({.color = Color::Black()});
3040  canvas.DrawCircle(Point::MakeXY(150, 150), 25, {.color = Color::Red()});
3041  canvas.DrawPicture(picture);
3042 
3043  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
3044 }
3045 
3046 TEST_P(AiksTest, DrawPictureWithText) {
3047  Canvas subcanvas;
3048  ASSERT_TRUE(RenderTextInCanvasSkia(
3049  GetContext(), subcanvas,
3050  "the quick brown fox jumped over the lazy dog!.?", "Roboto-Regular.ttf"));
3051  subcanvas.Translate({0, 10});
3052  subcanvas.Scale(Vector2(3, 3));
3053  ASSERT_TRUE(RenderTextInCanvasSkia(
3054  GetContext(), subcanvas,
3055  "the quick brown fox jumped over the very big lazy dog!.?",
3056  "Roboto-Regular.ttf"));
3057  auto picture = subcanvas.EndRecordingAsPicture();
3058 
3059  Canvas canvas;
3060  canvas.Scale(Vector2(.2, .2));
3061  canvas.Save();
3062  canvas.Translate({200, 200});
3063  canvas.Scale(Vector2(3.5, 3.5)); // The text must not be blurry after this.
3064  canvas.DrawPicture(picture);
3065  canvas.Restore();
3066 
3067  canvas.Scale(Vector2(1.5, 1.5));
3068  ASSERT_TRUE(RenderTextInCanvasSkia(
3069  GetContext(), canvas,
3070  "the quick brown fox jumped over the smaller lazy dog!.?",
3071  "Roboto-Regular.ttf"));
3072  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
3073 }
3074 
3075 TEST_P(AiksTest, DrawPictureClipped) {
3076  Canvas subcanvas;
3077  subcanvas.ClipRRect(Rect::MakeLTRB(100, 100, 400, 400), {15, 15});
3078  subcanvas.DrawPaint({.color = Color::Red()});
3079  auto picture = subcanvas.EndRecordingAsPicture();
3080 
3081  Canvas canvas;
3082  canvas.DrawPaint({.color = Color::CornflowerBlue()});
3083 
3084  // Draw a red RRect via DrawPicture.
3085  canvas.DrawPicture(picture);
3086 
3087  // Draw over the picture with a larger green rectangle, completely covering it
3088  // up.
3089  canvas.ClipRRect(Rect::MakeLTRB(100, 100, 400, 400).Expand(20), {15, 15});
3090  canvas.DrawPaint({.color = Color::Green()});
3091 
3092  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
3093 }
3094 
3095 TEST_P(AiksTest, MatrixSaveLayerFilter) {
3096  Canvas canvas;
3097  canvas.DrawPaint({.color = Color::Black()});
3098  canvas.SaveLayer({}, std::nullopt);
3099  {
3100  canvas.DrawCircle(Point(200, 200), 100,
3101  {.color = Color::Green().WithAlpha(0.5),
3102  .blend_mode = BlendMode::kPlus});
3103  // Should render a second circle, centered on the bottom-right-most edge of
3104  // the circle.
3105  canvas.SaveLayer({.image_filter = ImageFilter::MakeMatrix(
3106  Matrix::MakeTranslation(Vector2(1, 1) *
3107  (200 + 100 * k1OverSqrt2)) *
3108  Matrix::MakeScale(Vector2(1, 1) * 0.5) *
3109  Matrix::MakeTranslation(Vector2(-200, -200)),
3110  SamplerDescriptor{})},
3111  std::nullopt);
3112  canvas.DrawCircle(Point(200, 200), 100,
3113  {.color = Color::Green().WithAlpha(0.5),
3114  .blend_mode = BlendMode::kPlus});
3115  canvas.Restore();
3116  }
3117  canvas.Restore();
3118 
3119  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
3120 }
3121 
3122 TEST_P(AiksTest, MatrixBackdropFilter) {
3123  Canvas canvas;
3124  canvas.DrawPaint({.color = Color::Black()});
3125  canvas.SaveLayer({}, std::nullopt);
3126  {
3127  canvas.DrawCircle(Point(200, 200), 100,
3128  {.color = Color::Green().WithAlpha(0.5),
3129  .blend_mode = BlendMode::kPlus});
3130  // Should render a second circle, centered on the bottom-right-most edge of
3131  // the circle.
3132  canvas.SaveLayer(
3133  {}, std::nullopt,
3134  ImageFilter::MakeMatrix(
3135  Matrix::MakeTranslation(Vector2(1, 1) * (100 + 100 * k1OverSqrt2)) *
3136  Matrix::MakeScale(Vector2(1, 1) * 0.5) *
3137  Matrix::MakeTranslation(Vector2(-100, -100)),
3138  SamplerDescriptor{}));
3139  canvas.Restore();
3140  }
3141  canvas.Restore();
3142 
3143  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
3144 }
3145 
3146 TEST_P(AiksTest, SolidColorApplyColorFilter) {
3147  auto contents = SolidColorContents();
3148  contents.SetColor(Color::CornflowerBlue().WithAlpha(0.75));
3149  auto result = contents.ApplyColorFilter([](const Color& color) {
3150  return color.Blend(Color::LimeGreen().WithAlpha(0.75), BlendMode::kScreen);
3151  });
3152  ASSERT_TRUE(result);
3153  ASSERT_COLOR_NEAR(contents.GetColor(),
3154  Color(0.433247, 0.879523, 0.825324, 0.75));
3155 }
3156 
3157 TEST_P(AiksTest, DrawScaledTextWithPerspectiveNoSaveLayer) {
3158  Canvas canvas;
3159  // clang-format off
3160  canvas.Transform(Matrix(
3161  2.000000, 0.000000, 0.000000, 0.000000,
3162  1.445767, 2.637070, -0.507928, 0.001524,
3163  -2.451887, -0.534662, 0.861399, -0.002584,
3164  1063.481934, 1025.951416, -48.300270, 1.144901
3165  ));
3166  // clang-format on
3167 
3168  ASSERT_TRUE(RenderTextInCanvasSkia(GetContext(), canvas, "Hello world",
3169  "Roboto-Regular.ttf"));
3170 
3171  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
3172 }
3173 
3174 TEST_P(AiksTest, DrawScaledTextWithPerspectiveSaveLayer) {
3175  Canvas canvas;
3176  Paint save_paint;
3177  canvas.SaveLayer(save_paint);
3178  // clang-format off
3179  canvas.Transform(Matrix(
3180  2.000000, 0.000000, 0.000000, 0.000000,
3181  1.445767, 2.637070, -0.507928, 0.001524,
3182  -2.451887, -0.534662, 0.861399, -0.002584,
3183  1063.481934, 1025.951416, -48.300270, 1.144901
3184  ));
3185  // clang-format on
3186 
3187  ASSERT_TRUE(RenderTextInCanvasSkia(GetContext(), canvas, "Hello world",
3188  "Roboto-Regular.ttf"));
3189 }
3190 
3191 TEST_P(AiksTest, PipelineBlendSingleParameter) {
3192  Canvas canvas;
3193 
3194  // Should render a green square in the middle of a blue circle.
3195  canvas.SaveLayer({});
3196  {
3197  canvas.Translate(Point(100, 100));
3198  canvas.DrawCircle(Point(200, 200), 200, {.color = Color::Blue()});
3199  canvas.ClipRect(Rect::MakeXYWH(100, 100, 200, 200));
3200  canvas.DrawCircle(Point(200, 200), 200,
3201  {
3202  .color = Color::Green(),
3203  .blend_mode = BlendMode::kSourceOver,
3204  .image_filter = ImageFilter::MakeFromColorFilter(
3205  *ColorFilter::MakeBlend(BlendMode::kDestination,
3206  Color::White())),
3207  });
3208  canvas.Restore();
3209  }
3210 
3211  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
3212 }
3213 
3214 TEST_P(AiksTest, ClippedBlurFilterRendersCorrectlyInteractive) {
3215  auto callback = [&](AiksContext& renderer) -> std::optional<Picture> {
3216  auto point = IMPELLER_PLAYGROUND_POINT(Point(400, 400), 20, Color::Green());
3217 
3218  Canvas canvas;
3219  canvas.Translate(point - Point(400, 400));
3220  Paint paint;
3221  paint.mask_blur_descriptor = Paint::MaskBlurDescriptor{
3222  .style = FilterContents::BlurStyle::kNormal,
3223  .sigma = Radius{120 * 3},
3224  };
3225  paint.color = Color::Red();
3226  PathBuilder builder{};
3227  builder.AddRect(Rect::MakeLTRB(0, 0, 800, 800));
3228  canvas.DrawPath(builder.TakePath(), paint);
3229  return canvas.EndRecordingAsPicture();
3230  };
3231  ASSERT_TRUE(OpenPlaygroundHere(callback));
3232 }
3233 
3234 TEST_P(AiksTest, ClippedBlurFilterRendersCorrectly) {
3235  Canvas canvas;
3236  canvas.Translate(Point(0, -400));
3237  Paint paint;
3238  paint.mask_blur_descriptor = Paint::MaskBlurDescriptor{
3239  .style = FilterContents::BlurStyle::kNormal,
3240  .sigma = Radius{120 * 3},
3241  };
3242  paint.color = Color::Red();
3243  PathBuilder builder{};
3244  builder.AddRect(Rect::MakeLTRB(0, 0, 800, 800));
3245  canvas.DrawPath(builder.TakePath(), paint);
3246  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
3247 }
3248 
3249 TEST_P(AiksTest, CaptureContext) {
3250  auto capture_context = CaptureContext::MakeAllowlist({"TestDocument"});
3251 
3252  auto callback = [&](AiksContext& renderer) -> std::optional<Picture> {
3253  Canvas canvas;
3254 
3255  capture_context.Rewind();
3256  auto document = capture_context.GetDocument("TestDocument");
3257 
3258  auto color = document.AddColor("Background color", Color::CornflowerBlue());
3259  canvas.DrawPaint({.color = color});
3260 
3261  ImGui::Begin("TestDocument", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
3262  document.GetElement()->properties.Iterate([](CaptureProperty& property) {
3263  property.Invoke({.color = [](CaptureColorProperty& p) {
3264  ImGui::ColorEdit4(p.label.c_str(), reinterpret_cast<float*>(&p.value));
3265  }});
3266  });
3267  ImGui::End();
3268 
3269  return canvas.EndRecordingAsPicture();
3270  };
3271  OpenPlaygroundHere(callback);
3272 }
3273 
3274 TEST_P(AiksTest, CaptureInactivatedByDefault) {
3275  ASSERT_FALSE(GetContext()->capture.IsActive());
3276 }
3277 
3278 // Regression test for https://github.com/flutter/flutter/issues/134678.
3279 TEST_P(AiksTest, ReleasesTextureOnTeardown) {
3280  auto context = GetContext();
3281  std::weak_ptr<Texture> weak_texture;
3282 
3283  {
3284  auto texture = CreateTextureForFixture("table_mountain_nx.png");
3285 
3286  Canvas canvas;
3287  canvas.Scale(GetContentScale());
3288  canvas.Translate({100.0f, 100.0f, 0});
3289 
3290  Paint paint;
3291  paint.color_source = ColorSource::MakeImage(
3292  texture, Entity::TileMode::kClamp, Entity::TileMode::kClamp, {}, {});
3293  canvas.DrawRect(Rect::MakeXYWH(0, 0, 600, 600), paint);
3294 
3295  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
3296  }
3297 
3298  // See https://github.com/flutter/flutter/issues/134751.
3299  //
3300  // If the fence waiter was working this may not be released by the end of the
3301  // scope above. Adding a manual shutdown so that future changes to the fence
3302  // waiter will not flake this test.
3303  context->Shutdown();
3304 
3305  // The texture should be released by now.
3306  ASSERT_TRUE(weak_texture.expired()) << "When the texture is no longer in use "
3307  "by the backend, it should be "
3308  "released.";
3309 }
3310 
3311 // Regression test for https://github.com/flutter/flutter/issues/135441 .
3312 TEST_P(AiksTest, VerticesGeometryUVPositionData) {
3313  Canvas canvas;
3314  Paint paint;
3315  auto texture = CreateTextureForFixture("table_mountain_nx.png");
3316 
3317  paint.color_source = ColorSource::MakeImage(texture, Entity::TileMode::kClamp,
3318  Entity::TileMode::kClamp, {}, {});
3319 
3320  auto vertices = {Point(0, 0), Point(texture->GetSize().width, 0),
3321  Point(0, texture->GetSize().height)};
3322  std::vector<uint16_t> indices = {0u, 1u, 2u};
3323  std::vector<Point> texture_coordinates = {};
3324  std::vector<Color> vertex_colors = {};
3325  auto geometry = std::make_shared<VerticesGeometry>(
3326  vertices, indices, texture_coordinates, vertex_colors,
3327  Rect::MakeLTRB(0, 0, 1, 1), VerticesGeometry::VertexMode::kTriangleStrip);
3328 
3329  canvas.DrawVertices(geometry, BlendMode::kSourceOver, paint);
3330  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
3331 }
3332 
3333 // Regression test for https://github.com/flutter/flutter/issues/135441 .
3334 TEST_P(AiksTest, VerticesGeometryUVPositionDataWithTranslate) {
3335  Canvas canvas;
3336  Paint paint;
3337  auto texture = CreateTextureForFixture("table_mountain_nx.png");
3338 
3339  paint.color_source = ColorSource::MakeImage(
3340  texture, Entity::TileMode::kClamp, Entity::TileMode::kClamp, {},
3341  Matrix::MakeTranslation({100.0, 100.0}));
3342 
3343  auto vertices = {Point(0, 0), Point(texture->GetSize().width, 0),
3344  Point(0, texture->GetSize().height)};
3345  std::vector<uint16_t> indices = {0u, 1u, 2u};
3346  std::vector<Point> texture_coordinates = {};
3347  std::vector<Color> vertex_colors = {};
3348  auto geometry = std::make_shared<VerticesGeometry>(
3349  vertices, indices, texture_coordinates, vertex_colors,
3350  Rect::MakeLTRB(0, 0, 1, 1), VerticesGeometry::VertexMode::kTriangleStrip);
3351 
3352  canvas.DrawVertices(geometry, BlendMode::kSourceOver, paint);
3353  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
3354 }
3355 
3356 TEST_P(AiksTest, ClearBlendWithBlur) {
3357  Canvas canvas;
3358  Paint white;
3359  white.color = Color::Blue();
3360  canvas.DrawRect(Rect::MakeXYWH(0, 0, 600.0, 600.0), white);
3361 
3362  Paint clear;
3363  clear.blend_mode = BlendMode::kClear;
3364  clear.mask_blur_descriptor = Paint::MaskBlurDescriptor{
3365  .style = FilterContents::BlurStyle::kNormal,
3366  .sigma = Sigma(20),
3367  };
3368 
3369  canvas.DrawCircle(Point::MakeXY(300.0, 300.0), 200.0, clear);
3370 
3371  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
3372 }
3373 
3374 TEST_P(AiksTest, ClearBlend) {
3375  Canvas canvas;
3376  Paint white;
3377  white.color = Color::Blue();
3378  canvas.DrawRect(Rect::MakeXYWH(0, 0, 600.0, 600.0), white);
3379 
3380  Paint clear;
3381  clear.blend_mode = BlendMode::kClear;
3382 
3383  canvas.DrawCircle(Point::MakeXY(300.0, 300.0), 200.0, clear);
3384 }
3385 
3386 TEST_P(AiksTest, MatrixImageFilterMagnify) {
3387  Canvas canvas;
3388  canvas.Scale(GetContentScale());
3389  auto image = std::make_shared<Image>(CreateTextureForFixture("airplane.jpg"));
3390  canvas.Translate({600, -200});
3391  canvas.SaveLayer({
3392  .image_filter = std::make_shared<MatrixImageFilter>(
3393  Matrix::MakeScale({2, 2, 2}), SamplerDescriptor{}),
3394  });
3395  canvas.DrawImage(image, {0, 0},
3396  Paint{.color = Color::White().WithAlpha(0.5)});
3397  canvas.Restore();
3398 
3399  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
3400 }
3401 
3402 // Render a white circle at the top left corner of the screen.
3403 TEST_P(AiksTest, MatrixImageFilterDoesntCullWhenTranslatedFromOffscreen) {
3404  Canvas canvas;
3405  canvas.Scale(GetContentScale());
3406  canvas.Translate({100, 100});
3407  // Draw a circle in a SaveLayer at -300, but move it back on-screen with a
3408  // +300 translation applied by a SaveLayer image filter.
3409  canvas.SaveLayer({
3410  .image_filter = std::make_shared<MatrixImageFilter>(
3411  Matrix::MakeTranslation({300, 0}), SamplerDescriptor{}),
3412  });
3413  canvas.DrawCircle({-300, 0}, 100, {.color = Color::Green()});
3414  canvas.Restore();
3415 
3416  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
3417 }
3418 
3419 // Render a white circle at the top left corner of the screen.
3420 TEST_P(AiksTest,
3421  MatrixImageFilterDoesntCullWhenScaledAndTranslatedFromOffscreen) {
3422  Canvas canvas;
3423  canvas.Scale(GetContentScale());
3424  canvas.Translate({100, 100});
3425  // Draw a circle in a SaveLayer at -300, but move it back on-screen with a
3426  // +300 translation applied by a SaveLayer image filter.
3427  canvas.SaveLayer({
3428  .image_filter = std::make_shared<MatrixImageFilter>(
3429  Matrix::MakeTranslation({300, 0}) * Matrix::MakeScale({2, 2, 2}),
3430  SamplerDescriptor{}),
3431  });
3432  canvas.DrawCircle({-150, 0}, 50, {.color = Color::Green()});
3433  canvas.Restore();
3434 
3435  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
3436 }
3437 
3438 // This should be solid red, if you see a little red box this is broken.
3439 TEST_P(AiksTest, ClearColorOptimizationWhenSubpassIsBiggerThanParentPass) {
3440  SetWindowSize({400, 400});
3441  Canvas canvas;
3442  canvas.Scale(GetContentScale());
3443  canvas.DrawRect(Rect::MakeLTRB(200, 200, 300, 300), {.color = Color::Red()});
3444  canvas.SaveLayer({
3445  .image_filter = std::make_shared<MatrixImageFilter>(
3446  Matrix::MakeScale({2, 2, 1}), SamplerDescriptor{}),
3447  });
3448  // Draw a rectangle that would fully cover the parent pass size, but not
3449  // the subpass that it is rendered in.
3450  canvas.DrawRect(Rect::MakeLTRB(0, 0, 400, 400), {.color = Color::Green()});
3451  // Draw a bigger rectangle to force the subpass to be bigger.
3452  canvas.DrawRect(Rect::MakeLTRB(0, 0, 800, 800), {.color = Color::Red()});
3453  canvas.Restore();
3454 
3455  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
3456 }
3457 
3458 TEST_P(AiksTest, BlurHasNoEdge) {
3459  Canvas canvas;
3460  canvas.Scale(GetContentScale());
3461  canvas.DrawPaint({});
3462  Paint blur = {
3463  .color = Color::Green(),
3464  .mask_blur_descriptor =
3465  Paint::MaskBlurDescriptor{
3466  .style = FilterContents::BlurStyle::kNormal,
3467  .sigma = Sigma(47.6),
3468  },
3469  };
3470  canvas.DrawRect(Rect::MakeXYWH(300, 300, 200, 200), blur);
3471  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
3472 }
3473 
3474 TEST_P(AiksTest, EmptySaveLayerIgnoresPaint) {
3475  Canvas canvas;
3476  canvas.Scale(GetContentScale());
3477  canvas.DrawPaint(Paint{.color = Color::Red()});
3478  canvas.ClipRect(Rect::MakeXYWH(100, 100, 200, 200));
3479  canvas.SaveLayer(Paint{.color = Color::Blue()});
3480  canvas.Restore();
3481  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
3482 }
3483 
3484 TEST_P(AiksTest, EmptySaveLayerRendersWithClear) {
3485  Canvas canvas;
3486  canvas.Scale(GetContentScale());
3487  auto image = std::make_shared<Image>(CreateTextureForFixture("airplane.jpg"));
3488  canvas.DrawImage(image, {10, 10}, {});
3489  canvas.ClipRect(Rect::MakeXYWH(100, 100, 200, 200));
3490  canvas.SaveLayer(Paint{.blend_mode = BlendMode::kClear});
3491  canvas.Restore();
3492  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
3493 }
3494 
3495 TEST_P(AiksTest, BlurredRectangleWithShader) {
3496  Canvas canvas;
3497  canvas.Scale(GetContentScale());
3498 
3499  auto paint_lines = [&canvas](Scalar dx, Scalar dy, Paint paint) {
3500  auto draw_line = [&canvas, &paint](Point a, Point b) {
3501  canvas.DrawPath(PathBuilder{}.AddLine(a, b).TakePath(), paint);
3502  };
3503  paint.stroke_width = 5;
3504  paint.style = Paint::Style::kStroke;
3505  draw_line(Point(dx + 100, dy + 100), Point(dx + 200, dy + 200));
3506  draw_line(Point(dx + 100, dy + 200), Point(dx + 200, dy + 100));
3507  draw_line(Point(dx + 150, dy + 100), Point(dx + 200, dy + 150));
3508  draw_line(Point(dx + 100, dy + 150), Point(dx + 150, dy + 200));
3509  };
3510 
3511  AiksContext renderer(GetContext(), nullptr);
3512  Canvas recorder_canvas;
3513  for (int x = 0; x < 5; ++x) {
3514  for (int y = 0; y < 5; ++y) {
3515  Rect rect = Rect::MakeXYWH(x * 20, y * 20, 20, 20);
3516  Paint paint{.color =
3517  ((x + y) & 1) == 0 ? Color::Yellow() : Color::Blue()};
3518  recorder_canvas.DrawRect(rect, paint);
3519  }
3520  }
3521  Picture picture = recorder_canvas.EndRecordingAsPicture();
3522  std::shared_ptr<Texture> texture =
3523  picture.ToImage(renderer, ISize{100, 100})->GetTexture();
3524 
3525  ColorSource image_source = ColorSource::MakeImage(
3526  texture, Entity::TileMode::kRepeat, Entity::TileMode::kRepeat, {}, {});
3527  std::shared_ptr<ImageFilter> blur_filter = ImageFilter::MakeBlur(
3528  Sigma(5), Sigma(5), FilterContents::BlurStyle::kNormal,
3529  Entity::TileMode::kDecal);
3530  canvas.DrawRect(Rect::MakeLTRB(0, 0, 300, 600),
3531  Paint{.color = Color::DarkGreen()});
3532  canvas.DrawRect(Rect::MakeLTRB(100, 100, 200, 200),
3533  Paint{.color_source = image_source});
3534  canvas.DrawRect(Rect::MakeLTRB(300, 0, 600, 600),
3535  Paint{.color = Color::Red()});
3536  canvas.DrawRect(
3537  Rect::MakeLTRB(400, 100, 500, 200),
3538  Paint{.color_source = image_source, .image_filter = blur_filter});
3539  paint_lines(0, 300, Paint{.color_source = image_source});
3540  paint_lines(300, 300,
3541  Paint{.color_source = image_source, .image_filter = blur_filter});
3542  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
3543 }
3544 
3545 TEST_P(AiksTest, MaskBlurWithZeroSigmaIsSkipped) {
3546  Canvas canvas;
3547 
3548  Paint paint = {
3549  .color = Color::Blue(),
3550  .mask_blur_descriptor =
3551  Paint::MaskBlurDescriptor{
3552  .style = FilterContents::BlurStyle::kNormal,
3553  .sigma = Sigma(0),
3554  },
3555  };
3556 
3557  canvas.DrawCircle({300, 300}, 200, paint);
3558  canvas.DrawRect(Rect::MakeLTRB(100, 300, 500, 600), paint);
3559 
3560  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
3561 }
3562 
3563 TEST_P(AiksTest, GaussianBlurAtPeripheryVertical) {
3564  Canvas canvas;
3565 
3566  canvas.Scale(GetContentScale());
3567  canvas.DrawRRect(Rect::MakeLTRB(0, 0, GetWindowSize().width, 100),
3568  Size(10, 10), Paint{.color = Color::LimeGreen()});
3569  canvas.DrawRRect(Rect::MakeLTRB(0, 110, GetWindowSize().width, 210),
3570  Size(10, 10), Paint{.color = Color::Magenta()});
3571  canvas.ClipRect(Rect::MakeLTRB(100, 0, 200, GetWindowSize().height));
3572  canvas.SaveLayer({.blend_mode = BlendMode::kSource}, std::nullopt,
3573  ImageFilter::MakeBlur(Sigma(20.0), Sigma(20.0),
3574  FilterContents::BlurStyle::kNormal,
3575  Entity::TileMode::kClamp));
3576  canvas.Restore();
3577 
3578  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
3579 }
3580 
3581 TEST_P(AiksTest, GaussianBlurAtPeripheryHorizontal) {
3582  Canvas canvas;
3583 
3584  canvas.Scale(GetContentScale());
3585  std::shared_ptr<Texture> boston = CreateTextureForFixture("boston.jpg");
3586  canvas.DrawImageRect(
3587  std::make_shared<Image>(boston),
3588  Rect::MakeXYWH(0, 0, boston->GetSize().width, boston->GetSize().height),
3589  Rect::MakeLTRB(0, 0, GetWindowSize().width, 100), Paint{});
3590  canvas.DrawRRect(Rect::MakeLTRB(0, 110, GetWindowSize().width, 210),
3591  Size(10, 10), Paint{.color = Color::Magenta()});
3592  canvas.ClipRect(Rect::MakeLTRB(0, 50, GetWindowSize().width, 150));
3593  canvas.SaveLayer({.blend_mode = BlendMode::kSource}, std::nullopt,
3594  ImageFilter::MakeBlur(Sigma(20.0), Sigma(20.0),
3595  FilterContents::BlurStyle::kNormal,
3596  Entity::TileMode::kClamp));
3597  canvas.Restore();
3598  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
3599 }
3600 
3601 #define FLT_FORWARD(mock, real, method) \
3602  EXPECT_CALL(*mock, method()) \
3603  .WillRepeatedly(::testing::Return(real->method()));
3604 
3605 TEST_P(AiksTest, GaussianBlurWithoutDecalSupport) {
3606  if (GetParam() != PlaygroundBackend::kMetal) {
3607  GTEST_SKIP_(
3608  "This backend doesn't yet support setting device capabilities.");
3609  }
3610  if (!WillRenderSomething()) {
3611  // Sometimes these tests are run without playgrounds enabled which is
3612  // pointless for this test since we are asserting that
3613  // `SupportsDecalSamplerAddressMode` is called.
3614  GTEST_SKIP_("This test requires playgrounds.");
3615  }
3616 
3617  std::shared_ptr<const Capabilities> old_capabilities =
3618  GetContext()->GetCapabilities();
3619  auto mock_capabilities = std::make_shared<MockCapabilities>();
3620  EXPECT_CALL(*mock_capabilities, SupportsDecalSamplerAddressMode())
3621  .Times(::testing::AtLeast(1))
3622  .WillRepeatedly(::testing::Return(false));
3623  FLT_FORWARD(mock_capabilities, old_capabilities, GetDefaultColorFormat);
3624  FLT_FORWARD(mock_capabilities, old_capabilities, GetDefaultStencilFormat);
3625  FLT_FORWARD(mock_capabilities, old_capabilities, SupportsOffscreenMSAA);
3626  FLT_FORWARD(mock_capabilities, old_capabilities,
3627  SupportsImplicitResolvingMSAA);
3628  FLT_FORWARD(mock_capabilities, old_capabilities, SupportsReadFromResolve);
3629  FLT_FORWARD(mock_capabilities, old_capabilities, SupportsFramebufferFetch);
3630  FLT_FORWARD(mock_capabilities, old_capabilities, SupportsSSBO);
3631  FLT_FORWARD(mock_capabilities, old_capabilities, SupportsCompute);
3632  FLT_FORWARD(mock_capabilities, old_capabilities,
3633  SupportsTextureToTextureBlits);
3634  ASSERT_TRUE(SetCapabilities(mock_capabilities).ok());
3635 
3636  auto texture = std::make_shared<Image>(CreateTextureForFixture("boston.jpg"));
3637  Canvas canvas;
3638  canvas.Scale(GetContentScale() * 0.5);
3639  canvas.DrawPaint({.color = Color::Black()});
3640  canvas.DrawImage(
3641  texture, Point(200, 200),
3642  {
3643  .image_filter = ImageFilter::MakeBlur(
3644  Sigma(20.0), Sigma(20.0), FilterContents::BlurStyle::kNormal,
3645  Entity::TileMode::kDecal),
3646  });
3647  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
3648 }
3649 
3650 TEST_P(AiksTest, GaussianBlurOneDimension) {
3651  Canvas canvas;
3652 
3653  canvas.Scale(GetContentScale());
3654  canvas.Scale({0.5, 0.5, 1.0});
3655  std::shared_ptr<Texture> boston = CreateTextureForFixture("boston.jpg");
3656  canvas.DrawImage(std::make_shared<Image>(boston), Point(100, 100), Paint{});
3657  canvas.SaveLayer({.blend_mode = BlendMode::kSource}, std::nullopt,
3658  ImageFilter::MakeBlur(Sigma(50.0), Sigma(0.0),
3659  FilterContents::BlurStyle::kNormal,
3660  Entity::TileMode::kClamp));
3661  canvas.Restore();
3662  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
3663 }
3664 
3665 // Smoketest to catch issues with the coverage hint.
3666 // Draws a rotated blurred image within a rectangle clip. The center of the clip
3667 // rectangle is the center of the rotated image. The entire area of the clip
3668 // rectangle should be filled with opaque colors output by the blur.
3669 TEST_P(AiksTest, GaussianBlurRotatedAndClipped) {
3670  Canvas canvas;
3671  std::shared_ptr<Texture> boston = CreateTextureForFixture("boston.jpg");
3672  Rect bounds =
3673  Rect::MakeXYWH(0, 0, boston->GetSize().width, boston->GetSize().height);
3674  Vector2 image_center = Vector2(bounds.GetSize() / 2);
3675  Paint paint = {.image_filter =
3676  ImageFilter::MakeBlur(Sigma(20.0), Sigma(20.0),
3677  FilterContents::BlurStyle::kNormal,
3678  Entity::TileMode::kDecal)};
3679  Vector2 clip_size = {150, 75};
3680  Vector2 center = Vector2(1024, 768) / 2;
3681  canvas.Scale(GetContentScale());
3682  canvas.ClipRect(
3683  Rect::MakeLTRB(center.x, center.y, center.x, center.y).Expand(clip_size));
3684  canvas.Translate({center.x, center.y, 0});
3685  canvas.Scale({0.6, 0.6, 1});
3686  canvas.Rotate(Degrees(25));
3687 
3688  canvas.DrawImageRect(std::make_shared<Image>(boston), /*source=*/bounds,
3689  /*dest=*/bounds.Shift(-image_center), paint);
3690 
3691  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
3692 }
3693 
3694 TEST_P(AiksTest, GaussianBlurScaledAndClipped) {
3695  Canvas canvas;
3696  std::shared_ptr<Texture> boston = CreateTextureForFixture("boston.jpg");
3697  Rect bounds =
3698  Rect::MakeXYWH(0, 0, boston->GetSize().width, boston->GetSize().height);
3699  Vector2 image_center = Vector2(bounds.GetSize() / 2);
3700  Paint paint = {.image_filter =
3701  ImageFilter::MakeBlur(Sigma(20.0), Sigma(20.0),
3702  FilterContents::BlurStyle::kNormal,
3703  Entity::TileMode::kDecal)};
3704  Vector2 clip_size = {150, 75};
3705  Vector2 center = Vector2(1024, 768) / 2;
3706  canvas.Scale(GetContentScale());
3707  canvas.ClipRect(
3708  Rect::MakeLTRB(center.x, center.y, center.x, center.y).Expand(clip_size));
3709  canvas.Translate({center.x, center.y, 0});
3710  canvas.Scale({0.6, 0.6, 1});
3711 
3712  canvas.DrawImageRect(std::make_shared<Image>(boston), /*source=*/bounds,
3713  /*dest=*/bounds.Shift(-image_center), paint);
3714 
3715  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
3716 }
3717 
3718 TEST_P(AiksTest, GaussianBlurRotatedAndClippedInteractive) {
3719  std::shared_ptr<Texture> boston = CreateTextureForFixture("boston.jpg");
3720 
3721  auto callback = [&](AiksContext& renderer) -> std::optional<Picture> {
3722  const char* tile_mode_names[] = {"Clamp", "Repeat", "Mirror", "Decal"};
3723  const Entity::TileMode tile_modes[] = {
3724  Entity::TileMode::kClamp, Entity::TileMode::kRepeat,
3725  Entity::TileMode::kMirror, Entity::TileMode::kDecal};
3726 
3727  static float rotation = 0;
3728  static float scale = 0.6;
3729  static int selected_tile_mode = 3;
3730 
3731  ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
3732  {
3733  ImGui::SliderFloat("Rotation (degrees)", &rotation, -180, 180);
3734  ImGui::SliderFloat("Scale", &scale, 0, 2.0);
3735  ImGui::Combo("Tile mode", &selected_tile_mode, tile_mode_names,
3736  sizeof(tile_mode_names) / sizeof(char*));
3737  }
3738  ImGui::End();
3739 
3740  Canvas canvas;
3741  Rect bounds =
3742  Rect::MakeXYWH(0, 0, boston->GetSize().width, boston->GetSize().height);
3743  Vector2 image_center = Vector2(bounds.GetSize() / 2);
3744  Paint paint = {.image_filter =
3745  ImageFilter::MakeBlur(Sigma(20.0), Sigma(20.0),
3746  FilterContents::BlurStyle::kNormal,
3747  tile_modes[selected_tile_mode])};
3748  auto [handle_a, handle_b] = IMPELLER_PLAYGROUND_LINE(
3749  Point(362, 309), Point(662, 459), 20, Color::Red(), Color::Red());
3750  Vector2 center = Vector2(1024, 768) / 2;
3751  canvas.Scale(GetContentScale());
3752  canvas.ClipRect(
3753  Rect::MakeLTRB(handle_a.x, handle_a.y, handle_b.x, handle_b.y));
3754  canvas.Translate({center.x, center.y, 0});
3755  canvas.Scale({scale, scale, 1});
3756  canvas.Rotate(Degrees(rotation));
3757 
3758  canvas.DrawImageRect(std::make_shared<Image>(boston), /*source=*/bounds,
3759  /*dest=*/bounds.Shift(-image_center), paint);
3760  return canvas.EndRecordingAsPicture();
3761  };
3762 
3763  ASSERT_TRUE(OpenPlaygroundHere(callback));
3764 }
3765 
3766 TEST_P(AiksTest, SubpassWithClearColorOptimization) {
3767  Canvas canvas;
3768 
3769  // Use a non-srcOver blend mode to ensure that we don't detect this as an
3770  // opacity peephole optimization.
3771  canvas.SaveLayer(
3772  {.color = Color::Blue().WithAlpha(0.5), .blend_mode = BlendMode::kSource},
3773  Rect::MakeLTRB(0, 0, 200, 200));
3774  canvas.DrawPaint(
3775  {.color = Color::BlackTransparent(), .blend_mode = BlendMode::kSource});
3776  canvas.Restore();
3777 
3778  canvas.SaveLayer(
3779  {.color = Color::Blue(), .blend_mode = BlendMode::kDestinationOver});
3780  canvas.Restore();
3781 
3782  // This playground should appear blank on CI since we are only drawing
3783  // transparent black. If the clear color optimization is broken, the texture
3784  // will be filled with NaNs and may produce a magenta texture on macOS or iOS.
3785  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
3786 }
3787 } // namespace testing
3788 } // namespace impeller
BLEND_MODE_TEST
#define BLEND_MODE_TEST(blend_mode)
Definition: aiks_unittests.cc:2277
impeller::Color::DarkMagenta
static constexpr Color DarkMagenta()
Definition: color.h:378
impeller::Canvas::DrawPoints
void DrawPoints(std::vector< Point > points, Scalar radius, const Paint &paint, PointStyle point_style)
Definition: canvas.cc:563
impeller::Color::Blue
static constexpr Color Blue()
Definition: color.h:268
typeface_stb.h
impeller::Entity::ClipOperation::kIntersect
@ kIntersect
path.h
impeller::AiksPlayground
Definition: aiks_playground.h:17
ASSERT_COLOR_NEAR
#define ASSERT_COLOR_NEAR(a, b)
Definition: geometry_asserts.h:159
impeller::Entity::TileMode::kClamp
@ kClamp
impeller::k1OverSqrt2
constexpr float k1OverSqrt2
Definition: constants.h:50
impeller::Canvas::EndRecordingAsPicture
Picture EndRecordingAsPicture()
Definition: canvas.cc:657
impeller::Picture::pass
std::unique_ptr< EntityPass > pass
Definition: picture.h:21
impeller::Canvas::ClipOval
void ClipOval(const Rect &bounds, Entity::ClipOperation clip_op=Entity::ClipOperation::kIntersect)
Definition: canvas.cc:450
capture.h
impeller::PathBuilder::AddQuadraticCurve
PathBuilder & AddQuadraticCurve(Point p1, Point cp, Point p2)
Move to point p1, then insert a quadradic curve from p1 to p2 with the control point cp.
Definition: path_builder.cc:101
impeller::Canvas::DrawRRect
void DrawRRect(const Rect &rect, const Size &corner_radii, const Paint &paint)
Definition: canvas.cc:368
impeller::ImageFilter::MakeDilate
static std::shared_ptr< ImageFilter > MakeDilate(Radius radius_x, Radius radius_y)
Definition: image_filter.cc:29
impeller::TPoint::y
Type y
Definition: point.h:26
impeller::Entity::ClipOperation::kDifference
@ kDifference
impeller::Scalar
float Scalar
Definition: scalar.h:18
image_filter.h
impeller::AiksContext
Definition: aiks_context.h:20
impeller::Canvas::DrawPath
void DrawPath(Path path, const Paint &paint)
Definition: canvas.cc:250
impeller::Color::Red
static constexpr Color Red()
Definition: color.h:264
impeller::Entity::GetTransform
const Matrix & GetTransform() const
Get the global transform matrix for this Entity.
Definition: entity.cc:49
geometry_asserts.h
impeller::Paint::Style::kStroke
@ kStroke
aiks_unittests.h
impeller::ColorSource::MakeLinearGradient
static ColorSource MakeLinearGradient(Point start_point, Point end_point, std::vector< Color > colors, std::vector< Scalar > stops, Entity::TileMode tile_mode, Matrix effect_transform)
Definition: color_source.cc:45
impeller::Paint
Definition: paint.h:22
impeller::testing::BlendModeTest
static Picture BlendModeTest(BlendMode blend_mode, const std::shared_ptr< Image > &src_image, const std::shared_ptr< Image > &dst_image)
Definition: aiks_unittests.cc:2196
impeller::testing::AiksTest
AiksPlayground AiksTest
Definition: aiks_unittests.h:17
impeller::TRect< Scalar >::MakeXYWH
constexpr static TRect MakeXYWH(Type x, Type y, Type width, Type height)
Definition: rect.h:34
impeller::Canvas::Skew
void Skew(Scalar sx, Scalar sy)
Definition: canvas.cc:230
impeller::BlendMode
BlendMode
Definition: color.h:59
impeller::Color::MakeRGBA8
static constexpr Color MakeRGBA8(uint8_t r, uint8_t g, uint8_t b, uint8_t a)
Definition: color.h:154
solid_color_contents.h
impeller::Color
Definition: color.h:124
impeller::testing::TextRenderOptions::color
Color color
Definition: aiks_unittests.cc:679
impeller::BlendMode::kLuminosity
@ kLuminosity
impeller::Paint::color
Color color
Definition: paint.h:51
paint_pass_delegate.h
impeller::Entity::TileMode::kDecal
@ kDecal
impeller::BlendMode::kSource
@ kSource
impeller::PlaygroundBackend::kMetal
@ kMetal
impeller::BlendMode::kColorDodge
@ kColorDodge
impeller::Canvas::DrawTextFrame
void DrawTextFrame(const std::shared_ptr< TextFrame > &text_frame, Point position, const Paint &paint)
Definition: canvas.cc:702
impeller::BlendMode::kDestination
@ kDestination
impeller::Color::Purple
static constexpr Color Purple()
Definition: color.h:734
impeller::Canvas
Definition: canvas.h:48
impeller::PathBuilder
Definition: path_builder.h:14
impeller::Paint::MaskBlurDescriptor::style
FilterContents::BlurStyle style
Definition: paint.h:39
impeller::PointStyle::kRound
@ kRound
Points are drawn as squares.
impeller::testing::TextRenderOptions::mask_blur_descriptor
std::optional< Paint::MaskBlurDescriptor > mask_blur_descriptor
Definition: aiks_unittests.cc:681
impeller::Vector2
Point Vector2
Definition: point.h:312
impeller::Canvas::DrawVertices
void DrawVertices(const std::shared_ptr< VerticesGeometry > &vertices, BlendMode blend_mode, const Paint &paint)
Definition: canvas.cc:746
impeller::BlendMode::kColor
@ kColor
impeller::kPi
constexpr float kPi
Definition: constants.h:26
impeller::ImageFilter::MakeBlur
static std::shared_ptr< ImageFilter > MakeBlur(Sigma sigma_x, Sigma sigma_y, FilterContents::BlurStyle blur_style, Entity::TileMode tile_mode)
Definition: image_filter.cc:20
impeller::BlendMode::kDestinationOver
@ kDestinationOver
impeller::BlendMode::kPlus
@ kPlus
BLEND_MODE_TUPLE
#define BLEND_MODE_TUPLE(blend_mode)
Definition: aiks_unittests.cc:1000
impeller::Paint::MaskBlurDescriptor
Definition: paint.h:38
IMPELLER_PLAYGROUND_POINT
#define IMPELLER_PLAYGROUND_POINT(default_position, radius, color)
Definition: widgets.h:15
impeller::Color::CornflowerBlue
static constexpr Color CornflowerBlue()
Definition: color.h:334
impeller::testing::TextRenderOptions
Definition: aiks_unittests.cc:677
impeller::Canvas::DebugOptions::offscreen_texture_checkerboard
bool offscreen_texture_checkerboard
Definition: canvas.h:55
impeller::PathBuilder::AddRoundedRect
PathBuilder & AddRoundedRect(Rect rect, RoundingRadii radii)
Definition: path_builder.cc:149
impeller::Color::Yellow
static constexpr Color Yellow()
Definition: color.h:834
impeller::Radians::radians
Scalar radians
Definition: scalar.h:39
impeller::Color::Fuchsia
static constexpr Color Fuchsia()
Definition: color.h:458
impeller::ColorSource::MakeImage
static ColorSource MakeImage(std::shared_ptr< Texture > texture, Entity::TileMode x_tile_mode, Entity::TileMode y_tile_mode, SamplerDescriptor sampler_descriptor, Matrix effect_transform)
Definition: color_source.cc:163
impeller::Size
TSize< Scalar > Size
Definition: size.h:137
impeller::Canvas::debug_options
struct impeller::Canvas::DebugOptions debug_options
impeller::FilterContents::BlurStyle::kNormal
@ kNormal
Blurred inside and outside.
impeller::PathBuilder::SetConvexity
PathBuilder & SetConvexity(Convexity value)
Definition: path_builder.cc:84
sweep_gradient_contents.h
impeller::Canvas::SaveLayer
void SaveLayer(const Paint &paint, std::optional< Rect > bounds=std::nullopt, const std::shared_ptr< ImageFilter > &backdrop_filter=nullptr)
Definition: canvas.cc:676
impeller::Entity::TileMode::kRepeat
@ kRepeat
impeller::Matrix::MakeTranslation
static constexpr Matrix MakeTranslation(const Vector3 &t)
Definition: matrix.h:95
impeller::Paint::color_source
ColorSource color_source
Definition: paint.h:52
impeller::PlaygroundBackendToRuntimeStageBackend
constexpr RuntimeStageBackend PlaygroundBackendToRuntimeStageBackend(PlaygroundBackend backend)
Definition: playground.h:35
impeller::Vector3::x
Scalar x
Definition: vector.h:23
impeller::Canvas::DrawRect
void DrawRect(const Rect &rect, const Paint &paint)
Definition: canvas.cc:321
impeller::Canvas::GetCurrentTransform
const Matrix & GetCurrentTransform() const
Definition: canvas.cc:205
impeller::BlendMode::kModulate
@ kModulate
impeller::PathBuilder::AddRect
PathBuilder & AddRect(Rect rect)
Definition: path_builder.cc:116
impeller::Color::Maroon
static constexpr Color Maroon()
Definition: color.h:606
impeller::PathBuilder::RoundingRadii::bottom_right
Point bottom_right
Definition: path_builder.h:111
impeller::testing::TextRenderOptions::font_size
Scalar font_size
Definition: aiks_unittests.cc:678
impeller::testing::RenderTextInCanvasSTB
bool RenderTextInCanvasSTB(const std::shared_ptr< Context > &context, Canvas &canvas, const std::string &text, const std::string &font_fixture, TextRenderOptions options={})
Definition: aiks_unittests.cc:721
impeller::kPiOver2
constexpr float kPiOver2
Definition: constants.h:32
impeller::Matrix::MakeLookAt
static constexpr Matrix MakeLookAt(Vector3 position, Vector3 target, Vector3 up)
Definition: matrix.h:494
typographer_context_skia.h
impeller::Canvas::DrawImage
void DrawImage(const std::shared_ptr< Image > &image, Point offset, const Paint &paint, SamplerDescriptor sampler={})
Definition: canvas.cc:612
impeller::Matrix::MakePerspective
static constexpr Matrix MakePerspective(Radians fov_y, Scalar aspect_ratio, Scalar z_near, Scalar z_far)
Definition: matrix.h:468
impeller::ImageFilter::MakeFromColorFilter
static std::shared_ptr< ImageFilter > MakeFromColorFilter(const ColorFilter &color_filter)
Definition: image_filter.cc:52
impeller::Canvas::DrawPicture
void DrawPicture(const Picture &picture)
Definition: canvas.cc:583
impeller::Entity::TileMode::kMirror
@ kMirror
impeller::MakeTextFrameSTB
std::shared_ptr< TextFrame > MakeTextFrameSTB(const std::shared_ptr< TypefaceSTB > &typeface_stb, Font::Metrics metrics, const std::string &text)
Definition: text_frame_stb.cc:11
impeller::Entity::SetContents
void SetContents(std::shared_ptr< Contents > contents)
Definition: entity.cc:81
path_builder.h
impeller::kPhi
constexpr float kPhi
Definition: constants.h:53
impeller::SamplerDescriptor
Definition: sampler_descriptor.h:15
impeller::PathBuilder::RoundingRadii
Definition: path_builder.h:107
impeller::testing::INSTANTIATE_PLAYGROUND_SUITE
INSTANTIATE_PLAYGROUND_SUITE(AiksTest)
matrix.h
impeller::Color::Magenta
static constexpr Color Magenta()
Definition: color.h:602
impeller::Entity
Definition: entity.h:21
impeller::BlendMode::kLighten
@ kLighten
text_frame_skia.h
impeller::Paint::color_filter
std::shared_ptr< ColorFilter > color_filter
Definition: paint.h:64
impeller::Picture
Definition: picture.h:20
impeller::TSize< Scalar >
impeller::Canvas::DrawImageRect
void DrawImageRect(const std::shared_ptr< Image > &image, Rect source, Rect dest, const Paint &paint, SamplerDescriptor sampler={})
Definition: canvas.cc:626
impeller::PointStyle::kSquare
@ kSquare
Points are drawn as circles.
impeller::Point
TPoint< Scalar > Point
Definition: point.h:308
impeller::k2Pi
constexpr float k2Pi
Definition: constants.h:29
impeller::CaptureContext::MakeAllowlist
static CaptureContext MakeAllowlist(std::initializer_list< std::string > allowlist)
Definition: capture.cc:159
impeller::ColorSource
Definition: color_source.h:28
impeller::CaptureContext
Definition: capture.h:269
impeller::Canvas::Scale
void Scale(const Vector2 &scale)
Definition: canvas.cc:222
impeller::Color::OrangeRed
static constexpr Color OrangeRed()
Definition: color.h:686
impeller::BlendMode::kHardLight
@ kHardLight
node.h
material.h
impeller::Radius
For convolution filters, the "radius" is the size of the convolution kernel to use on the local space...
Definition: sigma.h:48
impeller::Matrix::GetScale
constexpr Vector3 GetScale() const
Definition: matrix.h:303
impeller::ColorFilter::MakeBlend
static std::shared_ptr< ColorFilter > MakeBlend(BlendMode blend_mode, Color color)
Definition: color_filter.cc:23
widgets.h
impeller::Canvas::Save
void Save()
Definition: canvas.cc:132
impeller::testing::GetBlendModeSelection
static BlendModeSelection GetBlendModeSelection()
Definition: aiks_unittests.cc:1007
conical_gradient_contents.h
impeller::Picture::Snapshot
std::optional< Snapshot > Snapshot(AiksContext &context)
Definition: picture.cc:17
impeller::BlendMode::kClear
@ kClear
text_frame_stb.h
impeller::Paint::style
Style style
Definition: paint.h:59
impeller::Color::DarkBlue
static constexpr Color DarkBlue()
Definition: color.h:350
impeller::EntityPass::Element
std::variant< Entity, std::unique_ptr< EntityPass > > Element
Definition: entity_pass.h:36
impeller::VerticesGeometry::VertexMode::kTriangleStrip
@ kTriangleStrip
impeller::Color::WithAlpha
constexpr Color WithAlpha(Scalar new_alpha) const
Definition: color.h:270
impeller::Entity::kLastAdvancedBlendMode
static constexpr BlendMode kLastAdvancedBlendMode
Definition: entity.h:24
impeller::ImageFilter::MakeLocalMatrix
static std::shared_ptr< ImageFilter > MakeLocalMatrix(const Matrix &matrix, const ImageFilter &internal_filter)
Definition: image_filter.cc:57
impeller::Paint::Style::kFill
@ kFill
impeller::SolidColorContents
Definition: solid_color_contents.h:25
impeller::Color::SkyBlue
static constexpr Color SkyBlue()
Definition: color.h:774
impeller::TRect< Scalar >::MakeOriginSize
constexpr static TRect MakeOriginSize(const TPoint< Type > &origin, const TSize< Type > &size)
Definition: rect.h:38
impeller::Canvas::DrawCircle
void DrawCircle(const Point &center, Scalar radius, const Paint &paint)
Definition: canvas.cc:395
impeller::Color::LightCoral
static constexpr Color LightCoral()
Definition: color.h:534
impeller::TypographerContextSTB::Make
static std::unique_ptr< TypographerContext > Make()
Definition: typographer_context_stb.cc:29
impeller::Color::Grey
static constexpr Color Grey()
Definition: color.h:486
impeller::Entity::GetContents
const std::shared_ptr< Contents > & GetContents() const
Definition: entity.cc:85
impeller::Color::White
static constexpr Color White()
Definition: color.h:256
impeller::Sigma
In filters that use Gaussian distributions, "sigma" is a size of one standard deviation in terms of t...
Definition: sigma.h:32
impeller::PathBuilder::RoundingRadii::top_left
Point top_left
Definition: path_builder.h:108
impeller::Canvas::Restore
bool Restore()
Definition: canvas.cc:168
impeller::Radians
Definition: scalar.h:38
impeller::ImageFilter::MakeErode
static std::shared_ptr< ImageFilter > MakeErode(Radius radius_x, Radius radius_y)
Definition: image_filter.cc:34
impeller::Canvas::DrawAtlas
void DrawAtlas(const std::shared_ptr< Image > &atlas, std::vector< Matrix > transforms, std::vector< Rect > texture_coordinates, std::vector< Color > colors, BlendMode blend_mode, SamplerDescriptor sampler, std::optional< Rect > cull_rect, const Paint &paint)
Definition: canvas.cc:806
impeller::PathBuilder::AddLine
PathBuilder & AddLine(const Point &p1, const Point &p2)
Move to point p1, then insert a line from p1 to p2.
Definition: path_builder.cc:370
canvas.h
impeller::Color::Green
static constexpr Color Green()
Definition: color.h:266
impeller::PathBuilder::TakePath
Path TakePath(FillType fill=FillType::kNonZero)
Definition: path_builder.cc:21
impeller::Canvas::DrawPaint
void DrawPaint(const Paint &paint)
Definition: canvas.cc:260
filter_input.h
impeller::Canvas::GetSaveCount
size_t GetSaveCount() const
Definition: canvas.cc:238
ASSERT_MATRIX_NEAR
#define ASSERT_MATRIX_NEAR(a, b)
Definition: geometry_asserts.h:156
impeller::testing::TextRenderOptions::position
Point position
Definition: aiks_unittests.cc:680
impeller::TRect::Shift
constexpr TRect< T > Shift(TPoint< T > offset) const
Returns a new rectangle translated by the given offset.
Definition: rect.h:366
impeller::testing::BlendModeSelection
Definition: aiks_unittests.cc:1002
impeller::Entity::TileMode
TileMode
Definition: entity.h:40
IMPELLER_FOR_EACH_BLEND_MODE
#define IMPELLER_FOR_EACH_BLEND_MODE(V)
Definition: color.h:19
impeller::MakeTextFrameFromTextBlobSkia
std::shared_ptr< TextFrame > MakeTextFrameFromTextBlobSkia(const sk_sp< SkTextBlob > &blob)
Definition: text_frame_skia.cc:41
impeller::TPoint::x
Type x
Definition: point.h:25
impeller::ColorSource::MakeRadialGradient
static ColorSource MakeRadialGradient(Point center, Scalar radius, std::vector< Color > colors, std::vector< Scalar > stops, Entity::TileMode tile_mode, Matrix effect_transform)
Definition: color_source.cc:108
impeller::ImageFilter::MakeMatrix
static std::shared_ptr< ImageFilter > MakeMatrix(const Matrix &matrix, SamplerDescriptor sampler_descriptor)
Definition: image_filter.cc:39
impeller::ColorFilter::MakeMatrix
static std::shared_ptr< ColorFilter > MakeMatrix(ColorMatrix color_matrix)
Definition: color_filter.cc:28
impeller::Canvas::ClipRRect
void ClipRRect(const Rect &rect, const Size &corner_radii, Entity::ClipOperation clip_op=Entity::ClipOperation::kIntersect)
Definition: canvas.cc:470
impeller::Color::AntiqueWhite
static constexpr Color AntiqueWhite()
Definition: color.h:278
impeller::ImageFilter::MakeCompose
static std::shared_ptr< ImageFilter > MakeCompose(const ImageFilter &inner, const ImageFilter &outer)
Definition: image_filter.cc:46
impeller::Picture::ToImage
std::shared_ptr< Image > ToImage(AiksContext &context, ISize size) const
Definition: picture.cc:31
impeller::Color::MediumTurquoise
static constexpr Color MediumTurquoise()
Definition: color.h:638
command_buffer.h
impeller::ColorSource::MakeRuntimeEffect
static ColorSource MakeRuntimeEffect(std::shared_ptr< RuntimeStage > runtime_stage, std::shared_ptr< std::vector< uint8_t >> uniform_data, std::vector< RuntimeEffectContents::TextureInput > texture_inputs)
Definition: color_source.cc:193
impeller::Canvas::DrawOval
void DrawOval(const Rect &rect, const Paint &paint)
Definition: canvas.cc:341
impeller::CaptureProperty
A capturable property type.
Definition: capture.h:68
impeller::testing::RenderTextInCanvasSkia
bool RenderTextInCanvasSkia(const std::shared_ptr< Context > &context, Canvas &canvas, const std::string &text, const std::string_view &font_fixture, TextRenderOptions options={})
Definition: aiks_unittests.cc:684
impeller::Color::GreenYellow
static constexpr Color GreenYellow()
Definition: color.h:482
FLT_FORWARD
#define FLT_FORWARD(mock, real, method)
Definition: aiks_unittests.cc:3601
impeller::TRect::GetSize
constexpr TSize< Type > GetSize() const
Returns the size of the rectangle as specified when it was constructed and which may be negative in e...
Definition: rect.h:159
impeller::Matrix::MakeRotationZ
static Matrix MakeRotationZ(Radians r)
Definition: matrix.h:209
impeller::Canvas::Rotate
void Rotate(Radians radians)
Definition: canvas.cc:234
image.h
impeller::ColorFilter::MakeLinearToSrgb
static std::shared_ptr< ColorFilter > MakeLinearToSrgb()
Definition: color_filter.cc:36
impeller::Color::Orange
static constexpr Color Orange()
Definition: color.h:682
impeller::TRect< Scalar >::MakeSize
constexpr static TRect MakeSize(const TSize< U > &size)
Definition: rect.h:44
impeller::PathBuilder::RoundingRadii::top_right
Point top_right
Definition: path_builder.h:110
constants.h
snapshot.h
impeller::Entity::Clone
Entity Clone() const
Definition: entity.cc:181
impeller::TPoint< Scalar >
impeller::Canvas::Transform
void Transform(const Matrix &transform)
Definition: canvas.cc:201
impeller::PathBuilder::MoveTo
PathBuilder & MoveTo(Point point, bool relative=false)
Definition: path_builder.cc:37
impeller::Color::BlackTransparent
static constexpr Color BlackTransparent()
Definition: color.h:262
impeller::testing::kFontFixture
static constexpr std::string_view kFontFixture
Definition: aiks_unittests.cc:824
impeller::Color::Black
static constexpr Color Black()
Definition: color.h:258
impeller::Paint::invert_colors
bool invert_colors
Definition: paint.h:61
impeller::PathBuilder::RoundingRadii::bottom_left
Point bottom_left
Definition: path_builder.h:109
impeller::testing::BlendModeSelection::blend_mode_values
std::vector< BlendMode > blend_mode_values
Definition: aiks_unittests.cc:1004
impeller::BlendMode::kScreen
@ kScreen
impeller::ScalarNearlyEqual
constexpr bool ScalarNearlyEqual(Scalar x, Scalar y, Scalar tolerance=kEhCloseEnough)
Definition: scalar.h:30
impeller::Degrees
Definition: scalar.h:46
color.h
impeller::Paint::HasColorFilter
bool HasColorFilter() const
Whether this paint has a color filter that can apply opacity.
Definition: paint.cc:198
impeller::Color::LimeGreen
static constexpr Color LimeGreen()
Definition: color.h:594
color_filter.h
impeller::PathBuilder::AddCircle
PathBuilder & AddCircle(const Point &center, Scalar radius)
Definition: path_builder.cc:134
typographer_context_stb.h
impeller::BlendMode::kHue
@ kHue
impeller::Color::DarkGreen
static constexpr Color DarkGreen()
Definition: color.h:366
radial_gradient_contents.h
impeller::Canvas::ClipRect
void ClipRect(const Rect &rect, Entity::ClipOperation clip_op=Entity::ClipOperation::kIntersect)
Definition: canvas.cc:429
impeller::TRect< Scalar >::MakeLTRB
constexpr static TRect MakeLTRB(Type left, Type top, Type right, Type bottom)
Definition: rect.h:27
impeller::ColorFilter::MakeSrgbToLinear
static std::shared_ptr< ColorFilter > MakeSrgbToLinear()
Definition: color_filter.cc:32
impeller::testing::BlendModeSelection::blend_mode_names
std::vector< const char * > blend_mode_names
Definition: aiks_unittests.cc:1003
impeller::testing::TEST_P
TEST_P(AiksTest, CanRenderLinearGradientClamp)
Definition: aiks_gradient_unittests.cc:48
impeller::Convexity::kConvex
@ kConvex
impeller::scene::Node::MakeFromFlatbuffer
static std::shared_ptr< Node > MakeFromFlatbuffer(const fml::Mapping &ipscene_mapping, Allocator &allocator)
Definition: node.cc:48
impeller::Canvas::ClipPath
void ClipPath(Path path, Entity::ClipOperation clip_op=Entity::ClipOperation::kIntersect)
Definition: canvas.cc:419
impeller::TSize< Scalar >::MakeWH
static constexpr TSize MakeWH(Type width, Type height)
Definition: size.h:34
impeller::RuntimeStageBackend::kMetal
@ kMetal
IMPELLER_PLAYGROUND_LINE
#define IMPELLER_PLAYGROUND_LINE(default_position_a, default_position_b, radius, color_a, color_b)
Definition: widgets.h:56
impeller
Definition: aiks_context.cc:10
impeller::Matrix::MakeScale
static constexpr Matrix MakeScale(const Vector3 &s)
Definition: matrix.h:104
impeller::SolidColorContents::Make
static std::unique_ptr< SolidColorContents > Make(Path path, Color color)
Definition: solid_color_contents.cc:89
impeller::Paint::mask_blur_descriptor
std::optional< MaskBlurDescriptor > mask_blur_descriptor
Definition: paint.h:65
impeller::BlendMode::kMultiply
@ kMultiply
impeller::Paint::stroke_width
Scalar stroke_width
Definition: paint.h:55
impeller::TRect< Scalar >
impeller::Matrix
A 4x4 matrix using column-major storage.
Definition: matrix.h:37
impeller::Vector3
Definition: vector.h:20
impeller::BlendMode::kSourceOver
@ kSourceOver
impeller::Paint::blend_mode
BlendMode blend_mode
Definition: paint.h:60
impeller::Color::Crimson
static constexpr Color Crimson()
Definition: color.h:342
impeller::TRect::Expand
constexpr TRect< T > Expand(T left, T top, T right, T bottom) const
Returns a rectangle with expanded edges. Negative expansion results in shrinking.
Definition: rect.h:373
impeller::Paint::image_filter
std::shared_ptr< ImageFilter > image_filter
Definition: paint.h:63
impeller::TPoint< Scalar >::MakeXY
static constexpr TPoint< Type > MakeXY(Type x, Type y)
Definition: point.h:41
linear_gradient_contents.h
impeller::Canvas::Translate
void Translate(const Vector3 &offset)
Definition: canvas.cc:218
impeller::Color::Blend
Color Blend(Color source, BlendMode blend_mode) const
Blends an unpremultiplied destination color into a given unpremultiplied source color to form a new u...
Definition: color.cc:222