RTree from DisplayList

Author: ColdPaleLight

ci/licenses_golden/licenses_flutter

@@ -100,6 +100,8 @@ FILE: ../../../flutter/display_list/display_list_paint_unittests.cc
 FILE: ../../../flutter/display_list/display_list_path_effect.cc
 FILE: ../../../flutter/display_list/display_list_path_effect.h
 FILE: ../../../flutter/display_list/display_list_path_effect_unittests.cc
+FILE: ../../../flutter/display_list/display_list_rtree.cc
+FILE: ../../../flutter/display_list/display_list_rtree.h
 FILE: ../../../flutter/display_list/display_list_sampling_options.h
 FILE: ../../../flutter/display_list/display_list_test_utils.cc
 FILE: ../../../flutter/display_list/display_list_test_utils.h

display_list/BUILD.gn

@@ -49,6 +49,8 @@ source_set("display_list") {
     "display_list_paint.h",
     "display_list_path_effect.cc",
     "display_list_path_effect.h",
+    "display_list_rtree.cc",
+    "display_list_rtree.h",
     "display_list_sampling_options.h",
     "display_list_tile_mode.h",
     "display_list_utils.cc",

display_list/display_list.cc

@@ -10,6 +10,7 @@
 #include "flutter/display_list/display_list_ops.h"
 #include "flutter/display_list/display_list_utils.h"
 #include "flutter/fml/trace_event.h"
+#include "include/core/SkRefCnt.h"
 
 namespace flutter {
 
@@ -34,15 +35,17 @@ DisplayList::DisplayList(uint8_t* ptr,
                          unsigned int nested_op_count,
                          const SkRect& bounds,
                          const SkRect& cull_rect,
-                         bool can_apply_group_opacity)
+                         bool can_apply_group_opacity,
+                         sk_sp<const DlRTree> rtree)
     : storage_(ptr),
       byte_count_(byte_count),
       op_count_(op_count),
       nested_byte_count_(nested_byte_count),
       nested_op_count_(nested_op_count),
       bounds_(bounds),
       bounds_cull_(cull_rect),
-      can_apply_group_opacity_(can_apply_group_opacity) {
+      can_apply_group_opacity_(can_apply_group_opacity),
+      rtree_(rtree) {
   static std::atomic<uint32_t> nextID{1};
   do {
     unique_id_ = nextID.fetch_add(+1, std::memory_order_relaxed);

display_list/display_list.h

@@ -5,8 +5,10 @@
 #ifndef FLUTTER_DISPLAY_LIST_DISPLAY_LIST_H_
 #define FLUTTER_DISPLAY_LIST_DISPLAY_LIST_H_
 
+#include <memory>
 #include <optional>
 
+#include "flutter/display_list/display_list_rtree.h"
 #include "flutter/display_list/display_list_sampling_options.h"
 #include "flutter/display_list/types.h"
 #include "flutter/fml/logging.h"
@@ -247,6 +249,8 @@ class DisplayList : public SkRefCnt {
 
   const SkRect& bounds() { return bounds_; }
 
+  sk_sp<const DlRTree> rtree() { return rtree_; }
+
   bool Equals(const DisplayList* other) const;
   bool Equals(const DisplayList& other) const { return Equals(&other); }
   bool Equals(sk_sp<const DisplayList> other) const {
@@ -265,7 +269,8 @@ class DisplayList : public SkRefCnt {
               unsigned int nested_op_count,
               const SkRect& bounds,
               const SkRect& cull_rect,
-              bool can_apply_group_opacity);
+              bool can_apply_group_opacity,
+              sk_sp<const DlRTree> rtree = nullptr);
 
   std::unique_ptr<uint8_t, SkFunctionWrapper<void(void*), sk_free>> storage_;
   size_t byte_count_;
@@ -276,12 +281,13 @@ class DisplayList : public SkRefCnt {
 
   uint32_t unique_id_;
   SkRect bounds_;
-
   // Only used for drawPaint() and drawColor()
   SkRect bounds_cull_;
 
   bool can_apply_group_opacity_;
 
+  sk_sp<const DlRTree> rtree_;
+
   void Dispatch(Dispatcher& ctx, uint8_t* ptr, uint8_t* end) const;
 
   friend class DisplayListBuilder;

display_list/display_list_builder.cc

@@ -50,14 +50,13 @@ void* DisplayListBuilder::Push(size_t pod, int op_inc, Args&&... args) {
 }
 
 sk_sp<DisplayList> DisplayListBuilder::Build() {
-  
   FML_DCHECK(build_count_ == 0);
   build_count_++;
 
   while (layer_stack_.size() > 1) {
     restore();
   }
- 
+
   size_t bytes = used_;
   int count = op_count_;
   size_t nested_bytes = nested_bytes_;
@@ -67,18 +66,17 @@ sk_sp<DisplayList> DisplayListBuilder::Build() {
   storage_.realloc(bytes);
   bool compatible = layer_stack_.back().is_group_opacity_compatible();
   FML_DCHECK(current_layer_ == &layer_stack_.back());
-  FML_DCHECK(accumulator_ == layer_stack_.back().layer_accumulator());
-  // accumulator_ = layer_stack_.back().layer_accumulator();
   return sk_sp<DisplayList>(new DisplayList(storage_.release(), bytes, count,
                                             nested_bytes, nested_count,
-                                            bounds(), cull_rect_, compatible));
+                                            bounds(), cull_rect_, compatible, rtree()));
 }
 
 DisplayListBuilder::DisplayListBuilder(const SkRect& cull_rect)
     : ClipBoundsDispatchHelper(&cull_rect), cull_rect_(cull_rect) {
-  layer_stack_.emplace_back(SkM44(), cull_rect, nullptr);
+  layer_stack_.emplace_back(SkM44(), cull_rect);
   current_layer_ = &layer_stack_.back();
-  accumulator_ = current_layer_->layer_accumulator();
+  combine_bounds_accumulator_.push_back(&rect_bounds_accumulator_);
+  combine_bounds_accumulator_.push_back(&rtree_bounds_accumulator_);
 }
 
 DisplayListBuilder::~DisplayListBuilder() {
@@ -436,72 +434,50 @@ void DisplayListBuilder::setAttributesFromPaint(
 void DisplayListBuilder::save() {
   ClipBoundsDispatchHelper::save();
   Push<SaveOp>(0, 1);
-  layer_stack_.emplace_back(current_layer_, accumulator_);
+  layer_stack_.emplace_back(current_layer_);
   current_layer_ = &layer_stack_.back();
-  accumulator_ = current_layer_->layer_accumulator();
+  accumulator()->save();
 }
 void DisplayListBuilder::restore() {
   if (layer_stack_.size() > 1) {
     // Grab the current layer info before we push the restore
     // on the stack.
-    LayerInfo& layer_info = layer_stack_.back();
+    LayerInfo layer_info = layer_stack_.back();
 
     ClipBoundsDispatchHelper::restore();
-
-    // BoundsAccumulator* outer_accumulator = layer_info.restore_accumulator();
     bool is_unbounded = layer_info.is_unbounded();
 
     // Before we pop_back we will get the current layer bounds from the
     // current accumulator and adjust ot as required based on the filter.
-    SkRect layer_bounds = accumulator_->bounds();
     std::shared_ptr<const DlImageFilter> filter = layer_info.filter();
+    const SkRect* clip = has_clip() ? &clip_bounds() : nullptr;
     if (filter) {
-      SkIRect filter_bounds;
-      if (filter->map_device_bounds(layer_bounds.roundOut(), matrix(),
-                                    filter_bounds)) {
-        layer_bounds.set(filter_bounds);
-
-        // We could leave the clipping to the code below that will
-        // finally accumulate the layer bounds, but the bounds do
-        // not normally need clipping unless they were modified by
-        // entering this filtering code path.
-        if (has_clip() && !layer_bounds.intersect(clip_bounds())) {
-          layer_bounds.setEmpty();
-        }
-      } else {
-        // If the filter cannot compute bounds then it might take an
-        // unbounded amount of space. This can sometimes happen if it
-        // modifies transparent black which means its affect will not
-        // be bounded by the transparent pixels outside of the layer
-        // drawable.
+        if (!accumulator()->restore(
+              [filter = filter, matrix = matrix()](const SkRect& input,
+                                                   SkRect& output) {
+                SkIRect output_bounds;
+                bool ret = filter->map_device_bounds(input.roundOut(), matrix,
+                                                     output_bounds);
+                output.set(output_bounds);
+                return ret;
+              },
+              clip)) {
         is_unbounded = true;
       }
+    } else {
+      accumulator()->restore(clip);
     }
 
-    
-
-    LayerInfo layer_info1 = layer_info;
-
     layer_stack_.pop_back();
     current_layer_ = &layer_stack_.back();
-    // Restore the accumulator before popping the LayerInfo so that
-    // it nevers points to an out of scope instance.
-    accumulator_ = current_layer_->layer_accumulator();
     Push<RestoreOp>(0, 1);
 
-    // Finally accumulate the impact of the layer into the new scope.
-    // Note that the bounds were already accumulated in device pixels
-    // and clipped to any clips involved so we do not need to go
-    // through any transforms or clips to accuulate them into this
-    // layer.
-    accumulator_->accumulate(layer_bounds);
-
     if (is_unbounded) {
       AccumulateUnbounded();
     }
 
-    if (layer_info1.has_layer) {
-      if (layer_info1.is_group_opacity_compatible()) {
+    if (layer_info.has_layer) {
+      if (layer_info.is_group_opacity_compatible()) {
         // We are now going to go back and modify the matching saveLayer
         // call to add the option indicating it can distribute an opacity
         // value to its children.
@@ -515,15 +491,15 @@ void DisplayListBuilder::restore() {
         // Once built, the DisplayList records must remain read only to
         // ensure consistency of rendering and |Equals()| behavior.
         SaveLayerOp* op = reinterpret_cast<SaveLayerOp*>(
-            storage_.get() + layer_info1.save_layer_offset);
+            storage_.get() + layer_info.save_layer_offset);
         op->options = op->options.with_can_distribute_opacity();
       }
     } else {
       // For regular save() ops there was no protecting layer so we have to
       // accumulate the values into the enclosing layer.
-      if (layer_info1.cannot_inherit_opacity) {
+      if (layer_info.cannot_inherit_opacity) {
         current_layer_->mark_incompatible();
-      } else if (layer_info1.has_compatible_op) {
+      } else if (layer_info.has_compatible_op) {
         current_layer_->add_compatible_op();
       }
     }
@@ -561,15 +537,13 @@ void DisplayListBuilder::saveLayer(const SkRect* bounds,
       // We will fill the clip of the outer layer when we restore
       AccumulateUnbounded();
     }
-    layer_stack_.emplace_back(current_layer_, accumulator_, save_layer_offset,
-                              true, current_.getImageFilter());
+    layer_stack_.emplace_back(current_layer_, save_layer_offset, true,
+                              current_.getImageFilter());
   } else {
-    layer_stack_.emplace_back(current_layer_, accumulator_, save_layer_offset,
-                              true, nullptr);
+    layer_stack_.emplace_back(current_layer_, save_layer_offset, true, nullptr);
   }
-
+  accumulator()->save();
   current_layer_ = &layer_stack_.back();
-  accumulator_ = layer_stack_.back().layer_accumulator();
   if (options.renders_with_attributes()) {
     // |current_opacity_compatibility_| does not take an ImageFilter into
     // account because an individual primitive with an ImageFilter can apply
@@ -936,7 +910,7 @@ void DisplayListBuilder::drawPoints(SkCanvas::PointMode mode,
   UpdateLayerOpacityCompatibility(false);
 
   if (count > 0) {
-    BoundsAccumulator ptBounds;
+    RectBoundsAccumulator ptBounds;
     for (size_t i = 0; i < count; i++) {
       ptBounds.accumulate(pts[i]);
     }
@@ -1152,7 +1126,7 @@ void DisplayListBuilder::drawAtlas(const sk_sp<DlImage> atlas,
   UpdateLayerOpacityCompatibility(false);
 
   SkPoint quad[4];
-  BoundsAccumulator atlasBounds;
+  RectBoundsAccumulator atlasBounds;
   for (int i = 0; i < count; i++) {
     const SkRect& src = tex[i];
     xform[i].toQuad(src.width(), src.height(), quad);
@@ -1322,7 +1296,7 @@ bool DisplayListBuilder::AdjustBoundsForPaint(SkRect& bounds,
 
 void DisplayListBuilder::AccumulateUnbounded() {
   if (has_clip()) {
-    accumulator_->accumulate(clip_bounds());
+    accumulator()->accumulate(clip_bounds());
   } else {
     layer_stack_.back().set_unbounded();
   }
@@ -1339,7 +1313,7 @@ void DisplayListBuilder::AccumulateOpBounds(SkRect& bounds,
 void DisplayListBuilder::AccumulateBounds(SkRect& bounds) {
   matrix().mapRect(&bounds);
   if (!has_clip() || bounds.intersect(clip_bounds())) {
-    accumulator_->accumulate(bounds);
+    accumulator()->accumulate(bounds);
   }
 }
 

display_list/display_list_builder.h

@@ -375,9 +375,6 @@ class DisplayListBuilder final : public virtual Dispatcher,
   static constexpr SkRect kMaxCullRect_ =
       SkRect::MakeLTRB(-1E9F, -1E9F, 1E9F, 1E9F);
 
-  // current accumulator based on saveLayer history
-  BoundsAccumulator* accumulator_;
-
   template <typename T, typename... Args>
   void* Push(size_t extra, int op_inc, Args&&... args);
 
@@ -393,7 +390,6 @@ class DisplayListBuilder final : public virtual Dispatcher,
   struct LayerInfo {
     explicit LayerInfo(const SkM44& matrix,
                        const SkRect& clip_bounds,
-                       BoundsAccumulator* outer,
                        size_t save_layer_offset = 0,
                        bool has_layer = false,
                        std::shared_ptr<const DlImageFilter> filter = nullptr)
@@ -403,18 +399,15 @@ class DisplayListBuilder final : public virtual Dispatcher,
           has_compatible_op(false),
           matrix(matrix),
           clip_bounds(clip_bounds),
-          outer_(outer),
           filter_(filter),
           is_unbounded_(false) {}
 
     explicit LayerInfo(const LayerInfo* current_layer,
-                       BoundsAccumulator* outer,
                        size_t save_layer_offset = 0,
                        bool has_layer = false,
                        std::shared_ptr<const DlImageFilter> filter = nullptr)
         : LayerInfo(current_layer->matrix,
                     current_layer->clip_bounds,
-                    outer,
                     save_layer_offset,
                     has_layer,
                     filter) {}
@@ -434,8 +427,6 @@ class DisplayListBuilder final : public virtual Dispatcher,
     SkM44 matrix;
     SkRect clip_bounds;
 
-    BoundsAccumulator layer_accumulator_;
-    BoundsAccumulator* outer_;
     std::shared_ptr<const DlImageFilter> filter_;
     bool is_unbounded_;
 
@@ -458,14 +449,6 @@ class DisplayListBuilder final : public virtual Dispatcher,
       }
     }
 
-    // The accumulator to use while this layer is put in play by
-    // a |save| or |saveLayer|
-    BoundsAccumulator* layer_accumulator() { return &layer_accumulator_; }
-
-    // The accumulator to use after this layer is removed from play
-    // via |restore|
-    BoundsAccumulator* restore_accumulator() { return outer_; }
-
     // The filter to apply to the layer bounds when it is restored
     std::shared_ptr<const DlImageFilter> filter() { return filter_; }
 
@@ -502,6 +485,10 @@ class DisplayListBuilder final : public virtual Dispatcher,
 
   std::vector<LayerInfo> layer_stack_;
   LayerInfo* current_layer_;
+  RectBoundsAccumulator rect_bounds_accumulator_;
+  RTreeBoundsAccumulator rtree_bounds_accumulator_;
+  CombineBoundsAccumulator combine_bounds_accumulator_;
+  BoundsAccumulator* accumulator() { return &combine_bounds_accumulator_; }
 
   // This flag indicates whether or not the current rendering attributes
   // are compatible with rendering ops applying an inherited opacity.
@@ -596,7 +583,15 @@ class DisplayListBuilder final : public virtual Dispatcher,
     if (is_unbounded()) {
       FML_LOG(INFO) << "returning partial bounds for unbounded DisplayList";
     }
-    return accumulator_->bounds();
+    return rect_bounds_accumulator_.bounds();
+  }
+
+  sk_sp<const DlRTree> rtree() const {
+    FML_DCHECK(layer_stack_.size() == 1);
+    if (is_unbounded()) {
+      FML_LOG(INFO) << "returning partial rtree for unbounded DisplayList";
+    }
+    return rtree_bounds_accumulator_.rtree();
   }
 
   bool paint_nops_on_transparency();