[Impeller] Replace Impeller opacity peephole delegate with DL variant.

impeller/aiks/aiks_unittests.cc

@@ -494,30 +494,6 @@ TEST_P(AiksTest, CanEmptyPictureConvertToImage) {
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
 }
 
-TEST_P(AiksTest, CanRenderGroupOpacity) {
- Canvas canvas;
-
- Paint red;
- red.color = Color::Red();
- Paint green;
- green.color = Color::Green().WithAlpha(0.5);
- Paint blue;
- blue.color = Color::Blue();
-
- Paint alpha;
- alpha.color = Color::Red().WithAlpha(0.5);
-
- canvas.SaveLayer(alpha);
-
- canvas.DrawRect(Rect::MakeXYWH(000, 000, 100, 100), red);
- canvas.DrawRect(Rect::MakeXYWH(020, 020, 100, 100), green);
- canvas.DrawRect(Rect::MakeXYWH(040, 040, 100, 100), blue);
-
- canvas.Restore();
-
- ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
-}
-
 TEST_P(AiksTest, CoordinateConversionsAreCorrect) {
  Canvas canvas;
 
@@ -1634,45 +1610,6 @@ TEST_P(AiksTest, PaintWithFilters) {
  ASSERT_FALSE(paint.HasColorFilter());
 }
 
-TEST_P(AiksTest, OpacityPeepHoleApplicationTest) {
- auto entity_pass = std::make_shared<EntityPass>();
- auto rect = Rect::MakeLTRB(0, 0, 100, 100);
- Paint paint;
- paint.color = Color::White().WithAlpha(0.5);
- paint.color_filter =
- ColorFilter::MakeBlend(BlendMode::kSourceOver, Color::Blue());
-
- // Paint has color filter, can't elide.
- auto delegate = std::make_shared<OpacityPeepholePassDelegate>(paint);
- ASSERT_FALSE(delegate->CanCollapseIntoParentPass(entity_pass.get()));
-
- paint.color_filter = nullptr;
- paint.image_filter = ImageFilter::MakeBlur(Sigma(1.0), Sigma(1.0),
- FilterContents::BlurStyle::kNormal,
- Entity::TileMode::kClamp);
-
- // Paint has image filter, can't elide.
- delegate = std::make_shared<OpacityPeepholePassDelegate>(paint);
- ASSERT_FALSE(delegate->CanCollapseIntoParentPass(entity_pass.get()));
-
- paint.image_filter = nullptr;
- paint.color = Color::Red();
-
- // Paint has no alpha, can't elide;
- delegate = std::make_shared<OpacityPeepholePassDelegate>(paint);
- ASSERT_FALSE(delegate->CanCollapseIntoParentPass(entity_pass.get()));
-
- // Positive test.
- Entity entity;
- entity.SetContents(SolidColorContents::Make(
- PathBuilder{}.AddRect(rect).TakePath(), Color::Red()));
- entity_pass->AddEntity(std::move(entity));
- paint.color = Color::Red().WithAlpha(0.5);
-
- delegate = std::make_shared<OpacityPeepholePassDelegate>(paint);
- ASSERT_TRUE(delegate->CanCollapseIntoParentPass(entity_pass.get()));
-}
-
 TEST_P(AiksTest, DrawPaintAbsorbsClears) {
  Canvas canvas;
  canvas.DrawPaint({.color = Color::Red(), .blend_mode = BlendMode::kSource});

impeller/aiks/canvas.cc

@@ -224,6 +224,7 @@ void Canvas::Save(bool create_subpass,
  entry.transform = transform_stack_.back().transform;
  entry.cull_rect = transform_stack_.back().cull_rect;
  entry.clip_height = transform_stack_.back().clip_height;
+ entry.distributed_opacity = transform_stack_.back().distributed_opacity;
  if (create_subpass) {
  entry.rendering_mode = Entity::RenderingMode::kSubpass;
  auto subpass = std::make_unique<EntityPass>();
@@ -827,6 +828,7 @@ void Canvas::AddRenderEntityToCurrentPass(Entity entity, bool reuse_depth) {
  ++current_depth_;
  }
  entity.SetClipDepth(current_depth_);
+ entity.SetInheritedOpacity(transform_stack_.back().distributed_opacity);
  GetCurrentPass().AddEntity(std::move(entity));
 }
 
@@ -838,8 +840,16 @@ void Canvas::SaveLayer(const Paint& paint,
  std::optional<Rect> bounds,
  const std::shared_ptr<ImageFilter>& backdrop_filter,
  ContentBoundsPromise bounds_promise,
- uint32_t total_content_depth) {
+ uint32_t total_content_depth,
+ bool can_distribute_opacity) {
  TRACE_EVENT0("flutter", "Canvas::saveLayer");
+ if (can_distribute_opacity) {
+ FML_DCHECK(!backdrop_filter);
+ Save(false, total_content_depth, paint.blend_mode, backdrop_filter);
+ transform_stack_.back().distributed_opacity *= paint.color.alpha;
+ return;
+ }
+
  Save(true, total_content_depth, paint.blend_mode, backdrop_filter);
 
  // The DisplayList bounds/rtree doesn't account for filters applied to parent
@@ -861,13 +871,7 @@ void Canvas::SaveLayer(const Paint& paint,
  new_layer_pass.SetRequiredMipCount(mip_count_visitor.GetRequiredMipCount());
  }
 
- // Only apply opacity peephole on default blending.
- if (paint.blend_mode == BlendMode::kSourceOver) {
- new_layer_pass.SetDelegate(
- std::make_shared<OpacityPeepholePassDelegate>(paint));
- } else {
- new_layer_pass.SetDelegate(std::make_shared<PaintPassDelegate>(paint));
- }
+ new_layer_pass.SetDelegate(std::make_shared<PaintPassDelegate>(paint));
 }
 
 void Canvas::DrawTextFrame(const std::shared_ptr<TextFrame>& text_frame,

impeller/aiks/canvas.h

@@ -36,6 +36,7 @@ struct CanvasStackEntry {
  size_t clip_height = 0u;
  // The number of clips tracked for this canvas stack entry.
  size_t num_clips = 0u;
+ Scalar distributed_opacity = 1.0f;
  Entity::RenderingMode rendering_mode = Entity::RenderingMode::kDirect;
 };
 
@@ -75,7 +76,8 @@ class Canvas {
  std::optional<Rect> bounds = std::nullopt,
  const std::shared_ptr<ImageFilter>& backdrop_filter = nullptr,
  ContentBoundsPromise bounds_promise = ContentBoundsPromise::kUnknown,
- uint32_t total_content_depth = kMaxDepth);
+ uint32_t total_content_depth = kMaxDepth,
+ bool can_distribute_opacity = false);
 
  virtual bool Restore();
 

impeller/aiks/experimental_canvas.cc

@@ -194,6 +194,7 @@ void ExperimentalCanvas::Save(uint32_t total_content_depth) {
  entry.transform = transform_stack_.back().transform;
  entry.cull_rect = transform_stack_.back().cull_rect;
  entry.clip_depth = current_depth_ + total_content_depth;
+ entry.distributed_opacity = transform_stack_.back().distributed_opacity;
  FML_CHECK(entry.clip_depth <= transform_stack_.back().clip_depth)
  << entry.clip_depth << " <=? " << transform_stack_.back().clip_depth
  << " after allocating " << total_content_depth;
@@ -207,7 +208,13 @@ void ExperimentalCanvas::SaveLayer(
  std::optional<Rect> bounds,
  const std::shared_ptr<ImageFilter>& backdrop_filter,
  ContentBoundsPromise bounds_promise,
- uint32_t total_content_depth) {
+ uint32_t total_content_depth,
+ bool can_distribute_opacity) {
+ if (can_distribute_opacity) {
+ Save(total_content_depth);
+ transform_stack_.back().distributed_opacity *= paint.color.alpha;
+ return;
+ }
  // Can we always guarantee that we get a bounds? Does a lack of bounds
  // indicate something?
  if (!bounds.has_value()) {
@@ -393,6 +400,8 @@ void ExperimentalCanvas::DrawTextFrame(
 
 void ExperimentalCanvas::AddRenderEntityToCurrentPass(Entity entity,
  bool reuse_depth) {
+ entity.SetInheritedOpacity(transform_stack_.back().distributed_opacity);
+
  auto transform = entity.GetTransform();
  entity.SetTransform(
  Matrix::MakeTranslation(Vector3(-GetGlobalPassPosition())) * transform);

impeller/aiks/experimental_canvas.h

@@ -49,7 +49,8 @@ class ExperimentalCanvas : public Canvas {
  std::optional<Rect> bounds,
  const std::shared_ptr<ImageFilter>& backdrop_filter,
  ContentBoundsPromise bounds_promise,
- uint32_t total_content_depth) override;
+ uint32_t total_content_depth,
+ bool can_distribute_opacity) override;
 
  bool Restore() override;
 

impeller/aiks/paint_pass_delegate.cc

@@ -5,7 +5,6 @@
 #include "impeller/aiks/paint_pass_delegate.h"
 
 #include "impeller/core/formats.h"
-#include "impeller/core/sampler_descriptor.h"
 #include "impeller/entity/contents/contents.h"
 #include "impeller/entity/contents/texture_contents.h"
 #include "impeller/entity/entity_pass.h"
@@ -54,106 +53,4 @@ std::shared_ptr<FilterContents> PaintPassDelegate::WithImageFilter(
  Entity::RenderingMode::kSubpass);
 }
 
-/// OpacityPeepholePassDelegate
-/// ----------------------------------------------
-
-OpacityPeepholePassDelegate::OpacityPeepholePassDelegate(Paint paint)
- : paint_(std::move(paint)) {}
-
-// |EntityPassDelgate|
-OpacityPeepholePassDelegate::~OpacityPeepholePassDelegate() = default;
-
-// |EntityPassDelgate|
-bool OpacityPeepholePassDelegate::CanElide() {
- return paint_.blend_mode == BlendMode::kDestination;
-}
-
-// |EntityPassDelgate|
-bool OpacityPeepholePassDelegate::CanCollapseIntoParentPass(
- EntityPass* entity_pass) {
- // Passes with enforced bounds that clip the contents can not be safely
- // collapsed.
- if (entity_pass->GetBoundsLimitMightClipContent()) {
- return false;
- }
-
- // OpacityPeepholePassDelegate will only get used if the pass's blend mode is
- // SourceOver, so no need to check here.
- if (paint_.color.alpha <= 0.0 || paint_.color.alpha >= 1.0 ||
- paint_.image_filter || paint_.color_filter) {
- return false;
- }
-
- // 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->GetElementCount() > 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) {
- const auto& contents = entity.GetContents();
- if (!entity.CanInheritOpacity()) {
- 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.SetInheritedOpacity(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->SetLabel("Subpass");
- 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);
-}
-
-// |EntityPassDelgate|
-std::shared_ptr<FilterContents> OpacityPeepholePassDelegate::WithImageFilter(
- const FilterInput::Variant& input,
- const Matrix& effect_transform) const {
- return paint_.WithImageFilter(input, effect_transform,
- Entity::RenderingMode::kSubpass);
-}
-
 } // namespace impeller

impeller/aiks/paint_pass_delegate.h

@@ -43,43 +43,6 @@ class PaintPassDelegate final : public EntityPassDelegate {
  PaintPassDelegate& operator=(const PaintPassDelegate&) = delete;
 };
 
-/// 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:
- explicit OpacityPeepholePassDelegate(Paint paint);
-
- // |EntityPassDelgate|
- ~OpacityPeepholePassDelegate() 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;
-
- // |EntityPassDelgate|
- std::shared_ptr<FilterContents> WithImageFilter(
- const FilterInput::Variant& input,
- const Matrix& effect_transform) const override;
-
- private:
- const Paint paint_;
-
- OpacityPeepholePassDelegate(const OpacityPeepholePassDelegate&) = delete;
-
- OpacityPeepholePassDelegate& operator=(const OpacityPeepholePassDelegate&) =
- delete;
-};
-
 } // namespace impeller
 
 #endif // FLUTTER_IMPELLER_AIKS_PAINT_PASS_DELEGATE_H_

impeller/display_list/BUILD.gn

@@ -52,6 +52,7 @@ impeller_component("display_list") {
 template("display_list_unittests_component") {
  target_name = invoker.target_name
  predefined_sources = [
+ "aiks_dl_opacity_unittests.cc",
  "aiks_dl_path_unittests.cc",
  "dl_golden_unittests.cc",
  "dl_playground.cc",