[Impeller] Coerce opaque ColorSourceContents to Source (#41525)

This coercion happens when Entities are appended to a pass, which is the
moment where we will need to perform depth sorting.

Author: bdero

impeller/aiks/aiks_unittests.cc

@@ -2136,5 +2136,32 @@ TEST_P(AiksTest, CanRenderOffscreenCheckerboard) {
   ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
 }
 
+TEST_P(AiksTest, OpaqueEntitiesGetCoercedToSource) {
+  Canvas canvas;
+  canvas.Scale(Vector2(1.618, 1.618));
+  canvas.DrawCircle(Point(), 10,
+                    {
+                        .color = Color::CornflowerBlue(),
+                        .blend_mode = BlendMode::kSourceOver,
+                    });
+  Picture picture = canvas.EndRecordingAsPicture();
+
+  // Extract the SolidColorSource.
+  Entity entity;
+  std::shared_ptr<SolidColorContents> contents;
+  picture.pass->IterateAllEntities([&e = entity, &contents](Entity& entity) {
+    if (ScalarNearlyEqual(entity.GetTransformation().GetScale().x, 1.618f)) {
+      e = entity;
+      contents =
+          std::static_pointer_cast<SolidColorContents>(entity.GetContents());
+      return false;
+    }
+    return true;
+  });
+
+  ASSERT_TRUE(contents->IsOpaque());
+  ASSERT_EQ(entity.GetBlendMode(), BlendMode::kSource);
+}
+
 }  // namespace testing
 }  // namespace impeller

impeller/aiks/color_source.cc

@@ -17,6 +17,7 @@
 #include "impeller/entity/contents/solid_color_contents.h"
 #include "impeller/entity/contents/sweep_gradient_contents.h"
 #include "impeller/entity/contents/tiled_texture_contents.h"
+#include "impeller/geometry/color.h"
 #include "impeller/geometry/matrix.h"
 #include "impeller/geometry/scalar.h"
 #include "impeller/runtime_stage/runtime_stage.h"

impeller/aiks/paint_pass_delegate.cc

@@ -7,6 +7,7 @@
 #include "impeller/entity/contents/contents.h"
 #include "impeller/entity/contents/texture_contents.h"
 #include "impeller/entity/entity_pass.h"
+#include "impeller/geometry/color.h"
 #include "impeller/geometry/path_builder.h"
 
 namespace impeller {
@@ -72,6 +73,8 @@ bool OpacityPeepholePassDelegate::CanElide() {
 // |EntityPassDelgate|
 bool OpacityPeepholePassDelegate::CanCollapseIntoParentPass(
     EntityPass* entity_pass) {
+  // 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.has_value() || paint_.color_filter.has_value()) {
     return false;
@@ -97,7 +100,7 @@ bool OpacityPeepholePassDelegate::CanCollapseIntoParentPass(
   auto had_subpass = entity_pass->IterateUntilSubpass(
       [&all_coverages, &all_can_accept](Entity& entity) {
         auto contents = entity.GetContents();
-        if (!contents->CanInheritOpacity(entity)) {
+        if (!entity.CanInheritOpacity()) {
           all_can_accept = false;
           return false;
         }
@@ -119,7 +122,7 @@ bool OpacityPeepholePassDelegate::CanCollapseIntoParentPass(
   }
   auto alpha = paint_.color.alpha;
   entity_pass->IterateUntilSubpass([&alpha](Entity& entity) {
-    entity.GetContents()->SetInheritedOpacity(alpha);
+    entity.SetInheritedOpacity(alpha);
     return true;
   });
   return true;

impeller/core/texture.cc

@@ -14,7 +14,8 @@ Texture::~Texture() = default;
 
 bool Texture::SetContents(const uint8_t* contents,
                           size_t length,
-                          size_t slice) {
+                          size_t slice,
+                          bool is_opaque) {
   if (!IsSliceValid(slice)) {
     VALIDATION_LOG << "Invalid slice for texture.";
     return false;
@@ -23,11 +24,13 @@ bool Texture::SetContents(const uint8_t* contents,
     return false;
   }
   intent_ = TextureIntent::kUploadFromHost;
+  is_opaque_ = is_opaque;
   return true;
 }
 
 bool Texture::SetContents(std::shared_ptr<const fml::Mapping> mapping,
-                          size_t slice) {
+                          size_t slice,
+                          bool is_opaque) {
   if (!IsSliceValid(slice)) {
     VALIDATION_LOG << "Invalid slice for texture.";
     return false;
@@ -39,9 +42,14 @@ bool Texture::SetContents(std::shared_ptr<const fml::Mapping> mapping,
     return false;
   }
   intent_ = TextureIntent::kUploadFromHost;
+  is_opaque_ = is_opaque;
   return true;
 }
 
+bool Texture::IsOpaque() const {
+  return is_opaque_;
+}
+
 size_t Texture::GetMipCount() const {
   return GetTextureDescriptor().mip_count;
 }

impeller/core/texture.h

@@ -22,15 +22,19 @@ class Texture {
 
   [[nodiscard]] bool SetContents(const uint8_t* contents,
                                  size_t length,
-                                 size_t slice = 0);
+                                 size_t slice = 0,
+                                 bool is_opaque = false);
 
   [[nodiscard]] bool SetContents(std::shared_ptr<const fml::Mapping> mapping,
-                                 size_t slice = 0);
+                                 size_t slice = 0,
+                                 bool is_opaque = false);
 
   virtual bool IsValid() const = 0;
 
   virtual ISize GetSize() const = 0;
 
+  bool IsOpaque() const;
+
   size_t GetMipCount() const;
 
   const TextureDescriptor& GetTextureDescriptor() const;
@@ -59,6 +63,7 @@ class Texture {
  private:
   TextureIntent intent_ = TextureIntent::kRenderToTexture;
   const TextureDescriptor desc_;
+  bool is_opaque_ = false;
 
   bool IsSliceValid(size_t slice) const;
 

impeller/entity/contents/conical_gradient_contents.cc

@@ -51,6 +51,18 @@ void ConicalGradientContents::SetFocus(std::optional<Point> focus,
   focus_radius_ = radius;
 }
 
+bool ConicalGradientContents::IsOpaque() const {
+  if (GetOpacity() < 1) {
+    return false;
+  }
+  for (auto color : colors_) {
+    if (!color.IsOpaque()) {
+      return false;
+    }
+  }
+  return true;
+}
+
 bool ConicalGradientContents::Render(const ContentContext& renderer,
                                      const Entity& entity,
                                      RenderPass& pass) const {

impeller/entity/contents/conical_gradient_contents.h

@@ -24,6 +24,9 @@ class ConicalGradientContents final : public ColorSourceContents {
 
   ~ConicalGradientContents() override;
 
+  // |Contents|
+  bool IsOpaque() const override;
+
   // |Contents|
   bool Render(const ContentContext& renderer,
               const Entity& entity,

impeller/entity/contents/contents.cc

@@ -45,6 +45,10 @@ Contents::Contents() = default;
 
 Contents::~Contents() = default;
 
+bool Contents::IsOpaque() const {
+  return false;
+}
+
 Contents::StencilCoverage Contents::GetStencilCoverage(
     const Entity& entity,
     const std::optional<Rect>& current_stencil_coverage) const {

impeller/entity/contents/contents.h

@@ -56,6 +56,12 @@ class Contents {
   /// @brief Get the screen space bounding rectangle that this contents affects.
   virtual std::optional<Rect> GetCoverage(const Entity& entity) const = 0;
 
+  /// @brief Whether this Contents only emits opaque source colors from the
+  ///        fragment stage. This value does not account for any entity
+  ///        properties (e.g. the blend mode), clips/visibility culling, or
+  ///        inherited opacity.
+  virtual bool IsOpaque() const;
+
   /// @brief Given the current screen space bounding rectangle of the stencil,
   ///        return the expected stencil coverage after this draw call. This
   ///        should only be implemented for contents that may write to the

impeller/entity/contents/linear_gradient_contents.cc

@@ -44,6 +44,18 @@ void LinearGradientContents::SetTileMode(Entity::TileMode tile_mode) {
   tile_mode_ = tile_mode;
 }
 
+bool LinearGradientContents::IsOpaque() const {
+  if (GetOpacity() < 1) {
+    return false;
+  }
+  for (auto color : colors_) {
+    if (!color.IsOpaque()) {
+      return false;
+    }
+  }
+  return true;
+}
+
 bool LinearGradientContents::Render(const ContentContext& renderer,
                                     const Entity& entity,
                                     RenderPass& pass) const {