[Impeller] Improve performance of CupertinoPicker with opacity peephole

impeller/aiks/canvas.cc

@@ -363,8 +363,15 @@ void Canvas::SaveLayer(
   Save(true, paint.blend_mode, backdrop_filter);
 
   auto& new_layer_pass = GetCurrentPass();
-  new_layer_pass.SetDelegate(
-      std::make_unique<PaintPassDelegate>(paint, bounds));
+
+  // Only apply opacity peephole on default blending.
+  if (paint.blend_mode == BlendMode::kSourceOver) {
+    new_layer_pass.SetDelegate(
+        std::make_unique<OpacityPeepholePassDelegate>(paint, bounds));
+  } else {
+    new_layer_pass.SetDelegate(
+        std::make_unique<PaintPassDelegate>(paint, bounds));
+  }
 
   if (bounds.has_value() && !backdrop_filter.has_value()) {
     // Render target switches due to a save layer can be elided. In such cases

impeller/aiks/paint_pass_delegate.cc

@@ -6,10 +6,14 @@
 
 #include "impeller/entity/contents/contents.h"
 #include "impeller/entity/contents/texture_contents.h"
+#include "impeller/entity/entity_pass.h"
 #include "impeller/geometry/path_builder.h"
 
 namespace impeller {
 
+/// PaintPassDelegate
+/// ----------------------------------------------
+
 PaintPassDelegate::PaintPassDelegate(Paint paint, std::optional<Rect> coverage)
     : paint_(std::move(paint)), coverage_(coverage) {}
 
@@ -27,7 +31,7 @@ bool PaintPassDelegate::CanElide() {
 }
 
 // |EntityPassDelgate|
-bool PaintPassDelegate::CanCollapseIntoParentPass() {
+bool PaintPassDelegate::CanCollapseIntoParentPass(EntityPass* entity_pass) {
   return false;
 }
 
@@ -44,4 +48,90 @@ std::shared_ptr<Contents> PaintPassDelegate::CreateContentsForSubpassTarget(
                                             effect_transform);
 }
 
+/// OpacityPeepholePassDelegate
+/// ----------------------------------------------
+
+OpacityPeepholePassDelegate::OpacityPeepholePassDelegate(
+    Paint paint,
+    std::optional<Rect> coverage)
+    : paint_(std::move(paint)), coverage_(coverage) {}
+
+// |EntityPassDelgate|
+OpacityPeepholePassDelegate::~OpacityPeepholePassDelegate() = default;
+
+// |EntityPassDelgate|
+std::optional<Rect> OpacityPeepholePassDelegate::GetCoverageRect() {
+  return coverage_;
+}
+
+// |EntityPassDelgate|
+bool OpacityPeepholePassDelegate::CanElide() {
+  return paint_.blend_mode == BlendMode::kDestination;
+}
+
+// |EntityPassDelgate|
+bool OpacityPeepholePassDelegate::CanCollapseIntoParentPass(
+    EntityPass* entity_pass) {
+  // Note: determing whether any coverage intersects has quadradic complexity in
+  // the number of rectangles, and depending on whether or not we cache at
+  // different levels of the entity tree may end up cubic. In the interest of
+  // proving whether or not this optimization is valuable, we only consider very
+  // simple peephole optimizations here - where there is a single drawing
+  // command wrapped in save layer. This would indicate something like an
+  // Opacity or FadeTransition wrapping a very simple widget, like in the
+  // CupertinoPicker.
+  if (entity_pass->GetEntityCount() > 3) {
+    // Single paint command with a save layer would be:
+    // 1. clip
+    // 2. draw command
+    // 3. restore.
+    return false;
+  }
+  bool all_can_accept = true;
+  std::vector<Rect> all_coverages;
+  auto had_subpass = entity_pass->IterateUntilSubpass(
+      [&all_coverages, &all_can_accept](Entity& entity) {
+        auto contents = entity.GetContents();
+        if (!contents->CanAcceptOpacity(entity)) {
+          all_can_accept = false;
+          return false;
+        }
+        auto maybe_coverage = contents->GetCoverage(entity);
+        if (maybe_coverage.has_value()) {
+          auto coverage = maybe_coverage.value();
+          for (const auto& cv : all_coverages) {
+            if (cv.IntersectsWithRect(coverage)) {
+              all_can_accept = false;
+              return false;
+            }
+          }
+          all_coverages.push_back(coverage);
+        }
+        return true;
+      });
+  if (had_subpass || !all_can_accept) {
+    return false;
+  }
+  auto alpha = paint_.color.alpha;
+  entity_pass->IterateUntilSubpass([&alpha](Entity& entity) {
+    entity.GetContents()->InheritOpacity(alpha);
+    return true;
+  });
+  return true;
+}
+
+// |EntityPassDelgate|
+std::shared_ptr<Contents>
+OpacityPeepholePassDelegate::CreateContentsForSubpassTarget(
+    std::shared_ptr<Texture> target,
+    const Matrix& effect_transform) {
+  auto contents = TextureContents::MakeRect(Rect::MakeSize(target->GetSize()));
+  contents->SetTexture(target);
+  contents->SetSourceRect(Rect::MakeSize(target->GetSize()));
+  contents->SetOpacity(paint_.color.alpha);
+  contents->SetDeferApplyingOpacity(true);
+  return paint_.WithFiltersForSubpassTarget(std::move(contents),
+                                            effect_transform);
+}
+
 }  // namespace impeller

impeller/aiks/paint_pass_delegate.h

@@ -12,6 +12,8 @@
 
 namespace impeller {
 
+class EntityPass;
+
 class PaintPassDelegate final : public EntityPassDelegate {
  public:
   PaintPassDelegate(Paint paint, std::optional<Rect> coverage);
@@ -26,7 +28,7 @@ class PaintPassDelegate final : public EntityPassDelegate {
   bool CanElide() override;
 
   // |EntityPassDelgate|
-  bool CanCollapseIntoParentPass() override;
+  bool CanCollapseIntoParentPass(EntityPass* entity_pass) override;
 
   // |EntityPassDelgate|
   std::shared_ptr<Contents> CreateContentsForSubpassTarget(
@@ -40,4 +42,37 @@ class PaintPassDelegate final : public EntityPassDelegate {
   FML_DISALLOW_COPY_AND_ASSIGN(PaintPassDelegate);
 };
 
+/// A delegate that attempts to forward opacity from a save layer to
+/// child contents.
+///
+/// Currently this has a hardcoded limit of 3 entities in a pass, and
+/// cannot forward to child subpass delegates.
+class OpacityPeepholePassDelegate final : public EntityPassDelegate {
+ public:
+  OpacityPeepholePassDelegate(Paint paint, std::optional<Rect> coverage);
+
+  // |EntityPassDelgate|
+  ~OpacityPeepholePassDelegate() override;
+
+  // |EntityPassDelegate|
+  std::optional<Rect> GetCoverageRect() override;
+
+  // |EntityPassDelgate|
+  bool CanElide() override;
+
+  // |EntityPassDelgate|
+  bool CanCollapseIntoParentPass(EntityPass* entity_pass) override;
+
+  // |EntityPassDelgate|
+  std::shared_ptr<Contents> CreateContentsForSubpassTarget(
+      std::shared_ptr<Texture> target,
+      const Matrix& effect_transform) override;
+
+ private:
+  const Paint paint_;
+  const std::optional<Rect> coverage_;
+
+  FML_DISALLOW_COPY_AND_ASSIGN(OpacityPeepholePassDelegate);
+};
+
 }  // namespace impeller

impeller/entity/contents/clip_contents.cc

@@ -70,6 +70,12 @@ bool ClipContents::ShouldRender(
   return true;
 }
 
+bool ClipContents::CanAcceptOpacity(const Entity& entity) const {
+  return true;
+}
+
+void ClipContents::InheritOpacity(Scalar opacity) {}
+
 bool ClipContents::Render(const ContentContext& renderer,
                           const Entity& entity,
                           RenderPass& pass) const {
@@ -166,6 +172,12 @@ bool ClipRestoreContents::ShouldRender(
   return true;
 }
 
+bool ClipRestoreContents::CanAcceptOpacity(const Entity& entity) const {
+  return true;
+}
+
+void ClipRestoreContents::InheritOpacity(Scalar opacity) {}
+
 bool ClipRestoreContents::Render(const ContentContext& renderer,
                                  const Entity& entity,
                                  RenderPass& pass) const {

impeller/entity/contents/clip_contents.h

@@ -41,6 +41,11 @@ class ClipContents final : public Contents {
   bool Render(const ContentContext& renderer,
               const Entity& entity,
               RenderPass& pass) const override;
+  // |Contents|
+  bool CanAcceptOpacity(const Entity& entity) const override;
+
+  // |Contents|
+  void InheritOpacity(Scalar opacity) override;
 
  private:
   std::unique_ptr<Geometry> geometry_;
@@ -78,6 +83,12 @@ class ClipRestoreContents final : public Contents {
               const Entity& entity,
               RenderPass& pass) const override;
 
+  // |Contents|
+  bool CanAcceptOpacity(const Entity& entity) const override;
+
+  // |Contents|
+  void InheritOpacity(Scalar opacity) override;
+
  private:
   std::optional<Rect> restore_coverage_;
 

impeller/entity/contents/color_source_contents.cc

@@ -42,6 +42,14 @@ std::optional<Rect> ColorSourceContents::GetCoverage(
   return geometry_->GetCoverage(entity.GetTransformation());
 };
 
+bool ColorSourceContents::CanAcceptOpacity(const Entity& entity) const {
+  return true;
+}
+
+void ColorSourceContents::InheritOpacity(Scalar opacity) {
+  SetAlpha(GetAlpha() * opacity);
+}
+
 bool ColorSourceContents::ShouldRender(
     const Entity& entity,
     const std::optional<Rect>& stencil_coverage) const {

impeller/entity/contents/color_source_contents.h

@@ -33,11 +33,17 @@ class ColorSourceContents : public Contents {
   bool ShouldRender(const Entity& entity,
                     const std::optional<Rect>& stencil_coverage) const override;
 
- protected:
-  const std::shared_ptr<Geometry>& GetGeometry() const;
+  // | Contents|
+  bool CanAcceptOpacity(const Entity& entity) const override;
+
+  // | Contents|
+  void InheritOpacity(Scalar opacity) override;
 
   Scalar GetAlpha() const;
 
+ protected:
+  const std::shared_ptr<Geometry>& GetGeometry() const;
+
  private:
   std::shared_ptr<Geometry> geometry_;
   Matrix inverse_matrix_;

impeller/entity/contents/contents.cc

@@ -110,6 +110,14 @@ std::optional<Snapshot> Contents::RenderToSnapshot(
   return snapshot;
 }
 
+bool Contents::CanAcceptOpacity(const Entity& entity) const {
+  return false;
+}
+
+void Contents::InheritOpacity(Scalar opacity) {
+  FML_UNREACHABLE();
+}
+
 bool Contents::ShouldRender(const Entity& entity,
                             const std::optional<Rect>& stencil_coverage) const {
   if (!stencil_coverage.has_value()) {

impeller/entity/contents/contents.h

@@ -83,6 +83,19 @@ class Contents {
 
   void SetColorSourceSize(Size size) { color_source_size_ = size; }
 
+  /// @brief Whether or not this contents can accept the opacity peephole
+  ///        optimization.
+  ///
+  ///        By default all contents return false. Contents are responsible
+  ///        for determining whether or not their own geometries intersect in
+  ///        a way that makes accepting opacity impossible. It is always safe
+  ///        to return false, especially if computing overlap would be
+  ///        computationally expensive.
+  virtual bool CanAcceptOpacity(const Entity& entity) const;
+
+  /// @brief Inherit the provided opacity.
+  virtual void InheritOpacity(Scalar opacity);
+
  protected:
 
  private:

impeller/entity/contents/solid_color_contents.cc

@@ -28,6 +28,17 @@ void SolidColorContents::SetGeometry(std::shared_ptr<Geometry> geometry) {
   geometry_ = std::move(geometry);
 }
 
+// | Contents|
+bool SolidColorContents::CanAcceptOpacity(const Entity& entity) const {
+  return true;
+}
+
+// | Contents|
+void SolidColorContents::InheritOpacity(Scalar opacity) {
+  auto color = color_;
+  color_ = color.WithAlpha(color.alpha * opacity);
+}
+
 std::optional<Rect> SolidColorContents::GetCoverage(
     const Entity& entity) const {
   if (color_.IsTransparent()) {

impeller/entity/contents/solid_color_contents.h

@@ -35,6 +35,12 @@ class SolidColorContents final : public Contents {
 
   const Color& GetColor() const;
 
+  // | Contents|
+  bool CanAcceptOpacity(const Entity& entity) const override;
+
+  // | Contents|
+  void InheritOpacity(Scalar opacity) override;
+
   // |Contents|
   std::optional<Rect> GetCoverage(const Entity& entity) const override;
 

impeller/entity/contents/text_contents.cc

@@ -50,6 +50,19 @@ void TextContents::SetColor(Color color) {
   color_ = color;
 }
 
+Color TextContents::GetColor() const {
+  return color_;
+}
+
+bool TextContents::CanAcceptOpacity(const Entity& entity) const {
+  return !frame_.MaybeHasOverlapping();
+}
+
+void TextContents::InheritOpacity(Scalar opacity) {
+  auto color = color_;
+  color_ = color.WithAlpha(color.alpha * opacity);
+}
+
 void TextContents::SetInverseMatrix(Matrix matrix) {
   inverse_matrix_ = matrix;
 }
@@ -122,9 +135,9 @@ static bool CommonRender(
   // interpolated vertex information is also used in the fragment shader to
   // sample from the glyph atlas.
 
-  const std::array<Point, 4> unit_points = {Point{0, 0}, Point{1, 0},
-                                            Point{0, 1}, Point{1, 1}};
-  const std::array<uint32_t, 6> indices = {0, 1, 2, 1, 2, 3};
+  constexpr std::array<Point, 4> unit_points = {Point{0, 0}, Point{1, 0},
+                                                Point{0, 1}, Point{1, 1}};
+  constexpr std::array<uint32_t, 6> indices = {0, 1, 2, 1, 2, 3};
 
   VertexBufferBuilder<typename VS::PerVertexData> vertex_builder;
 

impeller/entity/contents/text_contents.h

@@ -32,6 +32,12 @@ class TextContents final : public Contents {
 
   void SetColor(Color color);
 
+  Color GetColor() const;
+
+  bool CanAcceptOpacity(const Entity& entity) const override;
+
+  void InheritOpacity(Scalar opacity) override;
+
   void SetInverseMatrix(Matrix matrix);
 
   // |Contents|