Add FilterContents::GetSourceCoverage to enable filterd saveLayer clipping

flar · flar · commit 13b6e9e1a486 · 2023-10-23T13:04:03.000-07:00
diff --git a/impeller/entity/contents/filters/border_mask_blur_filter_contents.cc b/impeller/entity/contents/filters/border_mask_blur_filter_contents.cc
@@ -169,4 +169,15 @@ std::optional<Rect> BorderMaskBlurFilterContents::GetFilterCoverage(
               Size(extent.x, extent.y));
 }
 
+std::optional<Rect> BorderMaskBlurFilterContents::GetFilterSourceCoverage(
+    const Matrix& effect_transform,
+    const Rect& output_limit) const {
+  auto transformed_blur_vector =
+      effect_transform.TransformDirection(Vector2(Radius{sigma_x_}.radius, 0))
+          .Abs() +
+      effect_transform.TransformDirection(Vector2(0, Radius{sigma_y_}.radius))
+          .Abs();
+  return output_limit.Expand(transformed_blur_vector);
+}
+
 }  // namespace impeller
diff --git a/impeller/entity/contents/filters/border_mask_blur_filter_contents.h b/impeller/entity/contents/filters/border_mask_blur_filter_contents.h
@@ -27,6 +27,11 @@ class BorderMaskBlurFilterContents final : public FilterContents {
       const Entity& entity,
       const Matrix& effect_transform) const override;
 
+  // |FilterContents|
+  std::optional<Rect> GetFilterSourceCoverage(
+      const Matrix& effect_transform,
+      const Rect& output_limit) const override;
+
  private:
   // |FilterContents|
   std::optional<Entity> RenderFilter(
diff --git a/impeller/entity/contents/filters/color_filter_contents.cc b/impeller/entity/contents/filters/color_filter_contents.cc
@@ -99,4 +99,10 @@ std::optional<Scalar> ColorFilterContents::GetAlpha() const {
   return alpha_;
 }
 
+std::optional<Rect> ColorFilterContents::GetFilterSourceCoverage(
+    const Matrix& effect_transform,
+    const Rect& output_limit) const {
+  return output_limit;
+}
+
 }  // namespace impeller
diff --git a/impeller/entity/contents/filters/color_filter_contents.h b/impeller/entity/contents/filters/color_filter_contents.h
@@ -44,6 +44,11 @@ class ColorFilterContents : public FilterContents {
 
   std::optional<Scalar> GetAlpha() const;
 
+  // |FilterContents|
+  std::optional<Rect> GetFilterSourceCoverage(
+      const Matrix& effect_transform,
+      const Rect& output_limit) const override;
+
  private:
   AbsorbOpacity absorb_opacity_ = AbsorbOpacity::kNo;
   std::optional<Scalar> alpha_;
diff --git a/impeller/entity/contents/filters/filter_contents.cc b/impeller/entity/contents/filters/filter_contents.cc
@@ -218,6 +218,28 @@ std::optional<Rect> FilterContents::GetFilterCoverage(
   return result;
 }
 
+std::optional<Rect> FilterContents::GetSourceCoverage(
+    const Matrix& effect_transform,
+    const Rect& output_limit) const {
+  auto filter_input_coverage =
+      GetFilterSourceCoverage(effect_transform_, output_limit);
+
+  if (!filter_input_coverage.has_value()) {
+    return std::nullopt;
+  }
+
+  std::optional<Rect> inputs_coverage;
+  for (auto input : inputs_) {
+    auto input_coverage = input->GetSourceCoverage(
+        effect_transform, filter_input_coverage.value());
+    if (!input_coverage.has_value()) {
+      return std::nullopt;
+    }
+    inputs_coverage = Union(inputs_coverage, input_coverage.value());
+  }
+  return inputs_coverage;
+}
+
 std::optional<Entity> FilterContents::GetEntity(
     const ContentContext& renderer,
     const Entity& entity,
diff --git a/impeller/entity/contents/filters/filter_contents.h b/impeller/entity/contents/filters/filter_contents.h
@@ -128,6 +128,20 @@ class FilterContents : public Contents {
   // |Contents|
   const FilterContents* AsFilter() const override;
 
+  /// @brief Determines the coverage of source pixels that will be needed
+  ///        to apply this filter under the given transform and produce
+  ///        results anywhere within the indicated coverage limit.
+  ///
+  ///        This is useful for subpass rendering scenarios where a filter
+  ///        will be applied to the output of the subpass and we need to
+  ///        determine how large of a render target to allocate in order
+  ///        to collect all pixels that might affect the supplied output
+  ///        coverage limit. While we might clip the rendering of the subpass,
+  ///        we want to avoid clipping out any pixels that contribute to
+  ///        the output limit via the filtering operation.
+  std::optional<Rect> GetSourceCoverage(const Matrix& effect_transform,
+                                        const Rect& output_limit) const;
+
   virtual Matrix GetLocalTransform(const Matrix& parent_transform) const;
 
   Matrix GetTransform(const Matrix& parent_transform) const;
@@ -165,6 +179,10 @@ class FilterContents : public Contents {
       const Entity& entity,
       const Matrix& effect_transform) const;
 
+  virtual std::optional<Rect> GetFilterSourceCoverage(
+      const Matrix& effect_transform,
+      const Rect& output_limit) const = 0;
+
   /// @brief  Converts zero or more filter inputs into a render instruction.
   virtual std::optional<Entity> RenderFilter(
       const FilterInput::Vector& inputs,
diff --git a/impeller/entity/contents/filters/gaussian_blur_filter_contents.cc b/impeller/entity/contents/filters/gaussian_blur_filter_contents.cc
@@ -26,8 +26,8 @@ namespace impeller {
 DirectionalGaussianBlurFilterContents::DirectionalGaussianBlurFilterContents() =
     default;
 
-DirectionalGaussianBlurFilterContents::
-    ~DirectionalGaussianBlurFilterContents() = default;
+DirectionalGaussianBlurFilterContents::~
+DirectionalGaussianBlurFilterContents() = default;
 
 void DirectionalGaussianBlurFilterContents::SetSigma(Sigma sigma) {
   blur_sigma_ = sigma;
@@ -273,6 +273,17 @@ std::optional<Entity> DirectionalGaussianBlurFilterContents::RenderFilter(
       entity.GetBlendMode(), entity.GetClipDepth());
 }
 
+std::optional<Rect>
+DirectionalGaussianBlurFilterContents::GetFilterSourceCoverage(
+    const Matrix& effect_transform,
+    const Rect& output_limit) const {
+  auto transform = effect_transform.Basis();
+  auto transformed_blur_vector =
+      transform.TransformDirection(blur_direction_ * Radius{blur_sigma_}.radius)
+          .Abs();
+  return output_limit.Expand(transformed_blur_vector);
+}
+
 std::optional<Rect> DirectionalGaussianBlurFilterContents::GetFilterCoverage(
     const FilterInput::Vector& inputs,
     const Entity& entity,
diff --git a/impeller/entity/contents/filters/gaussian_blur_filter_contents.h b/impeller/entity/contents/filters/gaussian_blur_filter_contents.h
@@ -29,6 +29,11 @@ class DirectionalGaussianBlurFilterContents final : public FilterContents {
 
   void SetIsSecondPass(bool is_second_pass);
 
+  // |FilterContents|
+  std::optional<Rect> GetFilterSourceCoverage(
+      const Matrix& effect_transform,
+      const Rect& output_limit) const override;
+
   // |FilterContents|
   std::optional<Rect> GetFilterCoverage(
       const FilterInput::Vector& inputs,
diff --git a/impeller/entity/contents/filters/inputs/filter_contents_filter_input.cc b/impeller/entity/contents/filters/inputs/filter_contents_filter_input.cc
@@ -43,6 +43,12 @@ std::optional<Rect> FilterContentsFilterInput::GetCoverage(
   return filter_->GetCoverage(entity);
 }
 
+std::optional<Rect> FilterContentsFilterInput::GetSourceCoverage(
+    const Matrix& effect_transform,
+    const Rect& output_limit) const {
+  return filter_->GetSourceCoverage(effect_transform, output_limit);
+}
+
 Matrix FilterContentsFilterInput::GetLocalTransform(
     const Entity& entity) const {
   return filter_->GetLocalTransform(entity.GetTransformation());
diff --git a/impeller/entity/contents/filters/inputs/filter_contents_filter_input.h b/impeller/entity/contents/filters/inputs/filter_contents_filter_input.h
@@ -25,6 +25,11 @@ class FilterContentsFilterInput final : public FilterInput {
   // |FilterInput|
   std::optional<Rect> GetCoverage(const Entity& entity) const override;
 
+  // |FilterInput|
+  std::optional<Rect> GetSourceCoverage(
+      const Matrix& effect_transform,
+      const Rect& output_limit) const override;
+
   // |FilterInput|
   Matrix GetLocalTransform(const Entity& entity) const override;
 
diff --git a/impeller/entity/contents/filters/inputs/filter_input.cc b/impeller/entity/contents/filters/inputs/filter_input.cc
@@ -66,6 +66,12 @@ std::optional<Rect> FilterInput::GetLocalCoverage(const Entity& entity) const {
   return GetCoverage(local_entity);
 }
 
+std::optional<Rect> FilterInput::GetSourceCoverage(
+    const Matrix& effect_transform,
+    const Rect& output_limit) const {
+  return output_limit;
+}
+
 Matrix FilterInput::GetTransform(const Entity& entity) const {
   return entity.GetTransformation() * GetLocalTransform(entity);
 }
diff --git a/impeller/entity/contents/filters/inputs/filter_input.h b/impeller/entity/contents/filters/inputs/filter_input.h
@@ -56,6 +56,9 @@ class FilterInput {
 
   virtual std::optional<Rect> GetCoverage(const Entity& entity) const = 0;
 
+  virtual std::optional<Rect> GetSourceCoverage(const Matrix& effect_transform,
+                                                const Rect& output_limit) const;
+
   /// @brief  Get the local transform of this filter input. This transform is
   ///         relative to the `Entity` transform space.
   virtual Matrix GetLocalTransform(const Entity& entity) const;
diff --git a/impeller/entity/contents/filters/local_matrix_filter_contents.cc b/impeller/entity/contents/filters/local_matrix_filter_contents.cc
@@ -19,6 +19,17 @@ Matrix LocalMatrixFilterContents::GetLocalTransform(
   return matrix_;
 }
 
+std::optional<Rect> LocalMatrixFilterContents::GetFilterSourceCoverage(
+    const Matrix& effect_transform,
+    const Rect& output_limit) const {
+  auto matrix = matrix_.Basis();
+  if (matrix.GetDeterminant() == 0.0) {
+    return std::nullopt;
+  }
+  auto inverse = matrix.Invert();
+  return output_limit.TransformBounds(inverse);
+}
+
 std::optional<Entity> LocalMatrixFilterContents::RenderFilter(
     const FilterInput::Vector& inputs,
     const ContentContext& renderer,
diff --git a/impeller/entity/contents/filters/local_matrix_filter_contents.h b/impeller/entity/contents/filters/local_matrix_filter_contents.h
@@ -20,6 +20,11 @@ class LocalMatrixFilterContents final : public FilterContents {
   // |FilterContents|
   Matrix GetLocalTransform(const Matrix& parent_transform) const override;
 
+  // |FilterContents|
+  std::optional<Rect> GetFilterSourceCoverage(
+      const Matrix& effect_transform,
+      const Rect& output_limit) const override;
+
  private:
   // |FilterContents|
   std::optional<Entity> RenderFilter(
diff --git a/impeller/entity/contents/filters/matrix_filter_contents.cc b/impeller/entity/contents/filters/matrix_filter_contents.cc
@@ -68,6 +68,17 @@ std::optional<Entity> MatrixFilterContents::RenderFilter(
                               entity.GetClipDepth());
 }
 
+std::optional<Rect> MatrixFilterContents::GetFilterSourceCoverage(
+    const Matrix& effect_transform,
+    const Rect& output_limit) const {
+  auto matrix = matrix_.Basis();
+  if (matrix.GetDeterminant() == 0.0) {
+    return std::nullopt;
+  }
+  auto inverse = matrix.Invert();
+  return output_limit.TransformBounds(inverse);
+}
+
 std::optional<Rect> MatrixFilterContents::GetFilterCoverage(
     const FilterInput::Vector& inputs,
     const Entity& entity,
diff --git a/impeller/entity/contents/filters/matrix_filter_contents.h b/impeller/entity/contents/filters/matrix_filter_contents.h
@@ -41,6 +41,11 @@ class MatrixFilterContents final : public FilterContents {
       const Rect& coverage,
       const std::optional<Rect>& coverage_hint) const override;
 
+  // |FilterContents|
+  std::optional<Rect> GetFilterSourceCoverage(
+      const Matrix& effect_transform,
+      const Rect& output_limit) const override;
+
   Matrix matrix_;
   SamplerDescriptor sampler_descriptor_ = {};
   Entity::RenderingMode rendering_mode_ = Entity::RenderingMode::kDirect;
diff --git a/impeller/entity/contents/filters/morphology_filter_contents.cc b/impeller/entity/contents/filters/morphology_filter_contents.cc
@@ -192,4 +192,18 @@ std::optional<Rect> DirectionalMorphologyFilterContents::GetFilterCoverage(
   return Rect(origin, Size(size.x, size.y));
 }
 
+std::optional<Rect>
+DirectionalMorphologyFilterContents::GetFilterSourceCoverage(
+    const Matrix& effect_transform,
+    const Rect& output_limit) const {
+  auto transformed_vector =
+      effect_transform.TransformDirection(direction_ * radius_.radius).Abs();
+  switch (morph_type_) {
+    case FilterContents::MorphType::kDilate:
+      return output_limit.Expand(-transformed_vector);
+    case FilterContents::MorphType::kErode:
+      return output_limit.Expand(transformed_vector);
+  }
+}
+
 }  // namespace impeller
diff --git a/impeller/entity/contents/filters/morphology_filter_contents.h b/impeller/entity/contents/filters/morphology_filter_contents.h
@@ -29,6 +29,11 @@ class DirectionalMorphologyFilterContents final : public FilterContents {
       const Entity& entity,
       const Matrix& effect_transform) const override;
 
+  // |FilterContents|
+  std::optional<Rect> GetFilterSourceCoverage(
+      const Matrix& effect_transform,
+      const Rect& output_limit) const override;
+
  private:
   // |FilterContents|
   std::optional<Entity> RenderFilter(
diff --git a/impeller/entity/contents/filters/yuv_to_rgb_filter_contents.cc b/impeller/entity/contents/filters/yuv_to_rgb_filter_contents.cc
@@ -137,4 +137,10 @@ std::optional<Entity> YUVToRGBFilterContents::RenderFilter(
   return sub_entity;
 }
 
+std::optional<Rect> YUVToRGBFilterContents::GetFilterSourceCoverage(
+    const Matrix& effect_transform,
+    const Rect& output_limit) const {
+  return output_limit;
+}
+
 }  // namespace impeller
diff --git a/impeller/entity/contents/filters/yuv_to_rgb_filter_contents.h b/impeller/entity/contents/filters/yuv_to_rgb_filter_contents.h
@@ -26,6 +26,11 @@ class YUVToRGBFilterContents final : public FilterContents {
       const Rect& coverage,
       const std::optional<Rect>& coverage_hint) const override;
 
+  // |FilterContents|
+  std::optional<Rect> GetFilterSourceCoverage(
+      const Matrix& effect_transform,
+      const Rect& output_limit) const override;
+
   YUVColorSpace yuv_color_space_ = YUVColorSpace::kBT601LimitedRange;
 
   FML_DISALLOW_COPY_AND_ASSIGN(YUVToRGBFilterContents);
diff --git a/impeller/entity/entity_pass.cc b/impeller/entity/entity_pass.cc
@@ -201,7 +201,10 @@ std::optional<Rect> EntityPass::GetSubpassCoverage(
   // If the subpass has an image filter, then its coverage space may deviate
   // from the parent pass and make intersecting with the pass coverage limit
   // unsafe.
-  coverage_limit = image_filter ? std::nullopt : coverage_limit;
+  if (image_filter && coverage_limit.has_value()) {
+    coverage_limit = image_filter->GetSourceCoverage(subpass.xformation_,
+                                                     coverage_limit.value());
+  }
 
   auto entities_coverage = subpass.GetElementsCoverage(coverage_limit);
   // The entities don't cover anything. There is nothing to do.
diff --git a/impeller/geometry/rect.h b/impeller/geometry/rect.h
@@ -292,6 +292,15 @@ struct TRect {
                  size.height + amount * 2);
   }
 
+  /// @brief  Returns a rectangle with expanded edges in all directions.
+  ///         Negative expansion results in shrinking.
+  constexpr TRect<T> Expand(TPoint<T> amount) const {
+    return TRect(origin.x - amount.x,        //
+                 origin.y - amount.y,        //
+                 size.width + amount.x * 2,  //
+                 size.height + amount.y * 2);
+  }
+
   /// @brief  Returns a new rectangle that represents the projection of the
   ///         source rectangle onto this rectangle. In other words, the source
   ///         rectangle is redefined in terms of the corrdinate space of this
@@ -306,6 +315,33 @@ struct TRect {
 using Rect = TRect<Scalar>;
 using IRect = TRect<int64_t>;
 
+constexpr std::optional<Rect> Union(const Rect& a,
+                                    const std::optional<Rect> b) {
+  if (!b.has_value()) {
+    return a;
+  }
+  return a.Union(b.value());
+}
+
+constexpr std::optional<Rect> Union(const std::optional<Rect> a,
+                                    const Rect& b) {
+  if (!a.has_value()) {
+    return b;
+  }
+  return a.value().Union(b);
+}
+
+constexpr std::optional<Rect> Union(const std::optional<Rect> a,
+                                    const std::optional<Rect> b) {
+  if (!a.has_value()) {
+    return b;
+  }
+  if (!b.has_value()) {
+    return a;
+  }
+  return a.value().Union(b.value());
+}
+
 }  // namespace impeller
 
 namespace std {
