take advantage of DisplayList culling in Impeller

flar · flar · commit a8b1db13ba41 · 2023-04-28T18:39:39.000-07:00
diff --git a/display_list/display_list.cc b/display_list/display_list.cc
@@ -140,6 +140,11 @@ void DisplayList::Dispatch(DlOpReceiver& receiver) const {
   Dispatch(receiver, ptr, ptr + byte_count_, NopCuller::instance);
 }
 
+void DisplayList::Dispatch(DlOpReceiver& receiver,
+                           const SkIRect& cull_rect) const {
+  Dispatch(receiver, SkRect::Make(cull_rect));
+}
+
 void DisplayList::Dispatch(DlOpReceiver& receiver,
                            const SkRect& cull_rect) const {
   if (cull_rect.isEmpty()) {
diff --git a/display_list/display_list.h b/display_list/display_list.h
@@ -235,6 +235,7 @@ class DisplayList : public SkRefCnt {
 
   void Dispatch(DlOpReceiver& ctx) const;
   void Dispatch(DlOpReceiver& ctx, const SkRect& cull_rect) const;
+  void Dispatch(DlOpReceiver& ctx, const SkIRect& cull_rect) const;
 
   // From historical behavior, SkPicture always included nested bytes,
   // but nested ops are only included if requested. The defaults used
diff --git a/display_list/display_list_unittests.cc b/display_list/display_list_unittests.cc
@@ -2532,81 +2532,79 @@ TEST_F(DisplayListTest, RTreeRenderCulling) {
   main_receiver.drawRect({20, 20, 30, 30});
   auto main = main_builder.Build();
 
+  auto test = [main](SkIRect cull_rect, const sk_sp<DisplayList>& expected) {
+    {  // Test SkIRect culling
+      DisplayListBuilder culling_builder;
+      main->Dispatch(ToReceiver(culling_builder), cull_rect);
+
+      EXPECT_TRUE(DisplayListsEQ_Verbose(culling_builder.Build(), expected));
+    }
+
+    {  // Test SkRect culling
+      DisplayListBuilder culling_builder;
+      main->Dispatch(ToReceiver(culling_builder), SkRect::Make(cull_rect));
+
+      EXPECT_TRUE(DisplayListsEQ_Verbose(culling_builder.Build(), expected));
+    }
+  };
+
   {  // No rects
-    SkRect cull_rect = {11, 11, 19, 19};
+    SkIRect cull_rect = {11, 11, 19, 19};
 
     DisplayListBuilder expected_builder;
     auto expected = expected_builder.Build();
 
-    DisplayListBuilder culling_builder(cull_rect);
-    main->Dispatch(ToReceiver(culling_builder), cull_rect);
-
-    EXPECT_TRUE(DisplayListsEQ_Verbose(culling_builder.Build(), expected));
+    test(cull_rect, expected);
   }
 
   {  // Rect 1
-    SkRect cull_rect = {9, 9, 19, 19};
+    SkIRect cull_rect = {9, 9, 19, 19};
 
     DisplayListBuilder expected_builder;
     DlOpReceiver& expected_receiver = ToReceiver(expected_builder);
     expected_receiver.drawRect({0, 0, 10, 10});
     auto expected = expected_builder.Build();
 
-    DisplayListBuilder culling_builder(cull_rect);
-    main->Dispatch(ToReceiver(culling_builder), cull_rect);
-
-    EXPECT_TRUE(DisplayListsEQ_Verbose(culling_builder.Build(), expected));
+    test(cull_rect, expected);
   }
 
   {  // Rect 2
-    SkRect cull_rect = {11, 9, 21, 19};
+    SkIRect cull_rect = {11, 9, 21, 19};
 
     DisplayListBuilder expected_builder;
     DlOpReceiver& expected_receiver = ToReceiver(expected_builder);
     expected_receiver.drawRect({20, 0, 30, 10});
     auto expected = expected_builder.Build();
 
-    DisplayListBuilder culling_builder(cull_rect);
-    main->Dispatch(ToReceiver(culling_builder), cull_rect);
-
-    EXPECT_TRUE(DisplayListsEQ_Verbose(culling_builder.Build(), expected));
+    test(cull_rect, expected);
   }
 
   {  // Rect 3
-    SkRect cull_rect = {9, 11, 19, 21};
+    SkIRect cull_rect = {9, 11, 19, 21};
 
     DisplayListBuilder expected_builder;
     DlOpReceiver& expected_receiver = ToReceiver(expected_builder);
     expected_receiver.drawRect({0, 20, 10, 30});
     auto expected = expected_builder.Build();
 
-    DisplayListBuilder culling_builder(cull_rect);
-    main->Dispatch(ToReceiver(culling_builder), cull_rect);
-
-    EXPECT_TRUE(DisplayListsEQ_Verbose(culling_builder.Build(), expected));
+    test(cull_rect, expected);
   }
 
   {  // Rect 4
-    SkRect cull_rect = {11, 11, 21, 21};
+    SkIRect cull_rect = {11, 11, 21, 21};
 
     DisplayListBuilder expected_builder;
     DlOpReceiver& expected_receiver = ToReceiver(expected_builder);
     expected_receiver.drawRect({20, 20, 30, 30});
     auto expected = expected_builder.Build();
 
-    DisplayListBuilder culling_builder(cull_rect);
-    main->Dispatch(ToReceiver(culling_builder), cull_rect);
-
-    EXPECT_TRUE(DisplayListsEQ_Verbose(culling_builder.Build(), expected));
+    test(cull_rect, expected);
   }
 
   {  // All 4 rects
-    SkRect cull_rect = {9, 9, 21, 21};
-
-    DisplayListBuilder culling_builder(cull_rect);
-    main->Dispatch(ToReceiver(culling_builder), cull_rect);
+    SkIRect cull_rect = {9, 9, 21, 21};
 
-    EXPECT_TRUE(DisplayListsEQ_Verbose(culling_builder.Build(), main));
+    test(cull_rect, main);
   }
 }
 
diff --git a/impeller/aiks/canvas.cc b/impeller/aiks/canvas.cc
@@ -23,15 +23,25 @@
 namespace impeller {
 
 Canvas::Canvas() {
-  Initialize();
+  Initialize(Rect::MakeLTRB(-1e9, -1e9, 1e9, 1e9));
+}
+
+Canvas::Canvas(Rect cull_rect) {
+  Initialize(cull_rect);
+}
+
+Canvas::Canvas(IRect cull_rect) {
+  Initialize(Rect::MakeLTRB(cull_rect.GetLeft(), cull_rect.GetTop(),
+                            cull_rect.GetRight(), cull_rect.GetBottom()));
 }
 
 Canvas::~Canvas() = default;
 
-void Canvas::Initialize() {
+void Canvas::Initialize(Rect cull_rect) {
+  initial_cull_rect_ = cull_rect;
   base_pass_ = std::make_unique<EntityPass>();
   current_pass_ = base_pass_.get();
-  xformation_stack_.emplace_back(CanvasStackEntry{});
+  xformation_stack_.emplace_back(CanvasStackEntry{.clip_bounds = cull_rect});
   lazy_glyph_atlas_ = std::make_shared<LazyGlyphAtlas>();
   FML_DCHECK(GetSaveCount() == 1u);
   FML_DCHECK(base_pass_->GetSubpassesDepth() == 1u);
@@ -54,6 +64,7 @@ void Canvas::Save(
     std::optional<EntityPass::BackdropFilterProc> backdrop_filter) {
   auto entry = CanvasStackEntry{};
   entry.xformation = xformation_stack_.back().xformation;
+  entry.clip_bounds = xformation_stack_.back().clip_bounds;
   entry.stencil_depth = xformation_stack_.back().stencil_depth;
   if (create_subpass) {
     entry.is_subpass = true;
@@ -109,6 +120,11 @@ const Matrix& Canvas::GetCurrentTransformation() const {
   return xformation_stack_.back().xformation;
 }
 
+const Rect Canvas::GetCurrentLocalClipBounds() const {
+  Matrix inverse = xformation_stack_.back().xformation.Invert();
+  return xformation_stack_.back().clip_bounds.TransformBounds(inverse);
+}
+
 void Canvas::Translate(const Vector3& offset) {
   Concat(Matrix::MakeTranslation(offset));
 }
@@ -257,21 +273,22 @@ void Canvas::DrawCircle(Point center, Scalar radius, const Paint& paint) {
 }
 
 void Canvas::ClipPath(const Path& path, Entity::ClipOperation clip_op) {
-  ClipGeometry(Geometry::MakeFillPath(path), clip_op);
+  ClipGeometry(Geometry::MakeFillPath(path), clip_op, path.GetBoundingBox());
 }
 
 void Canvas::ClipRect(const Rect& rect, Entity::ClipOperation clip_op) {
-  ClipGeometry(Geometry::MakeRect(rect), clip_op);
+  ClipGeometry(Geometry::MakeRect(rect), clip_op, rect);
 }
 
 void Canvas::ClipRRect(const Rect& rect,
                        Scalar corner_radius,
                        Entity::ClipOperation clip_op) {
-  ClipGeometry(Geometry::MakeRRect(rect, corner_radius), clip_op);
+  ClipGeometry(Geometry::MakeRRect(rect, corner_radius), clip_op, rect);
 }
 
 void Canvas::ClipGeometry(std::unique_ptr<Geometry> geometry,
-                          Entity::ClipOperation clip_op) {
+                          Entity::ClipOperation clip_op,
+                          std::optional<Rect> geometry_bounds) {
   auto contents = std::make_shared<ClipContents>();
   contents->SetGeometry(std::move(geometry));
   contents->SetClipOperation(clip_op);
@@ -283,6 +300,19 @@ void Canvas::ClipGeometry(std::unique_ptr<Geometry> geometry,
 
   GetCurrentPass().AddEntity(entity);
 
+  if (geometry_bounds.has_value()) {
+    if (clip_op == Entity::ClipOperation::kIntersect) {
+      Rect transformed =
+          geometry_bounds.value().TransformBounds(GetCurrentTransformation());
+      auto new_bounds =
+          xformation_stack_.back().clip_bounds.Intersection(transformed);
+      xformation_stack_.back().clip_bounds = new_bounds.value_or(Rect{});
+    }
+    // else if kDifference we could chop off a side of the clip_bounds if
+    // the subtracted geometry was a rectangle and it spans the height or
+    // width of the current bounds.
+  }
+
   ++xformation_stack_.back().stencil_depth;
   xformation_stack_.back().contains_clips = true;
 }
@@ -364,7 +394,7 @@ Picture Canvas::EndRecordingAsPicture() {
   picture.pass = std::move(base_pass_);
 
   Reset();
-  Initialize();
+  Initialize(initial_cull_rect_);
 
   return picture;
 }
diff --git a/impeller/aiks/canvas.h b/impeller/aiks/canvas.h
@@ -40,6 +40,10 @@ class Canvas {
 
   Canvas();
 
+  explicit Canvas(Rect cull_rect);
+
+  explicit Canvas(IRect cull_rect);
+
   ~Canvas();
 
   void Save();
@@ -57,6 +61,8 @@ class Canvas {
 
   const Matrix& GetCurrentTransformation() const;
 
+  const Rect GetCurrentLocalClipBounds() const;
+
   void ResetTransform();
 
   void Transform(const Matrix& xformation);
@@ -135,8 +141,9 @@ class Canvas {
   EntityPass* current_pass_ = nullptr;
   std::deque<CanvasStackEntry> xformation_stack_;
   std::shared_ptr<LazyGlyphAtlas> lazy_glyph_atlas_;
+  Rect initial_cull_rect_;
 
-  void Initialize();
+  void Initialize(Rect cull_rect);
 
   void Reset();
 
@@ -145,7 +152,8 @@ class Canvas {
   size_t GetStencilDepth() const;
 
   void ClipGeometry(std::unique_ptr<Geometry> geometry,
-                    Entity::ClipOperation clip_op);
+                    Entity::ClipOperation clip_op,
+                    std::optional<Rect> geometry_bounds);
 
   void Save(bool create_subpass,
             BlendMode = BlendMode::kSourceOver,
diff --git a/impeller/display_list/dl_dispatcher.cc b/impeller/display_list/dl_dispatcher.cc
@@ -43,6 +43,10 @@ namespace impeller {
 
 DlDispatcher::DlDispatcher() = default;
 
+DlDispatcher::DlDispatcher(Rect cull_rect) : canvas_(cull_rect) {}
+
+DlDispatcher::DlDispatcher(IRect cull_rect) : canvas_(cull_rect) {}
+
 DlDispatcher::~DlDispatcher() = default;
 
 static BlendMode ToBlendMode(flutter::DlBlendMode mode) {
@@ -1053,7 +1057,15 @@ void DlDispatcher::drawDisplayList(
     canvas_.SaveLayer(save_paint);
   }
 
-  display_list->Dispatch(*this);
+  if (display_list->rtree()) {
+    Rect clip_bounds = canvas_.GetCurrentLocalClipBounds();
+    display_list->Dispatch(
+        *this,
+        SkRect::MakeLTRB(clip_bounds.GetLeft(), clip_bounds.GetTop(),
+                         clip_bounds.GetRight(), clip_bounds.GetBottom()));
+  } else {
+    display_list->Dispatch(*this);
+  }
 
   // Restore all saved state back to what it was before we interpreted
   // the display_list
diff --git a/impeller/display_list/dl_dispatcher.h b/impeller/display_list/dl_dispatcher.h
@@ -15,6 +15,10 @@ class DlDispatcher final : public flutter::DlOpReceiver {
  public:
   DlDispatcher();
 
+  explicit DlDispatcher(Rect cull_rect);
+
+  explicit DlDispatcher(IRect cull_rect);
+
   ~DlDispatcher();
 
   Picture EndRecordingAsPicture();
diff --git a/impeller/entity/entity_pass.h b/impeller/entity/entity_pass.h
@@ -236,6 +236,7 @@ class EntityPass {
 
 struct CanvasStackEntry {
   Matrix xformation;
+  Rect clip_bounds;
   size_t stencil_depth = 0u;
   bool is_subpass = false;
   bool contains_clips = false;
diff --git a/shell/gpu/gpu_surface_metal_impeller.mm b/shell/gpu/gpu_surface_metal_impeller.mm
@@ -104,9 +104,9 @@
           damage_[texture] = SkIRect::MakeEmpty();
         }
 
+        std::optional<SkIRect> buffer_damage = surface_frame.submit_info().buffer_damage;
         std::optional<impeller::IRect> clip_rect;
-        if (surface_frame.submit_info().buffer_damage.has_value()) {
-          auto buffer_damage = surface_frame.submit_info().buffer_damage;
+        if (buffer_damage.has_value()) {
           clip_rect = impeller::IRect::MakeXYWH(buffer_damage->x(), buffer_damage->y(),
                                                 buffer_damage->width(), buffer_damage->height());
         }
@@ -118,8 +118,13 @@
           return surface->Present();
         }
 
-        impeller::DlDispatcher impeller_dispatcher;
-        display_list->Dispatch(impeller_dispatcher);
+        if (!buffer_damage.has_value()) {
+          auto size = surface->GetSize();
+          buffer_damage = SkIRect::MakeWH(size.width, size.height);
+          clip_rect = impeller::IRect::MakeXYWH(0, 0, size.width, size.height);
+        }
+        impeller::DlDispatcher impeller_dispatcher(clip_rect.value());
+        display_list->Dispatch(impeller_dispatcher, buffer_damage.value());
         auto picture = impeller_dispatcher.EndRecordingAsPicture();
 
         return renderer->Render(
