make cull_rect std::optional and add unit tests of Canvas clip bounds methods

Author: flar

ci/licenses_golden/excluded_files

@@ -120,6 +120,7 @@
 ../../../flutter/impeller/.gitignore
 ../../../flutter/impeller/README.md
 ../../../flutter/impeller/aiks/aiks_unittests.cc
+../../../flutter/impeller/aiks/canvas_unittests.cc
 ../../../flutter/impeller/archivist/archivist_unittests.cc
 ../../../flutter/impeller/base/README.md
 ../../../flutter/impeller/base/base_unittests.cc

impeller/aiks/BUILD.gn

@@ -47,7 +47,10 @@ impeller_component("aiks_playground") {
 
 impeller_component("aiks_unittests") {
   testonly = true
-  sources = [ "aiks_unittests.cc" ]
+  sources = [
+    "aiks_unittests.cc",
+    "canvas_unittests.cc",
+  ]
   deps = [
     ":aiks",
     ":aiks_playground",

impeller/aiks/canvas.cc

@@ -23,7 +23,7 @@
 namespace impeller {
 
 Canvas::Canvas() {
-  Initialize(Rect::MakeLTRB(-1e9, -1e9, 1e9, 1e9));
+  Initialize(std::nullopt);
 }
 
 Canvas::Canvas(Rect cull_rect) {
@@ -37,11 +37,11 @@ Canvas::Canvas(IRect cull_rect) {
 
 Canvas::~Canvas() = default;
 
-void Canvas::Initialize(Rect cull_rect) {
+void Canvas::Initialize(std::optional<Rect> cull_rect) {
   initial_cull_rect_ = cull_rect;
   base_pass_ = std::make_unique<EntityPass>();
   current_pass_ = base_pass_.get();
-  xformation_stack_.emplace_back(CanvasStackEntry{.clip_bounds = cull_rect});
+  xformation_stack_.emplace_back(CanvasStackEntry{.cull_rect = cull_rect});
   lazy_glyph_atlas_ = std::make_shared<LazyGlyphAtlas>();
   FML_DCHECK(GetSaveCount() == 1u);
   FML_DCHECK(base_pass_->GetSubpassesDepth() == 1u);
@@ -64,7 +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.cull_rect = xformation_stack_.back().cull_rect;
   entry.stencil_depth = xformation_stack_.back().stencil_depth;
   if (create_subpass) {
     entry.is_subpass = true;
@@ -120,9 +120,13 @@ 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);
+const std::optional<Rect> Canvas::GetCurrentLocalCullingBounds() const {
+  auto cull_rect = xformation_stack_.back().cull_rect;
+  if (cull_rect.has_value()) {
+    Matrix inverse = xformation_stack_.back().xformation.Invert();
+    cull_rect = cull_rect.value().TransformBounds(inverse);
+  }
+  return cull_rect;
 }
 
 void Canvas::Translate(const Vector3& offset) {
@@ -273,22 +277,61 @@ 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, path.GetBoundingBox());
+  ClipGeometry(Geometry::MakeFillPath(path), clip_op);
+  if (clip_op == Entity::ClipOperation::kIntersect) {
+    auto bounds = path.GetBoundingBox();
+    if (bounds.has_value()) {
+      IntersectCulling(bounds.value());
+    }
+  }
 }
 
 void Canvas::ClipRect(const Rect& rect, Entity::ClipOperation clip_op) {
-  ClipGeometry(Geometry::MakeRect(rect), clip_op, rect);
+  ClipGeometry(Geometry::MakeRect(rect), clip_op);
+  switch (clip_op) {
+    case Entity::ClipOperation::kIntersect:
+      IntersectCulling(rect);
+      break;
+    case Entity::ClipOperation::kDifference:
+      SubtractCulling(rect);
+      break;
+  }
 }
 
 void Canvas::ClipRRect(const Rect& rect,
                        Scalar corner_radius,
                        Entity::ClipOperation clip_op) {
-  ClipGeometry(Geometry::MakeRRect(rect, corner_radius), clip_op, rect);
+  ClipGeometry(Geometry::MakeRRect(rect, corner_radius), clip_op);
+  switch (clip_op) {
+    case Entity::ClipOperation::kIntersect:
+      IntersectCulling(rect);
+      break;
+    case Entity::ClipOperation::kDifference:
+      if (corner_radius <= 0) {
+        SubtractCulling(rect);
+      } else {
+        // We subtract the inner "tall" and "wide" rectangle pieces
+        // that fit inside the corners which cover the greatest area
+        // without involving the curved corners
+        // Since this is a subtract operation, we can subtract each
+        // rectangle piece individually without fear of interference.
+        if (corner_radius * 2 < rect.size.width) {
+          SubtractCulling(Rect::MakeLTRB(
+              rect.GetLeft() + corner_radius, rect.GetTop(),
+              rect.GetRight() - corner_radius, rect.GetBottom()));
+        }
+        if (corner_radius * 2 < rect.size.height) {
+          SubtractCulling(Rect::MakeLTRB(
+              rect.GetLeft(), rect.GetTop() + corner_radius,  //
+              rect.GetRight(), rect.GetBottom() - corner_radius));
+        }
+      }
+      break;
+  }
 }
 
 void Canvas::ClipGeometry(std::unique_ptr<Geometry> geometry,
-                          Entity::ClipOperation clip_op,
-                          std::optional<Rect> geometry_bounds) {
+                          Entity::ClipOperation clip_op) {
   auto contents = std::make_shared<ClipContents>();
   contents->SetGeometry(std::move(geometry));
   contents->SetClipOperation(clip_op);
@@ -300,23 +343,35 @@ 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;
 }
 
+void Canvas::IntersectCulling(Rect clip_rect) {
+  clip_rect = clip_rect.TransformBounds(GetCurrentTransformation());
+  std::optional<Rect>& cull_rect = xformation_stack_.back().cull_rect;
+  if (cull_rect.has_value()) {
+    cull_rect = cull_rect
+                    .value()                  //
+                    .Intersection(clip_rect)  //
+                    .value_or(Rect{});
+  } else {
+    cull_rect = clip_rect;
+  }
+}
+
+void Canvas::SubtractCulling(Rect clip_rect) {
+  std::optional<Rect>& cull_rect = xformation_stack_.back().cull_rect;
+  if (cull_rect.has_value()) {
+    clip_rect = clip_rect.TransformBounds(GetCurrentTransformation());
+    cull_rect = cull_rect
+                    .value()            //
+                    .Cutout(clip_rect)  //
+                    .value_or(Rect{});
+  }
+  // else (no cull) diff (any clip) is non-rectangular
+}
+
 void Canvas::RestoreClip() {
   Entity entity;
   entity.SetTransformation(GetCurrentTransformation());

impeller/aiks/canvas.h

@@ -28,6 +28,15 @@ namespace impeller {
 
 class Entity;
 
+struct CanvasStackEntry {
+  Matrix xformation;
+  // |cull_rect| is conservative screen-space bounds of the clipped output area
+  std::optional<Rect> cull_rect;
+  size_t stencil_depth = 0u;
+  bool is_subpass = false;
+  bool contains_clips = false;
+};
+
 class Canvas {
  public:
   struct DebugOptions {
@@ -61,7 +70,7 @@ class Canvas {
 
   const Matrix& GetCurrentTransformation() const;
 
-  const Rect GetCurrentLocalClipBounds() const;
+  const std::optional<Rect> GetCurrentLocalCullingBounds() const;
 
   void ResetTransform();
 
@@ -141,9 +150,9 @@ class Canvas {
   EntityPass* current_pass_ = nullptr;
   std::deque<CanvasStackEntry> xformation_stack_;
   std::shared_ptr<LazyGlyphAtlas> lazy_glyph_atlas_;
-  Rect initial_cull_rect_;
+  std::optional<Rect> initial_cull_rect_;
 
-  void Initialize(Rect cull_rect);
+  void Initialize(std::optional<Rect> cull_rect);
 
   void Reset();
 
@@ -152,8 +161,10 @@ class Canvas {
   size_t GetStencilDepth() const;
 
   void ClipGeometry(std::unique_ptr<Geometry> geometry,
-                    Entity::ClipOperation clip_op,
-                    std::optional<Rect> geometry_bounds);
+                    Entity::ClipOperation clip_op);
+
+  void IntersectCulling(Rect clip_bounds);
+  void SubtractCulling(Rect clip_bounds);
 
   void Save(bool create_subpass,
             BlendMode = BlendMode::kSourceOver,