[Impeller] Add support for ImageFilter.shader (#53490)

Copy-pasta docs:

```
  /// Creates an image filter from a [FragmentShader].
  ///
  /// The fragment shader provided here has additional requirements to be used
  /// by the engine for filtering. The first uniform value must be a vec2, this
  /// will be set by the engine to the size of the bound texture. There must
  /// also be at least one sampler2D uniform, the first of which will be set by
  /// the engine to contain the filter input.
  ///
  /// For example, the following is a valid fragment shader that can be used
  /// with this API. Note that the uniform names are not required to have any
  /// particular value.
  ///
  /// ```glsl
  /// #include <flutter/runtime_effect.glsl>
  ///
  /// uniform vec2 u_size;
  /// uniform float u_time;
  ///
  /// uniform sampler2D u_texture_input;
  ///
  /// out vec4 frag_color;
  ///
  /// void main() {
  ///   frag_color = texture(u_texture_input, FlutterFragCoord().xy / u_size) * u_time;
  ///
  /// }
  ///
  /// ```
  ///
  /// This API is only supported when using the Impeller rendering engine. On
  /// other backends a [UnsupportedError] will be thrown. This error can be
  /// caught and used for feature detection.
  ```

Fixes jonahwilliams/flutter_shaders#34
Fixes jonahwilliams/flutter_shaders#26
Fixes flutter/flutter#132099

Author: Jonah Williams

ci/licenses_golden/licenses_flutter

@@ -42984,6 +42984,8 @@ ORIGIN: ../../../flutter/impeller/entity/contents/filters/matrix_filter_contents
 ORIGIN: ../../../flutter/impeller/entity/contents/filters/matrix_filter_contents.h + ../../../flutter/LICENSE
 ORIGIN: ../../../flutter/impeller/entity/contents/filters/morphology_filter_contents.cc + ../../../flutter/LICENSE
 ORIGIN: ../../../flutter/impeller/entity/contents/filters/morphology_filter_contents.h + ../../../flutter/LICENSE
+ORIGIN: ../../../flutter/impeller/entity/contents/filters/runtime_effect_filter_contents.cc + ../../../flutter/LICENSE
+ORIGIN: ../../../flutter/impeller/entity/contents/filters/runtime_effect_filter_contents.h + ../../../flutter/LICENSE
 ORIGIN: ../../../flutter/impeller/entity/contents/filters/srgb_to_linear_filter_contents.cc + ../../../flutter/LICENSE
 ORIGIN: ../../../flutter/impeller/entity/contents/filters/srgb_to_linear_filter_contents.h + ../../../flutter/LICENSE
 ORIGIN: ../../../flutter/impeller/entity/contents/filters/yuv_to_rgb_filter_contents.cc + ../../../flutter/LICENSE
@@ -45844,6 +45846,8 @@ FILE: ../../../flutter/impeller/entity/contents/filters/matrix_filter_contents.c
 FILE: ../../../flutter/impeller/entity/contents/filters/matrix_filter_contents.h
 FILE: ../../../flutter/impeller/entity/contents/filters/morphology_filter_contents.cc
 FILE: ../../../flutter/impeller/entity/contents/filters/morphology_filter_contents.h
+FILE: ../../../flutter/impeller/entity/contents/filters/runtime_effect_filter_contents.cc
+FILE: ../../../flutter/impeller/entity/contents/filters/runtime_effect_filter_contents.h
 FILE: ../../../flutter/impeller/entity/contents/filters/srgb_to_linear_filter_contents.cc
 FILE: ../../../flutter/impeller/entity/contents/filters/srgb_to_linear_filter_contents.h
 FILE: ../../../flutter/impeller/entity/contents/filters/yuv_to_rgb_filter_contents.cc

display_list/dl_builder.cc

@@ -286,7 +286,8 @@ void DisplayListBuilder::onSetImageFilter(const DlImageFilter* filter) {
       }
       case DlImageFilterType::kCompose:
       case DlImageFilterType::kLocalMatrix:
-      case DlImageFilterType::kColorFilter: {
+      case DlImageFilterType::kColorFilter:
+      case DlImageFilterType::kRuntimeEffect: {
         Push<SetSharedImageFilterOp>(0, filter);
         break;
       }

display_list/effects/dl_image_filter.h

@@ -7,6 +7,7 @@
 
 #include <utility>
 
+#include "display_list/effects/dl_color_source.h"
 #include "flutter/display_list/dl_attributes.h"
 #include "flutter/display_list/dl_sampling_options.h"
 #include "flutter/display_list/dl_tile_mode.h"
@@ -34,6 +35,7 @@ enum class DlImageFilterType {
   kCompose,
   kColorFilter,
   kLocalMatrix,
+  kRuntimeEffect,
 };
 
 class DlBlurImageFilter;
@@ -43,6 +45,7 @@ class DlMatrixImageFilter;
 class DlLocalMatrixImageFilter;
 class DlComposeImageFilter;
 class DlColorFilterImageFilter;
+class DlRuntimeEffectImageFilter;
 
 class DlImageFilter : public DlAttribute<DlImageFilter, DlImageFilterType> {
  public:
@@ -85,6 +88,12 @@ class DlImageFilter : public DlAttribute<DlImageFilter, DlImageFilterType> {
     return nullptr;
   }
 
+  // Return a DlRuntimeEffectImageFilter pointer to this object iff it is a
+  // DlRuntimeEffectImageFilter type of ImageFilter, otherwise return nullptr.
+  virtual const DlRuntimeEffectImageFilter* asRuntimeEffectFilter() const {
+    return nullptr;
+  }
+
   // Return a boolean indicating whether the image filtering operation will
   // modify transparent black. This is typically used to determine if applying
   // the ImageFilter to a temporary saveLayer buffer will turn the surrounding
@@ -742,6 +751,101 @@ class DlLocalMatrixImageFilter final : public DlImageFilter {
   std::shared_ptr<const DlImageFilter> image_filter_;
 };
 
+class DlRuntimeEffectImageFilter final : public DlImageFilter {
+ public:
+  explicit DlRuntimeEffectImageFilter(
+      sk_sp<DlRuntimeEffect> runtime_effect,
+      std::vector<std::shared_ptr<DlColorSource>> samplers,
+      std::shared_ptr<std::vector<uint8_t>> uniform_data)
+      : runtime_effect_(std::move(runtime_effect)),
+        samplers_(std::move(samplers)),
+        uniform_data_(std::move(uniform_data)) {}
+
+  std::shared_ptr<DlImageFilter> shared() const override {
+    return std::make_shared<DlRuntimeEffectImageFilter>(
+        this->runtime_effect_, this->samplers_, this->uniform_data_);
+  }
+
+  static std::shared_ptr<DlImageFilter> Make(
+      sk_sp<DlRuntimeEffect> runtime_effect,
+      std::vector<std::shared_ptr<DlColorSource>> samplers,
+      std::shared_ptr<std::vector<uint8_t>> uniform_data) {
+    return std::make_shared<DlRuntimeEffectImageFilter>(
+        std::move(runtime_effect), std::move(samplers),
+        std::move(uniform_data));
+  }
+
+  DlImageFilterType type() const override {
+    return DlImageFilterType::kRuntimeEffect;
+  }
+  size_t size() const override { return sizeof(*this); }
+
+  bool modifies_transparent_black() const override { return false; }
+
+  SkRect* map_local_bounds(const SkRect& input_bounds,
+                           SkRect& output_bounds) const override {
+    output_bounds = input_bounds;
+    return &output_bounds;
+  }
+
+  SkIRect* map_device_bounds(const SkIRect& input_bounds,
+                             const SkMatrix& ctm,
+                             SkIRect& output_bounds) const override {
+    output_bounds = input_bounds;
+    return &output_bounds;
+  }
+
+  SkIRect* get_input_device_bounds(const SkIRect& output_bounds,
+                                   const SkMatrix& ctm,
+                                   SkIRect& input_bounds) const override {
+    input_bounds = output_bounds;
+    return &input_bounds;
+  }
+
+  const DlRuntimeEffectImageFilter* asRuntimeEffectFilter() const override {
+    return this;
+  }
+
+  const sk_sp<DlRuntimeEffect> runtime_effect() const {
+    return runtime_effect_;
+  }
+
+  const std::vector<std::shared_ptr<DlColorSource>>& samplers() const {
+    return samplers_;
+  }
+
+  const std::shared_ptr<std::vector<uint8_t>>& uniform_data() const {
+    return uniform_data_;
+  }
+
+ protected:
+  bool equals_(const DlImageFilter& other) const override {
+    FML_DCHECK(other.type() == DlImageFilterType::kRuntimeEffect);
+    auto that = static_cast<const DlRuntimeEffectImageFilter*>(&other);
+    if (runtime_effect_ != that->runtime_effect_ ||
+        samplers_.size() != that->samplers().size() ||
+        uniform_data_->size() != that->uniform_data()->size()) {
+      return false;
+    }
+    for (auto i = 0u; i < samplers_.size(); i++) {
+      if (samplers_[i] != that->samplers()[i]) {
+        return false;
+      }
+    }
+    for (auto i = 0u; i < uniform_data_->size(); i++) {
+      if (uniform_data_->at(i) != that->uniform_data()->at(i)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+ private:
+  sk_sp<DlRuntimeEffect> runtime_effect_;
+  std::vector<std::shared_ptr<DlColorSource>> samplers_;
+  std::shared_ptr<std::vector<uint8_t>> uniform_data_;
+};
+
 }  // namespace flutter
 
 #endif  // FLUTTER_DISPLAY_LIST_EFFECTS_DL_IMAGE_FILTER_H_

display_list/effects/dl_image_filter_unittests.cc

@@ -12,6 +12,8 @@
 #include "flutter/display_list/utils/dl_comparable.h"
 #include "gtest/gtest.h"
 
+#include "include/core/SkMatrix.h"
+#include "include/core/SkRect.h"
 #include "third_party/skia/include/core/SkBlendMode.h"
 #include "third_party/skia/include/core/SkColorFilter.h"
 #include "third_party/skia/include/core/SkSamplingOptions.h"
@@ -823,5 +825,87 @@ TEST(DisplayListImageFilter, LocalImageFilterBounds) {
   }
 }
 
+TEST(DisplayListImageFilter, RuntimeEffectEquality) {
+  DlRuntimeEffectImageFilter filter_a(nullptr, {nullptr},
+                                      std::make_shared<std::vector<uint8_t>>());
+  DlRuntimeEffectImageFilter filter_b(nullptr, {nullptr},
+                                      std::make_shared<std::vector<uint8_t>>());
+
+  EXPECT_EQ(filter_a, filter_b);
+
+  DlRuntimeEffectImageFilter filter_c(
+      nullptr, {nullptr}, std::make_shared<std::vector<uint8_t>>(1));
+
+  EXPECT_NE(filter_a, filter_c);
+}
+
+TEST(DisplayListImageFilter, RuntimeEffectEqualityWithSamplers) {
+  auto image_a = std::make_shared<DlImageColorSource>(
+      nullptr, DlTileMode::kClamp, DlTileMode::kDecal);
+  auto image_b = std::make_shared<DlImageColorSource>(
+      nullptr, DlTileMode::kClamp, DlTileMode::kClamp);
+
+  DlRuntimeEffectImageFilter filter_a(nullptr, {nullptr, image_a},
+                                      std::make_shared<std::vector<uint8_t>>());
+  DlRuntimeEffectImageFilter filter_b(nullptr, {nullptr, image_a},
+                                      std::make_shared<std::vector<uint8_t>>());
+
+  EXPECT_EQ(filter_a, filter_b);
+
+  DlRuntimeEffectImageFilter filter_c(nullptr, {nullptr, image_b},
+                                      std::make_shared<std::vector<uint8_t>>());
+
+  EXPECT_NE(filter_a, filter_c);
+}
+
+TEST(DisplayListImageFilter, RuntimeEffectMapDeviceBounds) {
+  DlRuntimeEffectImageFilter filter_a(nullptr, {nullptr},
+                                      std::make_shared<std::vector<uint8_t>>());
+
+  auto input_bounds = SkIRect::MakeLTRB(0, 0, 100, 100);
+  SkMatrix identity;
+  SkIRect output_bounds;
+  SkIRect* result =
+      filter_a.map_device_bounds(input_bounds, identity, output_bounds);
+
+  EXPECT_NE(result, nullptr);
+  EXPECT_EQ(output_bounds, input_bounds);
+}
+
+TEST(DisplayListImageFilter, RuntimeEffectMapInputBounds) {
+  DlRuntimeEffectImageFilter filter_a(nullptr, {nullptr},
+                                      std::make_shared<std::vector<uint8_t>>());
+
+  auto input_bounds = SkRect::MakeLTRB(0, 0, 100, 100);
+
+  SkRect output_bounds;
+  SkRect* result = filter_a.map_local_bounds(input_bounds, output_bounds);
+
+  EXPECT_NE(result, nullptr);
+  EXPECT_EQ(output_bounds, input_bounds);
+}
+
+TEST(DisplayListImageFilter, RuntimeEffectGetInputDeviceBounds) {
+  DlRuntimeEffectImageFilter filter_a(nullptr, {nullptr},
+                                      std::make_shared<std::vector<uint8_t>>());
+
+  auto output_bounds = SkIRect::MakeLTRB(0, 0, 100, 100);
+
+  SkMatrix identity;
+  SkIRect input_bounds;
+  SkIRect* result =
+      filter_a.get_input_device_bounds(output_bounds, identity, input_bounds);
+
+  EXPECT_NE(result, nullptr);
+  EXPECT_EQ(output_bounds, input_bounds);
+}
+
+TEST(DisplayListImageFilter, RuntimeEffectModifiesTransparentBlack) {
+  DlRuntimeEffectImageFilter filter_a(nullptr, {nullptr},
+                                      std::make_shared<std::vector<uint8_t>>());
+
+  EXPECT_FALSE(filter_a.modifies_transparent_black());
+}
+
 }  // namespace testing
 }  // namespace flutter

display_list/skia/dl_sk_conversions.cc

@@ -231,6 +231,9 @@ sk_sp<SkImageFilter> ToSk(const DlImageFilter* filter) {
       }
       return skia_filter->makeWithLocalMatrix(lm_filter->matrix());
     }
+    case DlImageFilterType::kRuntimeEffect:
+      // UNSUPPORTED.
+      return nullptr;
   }
 }
 

impeller/display_list/aiks_dl_runtime_effect_unittests.cc

@@ -4,11 +4,12 @@
 
 #include <memory>
 
-#include "display_list/effects/dl_color_source.h"
-#include "flutter/impeller/display_list/aiks_unittests.h"
-
 #include "flutter/display_list/dl_builder.h"
 #include "flutter/display_list/dl_paint.h"
+#include "flutter/display_list/effects/dl_color_source.h"
+#include "flutter/display_list/effects/dl_image_filter.h"
+#include "flutter/display_list/effects/dl_runtime_effect.h"
+#include "flutter/impeller/display_list/aiks_unittests.h"
 
 #include "include/core/SkPath.h"
 #include "include/core/SkRRect.h"
@@ -83,5 +84,32 @@ TEST_P(AiksTest, DrawPaintTransformsBounds) {
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }
 
+TEST_P(AiksTest, CanRenderRuntimeEffectFilter) {
+  auto runtime_stages =
+      OpenAssetAsRuntimeStage("runtime_stage_filter_example.frag.iplr");
+
+  std::shared_ptr<RuntimeStage> runtime_stage =
+      runtime_stages[PlaygroundBackendToRuntimeStageBackend(GetBackend())];
+  ASSERT_TRUE(runtime_stage);
+  ASSERT_TRUE(runtime_stage->IsDirty());
+
+  std::vector<std::shared_ptr<DlColorSource>> sampler_inputs = {
+      nullptr,
+  };
+  auto uniform_data = std::make_shared<std::vector<uint8_t>>();
+  uniform_data->resize(sizeof(Vector2));
+
+  DlPaint paint;
+  paint.setColor(DlColor::kAqua());
+  paint.setImageFilter(std::make_shared<DlRuntimeEffectImageFilter>(
+      DlRuntimeEffect::MakeImpeller(runtime_stage), sampler_inputs,
+      uniform_data));
+
+  DisplayListBuilder builder;
+  builder.DrawRect(SkRect::MakeXYWH(0, 0, 400, 400), paint);
+
+  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
+}
+
 }  // namespace testing
 }  // namespace impeller

impeller/display_list/dl_dispatcher.cc

@@ -10,7 +10,7 @@
 #include <optional>
 #include <vector>
 
-#include "display_list/effects/dl_color_source.h"
+#include "display_list/dl_sampling_options.h"
 #include "display_list/effects/dl_image_filter.h"
 #include "flutter/fml/logging.h"
 #include "impeller/core/formats.h"

impeller/display_list/image_filter.cc

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "impeller/display_list/image_filter.h"
+#include "display_list/effects/dl_image_filter.h"
 #include "fml/logging.h"
 #include "impeller/display_list/color_filter.h"
 #include "impeller/display_list/skia_conversions.h"
@@ -102,6 +103,43 @@ std::shared_ptr<FilterContents> WrapInput(const flutter::DlImageFilter* filter,
           outer_dl_filter.get(),
           FilterInput::Make(WrapInput(inner_dl_filter.get(), input)));
     }
+    case flutter::DlImageFilterType::kRuntimeEffect: {
+      const flutter::DlRuntimeEffectImageFilter* runtime_filter =
+          filter->asRuntimeEffectFilter();
+      FML_DCHECK(runtime_filter);
+      std::shared_ptr<impeller::RuntimeStage> runtime_stage =
+          runtime_filter->runtime_effect()->runtime_stage();
+
+      std::vector<RuntimeEffectContents::TextureInput> texture_inputs;
+      size_t index = 0;
+      for (const std::shared_ptr<flutter::DlColorSource>& sampler :
+           runtime_filter->samplers()) {
+        if (index == 0 && sampler == nullptr) {
+          // Insert placeholder for filter.
+          texture_inputs.push_back(
+              {.sampler_descriptor = skia_conversions::ToSamplerDescriptor({}),
+               .texture = nullptr});
+          continue;
+        }
+        if (sampler == nullptr) {
+          return nullptr;
+        }
+        auto* image = sampler->asImage();
+        if (!image) {
+          return nullptr;
+        }
+        FML_DCHECK(image->image()->impeller_texture());
+        index++;
+        texture_inputs.push_back({
+            .sampler_descriptor =
+                skia_conversions::ToSamplerDescriptor(image->sampling()),
+            .texture = image->image()->impeller_texture(),
+        });
+      }
+      return FilterContents::MakeRuntimeEffect(input, std::move(runtime_stage),
+                                               runtime_filter->uniform_data(),
+                                               std::move(texture_inputs));
+    }
   }
   FML_UNREACHABLE();
 }

impeller/entity/BUILD.gn

@@ -139,6 +139,8 @@ impeller_component("entity") {
     "contents/filters/matrix_filter_contents.h",
     "contents/filters/morphology_filter_contents.cc",
     "contents/filters/morphology_filter_contents.h",
+    "contents/filters/runtime_effect_filter_contents.cc",
+    "contents/filters/runtime_effect_filter_contents.h",
     "contents/filters/srgb_to_linear_filter_contents.cc",
     "contents/filters/srgb_to_linear_filter_contents.h",
     "contents/filters/yuv_to_rgb_filter_contents.cc",