[Impeller] Add support for external GL textures to TiledTextureContents.

Author: bdero

impeller/compiler/shader_lib/impeller/BUILD.gn

@@ -10,10 +10,12 @@ copy("impeller") {
     "constants.glsl",
     "conversions.glsl",
     "dithering.glsl",
+    "external_texture_oes.glsl",
     "gaussian.glsl",
     "gradient.glsl",
     "path.glsl",
     "texture.glsl",
+    "tile_mode.glsl",
     "transform.glsl",
     "types.glsl",
   ]

impeller/compiler/shader_lib/impeller/external_texture_oes.glsl

@@ -0,0 +1,36 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <impeller/tile_mode.glsl>
+
+/// A triangle wave. 0->0, 1->1, 2->0, and so on... works with negative numbers.
+float TriangleWave(float x) {
+  return abs(mod(x + 1, 2) - 1);
+}
+
+/// OES_EGL_image_external states that only CLAMP_TO_EDGE is valid, so we
+/// emulate all other tile modes here by remapping the texture coordinates.
+vec4 IPSampleWithTileModeOES(sampler2D tex,
+                             vec2 coords,
+                             float x_tile_mode,
+                             float y_tile_mode) {
+  if (x_tile_mode == kTileModeDecal && (coords.x < 0 || coords.x >= 1) ||
+      y_tile_mode == kTileModeDecal && (coords.y < 0 || coords.y >= 1)) {
+    return vec4(0);
+  }
+
+  if (x_tile_mode == kTileModeRepeat) {
+    coords.x = mod(coords.x, 1);
+  } else if (x_tile_mode == kTileModeMirror) {
+    coords.x = TriangleWave(coords.x);
+  }
+
+  if (y_tile_mode == kTileModeRepeat) {
+    coords.y = mod(coords.y, 1);
+  } else if (y_tile_mode == kTileModeMirror) {
+    coords.y = TriangleWave(coords.y);
+  }
+
+  return texture(tex, coords);
+}

impeller/compiler/shader_lib/impeller/texture.glsl

@@ -7,6 +7,7 @@
 
 #include <impeller/branching.glsl>
 #include <impeller/conversions.glsl>
+#include <impeller/tile_mode.glsl>
 #include <impeller/types.glsl>
 
 /// Sample from a texture.
@@ -35,13 +36,6 @@ vec4 IPSampleLinear(sampler2D texture_sampler,
   return IPSample(texture_sampler, coords, y_coord_scale);
 }
 
-// These values must correspond to the order of the items in the
-// 'Entity::TileMode' enum class.
-const float kTileModeClamp = 0;
-const float kTileModeRepeat = 1;
-const float kTileModeMirror = 2;
-const float kTileModeDecal = 3;
-
 /// Remap a float using a tiling mode.
 ///
 /// When `tile_mode` is `kTileModeDecal`, no tiling is applied and `t` is

impeller/compiler/shader_lib/impeller/tile_mode.glsl

@@ -0,0 +1,10 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// These values must correspond to the order of the items in the
+// 'Entity::TileMode' enum class.
+const float kTileModeClamp = 0;
+const float kTileModeRepeat = 1;
+const float kTileModeMirror = 2;
+const float kTileModeDecal = 3;

impeller/entity/BUILD.gn

@@ -51,6 +51,7 @@ impeller_shaders("entity_shaders") {
     "shaders/texture_fill.vert",
     "shaders/texture_fill_external.frag",
     "shaders/tiled_texture_fill.frag",
+    "shaders/tiled_texture_fill_external.frag",
     "shaders/vertices.frag",
     "shaders/yuv_to_rgb_filter.frag",
     "shaders/yuv_to_rgb_filter.vert",

impeller/entity/contents/content_context.cc

@@ -340,6 +340,9 @@ ContentContext::ContentContext(
   if (GetContext()->GetBackendType() == Context::BackendType::kOpenGLES) {
     texture_external_pipelines_.CreateDefault(*context_, options);
   }
+  if (GetContext()->GetBackendType() == Context::BackendType::kOpenGLES) {
+    tiled_texture_external_pipelines_.CreateDefault(*context_, options);
+  }
 #endif  // IMPELLER_ENABLE_OPENGLES
   if (context_->GetCapabilities()->SupportsCompute()) {
     auto pipeline_desc =

impeller/entity/contents/content_context.h

@@ -84,6 +84,7 @@
 
 #ifdef IMPELLER_ENABLE_OPENGLES
 #include "impeller/entity/texture_fill_external.frag.h"
+#include "impeller/entity/tiled_texture_fill_external.frag.h"
 #endif  // IMPELLER_ENABLE_OPENGLES
 
 #if IMPELLER_ENABLE_3D
@@ -249,6 +250,10 @@ using UvComputeShaderPipeline = ComputePipelineBuilder<UvComputeShader>;
 #ifdef IMPELLER_ENABLE_OPENGLES
 using TextureExternalPipeline =
     RenderPipelineT<TextureFillVertexShader, TextureFillExternalFragmentShader>;
+
+using TiledTextureExternalPipeline =
+    RenderPipelineT<TextureFillVertexShader,
+                    TiledTextureFillExternalFragmentShader>;
 #endif  // IMPELLER_ENABLE_OPENGLES
 
 /// Pipeline state configuration.
@@ -398,6 +403,13 @@ class ContentContext {
                Context::BackendType::kOpenGLES);
     return GetPipeline(texture_external_pipelines_, opts);
   }
+
+  std::shared_ptr<Pipeline<PipelineDescriptor>> GetTiledTextureExternalPipeline(
+      ContentContextOptions opts) const {
+    FML_DCHECK(GetContext()->GetBackendType() ==
+               Context::BackendType::kOpenGLES);
+    return GetPipeline(tiled_texture_external_pipelines_, opts);
+  }
 #endif  // IMPELLER_ENABLE_OPENGLES
 
   std::shared_ptr<Pipeline<PipelineDescriptor>> GetPositionUVPipeline(
@@ -768,6 +780,8 @@ class ContentContext {
   mutable Variants<TexturePipeline> texture_pipelines_;
 #ifdef IMPELLER_ENABLE_OPENGLES
   mutable Variants<TextureExternalPipeline> texture_external_pipelines_;
+  mutable Variants<TiledTextureExternalPipeline>
+      tiled_texture_external_pipelines_;
 #endif  // IMPELLER_ENABLE_OPENGLES
   mutable Variants<PositionUVPipeline> position_uv_pipelines_;
   mutable Variants<TiledTexturePipeline> tiled_texture_pipelines_;

impeller/entity/contents/tiled_texture_contents.cc

@@ -10,6 +10,7 @@
 #include "impeller/entity/texture_fill.frag.h"
 #include "impeller/entity/texture_fill.vert.h"
 #include "impeller/entity/tiled_texture_fill.frag.h"
+#include "impeller/entity/tiled_texture_fill_external.frag.h"
 #include "impeller/geometry/path_builder.h"
 #include "impeller/renderer/render_pass.h"
 #include "impeller/renderer/sampler_library.h"
@@ -78,7 +79,7 @@ std::shared_ptr<Texture> TiledTextureContents::CreateFilterTexture(
   return nullptr;
 }
 
-SamplerDescriptor TiledTextureContents::CreateDescriptor(
+SamplerDescriptor TiledTextureContents::CreateSamplerDescriptor(
     const Capabilities& capabilities) const {
   SamplerDescriptor descriptor = sampler_descriptor_;
   auto width_mode = TileModeToAddressMode(x_tile_mode_, capabilities);
@@ -119,12 +120,16 @@ bool TiledTextureContents::Render(const ContentContext& renderer,
 
   using VS = TextureFillVertexShader;
   using FS = TiledTextureFillFragmentShader;
+  using FSExternal = TiledTextureFillExternalFragmentShader;
 
   const auto texture_size = texture_->GetSize();
   if (texture_size.IsEmpty()) {
     return true;
   }
 
+  bool is_external_texture =
+      texture_->GetTextureDescriptor().type == TextureType::kTextureExternalOES;
+
   auto& host_buffer = pass.GetTransientsBuffer();
 
   auto geometry_result = GetGeometry()->GetPositionUVBuffer(
@@ -153,34 +158,64 @@ bool TiledTextureContents::Render(const ContentContext& renderer,
     options.stencil_operation = StencilOperation::kIncrementClamp;
   }
   options.primitive_type = geometry_result.type;
+
+#ifdef IMPELLER_ENABLE_OPENGLES
+  if (is_external_texture) {
+    cmd.pipeline = renderer.GetTiledTextureExternalPipeline(options);
+  } else {
+    cmd.pipeline = uses_emulated_tile_mode
+                       ? renderer.GetTiledTexturePipeline(options)
+                       : renderer.GetTexturePipeline(options);
+  }
+#else
   cmd.pipeline = uses_emulated_tile_mode
                      ? renderer.GetTiledTexturePipeline(options)
                      : renderer.GetTexturePipeline(options);
+#endif  // IMPELLER_ENABLE_OPENGLES
 
   cmd.BindVertices(geometry_result.vertex_buffer);
   VS::BindFrameInfo(cmd, host_buffer.EmplaceUniform(frame_info));
 
-  if (uses_emulated_tile_mode) {
+  if (is_external_texture) {
+    FSExternal::FragInfo frag_info;
+    frag_info.x_tile_mode = static_cast<Scalar>(x_tile_mode_);
+    frag_info.y_tile_mode = static_cast<Scalar>(y_tile_mode_);
+    FSExternal::BindFragInfo(cmd, host_buffer.EmplaceUniform(frag_info));
+  } else if (uses_emulated_tile_mode) {
     FS::FragInfo frag_info;
     frag_info.x_tile_mode = static_cast<Scalar>(x_tile_mode_);
     frag_info.y_tile_mode = static_cast<Scalar>(y_tile_mode_);
     FS::BindFragInfo(cmd, host_buffer.EmplaceUniform(frag_info));
   }
 
-  if (color_filter_) {
-    auto filtered_texture = CreateFilterTexture(renderer);
-    if (!filtered_texture) {
-      return false;
-    }
-    FS::BindTextureSampler(
-        cmd, filtered_texture,
-        renderer.GetContext()->GetSamplerLibrary()->GetSampler(
-            CreateDescriptor(renderer.GetDeviceCapabilities())));
-  } else {
-    FS::BindTextureSampler(
+  if (is_external_texture) {
+    SamplerDescriptor sampler_desc;
+    // OES_EGL_image_external states that only CLAMP_TO_EDGE is valid, so we
+    // emulate all other tile modes here by remapping the texture coordinates.
+    sampler_desc.width_address_mode = SamplerAddressMode::kClampToEdge;
+    sampler_desc.height_address_mode = SamplerAddressMode::kClampToEdge;
+
+    // Also, external textures cannot be bound to color filters, so ignore this
+    // case for now.
+    FSExternal::BindSAMPLEREXTERNALOESTextureSampler(
         cmd, texture_,
-        renderer.GetContext()->GetSamplerLibrary()->GetSampler(
-            CreateDescriptor(renderer.GetDeviceCapabilities())));
+        renderer.GetContext()->GetSamplerLibrary()->GetSampler(sampler_desc));
+  } else {
+    if (color_filter_) {
+      auto filtered_texture = CreateFilterTexture(renderer);
+      if (!filtered_texture) {
+        return false;
+      }
+      FS::BindTextureSampler(
+          cmd, filtered_texture,
+          renderer.GetContext()->GetSamplerLibrary()->GetSampler(
+              CreateSamplerDescriptor(renderer.GetDeviceCapabilities())));
+    } else {
+      FS::BindTextureSampler(
+          cmd, texture_,
+          renderer.GetContext()->GetSamplerLibrary()->GetSampler(
+              CreateSamplerDescriptor(renderer.GetDeviceCapabilities())));
+    }
   }
 
   if (!pass.AddCommand(std::move(cmd))) {

impeller/entity/contents/tiled_texture_contents.h

@@ -45,7 +45,7 @@ class TiledTextureContents final : public ColorSourceContents {
   /// @param color_filter
   ///
   /// When applying a color filter to a tiled texture, we can reduce the
-  /// size and number of the subpasses required and the shader workloadby
+  /// size and number of the subpasses required and the shader workload by
   /// applying the filter to the untiled image and absorbing the opacity before
   /// tiling it into the final location.
   ///
@@ -66,7 +66,8 @@ class TiledTextureContents final : public ColorSourceContents {
   std::shared_ptr<Texture> CreateFilterTexture(
       const ContentContext& renderer) const;
 
-  SamplerDescriptor CreateDescriptor(const Capabilities& capabilities) const;
+  SamplerDescriptor CreateSamplerDescriptor(
+      const Capabilities& capabilities) const;
 
   bool UsesEmulatedTileMode(const Capabilities& capabilities) const;
 

impeller/entity/shaders/tiled_texture_fill_external.frag

@@ -0,0 +1,30 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+precision mediump float;
+
+#include <impeller/external_texture_oes.glsl>
+
+uniform sampler2D SAMPLER_EXTERNAL_OES_texture_sampler;
+
+uniform FragInfo {
+  float x_tile_mode;
+  float y_tile_mode;
+}
+frag_info;
+
+in vec2 v_texture_coords;
+in float v_alpha;
+
+out vec4 frag_color;
+
+void main() {
+  frag_color =
+      IPSampleWithTileModeOES(SAMPLER_EXTERNAL_OES_texture_sampler,  // sampler
+                              v_texture_coords,       // texture coordinates
+                              frag_info.x_tile_mode,  // x tile mode
+                              frag_info.y_tile_mode   // y tile mode
+                              ) *
+      v_alpha;
+}