test fixes

Author: jonahwilliams

impeller/aiks/canvas.cc

@@ -397,10 +397,9 @@ void Canvas::DrawVertices(std::unique_ptr<VerticesGeometry> vertices,
     GetCurrentPass().AddEntity(entity);
     return;
   }
-
   auto contents = std::make_shared<VerticesContents>();
-  contents->SetSrcContents(
-      paint.CreateContentsForGeometry(Geometry::MakeRect(rect.value())));
+  contents->SetSrcContents(paint.CreateContentsForGeometry(
+      Geometry::MakeRect(Rect::MakeSize(rect.value().size))));
   contents->SetColor(paint.color);
   contents->SetBlendMode(blend_mode);
   contents->SetGeometry(std::move(vertices));

impeller/display_list/display_list_unittests.cc

@@ -34,6 +34,15 @@
 namespace impeller {
 namespace testing {
 
+flutter::DlColor toColor(const float* components) {
+  auto value = (((std::lround(components[3] * 255) & 0xff) << 24) |
+                ((std::lround(components[0] * 255) & 0xff) << 16) |
+                ((std::lround(components[1] * 255) & 0xff) << 8) |
+                ((std::lround(components[2] * 255) & 0xff) << 0)) &
+               0xFFFFFFFF;
+  return flutter::DlColor(value);
+}
+
 using DisplayListTest = DisplayListPlayground;
 INSTANTIATE_PLAYGROUND_SUITE(DisplayListTest);
 
@@ -1159,6 +1168,97 @@ TEST_P(DisplayListTest, DrawShapes) {
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }
 
+TEST_P(DisplayListTest, DrawVerticesBlendModes) {
+  std::vector<const char*> blend_mode_names;
+  std::vector<flutter::DlBlendMode> blend_mode_values;
+  {
+    const std::vector<std::tuple<const char*, flutter::DlBlendMode>> blends = {
+        // Pipeline blends (Porter-Duff alpha compositing)
+        {"Clear", flutter::DlBlendMode::kClear},
+        {"Source", flutter::DlBlendMode::kSrc},
+        {"Destination", flutter::DlBlendMode::kDst},
+        {"SourceOver", flutter::DlBlendMode::kSrcOver},
+        {"DestinationOver", flutter::DlBlendMode::kDstOver},
+        {"SourceIn", flutter::DlBlendMode::kSrcIn},
+        {"DestinationIn", flutter::DlBlendMode::kDstIn},
+        {"SourceOut", flutter::DlBlendMode::kSrcOut},
+        {"DestinationOut", flutter::DlBlendMode::kDstOut},
+        {"SourceATop", flutter::DlBlendMode::kSrcATop},
+        {"DestinationATop", flutter::DlBlendMode::kDstATop},
+        {"Xor", flutter::DlBlendMode::kXor},
+        {"Plus", flutter::DlBlendMode::kPlus},
+        {"Modulate", flutter::DlBlendMode::kModulate},
+        // Advanced blends (color component blends)
+        {"Screen", flutter::DlBlendMode::kScreen},
+        {"Overlay", flutter::DlBlendMode::kOverlay},
+        {"Darken", flutter::DlBlendMode::kDarken},
+        {"Lighten", flutter::DlBlendMode::kLighten},
+        {"ColorDodge", flutter::DlBlendMode::kColorDodge},
+        {"ColorBurn", flutter::DlBlendMode::kColorBurn},
+        {"HardLight", flutter::DlBlendMode::kHardLight},
+        {"SoftLight", flutter::DlBlendMode::kSoftLight},
+        {"Difference", flutter::DlBlendMode::kDifference},
+        {"Exclusion", flutter::DlBlendMode::kExclusion},
+        {"Multiply", flutter::DlBlendMode::kMultiply},
+        {"Hue", flutter::DlBlendMode::kHue},
+        {"Saturation", flutter::DlBlendMode::kSaturation},
+        {"Color", flutter::DlBlendMode::kColor},
+        {"Luminosity", flutter::DlBlendMode::kLuminosity},
+    };
+    assert(blends.size() ==
+           static_cast<size_t>(flutter::DlBlendMode::kLastMode) + 1);
+    for (const auto& [name, mode] : blends) {
+      blend_mode_names.push_back(name);
+      blend_mode_values.push_back(mode);
+    }
+  }
+
+  auto callback = [&]() {
+    static int current_blend_index = 3;
+    static float dst_alpha = 1;
+    static float src_alpha = 1;
+    static float color0[4] = {1.0f, 0.0f, 0.0f, 1.0f};
+    static float color1[4] = {0.0f, 1.0f, 0.0f, 1.0f};
+    static float color2[4] = {0.0f, 0.0f, 1.0f, 1.0f};
+    static float src_color[4] = {1.0f, 1.0f, 1.0f, 1.0f};
+
+    ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
+    {
+      ImGui::ListBox("Blending mode", &current_blend_index,
+                     blend_mode_names.data(), blend_mode_names.size());
+      ImGui::SliderFloat("Source alpha", &src_alpha, 0, 1);
+      ImGui::ColorEdit4("Color A", color0);
+      ImGui::ColorEdit4("Color B", color1);
+      ImGui::ColorEdit4("Color C", color2);
+      ImGui::ColorEdit4("Source Color", src_color);
+      ImGui::SliderFloat("Destination alpha", &dst_alpha, 0, 1);
+    }
+    ImGui::End();
+
+    std::vector<SkPoint> positions = {SkPoint::Make(100, 300),
+                                      SkPoint::Make(200, 100),
+                                      SkPoint::Make(300, 300)};
+    std::vector<flutter::DlColor> colors = {
+        toColor(color0).modulateOpacity(dst_alpha),
+        toColor(color1).modulateOpacity(dst_alpha),
+        toColor(color2).modulateOpacity(dst_alpha)};
+
+    auto vertices = flutter::DlVertices::Make(
+        flutter::DlVertexMode::kTriangles, 3, positions.data(),
+        /*texture_coorindates=*/nullptr, colors.data());
+
+    flutter::DisplayListBuilder builder;
+    flutter::DlPaint paint;
+
+    paint.setColor(toColor(src_color).modulateOpacity(src_alpha));
+    builder.drawVertices(vertices, blend_mode_values[current_blend_index],
+                         paint);
+    return builder.Build();
+  };
+
+  ASSERT_TRUE(OpenPlaygroundHere(callback));
+}
+
 #ifdef IMPELLER_ENABLE_3D
 TEST_P(DisplayListTest, SceneColorSource) {
   // Load up the scene.

impeller/display_list/display_list_vertices_geometry.cc

@@ -235,17 +235,19 @@ GeometryResult DLVerticesGeometry::GetPositionUVBuffer(
   auto* dl_vertices = vertices_->vertices();
   auto* dl_colors = vertices_->colors();
 
-  auto coverage = ToRect(vertices_->bounds());
+  auto coverage_rect = ToRect(vertices_->bounds());
   std::vector<VS::PerVertexData> vertex_data(vertex_count);
   for (auto i = 0; i < vertex_count; i++) {
     auto dl_color = dl_colors[i];
     auto color = Color(dl_color.getRedF(), dl_color.getGreenF(),
                        dl_color.getBlueF(), dl_color.getAlphaF());
     auto sk_point = dl_vertices[i];
+    auto vertex = Point(sk_point.x(), sk_point.y());
+    auto coverage_coords = (vertex - coverage_rect.origin) / coverage_rect.size;
     vertex_data[i] = {
-        .vertices = Point(sk_point.x(), sk_point.y()),
+        .vertices = vertex,
         .dst_color = color,
-        .src_texture_coords = Point(sk_point.x(), sk_point.y()) / coverage.size,
+        .src_texture_coords = coverage_coords / coverage_rect.size,
     };
   }
 

impeller/entity/contents/vertices_contents.cc

@@ -180,8 +180,7 @@ bool VerticesContents::Render(const ContentContext& renderer,
   }
 
   VS::FrameInfo frame_info;
-  frame_info.mvp = Matrix::MakeOrthographic(pass.GetRenderTargetSize()) *
-                   entity.GetTransformation();
+  frame_info.mvp = geometry_result.transform;
 
   FS::FragInfo frag_info;
   frag_info.src_y_coord_scale = src_texture->texture->GetYCoordScale();
@@ -219,8 +218,7 @@ bool VerticesContents::RenderDestination(const ContentContext& renderer,
   cmd.BindVertices(geometry_result.vertex_buffer);
 
   VS::VertInfo vert_info;
-  vert_info.mvp = Matrix::MakeOrthographic(pass.GetRenderTargetSize()) *
-                  entity.GetTransformation();
+  vert_info.mvp = geometry_result.transform;
   VS::BindVertInfo(cmd, host_buffer.EmplaceUniform(vert_info));
 
   FS::FragInfo frag_info;