12 #include "flutter/display_list/geometry/dl_path_builder.h"
13 #include "flutter/display_list/testing/dl_test_snippets.h"
14 #include "fml/logging.h"
15 #include "gtest/gtest.h"
55 #include "impeller/renderer/testing/mocks.h"
57 #include "third_party/imgui/imgui.h"
78 auto image = CreateTextureForFixture(
"boston.jpg");
84 auto actual = filter->GetCoverage({});
87 ASSERT_TRUE(actual.has_value());
94 filter->SetCoverageHint(expected);
95 auto actual = filter->GetCoverage({});
97 ASSERT_TRUE(actual.has_value());
122 auto contents = std::make_unique<SolidColorContents>();
124 std::unique_ptr<Geometry> geom =
126 contents->SetGeometry(geom.get());
129 ASSERT_TRUE(OpenPlaygroundHere(std::move(entity)));
133 auto bridge = CreateTextureForFixture(
"bay_bridge.jpg");
145 auto contents = std::make_unique<TiledTextureContents>();
146 std::unique_ptr<Geometry> geom =
148 contents->SetGeometry(geom.get());
149 contents->SetTexture(bridge);
152 ASSERT_TRUE(OpenPlaygroundHere(std::move(entity)));
157 Point offset(100, 100);
188 auto contents = std::make_unique<SolidColorContents>();
189 std::unique_ptr<Geometry> geom =
191 contents->SetGeometry(geom.get());
195 return entity.
Render(context, pass);
197 ASSERT_TRUE(OpenPlaygroundHere(callback));
202 const Point margin(140, 180);
208 static Scalar miter_limit = 1.41421357;
211 ImGui::Begin(
"Controls",
nullptr, ImGuiWindowFlags_AlwaysAutoResize);
213 ImGui::SliderFloat(
"Miter limit", &miter_limit, 0, 30);
214 ImGui::SliderFloat(
"Stroke width", &width, 0, 100);
215 if (ImGui::Button(
"Reset")) {
216 miter_limit = 1.41421357;
223 auto render_path = [width = width, &context, &pass, &world_matrix](
225 auto contents = std::make_unique<SolidColorContents>();
226 std::unique_ptr<Geometry> geom =
231 .miter_limit = miter_limit,
233 contents->SetGeometry(geom.get());
241 if (coverage.has_value()) {
242 auto bounds_contents = std::make_unique<SolidColorContents>();
245 flutter::DlPath::MakeRect(entity.
GetCoverage().value()));
247 bounds_contents->SetGeometry(geom.get());
248 bounds_contents->SetColor(
Color::Green().WithAlpha(0.5));
250 bounds_entity.
SetContents(std::move(bounds_contents));
251 bounds_entity.
Render(context, pass);
254 entity.
Render(context, pass);
257 const Point a_def(0, 0), b_def(0, 100), c_def(150, 0), d_def(150, -100),
269 render_path(flutter::DlPathBuilder{}
271 .CubicCurveTo(
b, d, c)
285 render_path(flutter::DlPathBuilder{}
287 .CubicCurveTo(
b, d, c)
301 render_path(flutter::DlPathBuilder{}
303 .CubicCurveTo(
b, d, c)
320 render_path(flutter::DlPathBuilder{}
338 render_path(flutter::DlPathBuilder{}
356 render_path(flutter::DlPathBuilder{}
367 ASSERT_TRUE(OpenPlaygroundHere(callback));
373 flutter::DlPathBuilder{}
374 .MoveTo({237.164, 125.003})
375 .CubicCurveTo({236.709, 125.184}, {236.262, 125.358},
377 .CubicCurveTo({235.413, 125.68}, {234.994, 125.832},
379 .CubicCurveTo({234.592, 125.977}, {234.591, 125.977},
381 .CubicCurveTo({222.206, 130.435}, {207.708, 135.753},
383 .CubicCurveTo({162.77, 151.336}, {122.17, 156.894}, {84.1123, 160})
391 auto contents = std::make_shared<SolidColorContents>();
393 contents->SetGeometry(geom.get());
396 ASSERT_TRUE(OpenPlaygroundHere(std::move(entity)));
401 const char* input_axis[] = {
"X",
"Y",
"Z"};
402 static int rotation_axis_index = 0;
403 static float rotation = 0;
404 ImGui::Begin(
"Controls",
nullptr, ImGuiWindowFlags_AlwaysAutoResize);
405 ImGui::SliderFloat(
"Rotation", &rotation, -
kPi,
kPi);
406 ImGui::Combo(
"Rotation Axis", &rotation_axis_index, input_axis,
407 sizeof(input_axis) /
sizeof(
char*));
409 switch (rotation_axis_index) {
420 rotation_matrix =
Matrix{};
424 if (ImGui::Button(
"Reset")) {
428 Matrix current_transform =
432 pass.GetRenderTargetSize().height / 2.0)));
433 Matrix result_transform = current_transform * rotation_matrix;
442 auto contents = std::make_shared<SolidColorContents>();
444 contents->SetGeometry(geom.get());
447 return entity.
Render(context, pass);
449 ASSERT_TRUE(OpenPlaygroundHere(callback));
455 flutter::DlPathBuilder{}
456 .MoveTo({359.934, 96.6335})
457 .CubicCurveTo({358.189, 96.7055}, {356.436, 96.7908},
459 .CubicCurveTo({354.571, 96.8953}, {354.469, 96.9016},
461 .CubicCurveTo({352.672, 97.0038}, {350.969, 97.113},
463 .CubicCurveTo({349.048, 97.2506}, {348.836, 97.2678},
465 .CubicCurveTo({347.019, 97.4014}, {345.407, 97.5299},
467 .CubicCurveTo({343.428, 97.704}, {343.065, 97.7402},
469 .CubicCurveTo({341.221, 97.9086}, {339.736, 98.0505},
471 .CubicCurveTo({337.702, 98.2642}, {337.156, 98.3292},
473 .CubicCurveTo({335.284, 98.5356}, {333.956, 98.6837},
475 .CubicCurveTo({332.495, 98.8635}, {332.366, 98.8818},
477 .
LineTo({332.237, 102.601})
478 .
LineTo({321.778, 102.601})
479 .
LineTo({321.778, 100.382})
480 .CubicCurveTo({321.572, 100.413}, {321.367, 100.442},
482 .CubicCurveTo({319.22, 100.79}, {317.277, 101.123},
484 .CubicCurveTo({315.322, 101.481}, {315.311, 101.482},
486 .
LineTo({310.017, 105.94})
487 .
LineTo({309.779, 105.427})
488 .
LineTo({314.403, 101.651})
489 .CubicCurveTo({314.391, 101.653}, {314.379, 101.656},
491 .CubicCurveTo({312.528, 102.001}, {310.687, 102.366},
493 .CubicCurveTo({307.85, 102.955}, {306.855, 103.182}, {305.859, 103.4})
494 .CubicCurveTo({305.048, 103.579}, {304.236, 103.75},
496 .
LineTo({299.105, 107.578})
497 .
LineTo({298.867, 107.065})
498 .
LineTo({302.394, 104.185})
499 .
LineTo({302.412, 104.171})
500 .CubicCurveTo({301.388, 104.409}, {300.366, 104.67},
502 .CubicCurveTo({298.618, 105.1}, {297.89, 105.269}, {297.165, 105.455})
503 .CubicCurveTo({295.262, 105.94}, {293.36, 106.445},
505 .CubicCurveTo({291.132, 107.072}, {290.802, 107.163},
507 .CubicCurveTo({289.463, 107.544}, {288.455, 107.839},
509 .CubicCurveTo({286.476, 108.431}, {285.506, 108.73},
511 .CubicCurveTo({283.674, 109.304}, {282.812, 109.579},
513 .CubicCurveTo({281.177, 110.112}, {280.406, 110.377},
515 .CubicCurveTo({278.458, 111.037}, {277.256, 111.449},
517 .CubicCurveTo({276.76, 111.622}, {276.716, 111.637},
519 .CubicCurveTo({275.017, 112.239}, {273.365, 112.836},
521 .
LineTo({271.717, 113.449})
522 .CubicCurveTo({271.496, 113.496}, {271.238, 113.559},
524 .CubicCurveTo({270.893, 113.645}, {270.822, 113.663},
526 .CubicCurveTo({270.468, 113.755}, {270.169, 113.834},
528 .CubicCurveTo({269.789, 113.94}, {269.732, 113.957},
530 .CubicCurveTo({269.391, 114.053}, {269.081, 114.143},
532 .CubicCurveTo({268.628, 114.276}, {268.5, 114.314},
534 .CubicCurveTo({268.172, 114.412}, {267.959, 114.478},
536 .CubicCurveTo({263.349, 115.964}, {258.058, 117.695},
538 .CubicCurveTo({253.556, 119.255}, {253.547, 119.258},
540 .CubicCurveTo({251.844, 119.849}, {250.056, 120.474},
542 .CubicCurveTo({248, 121.197}, {247.812, 121.264}, {247.621, 121.331})
543 .CubicCurveTo({247.079, 121.522}, {246.531, 121.715},
545 .CubicCurveTo({245.554, 122.06}, {245.126, 122.212},
547 .CubicCurveTo({244.071, 122.586}, {243.437, 122.811},
549 .CubicCurveTo({242.189, 123.255}, {241.58, 123.472},
551 .CubicCurveTo({240.659, 123.801}, {240.357, 123.909},
553 .CubicCurveTo({239.12, 124.351}, {238.18, 124.687}, {237.22, 125.032})
554 .
LineTo({237.164, 125.003})
555 .CubicCurveTo({236.709, 125.184}, {236.262, 125.358},
557 .CubicCurveTo({235.413, 125.68}, {234.994, 125.832},
559 .CubicCurveTo({234.592, 125.977}, {234.591, 125.977},
561 .CubicCurveTo({222.206, 130.435}, {207.708, 135.753},
563 .CubicCurveTo({162.77, 151.336}, {122.17, 156.894}, {84.1123, 160})
568 .CubicCurveTo({359.978, 96.6317}, {359.956, 96.6326},
571 .MoveTo({337.336, 124.143})
572 .CubicCurveTo({337.274, 122.359}, {338.903, 121.511},
574 .CubicCurveTo({338.903, 121.511}, {338.96, 123.303},
577 .MoveTo({340.082, 121.849})
578 .CubicCurveTo({340.074, 121.917}, {340.062, 121.992},
580 .CubicCurveTo({340.039, 122.109}, {340.031, 122.142},
582 .CubicCurveTo({340.005, 122.26}, {339.98, 122.346},
584 .CubicCurveTo({339.941, 122.473}, {339.931, 122.507},
586 .CubicCurveTo({339.873, 122.672}, {339.819, 122.804},
588 .CubicCurveTo({339.747, 122.944}, {339.743, 122.949},
590 .CubicCurveTo({339.674, 123.08}, {339.593, 123.205},
592 .CubicCurveTo({339.473, 123.366}, {339.441, 123.401},
594 .CubicCurveTo({339.332, 123.534}, {339.243, 123.625},
596 .CubicCurveTo({339.105, 123.75}, {339.068, 123.786},
598 .CubicCurveTo({338.881, 123.937}, {338.724, 124.048},
600 .CubicCurveTo({338.532, 123.959}, {338.554, 123.79},
602 .CubicCurveTo({338.58, 123.625}, {338.58, 123.625}, {338.58, 123.625})
603 .CubicCurveTo({338.607, 123.455}, {338.65, 123.299},
605 .CubicCurveTo({338.708, 123.14}, {338.71, 123.127},
607 .CubicCurveTo({338.769, 122.971}, {338.833, 122.838},
609 .CubicCurveTo({338.911, 122.702}, {338.916, 122.69200000000001},
611 .CubicCurveTo({338.996, 122.557}, {339.072, 122.444},
613 .CubicCurveTo({339.161, 122.333}, {339.166, 122.326},
615 .CubicCurveTo({339.256, 122.215}, {339.339, 122.12},
617 .CubicCurveTo({339.428, 122.033}, {339.431, 122.03},
619 .CubicCurveTo({339.785, 121.687}, {340.106, 121.511},
621 .CubicCurveTo({340.106, 121.511}, {340.107, 121.645},
624 .MoveTo({340.678, 113.245})
625 .CubicCurveTo({340.594, 113.488}, {340.356, 113.655},
627 .CubicCurveTo({339.817, 113.948}, {339.465, 114.059},
629 .CubicCurveTo({338.251, 114.379}, {337.34, 114.516},
631 .CubicCurveTo({335.761, 114.516}, {335.072, 114.527},
633 .CubicCurveTo({334.125, 114.508}, {333.862, 114.462},
635 .CubicCurveTo({332.865, 114.318}, {332.096, 114.184},
637 .CubicCurveTo({330.979, 113.695}, {330.442, 113.34},
639 .CubicCurveTo({331.135, 111.755}, {333.219, 112.946},
641 .CubicCurveTo({334.54, 113.816}, {334.554, 113.8}, {334.569, 113.784})
642 .CubicCurveTo({333.38, 112.708}, {331.749, 110.985},
644 .CubicCurveTo({333.769, 109.82}, {334.713, 111.93},
646 .CubicCurveTo({334.915, 111.889}, {334.59, 109.636},
648 .CubicCurveTo({336.733, 109.636}, {336.408, 111.889},
650 .CubicCurveTo({336.609, 111.93}, {337.553, 109.82},
652 .CubicCurveTo({339.574, 110.984}, {337.942, 112.708},
654 .CubicCurveTo({336.768, 113.8}, {336.782, 113.816},
656 .CubicCurveTo({338.104, 112.946}, {340.187, 111.755},
658 .CubicCurveTo({340.71, 112.95}, {340.728, 113.102},
661 .MoveTo({346.357, 106.771})
662 .CubicCurveTo({346.295, 104.987}, {347.924, 104.139},
664 .CubicCurveTo({347.924, 104.139}, {347.982, 105.931},
667 .MoveTo({347.56, 106.771})
668 .CubicCurveTo({347.498, 104.987}, {349.127, 104.139},
670 .CubicCurveTo({349.127, 104.139}, {349.185, 105.931},
679 auto contents = std::make_shared<SolidColorContents>();
681 contents->SetGeometry(geom.get());
684 ASSERT_TRUE(OpenPlaygroundHere(std::move(entity)));
692 ASSERT_EQ(path_geometry->GetStrokeCap(),
Cap::kButt);
693 ASSERT_EQ(path_geometry->GetStrokeJoin(),
Join::kMiter);
715 ASSERT_EQ(path_geometry->GetStrokeCap(),
Cap::kRound);
723 ASSERT_FLOAT_EQ(path_geometry->GetMiterLimit(), 4);
733 ASSERT_FLOAT_EQ(path_geometry->GetMiterLimit(), 8);
740 .miter_limit = -1.0f,
743 ASSERT_FLOAT_EQ(path_geometry->GetMiterLimit(), 4);
748 std::vector<const char*> blend_mode_names;
749 std::vector<BlendMode> blend_mode_values;
762 blend_mode_names.push_back(
"Clear");
765 blend_mode_names.push_back(
"Source");
768 blend_mode_names.push_back(
"Destination");
771 blend_mode_names.push_back(
"SourceOver");
774 blend_mode_names.push_back(
"DestinationOver");
777 blend_mode_names.push_back(
"SourceIn");
780 blend_mode_names.push_back(
"DestinationIn");
783 blend_mode_names.push_back(
"SourceOut");
786 blend_mode_names.push_back(
"DestinationOut");
789 blend_mode_names.push_back(
"SourceATop");
792 blend_mode_names.push_back(
"DestinationATop");
795 blend_mode_names.push_back(
"Xor");
798 blend_mode_names.push_back(
"Plus");
801 blend_mode_names.push_back(
"Modulate");
808 auto draw_rect = [&context, &pass, &world_matrix](
815 auto r = rect.GetLTRB();
826 pass.SetCommandLabel(
"Blended Rectangle");
828 options.blend_mode = blend_mode;
831 pass.SetVertexBuffer(
834 VS::FrameInfo frame_info;
835 frame_info.mvp = pass.GetOrthographicTransform() * world_matrix;
838 FS::FragInfo frag_info;
839 frag_info.color = color.Premultiply();
842 return pass.Draw().ok();
845 ImGui::Begin(
"Controls",
nullptr, ImGuiWindowFlags_AlwaysAutoResize);
846 static Color color1(1, 0, 0, 0.5), color2(0, 1, 0, 0.5);
847 ImGui::ColorEdit4(
"Color 1",
reinterpret_cast<float*
>(&color1));
848 ImGui::ColorEdit4(
"Color 2",
reinterpret_cast<float*
>(&color2));
849 static int current_blend_index = 3;
850 ImGui::ListBox(
"Blending mode", ¤t_blend_index,
851 blend_mode_names.data(), blend_mode_names.size());
854 BlendMode selected_mode = blend_mode_values[current_blend_index];
867 pass.GetRenderTargetSize().height),
875 ASSERT_TRUE(OpenPlaygroundHere(callback));
880 static float scale = 20;
882 ImGui::Begin(
"Controls",
nullptr, ImGuiWindowFlags_AlwaysAutoResize);
883 ImGui::SliderFloat(
"Scale", &scale, 1, 100);
888 auto path = flutter::DlPathBuilder{}
889 .MoveTo({97.325, 34.818})
890 .CubicCurveTo({98.50862885295136, 34.81812293973836},
891 {99.46822048142015, 33.85863261475589},
892 {99.46822048142015, 32.67499810206613})
893 .CubicCurveTo({99.46822048142015, 31.491363589376355},
894 {98.50862885295136, 30.53187326439389},
895 {97.32499434685802, 30.531998226542708})
896 .CubicCurveTo({96.14153655073771, 30.532123170035373},
897 {95.18222070648729, 31.491540299350355},
898 {95.18222070648729, 32.67499810206613})
899 .CubicCurveTo({95.18222070648729, 33.85845590478189},
900 {96.14153655073771, 34.81787303409686},
901 {97.32499434685802, 34.81799797758954})
909 auto contents = std::make_shared<SolidColorContents>();
911 contents->SetGeometry(geom.get());
914 return entity.
Render(context, pass);
916 ASSERT_TRUE(OpenPlaygroundHere(callback));
920 auto bridge = CreateTextureForFixture(
"bay_bridge.jpg");
921 auto boston = CreateTextureForFixture(
"boston.jpg");
922 auto kalimba = CreateTextureForFixture(
"kalimba.jpg");
923 ASSERT_TRUE(bridge && boston && kalimba);
941 entity.SetContents(blend1);
942 return entity.Render(context, pass);
944 ASSERT_TRUE(OpenPlaygroundHere(callback));
949 CreateTextureForFixture(
"boston.jpg",
true);
953 const char* input_type_names[] = {
"Texture",
"Solid Color"};
954 const char* blur_type_names[] = {
"Image blur",
"Mask blur"};
955 const char* pass_variation_names[] = {
"New"};
956 const char* blur_style_names[] = {
"Normal",
"Solid",
"Outer",
"Inner"};
957 const char* tile_mode_names[] = {
"Clamp",
"Repeat",
"Mirror",
"Decal"};
966 static int selected_input_type = 0;
968 static int selected_blur_type = 0;
969 static int selected_pass_variation = 0;
970 static bool combined_sigma =
false;
971 static float blur_amount_coarse[2] = {0, 0};
972 static float blur_amount_fine[2] = {10, 10};
973 static int selected_blur_style = 0;
974 static int selected_tile_mode = 3;
975 static Color cover_color(1, 0, 0, 0.2);
976 static Color bounds_color(0, 1, 0, 0.1);
977 static float offset[2] = {500, 400};
978 static float rotation = 0;
979 static float scale[2] = {0.65, 0.65};
980 static float skew[2] = {0, 0};
981 static float path_rect[4] = {0, 0,
982 static_cast<float>(boston->GetSize().width),
983 static_cast<float>(boston->GetSize().height)};
985 ImGui::Begin(
"Controls",
nullptr, ImGuiWindowFlags_AlwaysAutoResize);
987 ImGui::Combo(
"Input type", &selected_input_type, input_type_names,
988 sizeof(input_type_names) /
sizeof(
char*));
989 if (selected_input_type == 0) {
990 ImGui::SliderFloat(
"Input opacity", &input_color.
alpha, 0, 1);
992 ImGui::ColorEdit4(
"Input color",
993 reinterpret_cast<float*
>(&input_color));
995 ImGui::Combo(
"Blur type", &selected_blur_type, blur_type_names,
996 sizeof(blur_type_names) /
sizeof(
char*));
997 if (selected_blur_type == 0) {
998 ImGui::Combo(
"Pass variation", &selected_pass_variation,
999 pass_variation_names,
1000 sizeof(pass_variation_names) /
sizeof(
char*));
1002 ImGui::Checkbox(
"Combined sigma", &combined_sigma);
1003 if (combined_sigma) {
1004 ImGui::SliderFloat(
"Sigma (coarse)", blur_amount_coarse, 0, 1000);
1005 ImGui::SliderFloat(
"Sigma (fine)", blur_amount_fine, 0, 10);
1006 blur_amount_coarse[1] = blur_amount_coarse[0];
1007 blur_amount_fine[1] = blur_amount_fine[0];
1009 ImGui::SliderFloat2(
"Sigma (coarse)", blur_amount_coarse, 0, 1000);
1010 ImGui::SliderFloat2(
"Sigma (fine)", blur_amount_fine, 0, 10);
1012 ImGui::Combo(
"Blur style", &selected_blur_style, blur_style_names,
1013 sizeof(blur_style_names) /
sizeof(
char*));
1014 ImGui::Combo(
"Tile mode", &selected_tile_mode, tile_mode_names,
1015 sizeof(tile_mode_names) /
sizeof(
char*));
1016 ImGui::ColorEdit4(
"Cover color",
reinterpret_cast<float*
>(&cover_color));
1017 ImGui::ColorEdit4(
"Bounds color ",
1018 reinterpret_cast<float*
>(&bounds_color));
1019 ImGui::SliderFloat2(
"Translation", offset, 0,
1020 pass.GetRenderTargetSize().width);
1021 ImGui::SliderFloat(
"Rotation", &rotation, 0,
kPi * 2);
1022 ImGui::SliderFloat2(
"Scale", scale, 0, 3);
1023 ImGui::SliderFloat2(
"Skew", skew, -3, 3);
1024 ImGui::SliderFloat4(
"Path XYWH", path_rect, -1000, 1000);
1028 auto blur_sigma_x =
Sigma{blur_amount_coarse[0] + blur_amount_fine[0]};
1029 auto blur_sigma_y =
Sigma{blur_amount_coarse[1] + blur_amount_fine[1]};
1031 std::shared_ptr<Contents> input;
1035 Rect::MakeXYWH(path_rect[0], path_rect[1], path_rect[2], path_rect[3]);
1037 std::unique_ptr<Geometry> solid_color_input;
1038 if (selected_input_type == 0) {
1039 auto texture = std::make_shared<TextureContents>();
1041 texture->SetDestinationRect(input_rect);
1042 texture->SetTexture(boston);
1043 texture->SetOpacity(input_color.
alpha);
1046 input_size = input_rect.GetSize();
1048 auto fill = std::make_shared<SolidColorContents>();
1049 fill->SetColor(input_color);
1053 fill->SetGeometry(solid_color_input.get());
1056 input_size = input_rect.GetSize();
1059 std::shared_ptr<FilterContents> blur;
1060 switch (selected_pass_variation) {
1062 blur = std::make_shared<GaussianBlurFilterContents>(
1063 blur_sigma_x.sigma, blur_sigma_y.sigma,
1064 tile_modes[selected_tile_mode], blur_styles[selected_blur_style],
1071 tile_modes[selected_tile_mode], blur_styles[selected_blur_style]);
1078 blur_styles[selected_blur_style]);
1087 auto target_contents = selected_blur_type == 0 ? blur : mask_blur;
1093 entity.
Render(context, pass);
1098 std::unique_ptr<Geometry> geom =
1100 auto contents = std::make_shared<SolidColorContents>();
1101 contents->SetColor(cover_color);
1102 contents->SetGeometry(geom.get());
1105 cover_entity.
Render(context, pass);
1109 std::optional<Rect> target_contents_coverage =
1111 if (target_contents_coverage.has_value()) {
1112 std::unique_ptr<Geometry> geom =
1114 target_contents->GetCoverage(entity).value()));
1115 auto contents = std::make_shared<SolidColorContents>();
1116 contents->SetColor(bounds_color);
1117 contents->SetGeometry(geom.get());
1121 bounds_entity.
Render(context, pass);
1126 ASSERT_TRUE(OpenPlaygroundHere(callback));
1130 auto boston = CreateTextureForFixture(
"boston.jpg");
1131 ASSERT_TRUE(boston);
1134 const char* morphology_type_names[] = {
"Dilate",
"Erode"};
1139 static int selected_morphology_type = 0;
1140 static float radius[2] = {20, 20};
1141 static Color cover_color(1, 0, 0, 0.2);
1142 static Color bounds_color(0, 1, 0, 0.1);
1143 static float offset[2] = {500, 400};
1144 static float rotation = 0;
1145 static float scale[2] = {0.65, 0.65};
1146 static float skew[2] = {0, 0};
1147 static float path_rect[4] = {0, 0,
1148 static_cast<float>(boston->GetSize().width),
1149 static_cast<float>(boston->GetSize().height)};
1150 static float effect_transform_scale = 1;
1152 ImGui::Begin(
"Controls",
nullptr, ImGuiWindowFlags_AlwaysAutoResize);
1154 ImGui::Combo(
"Morphology type", &selected_morphology_type,
1155 morphology_type_names,
1156 sizeof(morphology_type_names) /
sizeof(
char*));
1157 ImGui::SliderFloat2(
"Radius", radius, 0, 200);
1158 ImGui::SliderFloat(
"Input opacity", &input_color.
alpha, 0, 1);
1159 ImGui::ColorEdit4(
"Cover color",
reinterpret_cast<float*
>(&cover_color));
1160 ImGui::ColorEdit4(
"Bounds color ",
1161 reinterpret_cast<float*
>(&bounds_color));
1162 ImGui::SliderFloat2(
"Translation", offset, 0,
1163 pass.GetRenderTargetSize().width);
1164 ImGui::SliderFloat(
"Rotation", &rotation, 0,
kPi * 2);
1165 ImGui::SliderFloat2(
"Scale", scale, 0, 3);
1166 ImGui::SliderFloat2(
"Skew", skew, -3, 3);
1167 ImGui::SliderFloat4(
"Path XYWH", path_rect, -1000, 1000);
1168 ImGui::SliderFloat(
"Effect transform scale", &effect_transform_scale, 0,
1173 std::shared_ptr<Contents> input;
1177 Rect::MakeXYWH(path_rect[0], path_rect[1], path_rect[2], path_rect[3]);
1178 auto texture = std::make_shared<TextureContents>();
1180 texture->SetDestinationRect(input_rect);
1181 texture->SetTexture(boston);
1182 texture->SetOpacity(input_color.
alpha);
1185 input_size = input_rect.GetSize();
1189 morphology_types[selected_morphology_type]);
1191 Vector2{effect_transform_scale, effect_transform_scale}));
1204 entity.
Render(context, pass);
1209 std::unique_ptr<Geometry> geom =
1211 auto cover_contents = std::make_shared<SolidColorContents>();
1212 cover_contents->SetColor(cover_color);
1213 cover_contents->SetGeometry(geom.get());
1216 cover_entity.
Render(context, pass);
1221 flutter::DlPath::MakeRect(contents->GetCoverage(entity).value()));
1222 auto bounds_contents = std::make_shared<SolidColorContents>();
1223 bounds_contents->SetColor(bounds_color);
1224 bounds_contents->SetGeometry(bounds_geom.get());
1225 bounds_entity.
SetContents(std::move(bounds_contents));
1228 bounds_entity.
Render(context, pass);
1232 ASSERT_TRUE(OpenPlaygroundHere(callback));
1244 entity.
SetContents(std::make_shared<SolidColorContents>());
1251 flutter::DlPath::MakeLine({0, 0}, {10, 10}),
1256 .miter_limit = 4.0f,
1260 auto contents = std::make_unique<SolidColorContents>();
1261 contents->SetGeometry(geometry.get());
1263 entity.SetContents(std::move(contents));
1264 auto actual = entity.GetCoverage();
1267 ASSERT_TRUE(actual.has_value());
1274 flutter::DlPath::MakeLine({0, 0}, {10, 10}),
1283 auto contents = std::make_unique<SolidColorContents>();
1284 contents->SetGeometry(geometry.get());
1286 entity.SetContents(std::move(contents));
1287 auto actual = entity.GetCoverage();
1291 ASSERT_TRUE(actual.has_value());
1298 flutter::DlPath::MakeLine({0, 0}, {10, 10}),
1303 .miter_limit = 2.0f,
1307 auto contents = std::make_unique<SolidColorContents>();
1308 contents->SetGeometry(geometry.get());
1310 entity.SetContents(std::move(contents));
1311 auto actual = entity.GetCoverage();
1314 ASSERT_TRUE(actual.has_value());
1320 auto fill = std::make_shared<SolidColorContents>();
1323 fill->SetGeometry(geom.get());
1331 auto actual = border_mask_blur->GetCoverage(e);
1333 ASSERT_TRUE(actual.has_value());
1340 auto actual = border_mask_blur->GetCoverage(e);
1341 auto expected =
Rect::MakeXYWH(-287.792, -4.94975, 504.874, 504.874);
1342 ASSERT_TRUE(actual.has_value());
1350 auto fill = std::make_shared<SolidColorContents>();
1354 fill->SetGeometry(geom.get());
1356 auto coverage = fill->GetCoverage({});
1357 ASSERT_TRUE(coverage.has_value());
1363 auto fill = std::make_shared<SolidColorContents>();
1367 fill->SetGeometry(geom.get());
1375 ASSERT_TRUE(coverage.has_value());
1381 auto fill = std::make_shared<SolidColorContents>();
1385 fill->SetGeometry(geom.get());
1387 auto coverage = fill->GetCoverage({});
1388 ASSERT_FALSE(coverage.has_value());
1395 static float corner_radius = 100;
1397 static bool show_coverage =
false;
1403 ImGui::Begin(
"Controls",
nullptr, ImGuiWindowFlags_AlwaysAutoResize);
1404 ImGui::SliderFloat(
"Corner radius", &corner_radius, 0, 300);
1405 ImGui::SliderFloat(
"Blur radius", &
blur_radius, 0, 300);
1406 ImGui::ColorEdit4(
"Color",
reinterpret_cast<Scalar*
>(&color));
1407 ImGui::Checkbox(
"Show coverage", &show_coverage);
1408 if (show_coverage) {
1409 ImGui::ColorEdit4(
"Coverage color",
1410 reinterpret_cast<Scalar*
>(&coverage_color));
1414 auto [top_left, bottom_right] =
1417 Rect::MakeLTRB(top_left.x, top_left.y, bottom_right.x, bottom_right.y);
1419 auto contents = std::make_unique<SolidRRectBlurContents>();
1420 contents->SetShape(rect, corner_radius);
1421 contents->SetColor(color);
1427 entity.
Render(context, pass);
1430 if (show_coverage && coverage.has_value()) {
1431 auto bounds_contents = std::make_unique<SolidColorContents>();
1433 flutter::DlPath::MakeRect(entity.
GetCoverage().value()));
1434 bounds_contents->SetGeometry(geom.get());
1435 bounds_contents->SetColor(coverage_color.
Premultiply());
1437 bounds_entity.
SetContents(std::move(bounds_contents));
1438 bounds_entity.
Render(context, pass);
1443 ASSERT_TRUE(OpenPlaygroundHere(callback));
1448 auto fill = std::make_shared<SolidColorContents>();
1451 fill->SetGeometry(geom.get());
1469 auto actual = filter->GetCoverage(e);
1472 ASSERT_TRUE(actual.has_value());
1477 auto bay_bridge = CreateTextureForFixture(
"bay_bridge.jpg");
1478 ASSERT_TRUE(bay_bridge);
1488 static float offset[2] = {500, 400};
1489 static float rotation = 0;
1490 static float scale[2] = {0.65, 0.65};
1491 static float skew[2] = {0, 0};
1494 ImGui::Begin(
"Color Matrix",
nullptr, ImGuiWindowFlags_AlwaysAutoResize);
1496 std::string label =
"##1";
1497 for (
int i = 0; i < 20; i += 5) {
1498 ImGui::InputScalarN(label.c_str(), ImGuiDataType_Float,
1499 &(color_matrix.
array[i]), 5,
nullptr,
nullptr,
1504 ImGui::SliderFloat2(
"Translation", &offset[0], 0,
1505 pass.GetRenderTargetSize().width);
1506 ImGui::SliderFloat(
"Rotation", &rotation, 0,
kPi * 2);
1507 ImGui::SliderFloat2(
"Scale", &scale[0], 0, 3);
1508 ImGui::SliderFloat2(
"Skew", &skew[0], -3, 3);
1526 entity.
Render(context, pass);
1531 ASSERT_TRUE(OpenPlaygroundHere(callback));
1538 auto fill = std::make_shared<SolidColorContents>();
1539 fill->SetGeometry(geom.get());
1549 auto actual = filter->GetCoverage(e);
1552 ASSERT_TRUE(actual.has_value());
1557 auto image = CreateTextureForFixture(
"kalimba.jpg");
1580 return entity_left.
Render(context, pass) &&
1581 entity_right.
Render(context, pass);
1584 ASSERT_TRUE(OpenPlaygroundHere(callback));
1589 auto fill = std::make_shared<SolidColorContents>();
1592 fill->SetGeometry(geom.get());
1602 auto actual = filter->GetCoverage(e);
1605 ASSERT_TRUE(actual.has_value());
1610 auto image = CreateTextureForFixture(
"embarcadero.jpg");
1633 return entity_left.
Render(context, pass) &&
1634 entity_right.
Render(context, pass);
1637 ASSERT_TRUE(OpenPlaygroundHere(callback));
1642 switch (yuv_color_space) {
1644 yuv.
x = rgb.
x * 0.299 + rgb.
y * 0.587 + rgb.
z * 0.114;
1645 yuv.
y = rgb.
x * -0.169 + rgb.
y * -0.331 + rgb.
z * 0.5 + 0.5;
1646 yuv.
z = rgb.
x * 0.5 + rgb.
y * -0.419 + rgb.
z * -0.081 + 0.5;
1649 yuv.
x = rgb.
x * 0.257 + rgb.
y * 0.516 + rgb.
z * 0.100 + 0.063;
1650 yuv.
y = rgb.
x * -0.145 + rgb.
y * -0.291 + rgb.
z * 0.439 + 0.5;
1651 yuv.
z = rgb.
x * 0.429 + rgb.
y * -0.368 + rgb.
z * -0.071 + 0.5;
1660 Vector3 red = {244.0 / 255.0, 67.0 / 255.0, 54.0 / 255.0};
1661 Vector3 green = {76.0 / 255.0, 175.0 / 255.0, 80.0 / 255.0};
1662 Vector3 blue = {33.0 / 255.0, 150.0 / 255.0, 243.0 / 255.0};
1663 Vector3 white = {1.0, 1.0, 1.0};
1668 std::vector<Vector3> yuvs{red_yuv, green_yuv, blue_yuv, white_yuv};
1669 std::vector<uint8_t> y_data;
1670 std::vector<uint8_t> uv_data;
1671 for (
int i = 0; i < 4; i++) {
1673 uint8_t y = std::round(yuv.x * 255.0);
1674 uint8_t u = std::round(yuv.y * 255.0);
1675 uint8_t v = std::round(yuv.z * 255.0);
1676 for (
int j = 0; j < 16; j++) {
1677 y_data.push_back(y);
1679 for (
int j = 0; j < 8; j++) {
1680 uv_data.push_back(j % 2 == 0 ? u : v);
1684 auto blit_pass = cmd_buffer->CreateBlitPass();
1689 y_texture_descriptor.
size = {8, 8};
1692 auto y_mapping = std::make_shared<fml::DataMapping>(y_data);
1693 auto y_mapping_buffer =
1701 uv_texture_descriptor.
size = {4, 4};
1704 auto uv_mapping = std::make_shared<fml::DataMapping>(uv_data);
1705 auto uv_mapping_buffer =
1710 if (!blit_pass->EncodeCommands() ||
1712 FML_DLOG(ERROR) <<
"Could not copy contents into Y/UV texture.";
1715 return {y_texture, uv_texture};
1722 <<
"YUV to RGB filter is not supported on OpenGLES backend yet.";
1728 for (
int i = 0; i < 2; i++) {
1729 auto yuv_color_space = yuv_color_space_array[i];
1733 textures[0], textures[1], yuv_color_space);
1736 auto snapshot = filter_contents->RenderToSnapshot(context, filter_entity);
1740 contents->SetTexture(snapshot->texture);
1741 contents->SetSourceRect(
Rect::MakeSize(snapshot->texture->GetSize()));
1745 entity.
Render(context, pass);
1749 ASSERT_TRUE(OpenPlaygroundHere(callback));
1753 auto runtime_stages =
1754 OpenAssetAsRuntimeStage(
"runtime_stage_example.frag.iplr");
1755 auto runtime_stage =
1757 ASSERT_TRUE(runtime_stage);
1758 ASSERT_TRUE(runtime_stage->IsDirty());
1760 bool expect_dirty =
true;
1766 EXPECT_EQ(runtime_stage->IsDirty(), expect_dirty);
1768 auto contents = std::make_shared<RuntimeEffectContents>();
1769 contents->SetGeometry(geom.get());
1770 contents->SetRuntimeStage(runtime_stage);
1772 struct FragUniforms {
1776 .iResolution =
Vector2(GetWindowSize().width, GetWindowSize().height),
1777 .iTime =
static_cast<Scalar>(GetSecondsElapsed()),
1779 auto uniform_data = std::make_shared<std::vector<uint8_t>>();
1780 uniform_data->resize(
sizeof(FragUniforms));
1781 memcpy(uniform_data->data(), &frag_uniforms,
sizeof(FragUniforms));
1782 contents->SetUniformData(uniform_data);
1786 bool result = contents->Render(context, entity, pass);
1789 first_pipeline = pass.GetCommands().back().pipeline;
1791 EXPECT_EQ(pass.GetCommands().back().pipeline, first_pipeline);
1793 expect_dirty =
false;
1798 auto content_context = GetContentContext();
1801 content_context->GetRenderTargetCache()->CreateOffscreen(
1802 *content_context->GetContext(), {1, 1}, 1u);
1804 testing::MockRenderPass mock_pass(GetContext(), target);
1805 callback(*content_context, mock_pass);
1806 callback(*content_context, mock_pass);
1809 runtime_stages = OpenAssetAsRuntimeStage(
"runtime_stage_example.frag.iplr");
1813 ASSERT_TRUE(runtime_stage->IsDirty());
1814 expect_dirty =
true;
1816 callback(*content_context, mock_pass);
1821 auto runtime_stages =
1822 OpenAssetAsRuntimeStage(
"runtime_stage_example.frag.iplr");
1823 auto runtime_stage =
1825 ASSERT_TRUE(runtime_stage);
1826 ASSERT_TRUE(runtime_stage->IsDirty());
1828 auto contents = std::make_shared<RuntimeEffectContents>();
1830 contents->SetGeometry(geom.get());
1831 contents->SetRuntimeStage(runtime_stage);
1833 struct FragUniforms {
1837 .iResolution =
Vector2(GetWindowSize().width, GetWindowSize().height),
1838 .iTime =
static_cast<Scalar>(GetSecondsElapsed()),
1840 auto uniform_data = std::make_shared<std::vector<uint8_t>>();
1841 uniform_data->resize(
sizeof(FragUniforms));
1842 memcpy(uniform_data->data(), &frag_uniforms,
sizeof(FragUniforms));
1843 contents->SetUniformData(uniform_data);
1851 GetContentContext()->GetRenderTargetCache()->CreateOffscreenMSAA(
1852 *GetContext(), {GetWindowSize().width, GetWindowSize().height}, 1,
1853 "RuntimeEffect Texture");
1854 testing::MockRenderPass pass(GetContext(), target);
1856 ASSERT_TRUE(contents->Render(*GetContentContext(), entity, pass));
1857 ASSERT_EQ(pass.GetCommands().size(), 1u);
1858 const auto& command = pass.GetCommands()[0];
1859 ASSERT_TRUE(command.pipeline->GetDescriptor()
1860 .GetDepthStencilAttachmentDescriptor()
1862 ASSERT_TRUE(command.pipeline->GetDescriptor()
1863 .GetFrontStencilAttachmentDescriptor()
1868 auto runtime_stages =
1869 OpenAssetAsRuntimeStage(
"runtime_stage_example.frag.iplr");
1870 auto runtime_stage =
1872 ASSERT_TRUE(runtime_stage);
1873 ASSERT_TRUE(runtime_stage->IsDirty());
1875 auto contents = std::make_shared<RuntimeEffectContents>();
1876 contents->SetRuntimeStage(runtime_stage);
1878 EXPECT_TRUE(contents->BootstrapShader(*GetContentContext()));
1883 GTEST_SKIP() <<
"Test only applies to Vulkan";
1886 auto runtime_stages =
1887 OpenAssetAsRuntimeStage(
"runtime_stage_example.frag.iplr");
1888 auto runtime_stage =
1890 ASSERT_TRUE(runtime_stage);
1891 ASSERT_TRUE(runtime_stage->IsDirty());
1893 auto contents = std::make_shared<RuntimeEffectContents>();
1895 contents->SetGeometry(geom.get());
1896 contents->SetRuntimeStage(runtime_stage);
1898 struct FragUniforms {
1902 .iResolution =
Vector2(GetWindowSize().width, GetWindowSize().height),
1903 .iTime =
static_cast<Scalar>(GetSecondsElapsed()),
1905 auto uniform_data = std::make_shared<std::vector<uint8_t>>();
1906 uniform_data->resize(
sizeof(FragUniforms));
1907 memcpy(uniform_data->data(), &frag_uniforms,
sizeof(FragUniforms));
1910 uniform_data, GetContentContext()->GetTransientsBuffer(),
1911 runtime_stage->GetUniforms()[0],
1912 GetContentContext()->GetTransientsBuffer().GetMinimumUniformAlignment());
1922 auto image = CreateTextureForFixture(
"boston.jpg");
1932 return entity.
Render(context, pass);
1934 ASSERT_TRUE(OpenPlaygroundHere(callback));
1938 auto image = CreateTextureForFixture(
"boston.jpg");
1948 return entity.
Render(context, pass);
1950 ASSERT_TRUE(OpenPlaygroundHere(callback));
1954 auto image = CreateTextureForFixture(
"boston.jpg");
1964 return entity.
Render(context, pass);
1966 ASSERT_TRUE(OpenPlaygroundHere(callback));
1970 auto image = CreateTextureForFixture(
"boston.jpg");
1980 return entity.
Render(context, pass);
1982 ASSERT_TRUE(OpenPlaygroundHere(callback));
1986 auto image = CreateTextureForFixture(
"boston.jpg");
1996 return entity.
Render(context, pass);
1998 ASSERT_TRUE(OpenPlaygroundHere(callback));
2002 auto arrow_head = flutter::DlPathBuilder{}
2012 .miter_limit = 4.0f,
2022 auto coverage = geometry->GetCoverage(
transform);
2033 EXPECT_TRUE(contents.
IsOpaque(matrix));
2035 EXPECT_FALSE(contents.
IsOpaque(matrix));
2043 EXPECT_FALSE(contents.
IsOpaque(matrix));
2053 EXPECT_FALSE(contents.
IsOpaque(matrix));
2055 EXPECT_FALSE(contents.
IsOpaque(matrix));
2059 flutter::DlPathBuilder{}.MoveTo({0, 0}).
LineTo({100, 100}).TakePath(),
2064 EXPECT_FALSE(contents.
IsOpaque(matrix));
2074 EXPECT_TRUE(contents.
IsOpaque(matrix));
2076 EXPECT_FALSE(contents.
IsOpaque(matrix));
2079 EXPECT_FALSE(contents.
IsOpaque(matrix));
2083 flutter::DlPathBuilder{}.MoveTo({0, 0}).
LineTo({100, 100}).TakePath(),
2088 EXPECT_FALSE(contents.
IsOpaque(matrix));
2098 EXPECT_TRUE(contents.
IsOpaque(matrix));
2100 EXPECT_FALSE(contents.
IsOpaque(matrix));
2103 EXPECT_FALSE(contents.
IsOpaque(matrix));
2107 flutter::DlPathBuilder{}.MoveTo({0, 0}).
LineTo({100, 100}).TakePath(),
2112 EXPECT_FALSE(contents.
IsOpaque(matrix));
2122 EXPECT_TRUE(contents.
IsOpaque(matrix));
2124 EXPECT_FALSE(contents.
IsOpaque(matrix));
2127 EXPECT_FALSE(contents.
IsOpaque(matrix));
2131 flutter::DlPathBuilder{}.MoveTo({0, 0}).
LineTo({100, 100}).TakePath(),
2136 EXPECT_FALSE(contents.
IsOpaque(matrix));
2141 auto bay_bridge = CreateTextureForFixture(
"bay_bridge.jpg");
2147 EXPECT_FALSE(contents.
IsOpaque(matrix));
2151 std::vector<Point>
points = {{10, 20}, {100, 200}};
2161 auto src_contents = std::make_shared<SolidColorContents>();
2163 src_contents->SetGeometry(src_geom.get());
2166 auto dst_contents = std::make_shared<SolidColorContents>();
2168 dst_contents->SetGeometry(dst_geom.get());
2175 ASSERT_TRUE(OpenPlaygroundHere(std::move(entity)));
2187 auto content_context = GetContentContext();
2189 auto default_gyph = content_context->GetGlyphAtlasPipeline({
2191 .has_depth_stencil_attachments =
false,
2193 auto alt_gyph = content_context->GetGlyphAtlasPipeline(
2195 .has_depth_stencil_attachments =
true});
2197 EXPECT_NE(default_gyph, alt_gyph);
2198 EXPECT_EQ(default_gyph->GetDescriptor().GetSpecializationConstants(),
2199 alt_gyph->GetDescriptor().GetSpecializationConstants());
2201 auto use_a8 = GetContext()->GetCapabilities()->GetDefaultGlyphAtlasFormat() ==
2204 std::vector<Scalar> expected_constants = {
static_cast<Scalar>(use_a8)};
2205 EXPECT_EQ(default_gyph->GetDescriptor().GetSpecializationConstants(),
2206 expected_constants);
2210 auto content_context = GetContentContext();
2211 auto default_color_burn = content_context->GetMorphologyFilterPipeline({
2215 auto decal_supported =
static_cast<Scalar>(
2216 GetContext()->GetCapabilities()->SupportsDecalSamplerAddressMode());
2217 std::vector<Scalar> expected_constants = {decal_supported};
2218 ASSERT_EQ(default_color_burn->GetDescriptor().GetSpecializationConstants(),
2219 expected_constants);
2227 auto hash_a = opts.
ToKey();
2230 auto hash_b = opts.
ToKey();
2233 auto hash_c = opts.
ToKey();
2236 auto hash_d = opts.
ToKey();
2238 EXPECT_NE(hash_a, hash_b);
2239 EXPECT_NE(hash_b, hash_c);
2240 EXPECT_NE(hash_c, hash_d);
2257 bool expected_layout =
false;
2259 FragmentShader::kDescriptorSetLayouts) {
2260 if (layout.binding == 64 &&
2262 expected_layout =
true;
2265 EXPECT_TRUE(expected_layout);
2271 testing::MockRenderPass mock_pass(GetContext(), target);
2276 return geometry->GetPositionBuffer(*GetContentContext(), {}, mock_pass);
2282 get_result(flutter::DlPath::MakeRect(
Rect::MakeLTRB(0, 0, 100, 100)));
2302 GTEST_SKIP() <<
"Validation is only fatal on Vulkan backend.";
2307 GetContentContext()->GetBlendColorBurnPipeline({
2309 .has_depth_stencil_attachments =
false,
2317 EXPECT_TRUE(path.GetBounds().IsEmpty());
2323 GetContentContext()->GetRenderTargetCache()->CreateOffscreen(
2324 *GetContext(), {1, 1}, 1u);
2325 testing::MockRenderPass render_pass(GetContext(), target);
2326 auto position_result =
2327 geom->GetPositionBuffer(*GetContentContext(), entity, render_pass);
2329 EXPECT_EQ(position_result.vertex_buffer.vertex_count, 0u);
2337 EXPECT_TRUE(path.GetBounds().IsEmpty());
2339 auto contents = std::make_shared<SolidColorContents>();
2341 contents->SetGeometry(geom.get());
2348 ASSERT_TRUE(OpenPlaygroundHere(std::move(entity)));
2354 static float alpha = 10;
2355 static float beta = 10;
2356 static float radius = 40;
2357 static int degree = 4;
2360 ImGui::Begin(
"Controls",
nullptr, ImGuiWindowFlags_AlwaysAutoResize);
2361 ImGui::SliderFloat(
"Alpha", &alpha, 0, 100);
2362 ImGui::SliderFloat(
"Beta", &beta, 0, 100);
2363 ImGui::SliderInt(
"Degreee", °ree, 1, 20);
2364 ImGui::SliderFloat(
"Radius", &radius, 0, 400);
2365 ImGui::ColorEdit4(
"Color",
reinterpret_cast<float*
>(&color));
2368 auto contents = std::make_shared<SolidColorContents>();
2369 std::unique_ptr<SuperellipseGeometry> geom =
2370 std::make_unique<SuperellipseGeometry>(
Point{400, 400}, radius, degree,
2372 contents->SetColor(color);
2373 contents->SetGeometry(geom.get());
2378 return entity.
Render(context, pass);
2381 ASSERT_TRUE(OpenPlaygroundHere(callback));
2387 static int style_index = 0;
2388 static float center[2] = {830, 830};
2389 static float size[2] = {600, 600};
2390 static bool horizontal_symmetry =
true;
2391 static bool vertical_symmetry =
true;
2392 static bool corner_symmetry =
true;
2394 const char* style_options[] = {
"Fill",
"Stroke"};
2398 static std::array<float, 2> radius_tl = {200};
2399 static std::array<float, 2> radius_tr;
2400 static std::array<float, 2> radius_bl;
2401 static std::array<float, 2> radius_br;
2403 auto AddRadiusControl = [](std::array<float, 2>& radii,
const char* tb_name,
2404 const char* lr_name) {
2405 std::string name =
"Radius";
2406 if (!horizontal_symmetry || !vertical_symmetry) {
2409 if (!vertical_symmetry) {
2410 name = name +
" " + tb_name;
2412 if (!horizontal_symmetry) {
2413 name = name +
" " + lr_name;
2415 if (corner_symmetry) {
2416 ImGui::SliderFloat(name.c_str(), radii.data(), 0, 1000);
2418 ImGui::SliderFloat2(name.c_str(), radii.data(), 0, 1000);
2422 if (corner_symmetry) {
2423 radius_tl[1] = radius_tl[0];
2424 radius_tr[1] = radius_tr[0];
2425 radius_bl[1] = radius_bl[0];
2426 radius_br[1] = radius_br[0];
2429 ImGui::Begin(
"Controls",
nullptr, ImGuiWindowFlags_AlwaysAutoResize);
2431 ImGui::Combo(
"Style", &style_index, style_options,
2432 sizeof(style_options) /
sizeof(
char*));
2433 ImGui::SliderFloat2(
"Center", center, 0, 1000);
2434 ImGui::SliderFloat2(
"Size", size, 0, 1000);
2435 ImGui::Checkbox(
"Symmetry: Horizontal", &horizontal_symmetry);
2436 ImGui::Checkbox(
"Symmetry: Vertical", &vertical_symmetry);
2437 ImGui::Checkbox(
"Symmetry: Corners", &corner_symmetry);
2438 AddRadiusControl(radius_tl,
"Top",
"Left");
2439 if (!horizontal_symmetry) {
2440 AddRadiusControl(radius_tr,
"Top",
"Right");
2442 radius_tr = radius_tl;
2444 if (!vertical_symmetry) {
2445 AddRadiusControl(radius_bl,
"Bottom",
"Left");
2447 radius_bl = radius_tl;
2449 if (!horizontal_symmetry && !vertical_symmetry) {
2450 AddRadiusControl(radius_br,
"Bottom",
"Right");
2452 if (horizontal_symmetry) {
2453 radius_br = radius_bl;
2455 radius_br = radius_tr;
2463 .
top_left = {radius_tl[0], radius_tl[1]},
2464 .top_right = {radius_tr[0], radius_tr[1]},
2465 .bottom_left = {radius_bl[0], radius_bl[1]},
2466 .bottom_right = {radius_br[0], radius_br[1]},
2473 std::unique_ptr<Geometry> geom;
2474 if (style_index == 0) {
2475 geom = std::make_unique<RoundSuperellipseGeometry>(
2479 path = flutter::DlPath::MakeRoundSuperellipse(rse);
2483 auto contents = std::make_shared<SolidColorContents>();
2485 contents->SetGeometry(geom.get());
2490 return entity.
Render(context, pass);
2493 ASSERT_TRUE(OpenPlaygroundHere(callback));
2499 auto result = contents.ApplyColorFilter([](
const Color& color) {
2502 ASSERT_TRUE(result);
2504 Color(0.424452, 0.828743, 0.79105, 0.9375));
2507 #define APPLY_COLOR_FILTER_GRADIENT_TEST(name) \
2508 TEST_P(EntityTest, name##GradientApplyColorFilter) { \
2509 auto contents = name##GradientContents(); \
2510 contents.SetColors({Color::CornflowerBlue().WithAlpha(0.75)}); \
2511 auto result = contents.ApplyColorFilter([](const Color& color) { \
2512 return color.Blend(Color::LimeGreen().WithAlpha(0.75), \
2513 BlendMode::kScreen); \
2515 ASSERT_TRUE(result); \
2517 std::vector<Color> expected = {Color(0.433247, 0.879523, 0.825324, 0.75)}; \
2518 ASSERT_COLORS_NEAR(contents.GetColors(), expected); \
2527 flutter::DlPathBuilder builder;
2528 for (
int i = 0; i < 10000; i++) {
2529 builder.LineTo(
Point(i, i));
2537 auto cmd_buffer = content_context.GetContext()->CreateCommandBuffer();
2540 content_context.GetContext()->GetResourceAllocator());
2543 *content_context.GetContext(), {10, 10}, 1);
2544 auto pass = cmd_buffer->CreateRenderPass(render_target);
2547 geom->GetPositionBuffer(content_context, entity, *pass);
2553 Point* written_data =
reinterpret_cast<Point*
>(
2557 std::vector<Point> expected = {
2558 Point(2043.46, 2050.54),
2559 Point(2050.54, 2043.46),
2560 Point(2044.46, 2051.54),
2561 Point(2051.54, 2044.46),
2562 Point(2045.46, 2052.54)
2566 EXPECT_NEAR(point.
x, expected[0].x, 0.1);
2567 EXPECT_NEAR(point.
y, expected[0].y, 0.1);
2570 EXPECT_NEAR(point.
x, expected[1].x, 0.1);
2571 EXPECT_NEAR(point.
y, expected[1].y, 0.1);
2574 EXPECT_NEAR(point.
x, expected[2].x, 0.1);
2575 EXPECT_NEAR(point.
y, expected[2].y, 0.1);
2578 EXPECT_NEAR(point.
x, expected[3].x, 0.1);
2579 EXPECT_NEAR(point.
y, expected[3].y, 0.1);
2582 EXPECT_NEAR(point.
x, expected[4].x, 0.1);
2583 EXPECT_NEAR(point.
y, expected[4].y, 0.1);
2591 bool SetLabel(std::string_view label)
override {
return true; }
2600 return const_cast<uint8_t*
>(storage_.data());
2603 void Flush(std::optional<Range> range)
const override {
2604 flush_called_ =
true;
2610 std::vector<uint8_t> storage_;
2611 mutable bool flush_called_ =
false;
2617 return ISize(1024, 1024);
2622 return std::make_shared<FlushTestDeviceBuffer>(desc);
2634 const std::shared_ptr<Context>& context,
2635 const std::shared_ptr<TypographerContext>& typographer_context,
2636 const std::shared_ptr<Allocator>& allocator)
2639 allocator, context->GetIdleWaiter(),
2640 context->GetCapabilities()->GetMinimumUniformAlignment()));
2646 testing::MockRenderPass mock_pass(GetContext(), target);
2648 auto content_context = std::make_shared<FlushTestContentContext>(
2649 GetContext(), GetTypographerContext(),
2650 std::make_shared<FlushTestAllocator>());
2653 auto result = geometry->GetPositionBuffer(*content_context, {}, mock_pass);
2656 result.vertex_buffer.vertex_buffer.GetBuffer());
2657 EXPECT_TRUE(device_buffer->flush_called());
An object that allocates device memory.
static std::shared_ptr< ColorFilterContents > MakeColorMatrix(FilterInput::Ref input, const ColorMatrix &color_matrix)
static std::shared_ptr< ColorFilterContents > MakeSrgbToLinearFilter(FilterInput::Ref input)
static std::shared_ptr< ColorFilterContents > MakeLinearToSrgbFilter(FilterInput::Ref input)
static std::shared_ptr< ColorFilterContents > MakeBlend(BlendMode blend_mode, FilterInput::Vector inputs, std::optional< Color > foreground_color=std::nullopt)
the [inputs] are expected to be in the order of dst, src.
void SetGeometry(const Geometry *geometry)
Set the geometry that this contents will use to render.
void SetColors(std::vector< Color > colors)
HostBuffer & GetTransientsBuffer() const
Retrieve the currnent host buffer for transient storage.
void SetTransientsBuffer(std::shared_ptr< HostBuffer > host_buffer)
PipelineRef GetSolidFillPipeline(ContentContextOptions opts) const
virtual bool IsOpaque(const Matrix &transform) const
Whether this Contents only emits opaque source colors from the fragment stage. This value does not ac...
To do anything rendering related with Impeller, you need a context.
virtual std::shared_ptr< CommandBuffer > CreateCommandBuffer() const =0
Create a new command buffer. Command buffers can be used to encode graphics, blit,...
virtual std::shared_ptr< CommandQueue > GetCommandQueue() const =0
Return the graphics queue for submitting command buffers.
virtual std::shared_ptr< Allocator > GetResourceAllocator() const =0
Returns the allocator used to create textures and buffers on the device.
static BufferView AsBufferView(std::shared_ptr< DeviceBuffer > buffer)
Create a buffer view of this entire buffer.
virtual uint8_t * OnGetContents() const =0
void SetTransform(const Matrix &transform)
Set the global transform matrix for this Entity.
std::optional< Rect > GetCoverage() const
BlendMode GetBlendMode() const
void SetContents(std::shared_ptr< Contents > contents)
void SetBlendMode(BlendMode blend_mode)
bool Render(const ContentContext &renderer, RenderPass &parent_pass) const
const Matrix & GetTransform() const
Get the global transform matrix for this Entity.
static constexpr BlendMode kLastPipelineBlendMode
@ kNormal
Blurred inside and outside.
@ kOuter
Nothing inside, blurred outside.
@ kInner
Blurred inside, nothing outside.
@ kSolid
Solid inside, blurred outside.
static std::shared_ptr< FilterContents > MakeMorphology(FilterInput::Ref input, Radius radius_x, Radius radius_y, MorphType morph_type)
static std::shared_ptr< FilterContents > MakeBorderMaskBlur(FilterInput::Ref input, Sigma sigma_x, Sigma sigma_y, BlurStyle blur_style=BlurStyle::kNormal)
static std::shared_ptr< FilterContents > MakeGaussianBlur(const FilterInput::Ref &input, Sigma sigma_x, Sigma sigma_y, Entity::TileMode tile_mode=Entity::TileMode::kDecal, BlurStyle mask_blur_style=BlurStyle::kNormal, const Geometry *mask_geometry=nullptr)
static std::shared_ptr< FilterContents > MakeYUVToRGBFilter(std::shared_ptr< Texture > y_texture, std::shared_ptr< Texture > uv_texture, YUVColorSpace yuv_color_space)
static std::unique_ptr< Geometry > MakeFillPath(const flutter::DlPath &path, std::optional< Rect > inner_rect=std::nullopt)
static std::unique_ptr< Geometry > MakeRect(const Rect &rect)
static std::unique_ptr< Geometry > MakeStrokePath(const flutter::DlPath &path, const StrokeParameters &stroke={})
static std::unique_ptr< Geometry > MakeRoundSuperellipse(const Rect &rect, Scalar corner_radius)
static std::unique_ptr< Geometry > MakeCover()
static std::shared_ptr< HostBuffer > Create(const std::shared_ptr< Allocator > &allocator, const std::shared_ptr< const IdleWaiter > &idle_waiter, size_t minimum_uniform_alignment)
BufferView EmplaceUniform(const UniformType &uniform)
Emplace uniform data onto the host buffer. Ensure that backend specific uniform alignment requirement...
void SetTileMode(Entity::TileMode tile_mode)
void SetColors(std::vector< Color > colors)
bool IsOpaque(const Matrix &transform) const override
Whether this Contents only emits opaque source colors from the fragment stage. This value does not ac...
A geometry class specialized for Canvas::DrawPoints.
std::optional< Rect > GetCoverage(const Matrix &transform) const override
bool IsOpaque(const Matrix &transform) const override
Whether this Contents only emits opaque source colors from the fragment stage. This value does not ac...
void SetTileMode(Entity::TileMode tile_mode)
void SetColors(std::vector< Color > colors)
Render passes encode render commands directed as one specific render target into an underlying comman...
VertexShader_ VertexShader
FragmentShader_ FragmentShader
a wrapper around the impeller [Allocator] instance that can be used to provide caching of allocated r...
virtual RenderTarget CreateOffscreen(const Context &context, ISize size, int mip_count, std::string_view label="Offscreen", RenderTarget::AttachmentConfig color_attachment_config=RenderTarget::kDefaultColorAttachmentConfig, std::optional< RenderTarget::AttachmentConfig > stencil_attachment_config=RenderTarget::kDefaultStencilAttachmentConfig, const std::shared_ptr< Texture > &existing_color_texture=nullptr, const std::shared_ptr< Texture > &existing_depth_stencil_texture=nullptr)
static BufferView EmplaceVulkanUniform(const std::shared_ptr< const std::vector< uint8_t >> &input_data, HostBuffer &host_buffer, const RuntimeUniformDescription &uniform, size_t minimum_uniform_alignment)
bool IsOpaque(const Matrix &transform) const override
Whether this Contents only emits opaque source colors from the fragment stage. This value does not ac...
void SetColor(Color color)
A Geometry that produces fillable vertices representing the stroked outline of a |DlPath| object usin...
static Rational RoundScaledFontSize(Scalar scale)
static std::shared_ptr< TextureContents > MakeRect(Rect destination)
bool IsOpaque(const Matrix &transform) const override
Whether this Contents only emits opaque source colors from the fragment stage. This value does not ac...
void SetTexture(std::shared_ptr< Texture > texture)
VertexBuffer CreateVertexBuffer(HostBuffer &host_buffer) const
VertexBufferBuilder & AddVertices(std::initializer_list< VertexType_ > vertices)
std::shared_ptr< Texture > OnCreateTexture(const TextureDescriptor &desc) override
std::shared_ptr< DeviceBuffer > OnCreateBuffer(const DeviceBufferDescriptor &desc) override
ISize GetMaxTextureSizeSupported() const override
FlushTestContentContext(const std::shared_ptr< Context > &context, const std::shared_ptr< TypographerContext > &typographer_context, const std::shared_ptr< Allocator > &allocator)
bool OnCopyHostBuffer(const uint8_t *source, Range source_range, size_t offset)
void Flush(std::optional< Range > range) const override
bool SetLabel(std::string_view label, Range range) override
bool SetLabel(std::string_view label) override
uint8_t * OnGetContents() const override
FlushTestDeviceBuffer(const DeviceBufferDescriptor &desc)
bool flush_called() const
Vector2 blur_radius
Blur radius in source pixels based on scaled_sigma.
Vector2 padding
The halo padding in source space.
#define ASSERT_RECT_NEAR(a, b)
#define ASSERT_COLOR_NEAR(a, b)
EntityPlayground EntityTest
Rect RectMakeCenterSize(Point center, Size size)
TEST_P(AiksTest, DrawAtlasNoColor)
APPLY_COLOR_FILTER_GRADIENT_TEST(Linear)
INSTANTIATE_PLAYGROUND_SUITE(AiksTest)
static Vector3 RGBToYUV(Vector3 rgb, YUVColorSpace yuv_color_space)
static std::vector< std::shared_ptr< Texture > > CreateTestYUVTextures(Context *context, YUVColorSpace yuv_color_space)
Join
An enum that describes ways to join two segments of a path.
@ kPoint
Draws a point at each input vertex.
Point DrawPlaygroundPoint(PlaygroundPoint &point)
std::tuple< Point, Point > DrawPlaygroundLine(PlaygroundPoint &point_a, PlaygroundPoint &point_b)
constexpr RuntimeStageBackend PlaygroundBackendToRuntimeStageBackend(PlaygroundBackend backend)
Cap
An enum that describes ways to decorate the end of a path contour.
LinePipeline::FragmentShader FS
LinePipeline::VertexShader VS
void MoveTo(PathBuilder *builder, Scalar x, Scalar y)
static constexpr size_t kPointArenaSize
The size of the point arena buffer stored on the tessellator.
void LineTo(PathBuilder *builder, Scalar x, Scalar y)
ContentContextOptions OptionsFromPass(const RenderPass &pass)
void Close(PathBuilder *builder)
const DeviceBuffer * GetBuffer() const
static constexpr Color LimeGreen()
static constexpr Color MintCream()
static constexpr Color DeepPink()
static constexpr Color Black()
static constexpr Color CornflowerBlue()
static constexpr Color White()
constexpr Color WithAlpha(Scalar new_alpha) const
static constexpr Color WhiteTransparent()
static constexpr Color Coral()
static constexpr Color Red()
constexpr Color Premultiply() const
Color Blend(Color source, BlendMode blend_mode) const
Blends an unpremultiplied destination color into a given unpremultiplied source color to form a new u...
static constexpr Color Blue()
static constexpr Color Green()
PrimitiveType primitive_type
bool has_depth_stencil_attachments
constexpr uint64_t ToKey() const
@ kNormal
The geometry has no overlapping triangles.
VertexBuffer vertex_buffer
A 4x4 matrix using column-major storage.
static constexpr Matrix MakeTranslation(const Vector3 &t)
constexpr bool IsIdentity() const
static Matrix MakeRotationY(Radians r)
static constexpr Matrix MakeSkew(Scalar sx, Scalar sy)
static Matrix MakeRotationZ(Radians r)
static constexpr Matrix MakeScale(const Vector3 &s)
static Matrix MakeRotationX(Radians r)
For convolution filters, the "radius" is the size of the convolution kernel to use on the local space...
static RoundSuperellipse MakeRectRadii(const Rect &rect, const RoundingRadii &radii)
In filters that use Gaussian distributions, "sigma" is a size of one standard deviation in terms of t...
constexpr static TRect MakeXYWH(Type x, Type y, Type width, Type height)
constexpr TRect< T > Shift(T dx, T dy) const
Returns a new rectangle translated by the given offset.
constexpr static TRect MakeSize(const TSize< U > &size)
constexpr static TRect MakeLTRB(Type left, Type top, Type right, Type bottom)
A lightweight object that describes the attributes of a texture that can then used an allocator to cr...
std::vector< Point > points