[Impeller] Apply color filters on the CPU for solid colors & gradients. (flutter#43519)

Apply color filters on the CPU for solid colors and gradients. This
fixes flutter/flutter#127232 for the purely
color-based color sources.

We still need to make the other special color blending paths respect the
geometry mask in order to fully resolve the underlying issue:
* SaveLayers (if they have an interesting matrix filter -- without a
matrix filter, it'll always work today)
* TiledTextureContents
* TextContents
* VerticesContents
* AtlasContents

Author: bdero

impeller/aiks/aiks_unittests.cc

@@ -18,7 +18,9 @@
 #include "impeller/aiks/paint_pass_delegate.h"
 #include "impeller/aiks/testing/context_spy.h"
 #include "impeller/entity/contents/color_source_contents.h"
+#include "impeller/entity/contents/conical_gradient_contents.h"
 #include "impeller/entity/contents/filters/inputs/filter_input.h"
+#include "impeller/entity/contents/linear_gradient_contents.h"
 #include "impeller/entity/contents/scene_contents.h"
 #include "impeller/entity/contents/solid_color_contents.h"
 #include "impeller/entity/contents/tiled_texture_contents.h"
@@ -393,6 +395,30 @@ TEST_P(AiksTest, CanRenderLinearGradientDecal) {
   CanRenderLinearGradient(this, Entity::TileMode::kDecal);
 }
 
+TEST_P(AiksTest, CanRenderLinearGradientDecalWithColorFilter) {
+  Canvas canvas;
+  canvas.Scale(GetContentScale());
+  Paint paint;
+  canvas.Translate({100.0f, 0, 0});
+
+  std::vector<Color> colors = {Color{0.9568, 0.2627, 0.2118, 1.0},
+                               Color{0.1294, 0.5882, 0.9529, 0.0}};
+  std::vector<Scalar> stops = {0.0, 1.0};
+
+  paint.color_source = ColorSource::MakeLinearGradient(
+      {0, 0}, {200, 200}, std::move(colors), std::move(stops),
+      Entity::TileMode::kDecal, {});
+  // Overlay the gradient with 25% green. This should appear as the entire
+  // rectangle being drawn with 25% green, including the border area outside the
+  // decal gradient.
+  paint.color_filter = ColorFilter::MakeBlend(BlendMode::kSourceOver,
+                                              Color::Green().WithAlpha(0.25));
+
+  paint.color = Color(1.0, 1.0, 1.0, 1.0);
+  canvas.DrawRect({0, 0, 600, 600}, paint);
+  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
+}
+
 namespace {
 void CanRenderLinearGradientWithOverlappingStops(AiksTest* aiks_test,
                                                  Entity::TileMode tile_mode) {
@@ -2896,5 +2922,35 @@ TEST_P(AiksTest, MatrixBackdropFilter) {
   ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
 }
 
+TEST_P(AiksTest, SolidColorApplyColorFilter) {
+  auto contents = SolidColorContents();
+  contents.SetColor(Color::CornflowerBlue().WithAlpha(0.75));
+  auto result = contents.ApplyColorFilter([](const Color& color) {
+    return color.Blend(Color::LimeGreen().WithAlpha(0.75), BlendMode::kScreen);
+  });
+  ASSERT_TRUE(result);
+  ASSERT_COLOR_NEAR(contents.GetColor(),
+                    Color(0.433247, 0.879523, 0.825324, 0.75));
+}
+
+#define APPLY_COLOR_FILTER_GRADIENT_TEST(name)                                 \
+  TEST_P(AiksTest, name##GradientApplyColorFilter) {                           \
+    auto contents = name##GradientContents();                                  \
+    contents.SetColors({Color::CornflowerBlue().WithAlpha(0.75)});             \
+    auto result = contents.ApplyColorFilter([](const Color& color) {           \
+      return color.Blend(Color::LimeGreen().WithAlpha(0.75),                   \
+                         BlendMode::kScreen);                                  \
+    });                                                                        \
+    ASSERT_TRUE(result);                                                       \
+                                                                               \
+    std::vector<Color> expected = {Color(0.433247, 0.879523, 0.825324, 0.75)}; \
+    ASSERT_COLORS_NEAR(contents.GetColors(), expected);                        \
+  }
+
+APPLY_COLOR_FILTER_GRADIENT_TEST(Linear);
+APPLY_COLOR_FILTER_GRADIENT_TEST(Radial);
+APPLY_COLOR_FILTER_GRADIENT_TEST(Conical);
+APPLY_COLOR_FILTER_GRADIENT_TEST(Sweep);
+
 }  // namespace testing
 }  // namespace impeller

impeller/aiks/color_filter.cc

@@ -43,7 +43,7 @@ BlendColorFilter::BlendColorFilter(BlendMode blend_mode, Color color)
 
 BlendColorFilter::~BlendColorFilter() = default;
 
-std::shared_ptr<ColorFilterContents> BlendColorFilter::GetColorFilter(
+std::shared_ptr<ColorFilterContents> BlendColorFilter::WrapWithGPUColorFilter(
     std::shared_ptr<FilterInput> input,
     bool absorb_opacity) const {
   auto filter =
@@ -67,7 +67,7 @@ MatrixColorFilter::MatrixColorFilter(ColorMatrix color_matrix)
 
 MatrixColorFilter::~MatrixColorFilter() = default;
 
-std::shared_ptr<ColorFilterContents> MatrixColorFilter::GetColorFilter(
+std::shared_ptr<ColorFilterContents> MatrixColorFilter::WrapWithGPUColorFilter(
     std::shared_ptr<FilterInput> input,
     bool absorb_opacity) const {
   auto filter =
@@ -90,7 +90,8 @@ SrgbToLinearColorFilter::SrgbToLinearColorFilter() = default;
 
 SrgbToLinearColorFilter::~SrgbToLinearColorFilter() = default;
 
-std::shared_ptr<ColorFilterContents> SrgbToLinearColorFilter::GetColorFilter(
+std::shared_ptr<ColorFilterContents>
+SrgbToLinearColorFilter::WrapWithGPUColorFilter(
     std::shared_ptr<FilterInput> input,
     bool absorb_opacity) const {
   auto filter = ColorFilterContents::MakeSrgbToLinearFilter({std::move(input)});
@@ -111,7 +112,8 @@ LinearToSrgbColorFilter::LinearToSrgbColorFilter() = default;
 
 LinearToSrgbColorFilter::~LinearToSrgbColorFilter() = default;
 
-std::shared_ptr<ColorFilterContents> LinearToSrgbColorFilter::GetColorFilter(
+std::shared_ptr<ColorFilterContents>
+LinearToSrgbColorFilter::WrapWithGPUColorFilter(
     std::shared_ptr<FilterInput> input,
     bool absorb_opacity) const {
   auto filter = ColorFilterContents::MakeSrgbToLinearFilter({std::move(input)});

impeller/aiks/color_filter.h

@@ -17,6 +17,8 @@ struct Paint;
 
 class ColorFilter {
  public:
+  /// A procedure that filters a given unpremultiplied color to produce a new
+  /// unpremultiplied color.
   using ColorFilterProc = std::function<Color(Color)>;
 
   ColorFilter();
@@ -32,10 +34,19 @@ class ColorFilter {
 
   static std::shared_ptr<ColorFilter> MakeLinearToSrgb();
 
-  virtual std::shared_ptr<ColorFilterContents> GetColorFilter(
+  /// @brief  Wraps the given filter input with a GPU-based filter that will
+  ///         perform the color operation. The given input will first be
+  ///         rendered to a texture and then filtered.
+  ///
+  ///         Note that this operation has no consideration for the original
+  ///         geometry mask of the filter input. And the entire input texture is
+  ///         treated as color information.
+  virtual std::shared_ptr<ColorFilterContents> WrapWithGPUColorFilter(
       std::shared_ptr<FilterInput> input,
       bool absorb_opacity) const = 0;
 
+  /// @brief Returns a function that can be used to filter unpremultiplied
+  ///        Impeller Colors on the CPU.
   virtual ColorFilterProc GetCPUColorFilterProc() const = 0;
 };
 
@@ -50,7 +61,7 @@ class BlendColorFilter final : public ColorFilter {
   ~BlendColorFilter() override;
 
   // |ColorFilter|
-  std::shared_ptr<ColorFilterContents> GetColorFilter(
+  std::shared_ptr<ColorFilterContents> WrapWithGPUColorFilter(
       std::shared_ptr<FilterInput> input,
       bool absorb_opacity) const override;
 
@@ -73,7 +84,7 @@ class MatrixColorFilter final : public ColorFilter {
   ~MatrixColorFilter() override;
 
   // |ColorFilter|
-  std::shared_ptr<ColorFilterContents> GetColorFilter(
+  std::shared_ptr<ColorFilterContents> WrapWithGPUColorFilter(
       std::shared_ptr<FilterInput> input,
       bool absorb_opacity) const override;
 
@@ -95,7 +106,7 @@ class SrgbToLinearColorFilter final : public ColorFilter {
   ~SrgbToLinearColorFilter() override;
 
   // |ColorFilter|
-  std::shared_ptr<ColorFilterContents> GetColorFilter(
+  std::shared_ptr<ColorFilterContents> WrapWithGPUColorFilter(
       std::shared_ptr<FilterInput> input,
       bool absorb_opacity) const override;
 
@@ -114,7 +125,7 @@ class LinearToSrgbColorFilter final : public ColorFilter {
   ~LinearToSrgbColorFilter() override;
 
   // |ColorFilter|
-  std::shared_ptr<ColorFilterContents> GetColorFilter(
+  std::shared_ptr<ColorFilterContents> WrapWithGPUColorFilter(
       std::shared_ptr<FilterInput> input,
       bool absorb_opacity) const override;
 

impeller/aiks/color_source.cc

@@ -175,7 +175,8 @@ ColorSource ColorSource::MakeImage(std::shared_ptr<Texture> texture,
     if (paint.color_filter) {
       TiledTextureContents::ColorFilterProc filter_proc =
           [color_filter = paint.color_filter](FilterInput::Ref input) {
-            return color_filter->GetColorFilter(std::move(input), false);
+            return color_filter->WrapWithGPUColorFilter(std::move(input),
+                                                        false);
           };
       contents->SetColorFilter(filter_proc);
     }

impeller/aiks/paint.cc

@@ -89,11 +89,20 @@ std::shared_ptr<Contents> Paint::WithColorFilter(
   if (color_source.GetType() == ColorSource::Type::kImage) {
     return input;
   }
-  if (color_filter) {
-    input =
-        color_filter->GetColorFilter(FilterInput::Make(input), absorb_opacity);
+
+  if (!color_filter) {
+    return input;
   }
-  return input;
+
+  // Attempt to apply the color filter on the CPU first.
+  // Note: This is not just an optimization; some color sources rely on
+  //       CPU-applied color filters to behave properly.
+  if (input->ApplyColorFilter(color_filter->GetCPUColorFilterProc())) {
+    return input;
+  }
+
+  return color_filter->WrapWithGPUColorFilter(FilterInput::Make(input),
+                                              absorb_opacity);
 }
 
 /// A color matrix which inverts colors.

impeller/compiler/shader_lib/impeller/texture.glsl

@@ -114,10 +114,11 @@ vec4 IPSampleLinearWithTileMode(sampler2D tex,
                                 float y_coord_scale,
                                 vec2 half_texel,
                                 float x_tile_mode,
-                                float y_tile_mode) {
+                                float y_tile_mode,
+                                vec4 decal_border_color) {
   if (x_tile_mode == kTileModeDecal && (coords.x < 0 || coords.x >= 1) ||
       y_tile_mode == kTileModeDecal && (coords.y < 0 || coords.y >= 1)) {
-    return vec4(0);
+    return decal_border_color;
   }
 
   return IPSampleLinear(tex, IPVec2Tile(coords, x_tile_mode, y_tile_mode),
@@ -152,9 +153,10 @@ vec4 IPSampleLinearWithTileMode(sampler2D tex,
                                 vec2 coords,
                                 float y_coord_scale,
                                 vec2 half_texel,
-                                float tile_mode) {
+                                float tile_mode,
+                                vec4 decal_border_color) {
   return IPSampleLinearWithTileMode(tex, coords, y_coord_scale, half_texel,
-                                    tile_mode, tile_mode);
+                                    tile_mode, tile_mode, decal_border_color);
 }
 
 #endif

impeller/display_list/dl_dispatcher.cc

@@ -665,7 +665,7 @@ static Paint::ImageFilterProc ToImageFilterProc(
         // "absorb opacity" flag to false. For image filters, the snapshot
         // opacity needs to be deferred until the result of the filter chain is
         // being blended with the layer.
-        return filter->GetColorFilter(std::move(input), false);
+        return filter->WrapWithGPUColorFilter(std::move(input), false);
       };
       break;
     }

impeller/entity/contents/conical_gradient_contents.cc

@@ -70,6 +70,7 @@ bool ConicalGradientContents::RenderSSBO(const ContentContext& renderer,
   frag_info.center = center_;
   frag_info.radius = radius_;
   frag_info.tile_mode = static_cast<Scalar>(tile_mode_);
+  frag_info.decal_border_color = decal_border_color_;
   frag_info.alpha = GetOpacity();
   if (focus_) {
     frag_info.focus = focus_.value();
@@ -140,6 +141,7 @@ bool ConicalGradientContents::RenderTexture(const ContentContext& renderer,
   frag_info.center = center_;
   frag_info.radius = radius_;
   frag_info.tile_mode = static_cast<Scalar>(tile_mode_);
+  frag_info.decal_border_color = decal_border_color_;
   frag_info.texture_sampler_y_coord_scale = gradient_texture->GetYCoordScale();
   frag_info.alpha = GetOpacity();
   frag_info.half_texel = Vector2(0.5 / gradient_texture->GetSize().width,
@@ -193,4 +195,13 @@ bool ConicalGradientContents::RenderTexture(const ContentContext& renderer,
   return true;
 }
 
+bool ConicalGradientContents::ApplyColorFilter(
+    const ColorFilterProc& color_filter_proc) {
+  for (Color& color : colors_) {
+    color = color_filter_proc(color);
+  }
+  decal_border_color_ = color_filter_proc(decal_border_color_);
+  return true;
+}
+
 }  // namespace impeller

impeller/entity/contents/conical_gradient_contents.h

@@ -29,6 +29,10 @@ class ConicalGradientContents final : public ColorSourceContents {
               const Entity& entity,
               RenderPass& pass) const override;
 
+  // |Contents|
+  [[nodiscard]] bool ApplyColorFilter(
+      const ColorFilterProc& color_filter_proc) override;
+
   void SetCenterAndRadius(Point center, Scalar radius);
 
   void SetColors(std::vector<Color> colors);
@@ -56,6 +60,7 @@ class ConicalGradientContents final : public ColorSourceContents {
   std::vector<Color> colors_;
   std::vector<Scalar> stops_;
   Entity::TileMode tile_mode_;
+  Color decal_border_color_ = Color::BlackTransparent();
   std::optional<Point> focus_;
   Scalar focus_radius_ = 0.0f;
 

impeller/entity/contents/contents.cc

@@ -123,6 +123,11 @@ std::optional<Color> Contents::AsBackgroundColor(const Entity& entity,
   return {};
 }
 
+bool Contents::ApplyColorFilter(
+    const Contents::ColorFilterProc& color_filter_proc) {
+  return false;
+}
+
 bool Contents::ShouldRender(const Entity& entity,
                             const std::optional<Rect>& stencil_coverage) const {
   if (!stencil_coverage.has_value()) {