[Impeller] Dont blow away coverage hint on advanced blends.

impeller/entity/contents/content_context.cc

@@ -162,16 +162,19 @@ static std::unique_ptr<PipelineT> CreateDefaultPipeline(
 
 ContentContext::ContentContext(
     std::shared_ptr<Context> context,
-    std::shared_ptr<TypographerContext> typographer_context)
+    std::shared_ptr<TypographerContext> typographer_context,
+    std::shared_ptr<RenderTargetAllocator> render_target_allocator)
     : context_(std::move(context)),
       lazy_glyph_atlas_(
           std::make_shared<LazyGlyphAtlas>(std::move(typographer_context))),
       tessellator_(std::make_shared<Tessellator>()),
 #if IMPELLER_ENABLE_3D
       scene_context_(std::make_shared<scene::SceneContext>(context_)),
 #endif  // IMPELLER_ENABLE_3D
-      render_target_cache_(std::make_shared<RenderTargetCache>(
-          context_->GetResourceAllocator())) {
+      render_target_cache_(render_target_allocator == nullptr
+                               ? std::make_shared<RenderTargetCache>(
+                                     context_->GetResourceAllocator())
+                               : std::move(render_target_allocator)) {
   if (!context_ || !context_->IsValid()) {
     return;
   }

impeller/entity/contents/content_context.h

@@ -343,7 +343,8 @@ class ContentContext {
  public:
   explicit ContentContext(
       std::shared_ptr<Context> context,
-      std::shared_ptr<TypographerContext> typographer_context);
+      std::shared_ptr<TypographerContext> typographer_context,
+      std::shared_ptr<RenderTargetAllocator> render_target_allocator = nullptr);
 
   ~ContentContext();
 

impeller/entity/entity_pass.cc

@@ -783,7 +783,16 @@ bool EntityPass::OnRender(
     // rendered output will actually be used, and so we set this to the current
     // stencil coverage (which is the max clip bounds). The contents may
     // optionally use this hint to avoid unnecessary rendering work.
-    element_entity.GetContents()->SetCoverageHint(current_stencil_coverage);
+    if (element_entity.GetContents()->GetCoverageHint().has_value()) {
+      // If the element already has a coverage hint (because its an advanced
+      // blend), then we need to intersect the stencil coverage hint with the
+      // existing coverage hint.
+      element_entity.GetContents()->SetCoverageHint(
+          current_stencil_coverage->Intersection(
+              element_entity.GetContents()->GetCoverageHint().value()));
+    } else {
+      element_entity.GetContents()->SetCoverageHint(current_stencil_coverage);
+    }
 
     switch (stencil_coverage.type) {
       case Contents::StencilCoverage::Type::kNoChange:

impeller/entity/entity_unittests.cc

@@ -7,12 +7,14 @@
 #include <memory>
 #include <optional>
 #include <unordered_map>
+#include <utility>
 #include <vector>
 
 #include "flutter/testing/testing.h"
 #include "fml/logging.h"
 #include "fml/time/time_point.h"
 #include "gtest/gtest.h"
+#include "impeller/core/texture_descriptor.h"
 #include "impeller/entity/contents/atlas_contents.h"
 #include "impeller/entity/contents/clip_contents.h"
 #include "impeller/entity/contents/conical_gradient_contents.h"
@@ -42,6 +44,7 @@
 #include "impeller/geometry/geometry_asserts.h"
 #include "impeller/geometry/path_builder.h"
 #include "impeller/geometry/sigma.h"
+#include "impeller/geometry/vector.h"
 #include "impeller/playground/playground.h"
 #include "impeller/playground/widgets.h"
 #include "impeller/renderer/command.h"
@@ -2441,6 +2444,89 @@ TEST_P(EntityTest, TextContentsCeilsGlyphScaleToDecimal) {
   ASSERT_EQ(TextFrame::RoundScaledFontSize(0.0f, 12), 0.0f);
 }
 
+class TestRenderTargetAllocator : public RenderTargetAllocator {
+ public:
+  explicit TestRenderTargetAllocator(std::shared_ptr<Allocator> allocator)
+      : RenderTargetAllocator(std::move(allocator)) {}
+
+  ~TestRenderTargetAllocator() = default;
+
+  std::shared_ptr<Texture> CreateTexture(
+      const TextureDescriptor& desc) override {
+    allocated_.push_back(desc);
+    return RenderTargetAllocator::CreateTexture(desc);
+  }
+
+  void Start() override { RenderTargetAllocator::Start(); }
+
+  void End() override { RenderTargetAllocator::End(); }
+
+  std::vector<TextureDescriptor> GetDescriptors() const { return allocated_; }
+
+ private:
+  std::vector<TextureDescriptor> allocated_;
+};
+
+TEST_P(EntityTest, AdvancedBlendCoverageHintIsNotResetByEntityPass) {
+  if (GetContext()->GetCapabilities()->SupportsFramebufferFetch()) {
+    GTEST_SKIP() << "Backends that support framebuffer fetch dont use coverage "
+                    "for advanced blends.";
+  }
+
+  auto contents = std::make_shared<SolidColorContents>();
+  contents->SetGeometry(Geometry::MakeRect({100, 100, 100, 100}));
+  contents->SetColor(Color::Red());
+
+  Entity entity;
+  entity.SetTransformation(Matrix::MakeScale(Vector3(2, 2, 1)));
+  entity.SetBlendMode(BlendMode::kColorBurn);
+  entity.SetContents(contents);
+
+  auto coverage = entity.GetCoverage();
+  EXPECT_TRUE(coverage.has_value());
+
+  auto pass = std::make_unique<EntityPass>();
+  auto test_allocator = std::make_shared<TestRenderTargetAllocator>(
+      GetContext()->GetResourceAllocator());
+  auto stencil_config = RenderTarget::AttachmentConfig{
+      .storage_mode = StorageMode::kDevicePrivate,
+      .load_action = LoadAction::kClear,
+      .store_action = StoreAction::kDontCare,
+      .clear_color = Color::BlackTransparent()};
+  auto rt = RenderTarget::CreateOffscreen(
+      *GetContext(), *test_allocator, ISize::MakeWH(1000, 1000), "Offscreen",
+      RenderTarget::kDefaultColorAttachmentConfig, stencil_config);
+  auto content_context = ContentContext(
+      GetContext(), TypographerContextSkia::Make(), test_allocator);
+  pass->AddEntity(entity);
+
+  EXPECT_TRUE(pass->Render(content_context, rt));
+
+  if (test_allocator->GetDescriptors().size() == 6u) {
+    EXPECT_EQ(test_allocator->GetDescriptors()[0].size, ISize(1000, 1000));
+    EXPECT_EQ(test_allocator->GetDescriptors()[1].size, ISize(1000, 1000));
+
+    EXPECT_EQ(test_allocator->GetDescriptors()[2].size, ISize(200, 200));
+    EXPECT_EQ(test_allocator->GetDescriptors()[3].size, ISize(200, 200));
+    EXPECT_EQ(test_allocator->GetDescriptors()[4].size, ISize(200, 200));
+    EXPECT_EQ(test_allocator->GetDescriptors()[5].size, ISize(200, 200));
+  } else if (test_allocator->GetDescriptors().size() == 9u) {
+    // Onscreen render target.
+    EXPECT_EQ(test_allocator->GetDescriptors()[0].size, ISize(1000, 1000));
+    EXPECT_EQ(test_allocator->GetDescriptors()[1].size, ISize(1000, 1000));
+    EXPECT_EQ(test_allocator->GetDescriptors()[2].size, ISize(1000, 1000));
+    EXPECT_EQ(test_allocator->GetDescriptors()[3].size, ISize(1000, 1000));
+    EXPECT_EQ(test_allocator->GetDescriptors()[4].size, ISize(1000, 1000));
+
+    EXPECT_EQ(test_allocator->GetDescriptors()[5].size, ISize(200, 200));
+    EXPECT_EQ(test_allocator->GetDescriptors()[5].size, ISize(200, 200));
+    EXPECT_EQ(test_allocator->GetDescriptors()[6].size, ISize(200, 200));
+    EXPECT_EQ(test_allocator->GetDescriptors()[7].size, ISize(200, 200));
+  } else {
+    EXPECT_TRUE(false);
+  }
+}
+
 }  // namespace testing
 }  // namespace impeller