[Impeller] Reland: Use the scissor to limit all draws by clip coverage.

impeller/aiks/aiks_unittests.cc

@@ -30,6 +30,7 @@
 #include "impeller/geometry/path.h"
 #include "impeller/geometry/path_builder.h"
 #include "impeller/geometry/rect.h"
+#include "impeller/geometry/size.h"
 #include "impeller/playground/widgets.h"
 #include "impeller/renderer/command_buffer.h"
 #include "impeller/renderer/snapshot.h"
@@ -3427,6 +3428,36 @@ TEST_P(AiksTest, CanDrawPerspectiveTransformWithClips) {
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }
 
+TEST_P(AiksTest, CanRenderClippedBackdropFilter) {
+  Canvas canvas;
+  Paint paint;
+
+  canvas.Scale(GetContentScale());
+
+  // Draw something interesting in the background.
+  std::vector<Color> colors = {Color{0.9568, 0.2627, 0.2118, 1.0},
+                               Color{0.1294, 0.5882, 0.9529, 1.0}};
+  std::vector<Scalar> stops = {
+      0.0,
+      1.0,
+  };
+  paint.color_source = ColorSource::MakeLinearGradient(
+      {0, 0}, {100, 100}, std::move(colors), std::move(stops),
+      Entity::TileMode::kRepeat, {});
+  canvas.DrawPaint(paint);
+
+  Rect clip_rect = Rect::MakeLTRB(50, 50, 400, 300);
+
+  // Draw a clipped SaveLayer, where the clip coverage and SaveLayer size are
+  // the same.
+  canvas.ClipRRect(clip_rect, Size(100, 100),
+                   Entity::ClipOperation::kIntersect);
+  canvas.SaveLayer({}, clip_rect,
+                   ImageFilter::MakeFromColorFilter(*ColorFilter::MakeBlend(
+                       BlendMode::kExclusion, Color::Red())));
+  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
+}
+
 }  // namespace testing
 }  // namespace impeller
 

impeller/entity/entity_pass.cc

@@ -25,6 +25,7 @@
 #include "impeller/entity/inline_pass_context.h"
 #include "impeller/geometry/color.h"
 #include "impeller/geometry/rect.h"
+#include "impeller/geometry/size.h"
 #include "impeller/renderer/command_buffer.h"
 
 #ifdef IMPELLER_DEBUG
@@ -752,6 +753,25 @@ EntityPass::EntityResult EntityPass::GetEntityForElement(
   FML_UNREACHABLE();
 }
 
+static void SetClipScissor(std::optional<Rect> clip_coverage,
+                           RenderPass& pass,
+                           Point global_pass_position) {
+  if constexpr (!ContentContext::kEnableStencilThenCover) {
+    return;
+  }
+  // Set the scissor to the clip coverage area. We do this prior to rendering
+  // the clip itself and all its contents.
+  IRect scissor;
+  if (clip_coverage.has_value()) {
+    clip_coverage = clip_coverage->Shift(-global_pass_position);
+    scissor = IRect::RoundOut(clip_coverage.value());
+    // The scissor rect must not exceed the size of the render target.
+    scissor = scissor.Intersection(IRect::MakeSize(pass.GetRenderTargetSize()))
+                  .value_or(IRect());
+  }
+  pass.SetScissor(scissor);
+}
+
 bool EntityPass::RenderElement(Entity& element_entity,
                                size_t clip_depth_floor,
                                InlinePassContext& pass_context,
@@ -767,17 +787,6 @@ bool EntityPass::RenderElement(Entity& element_entity,
     return false;
   }
 
-  if (result.just_created) {
-    // Restore any clips that were recorded before the backdrop filter was
-    // applied.
-    auto& replay_entities = clip_coverage_stack.GetReplayEntities();
-    for (const auto& entity : replay_entities) {
-      if (!entity.Render(renderer, *result.pass)) {
-        VALIDATION_LOG << "Failed to render entity for clip restore.";
-      }
-    }
-  }
-
   // If the pass context returns a backdrop texture, we need to draw it to the
   // current pass. We do this because it's faster and takes significantly less
   // memory than storing/loading large MSAA textures. Also, it's not possible to
@@ -801,6 +810,19 @@ bool EntityPass::RenderElement(Entity& element_entity,
     }
   }
 
+  if (result.just_created) {
+    // Restore any clips that were recorded before the backdrop filter was
+    // applied.
+    auto& replay_entities = clip_coverage_stack.GetReplayEntities();
+    for (const auto& replay : replay_entities) {
+      SetClipScissor(clip_coverage_stack.CurrentClipCoverage(), *result.pass,
+                     global_pass_position);
+      if (!replay.entity.Render(renderer, *result.pass)) {
+        VALIDATION_LOG << "Failed to render entity for clip restore.";
+      }
+    }
+  }
+
   auto current_clip_coverage = clip_coverage_stack.CurrentClipCoverage();
   if (current_clip_coverage.has_value()) {
     // Entity transforms are relative to the current pass position, so we need
@@ -826,11 +848,18 @@ bool EntityPass::RenderElement(Entity& element_entity,
   element_entity.GetContents()->SetCoverageHint(
       Rect::Intersection(element_coverage_hint, current_clip_coverage));
 
-  if (!clip_coverage_stack.AppendClipCoverage(clip_coverage, element_entity,
-                                              clip_depth_floor,
-                                              global_pass_position)) {
-    // If the entity's coverage change did not change the clip coverage, we
-    // don't need to render it.
+  EntityPassClipStack::ClipStateResult clip_state_result =
+      clip_coverage_stack.ApplyClipState(clip_coverage, element_entity,
+                                         clip_depth_floor,
+                                         global_pass_position);
+
+  if (clip_state_result.clip_did_change) {
+    // We only need to update the pass scissor if the clip state has changed.
+    SetClipScissor(clip_coverage_stack.CurrentClipCoverage(), *result.pass,
+                   global_pass_position);
+  }
+
+  if (!clip_state_result.should_render) {
     return true;
   }
 

impeller/entity/entity_pass_clip_stack.cc

@@ -49,20 +49,23 @@ EntityPassClipStack::GetClipCoverageLayers() const {
   return subpass_state_.back().clip_coverage;
 }
 
-bool EntityPassClipStack::AppendClipCoverage(
-    Contents::ClipCoverage clip_coverage,
+EntityPassClipStack::ClipStateResult EntityPassClipStack::ApplyClipState(
+    Contents::ClipCoverage global_clip_coverage,
     Entity& entity,
     size_t clip_depth_floor,
     Point global_pass_position) {
+  ClipStateResult result = {.should_render = false, .clip_did_change = false};
+
   auto& subpass_state = GetCurrentSubpassState();
-  switch (clip_coverage.type) {
+  switch (global_clip_coverage.type) {
     case Contents::ClipCoverage::Type::kNoChange:
       break;
     case Contents::ClipCoverage::Type::kAppend: {
       auto op = CurrentClipCoverage();
       subpass_state.clip_coverage.push_back(
-          ClipCoverageLayer{.coverage = clip_coverage.coverage,
+          ClipCoverageLayer{.coverage = global_clip_coverage.coverage,
                             .clip_depth = entity.GetClipDepth() + 1});
+      result.clip_did_change = true;
 
       FML_DCHECK(subpass_state.clip_coverage.back().clip_depth ==
                  subpass_state.clip_coverage.front().clip_depth +
@@ -71,14 +74,14 @@ bool EntityPassClipStack::AppendClipCoverage(
       if (!op.has_value()) {
         // Running this append op won't impact the clip buffer because the
         // whole screen is already being clipped, so skip it.
-        return false;
+        return result;
       }
     } break;
     case Contents::ClipCoverage::Type::kRestore: {
       if (subpass_state.clip_coverage.back().clip_depth <=
           entity.GetClipDepth()) {
         // Drop clip restores that will do nothing.
-        return false;
+        return result;
       }
 
       auto restoration_index = entity.GetClipDepth() -
@@ -96,18 +99,19 @@ bool EntityPassClipStack::AppendClipCoverage(
         restore_coverage = restore_coverage->Shift(-global_pass_position);
       }
       subpass_state.clip_coverage.resize(restoration_index + 1);
+      result.clip_did_change = true;
 
       if constexpr (ContentContext::kEnableStencilThenCover) {
         // Skip all clip restores when stencil-then-cover is enabled.
         if (subpass_state.clip_coverage.back().coverage.has_value()) {
-          RecordEntity(entity, clip_coverage.type);
+          RecordEntity(entity, global_clip_coverage.type, Rect());
         }
-        return false;
+        return result;
       }
 
       if (!subpass_state.clip_coverage.back().coverage.has_value()) {
         // Running this restore op won't make anything renderable, so skip it.
-        return false;
+        return result;
       }
 
       auto restore_contents =
@@ -130,19 +134,23 @@ bool EntityPassClipStack::AppendClipCoverage(
 #endif
 
   entity.SetClipDepth(entity.GetClipDepth() - clip_depth_floor);
-  RecordEntity(entity, clip_coverage.type);
+  RecordEntity(entity, global_clip_coverage.type,
+               subpass_state.clip_coverage.back().coverage);
 
-  return true;
+  result.should_render = true;
+  return result;
 }
 
 void EntityPassClipStack::RecordEntity(const Entity& entity,
-                                       Contents::ClipCoverage::Type type) {
+                                       Contents::ClipCoverage::Type type,
+                                       std::optional<Rect> clip_coverage) {
   auto& subpass_state = GetCurrentSubpassState();
   switch (type) {
     case Contents::ClipCoverage::Type::kNoChange:
       return;
     case Contents::ClipCoverage::Type::kAppend:
-      subpass_state.rendered_clip_entities.push_back(entity.Clone());
+      subpass_state.rendered_clip_entities.push_back(
+          {.entity = entity.Clone(), .clip_coverage = clip_coverage});
       break;
     case Contents::ClipCoverage::Type::kRestore:
       if (!subpass_state.rendered_clip_entities.empty()) {
@@ -157,7 +165,8 @@ EntityPassClipStack::GetCurrentSubpassState() {
   return subpass_state_.back();
 }
 
-const std::vector<Entity>& EntityPassClipStack::GetReplayEntities() const {
+const std::vector<EntityPassClipStack::ReplayResult>&
+EntityPassClipStack::GetReplayEntities() const {
   return subpass_state_.back().rendered_clip_entities;
 }
 

impeller/entity/entity_pass_clip_stack.h

@@ -6,6 +6,8 @@
 #define FLUTTER_IMPELLER_ENTITY_ENTITY_PASS_CLIP_STACK_H_
 
 #include "impeller/entity/contents/contents.h"
+#include "impeller/entity/entity.h"
+#include "impeller/geometry/rect.h"
 
 namespace impeller {
 
@@ -21,6 +23,20 @@ struct ClipCoverageLayer {
 ///        stencil buffer is left in an identical state.
 class EntityPassClipStack {
  public:
+  struct ReplayResult {
+    Entity entity;
+    std::optional<Rect> clip_coverage;
+  };
+
+  struct ClipStateResult {
+    /// Whether or not the Entity should be rendered. If false, the Entity may
+    /// be safely skipped.
+    bool should_render = false;
+    /// Whether or not the current clip coverage changed during the call to
+    /// `ApplyClipState`.
+    bool clip_did_change = false;
+  };
+
   /// Create a new [EntityPassClipStack] with an initialized coverage rect.
   explicit EntityPassClipStack(const Rect& initial_coverage_rect);
 
@@ -34,24 +50,27 @@ class EntityPassClipStack {
 
   bool HasCoverage() const;
 
-  /// Returns true if entity should be rendered.
-  bool AppendClipCoverage(Contents::ClipCoverage clip_coverage,
-                          Entity& entity,
-                          size_t clip_depth_floor,
-                          Point global_pass_position);
+  /// @brief  Applies the current clip state to an Entity. If the given Entity
+  ///         is a clip operation, then the clip state is updated accordingly.
+  ClipStateResult ApplyClipState(Contents::ClipCoverage global_clip_coverage,
+                                 Entity& entity,
+                                 size_t clip_depth_floor,
+                                 Point global_pass_position);
 
   // Visible for testing.
-  void RecordEntity(const Entity& entity, Contents::ClipCoverage::Type type);
+  void RecordEntity(const Entity& entity,
+                    Contents::ClipCoverage::Type type,
+                    std::optional<Rect> clip_coverage);
 
   // Visible for testing.
-  const std::vector<Entity>& GetReplayEntities() const;
+  const std::vector<ReplayResult>& GetReplayEntities() const;
 
   // Visible for testing.
   const std::vector<ClipCoverageLayer> GetClipCoverageLayers() const;
 
  private:
   struct SubpassState {
-    std::vector<Entity> rendered_clip_entities;
+    std::vector<ReplayResult> rendered_clip_entities;
     std::vector<ClipCoverageLayer> clip_coverage;
   };