[Impeller] implement mask blur for textures (#51183)

fixes flutter/flutter#144266

## Pre-launch Checklist

- [x] I read the [Contributor Guide] and followed the process outlined
there for submitting PRs.
- [x] I read the [Tree Hygiene] wiki page, which explains my
responsibilities.
- [x] I read and followed the [Flutter Style Guide] and the [C++,
Objective-C, Java style guides].
- [x] I listed at least one issue that this PR fixes in the description
above.
- [x] I added new tests to check the change I am making or feature I am
adding, or the PR is [test-exempt]. See [testing the engine] for
instructions on writing and running engine tests.
- [x] I updated/added relevant documentation (doc comments with `///`).
- [x] I signed the [CLA].
- [x] All existing and new tests are passing.

If you need help, consider asking for advice on the #hackers-new channel
on [Discord].

<!-- Links -->
[Contributor Guide]:
https://github.com/flutter/flutter/wiki/Tree-hygiene#overview
[Tree Hygiene]: https://github.com/flutter/flutter/wiki/Tree-hygiene
[test-exempt]:
https://github.com/flutter/flutter/wiki/Tree-hygiene#tests
[Flutter Style Guide]:
https://github.com/flutter/flutter/wiki/Style-guide-for-Flutter-repo
[C++, Objective-C, Java style guides]:
https://github.com/flutter/engine/blob/main/CONTRIBUTING.md#style
[testing the engine]:
https://github.com/flutter/flutter/wiki/Testing-the-engine
[CLA]: https://cla.developers.google.com/
[flutter/tests]: https://github.com/flutter/tests
[breaking change policy]:
https://github.com/flutter/flutter/wiki/Tree-hygiene#handling-breaking-changes
[Discord]: https://github.com/flutter/flutter/wiki/Chat

Author: gaaclarke

impeller/aiks/aiks_blur_unittests.cc

@@ -839,6 +839,32 @@ TEST_P(AiksTest, GaussianBlurStyleSolid) {
   ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
 }
 
+TEST_P(AiksTest, MaskBlurTexture) {
+  Scalar sigma = 30;
+  auto callback = [&](AiksContext& renderer) -> std::optional<Picture> {
+    if (AiksTest::ImGuiBegin("Controls", nullptr,
+                             ImGuiWindowFlags_AlwaysAutoResize)) {
+      ImGui::SliderFloat("Sigma", &sigma, 0, 500);
+      ImGui::End();
+    }
+    Canvas canvas;
+    canvas.Scale(GetContentScale());
+    Paint paint;
+    paint.color = Color::Green();
+    paint.mask_blur_descriptor = Paint::MaskBlurDescriptor{
+        .style = FilterContents::BlurStyle::kNormal,
+        .sigma = Sigma(sigma),
+    };
+    std::shared_ptr<Texture> boston = CreateTextureForFixture("boston.jpg");
+    canvas.DrawImage(std::make_shared<Image>(boston), {200, 200}, paint);
+    Paint red;
+    red.color = Color::Red();
+    canvas.DrawRect(Rect::MakeXYWH(0, 0, 200, 200), red);
+    return canvas.EndRecordingAsPicture();
+  };
+  ASSERT_TRUE(OpenPlaygroundHere(callback));
+}
+
 TEST_P(AiksTest, GuassianBlurUpdatesMipmapContents) {
   // This makes sure if mip maps are recycled across invocations of blurs the
   // contents get updated each frame correctly. If they aren't updated the color

impeller/aiks/canvas.cc

@@ -728,14 +728,19 @@ void Canvas::DrawImageRect(const std::shared_ptr<Image>& image,
     return;
   }
 
-  auto contents = TextureContents::MakeRect(dest);
-  contents->SetTexture(image->GetTexture());
-  contents->SetSourceRect(source);
-  contents->SetStrictSourceRect(src_rect_constraint ==
-                                SourceRectConstraint::kStrict);
-  contents->SetSamplerDescriptor(std::move(sampler));
-  contents->SetOpacity(paint.color.alpha);
-  contents->SetDeferApplyingOpacity(paint.HasColorFilter());
+  auto texture_contents = TextureContents::MakeRect(dest);
+  texture_contents->SetTexture(image->GetTexture());
+  texture_contents->SetSourceRect(source);
+  texture_contents->SetStrictSourceRect(src_rect_constraint ==
+                                        SourceRectConstraint::kStrict);
+  texture_contents->SetSamplerDescriptor(std::move(sampler));
+  texture_contents->SetOpacity(paint.color.alpha);
+  texture_contents->SetDeferApplyingOpacity(paint.HasColorFilter());
+
+  std::shared_ptr<Contents> contents = texture_contents;
+  if (paint.mask_blur_descriptor.has_value()) {
+    contents = paint.mask_blur_descriptor->CreateMaskBlur(texture_contents);
+  }
 
   Entity entity;
   entity.SetBlendMode(paint.blend_mode);

impeller/aiks/paint.cc

@@ -9,6 +9,7 @@
 #include "impeller/entity/contents/color_source_contents.h"
 #include "impeller/entity/contents/filters/color_filter_contents.h"
 #include "impeller/entity/contents/filters/filter_contents.h"
+#include "impeller/entity/contents/filters/gaussian_blur_filter_contents.h"
 #include "impeller/entity/contents/solid_color_contents.h"
 #include "impeller/entity/geometry/geometry.h"
 
@@ -121,6 +122,34 @@ std::shared_ptr<Contents> Paint::WithColorFilter(
                                               absorb_opacity);
 }
 
+std::shared_ptr<FilterContents> Paint::MaskBlurDescriptor::CreateMaskBlur(
+    std::shared_ptr<TextureContents> texture_contents) const {
+  Scalar expand_amount = GaussianBlurFilterContents::CalculateBlurRadius(
+      GaussianBlurFilterContents::ScaleSigma(sigma.sigma));
+  texture_contents->SetSourceRect(
+      texture_contents->GetSourceRect().Expand(expand_amount, expand_amount));
+  auto mask = std::make_shared<SolidColorContents>();
+  mask->SetColor(Color::White());
+  std::optional<Rect> coverage = texture_contents->GetCoverage({});
+  std::shared_ptr<Geometry> geometry;
+  if (coverage) {
+    texture_contents->SetDestinationRect(
+        coverage.value().Expand(expand_amount, expand_amount));
+    geometry = Geometry::MakeRect(coverage.value());
+  }
+  mask->SetGeometry(geometry);
+  auto descriptor = texture_contents->GetSamplerDescriptor();
+  texture_contents->SetSamplerDescriptor(descriptor);
+  std::shared_ptr<FilterContents> blurred_mask =
+      FilterContents::MakeGaussianBlur(FilterInput::Make(mask), sigma, sigma,
+                                       Entity::TileMode::kDecal, style,
+                                       geometry);
+
+  return ColorFilterContents::MakeBlend(
+      BlendMode::kSourceIn,
+      {FilterInput::Make(blurred_mask), FilterInput::Make(texture_contents)});
+}
+
 std::shared_ptr<FilterContents> Paint::MaskBlurDescriptor::CreateMaskBlur(
     std::shared_ptr<ColorSourceContents> color_source_contents,
     const std::shared_ptr<ColorFilter>& color_filter) const {

impeller/aiks/paint.h

@@ -13,6 +13,7 @@
 #include "impeller/entity/contents/contents.h"
 #include "impeller/entity/contents/filters/color_filter_contents.h"
 #include "impeller/entity/contents/filters/filter_contents.h"
+#include "impeller/entity/contents/texture_contents.h"
 #include "impeller/entity/entity.h"
 #include "impeller/entity/geometry/geometry.h"
 #include "impeller/geometry/color.h"
@@ -43,6 +44,9 @@ struct Paint {
         std::shared_ptr<ColorSourceContents> color_source_contents,
         const std::shared_ptr<ColorFilter>& color_filter) const;
 
+    std::shared_ptr<FilterContents> CreateMaskBlur(
+        std::shared_ptr<TextureContents> texture_contents) const;
+
     std::shared_ptr<FilterContents> CreateMaskBlur(
         const FilterInput::Ref& input,
         bool is_solid_color) const;

testing/impeller_golden_tests_output.txt

@@ -516,6 +516,9 @@ impeller_Play_AiksTest_ImageFilteredUnboundedSaveLayerWithUnboundedContents_Vulk
 impeller_Play_AiksTest_LinearToSrgbFilterSubpassCollapseOptimization_Metal.png
 impeller_Play_AiksTest_LinearToSrgbFilterSubpassCollapseOptimization_OpenGLES.png
 impeller_Play_AiksTest_LinearToSrgbFilterSubpassCollapseOptimization_Vulkan.png
+impeller_Play_AiksTest_MaskBlurTexture_Metal.png
+impeller_Play_AiksTest_MaskBlurTexture_OpenGLES.png
+impeller_Play_AiksTest_MaskBlurTexture_Vulkan.png
 impeller_Play_AiksTest_MaskBlurVariantTestInnerTranslucentWithBlurImageFilter_Metal.png
 impeller_Play_AiksTest_MaskBlurVariantTestInnerTranslucentWithBlurImageFilter_OpenGLES.png
 impeller_Play_AiksTest_MaskBlurVariantTestInnerTranslucentWithBlurImageFilter_Vulkan.png