[impeller] implement GetPositionUVBuffer

Author: jonahwilliams

impeller/entity/contents/tiled_texture_contents.cc

@@ -86,13 +86,6 @@ bool TiledTextureContents::Render(const ContentContext& renderer,
   if (texture_ == nullptr) {
     return true;
   }
-  // TODO(jonahwilliams): this is a special case for VerticesGeometry which
-  // implements GetPositionUVBuffer. The general geometry case does not use
-  // this method (see note below).
-  auto geometry = GetGeometry();
-  if (geometry->GetVertexType() == GeometryVertexType::kUV) {
-    return RenderVertices(renderer, entity, pass);
-  }
 
   using VS = TiledTextureFillVertexShader;
   using FS = TiledTextureFillFragmentShader;
@@ -104,21 +97,14 @@ bool TiledTextureContents::Render(const ContentContext& renderer,
 
   auto& host_buffer = pass.GetTransientsBuffer();
 
-  auto geometry_result =
-      GetGeometry()->GetPositionBuffer(renderer, entity, pass);
-
-  // TODO(bdero): The geometry should be fetched from GetPositionUVBuffer and
-  //              contain coverage-mapped UVs, and this should use
-  //              position_uv.vert.
-  //              https://github.com/flutter/flutter/issues/118553
+  auto bounds_origin = GetGeometry()->GetCoverage(Matrix())->origin;
+  auto geometry_result = GetGeometry()->GetPositionUVBuffer(
+      Rect(bounds_origin, Size(texture_size)), GetInverseMatrix(), renderer,
+      entity, pass);
 
   VS::FrameInfo frame_info;
   frame_info.mvp = geometry_result.transform;
   frame_info.texture_sampler_y_coord_scale = texture_->GetYCoordScale();
-  frame_info.effect_transform = GetInverseMatrix();
-  frame_info.bounds_origin = geometry->GetCoverage(Matrix())->origin;
-  frame_info.texture_size = Vector2(static_cast<Scalar>(texture_size.width),
-                                    static_cast<Scalar>(texture_size.height));
 
   FS::FragInfo frag_info;
   frag_info.x_tile_mode = static_cast<Scalar>(x_tile_mode_);
@@ -169,73 +155,4 @@ bool TiledTextureContents::Render(const ContentContext& renderer,
   return true;
 }
 
-bool TiledTextureContents::RenderVertices(const ContentContext& renderer,
-                                          const Entity& entity,
-                                          RenderPass& pass) const {
-  using VS = PositionUVPipeline::VertexShader;
-  using FS = PositionUVPipeline::FragmentShader;
-
-  const auto texture_size = texture_->GetSize();
-  if (texture_size.IsEmpty()) {
-    return true;
-  }
-
-  auto& host_buffer = pass.GetTransientsBuffer();
-
-  auto geometry_result = GetGeometry()->GetPositionUVBuffer(
-      Rect::MakeSize(texture_size), GetInverseMatrix(), renderer, entity, pass);
-
-  VS::FrameInfo frame_info;
-  frame_info.mvp = geometry_result.transform;
-  frame_info.texture_sampler_y_coord_scale = texture_->GetYCoordScale();
-
-  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_);
-  frag_info.alpha = GetAlpha();
-
-  Command cmd;
-  cmd.label = "PositionUV";
-  cmd.stencil_reference = entity.GetStencilDepth();
-
-  auto options = OptionsFromPassAndEntity(pass, entity);
-  if (geometry_result.prevent_overdraw) {
-    options.stencil_compare = CompareFunction::kEqual;
-    options.stencil_operation = StencilOperation::kIncrementClamp;
-  }
-  options.primitive_type = geometry_result.type;
-  cmd.pipeline = renderer.GetPositionUVPipeline(options);
-
-  cmd.BindVertices(geometry_result.vertex_buffer);
-  VS::BindFrameInfo(cmd, host_buffer.EmplaceUniform(frame_info));
-  FS::BindFragInfo(cmd, host_buffer.EmplaceUniform(frag_info));
-
-  if (color_filter_.has_value()) {
-    auto filtered_texture = CreateFilterTexture(renderer);
-    if (!filtered_texture.has_value()) {
-      return false;
-    }
-    FS::BindTextureSampler(
-        cmd, filtered_texture.value(),
-        renderer.GetContext()->GetSamplerLibrary()->GetSampler(
-            CreateDescriptor()));
-  } else {
-    FS::BindTextureSampler(
-        cmd, texture_,
-        renderer.GetContext()->GetSamplerLibrary()->GetSampler(
-            CreateDescriptor()));
-  }
-
-  if (!pass.AddCommand(std::move(cmd))) {
-    return false;
-  }
-
-  if (geometry_result.prevent_overdraw) {
-    auto restore = ClipRestoreContents();
-    restore.SetRestoreCoverage(GetCoverage(entity));
-    return restore.Render(renderer, entity, pass);
-  }
-  return true;
-}
-
 }  // namespace impeller

impeller/entity/contents/tiled_texture_contents.h

@@ -53,10 +53,6 @@ class TiledTextureContents final : public ColorSourceContents {
   std::optional<std::shared_ptr<Texture>> CreateFilterTexture(
       const ContentContext& renderer) const;
 
-  bool RenderVertices(const ContentContext& renderer,
-                      const Entity& entity,
-                      RenderPass& pass) const;
-
   SamplerDescriptor CreateDescriptor() const;
 
   std::shared_ptr<Texture> texture_;

impeller/entity/geometry.cc

@@ -5,6 +5,7 @@
 #include "impeller/entity/geometry.h"
 #include "impeller/entity/contents/content_context.h"
 #include "impeller/entity/position_color.vert.h"
+#include "impeller/entity/texture_fill.vert.h"
 #include "impeller/geometry/matrix.h"
 #include "impeller/geometry/path_builder.h"
 #include "impeller/renderer/device_buffer.h"
@@ -51,6 +52,40 @@ std::unique_ptr<Geometry> Geometry::MakeRect(Rect rect) {
   return std::make_unique<RectGeometry>(rect);
 }
 
+static GeometryResult ComputeUVGeometryForRect(Rect source_rect,
+                                               Rect texture_coverage,
+                                               Matrix effect_transform,
+                                               const ContentContext& renderer,
+                                               const Entity& entity,
+                                               RenderPass& pass) {
+  constexpr uint16_t kRectIndicies[4] = {0, 1, 2, 3};
+  auto& host_buffer = pass.GetTransientsBuffer();
+
+  std::vector<Point> data(8);
+  auto points = source_rect.GetPoints();
+  for (auto i = 0u, j = 0u; i < 8; i += 2, j++) {
+    data[i] = points[j];
+    data[i + 1] = effect_transform * ((points[j] - texture_coverage.origin) /
+                                      texture_coverage.size);
+  }
+
+  return GeometryResult{
+      .type = PrimitiveType::kTriangleStrip,
+      .vertex_buffer =
+          {
+              .vertex_buffer = host_buffer.Emplace(
+                  data.data(), 16 * sizeof(float), alignof(float)),
+              .index_buffer = host_buffer.Emplace(
+                  kRectIndicies, 4 * sizeof(uint16_t), alignof(uint16_t)),
+              .index_count = 4,
+              .index_type = IndexType::k16bit,
+          },
+      .transform = Matrix::MakeOrthographic(pass.GetRenderTargetSize()) *
+                   entity.GetTransformation(),
+      .prevent_overdraw = false,
+  };
+}
+
 /////// Path Geometry ///////
 
 FillPathGeometry::FillPathGeometry(const Path& path) : path_(path) {}
@@ -89,6 +124,51 @@ GeometryResult FillPathGeometry::GetPositionBuffer(
   };
 }
 
+// |Geometry|
+GeometryResult FillPathGeometry::GetPositionUVBuffer(
+    Rect texture_coverage,
+    Matrix effect_transform,
+    const ContentContext& renderer,
+    const Entity& entity,
+    RenderPass& pass) {
+  using VS = TextureFillVertexShader;
+
+  VertexBufferBuilder<VS::PerVertexData> vertex_builder;
+  auto tesselation_result = renderer.GetTessellator()->Tessellate(
+      path_.GetFillType(),
+      path_.CreatePolyline(entity.GetTransformation().GetMaxBasisLength()),
+      [&vertex_builder, &texture_coverage, &effect_transform](
+          const float* vertices, size_t vertices_count, const uint16_t* indices,
+          size_t indices_count) {
+        for (auto i = 0u; i < vertices_count; i += 2) {
+          VS::PerVertexData data;
+          Point vtx = {vertices[i], vertices[i + 1]};
+          data.position = vtx;
+          auto coverage_coords =
+              ((vtx - texture_coverage.origin) / texture_coverage.size) /
+              texture_coverage.size;
+          data.texture_coords = effect_transform * coverage_coords;
+          vertex_builder.AppendVertex(data);
+        }
+        FML_DCHECK(vertex_builder.GetVertexCount() == vertices_count / 2);
+        for (auto i = 0u; i < indices_count; i++) {
+          vertex_builder.AppendIndex(indices[i]);
+        }
+        return true;
+      });
+  if (tesselation_result != Tessellator::Result::kSuccess) {
+    return {};
+  }
+  return GeometryResult{
+      .type = PrimitiveType::kTriangle,
+      .vertex_buffer =
+          vertex_builder.CreateVertexBuffer(pass.GetTransientsBuffer()),
+      .transform = Matrix::MakeOrthographic(pass.GetRenderTargetSize()) *
+                   entity.GetTransformation(),
+      .prevent_overdraw = false,
+  };
+}
+
 GeometryVertexType FillPathGeometry::GetVertexType() const {
   return GeometryVertexType::kPosition;
 }
@@ -300,9 +380,9 @@ StrokePathGeometry::CapProc StrokePathGeometry::GetCapProc(Cap stroke_cap) {
 }
 
 // static
-VertexBuffer StrokePathGeometry::CreateSolidStrokeVertices(
+VertexBufferBuilder<SolidFillVertexShader::PerVertexData>
+StrokePathGeometry::CreateSolidStrokeVertices(
     const Path& path,
-    HostBuffer& buffer,
     Scalar stroke_width,
     Scalar scaled_miter_limit,
     Cap cap,
@@ -422,7 +502,7 @@ VertexBuffer StrokePathGeometry::CreateSolidStrokeVertices(
     }
   }
 
-  return vtx_builder.CreateVertexBuffer(buffer);
+  return vtx_builder;
 }
 
 GeometryResult StrokePathGeometry::GetPositionBuffer(
@@ -441,14 +521,59 @@ GeometryResult StrokePathGeometry::GetPositionBuffer(
   Scalar stroke_width = std::max(stroke_width_, min_size);
 
   auto& host_buffer = pass.GetTransientsBuffer();
-  auto vertex_buffer = CreateSolidStrokeVertices(
-      path_, host_buffer, stroke_width, miter_limit_ * stroke_width_ * 0.5,
-      stroke_cap_, GetJoinProc(stroke_join_), GetCapProc(stroke_cap_),
+  auto vertex_builder = CreateSolidStrokeVertices(
+      path_, stroke_width, miter_limit_ * stroke_width_ * 0.5, stroke_cap_,
+      GetJoinProc(stroke_join_), GetCapProc(stroke_cap_),
       entity.GetTransformation().GetMaxBasisLength());
 
   return GeometryResult{
       .type = PrimitiveType::kTriangleStrip,
-      .vertex_buffer = vertex_buffer,
+      .vertex_buffer = vertex_builder.CreateVertexBuffer(host_buffer),
+      .transform = Matrix::MakeOrthographic(pass.GetRenderTargetSize()) *
+                   entity.GetTransformation(),
+      .prevent_overdraw = true,
+  };
+}
+
+GeometryResult StrokePathGeometry::GetPositionUVBuffer(
+    Rect texture_coverage,
+    Matrix effect_transform,
+    const ContentContext& renderer,
+    const Entity& entity,
+    RenderPass& pass) {
+  if (stroke_width_ < 0.0) {
+    return {};
+  }
+  auto determinant = entity.GetTransformation().GetDeterminant();
+  if (determinant == 0) {
+    return {};
+  }
+
+  Scalar min_size = 1.0f / sqrt(std::abs(determinant));
+  Scalar stroke_width = std::max(stroke_width_, min_size);
+
+  auto& host_buffer = pass.GetTransientsBuffer();
+  auto stroke_builder = CreateSolidStrokeVertices(
+      path_, stroke_width, miter_limit_ * stroke_width_ * 0.5, stroke_cap_,
+      GetJoinProc(stroke_join_), GetCapProc(stroke_cap_),
+      entity.GetTransformation().GetMaxBasisLength());
+
+  VertexBufferBuilder<TextureFillVertexShader::PerVertexData> vertex_builder;
+  stroke_builder.IterateVertices(
+      [&vertex_builder, &texture_coverage,
+       &effect_transform](SolidFillVertexShader::PerVertexData old_vtx) {
+        TextureFillVertexShader::PerVertexData data;
+        data.position = old_vtx.position;
+        auto coverage_coords = ((old_vtx.position - texture_coverage.origin) /
+                                texture_coverage.size) /
+                               texture_coverage.size;
+        data.texture_coords = effect_transform * coverage_coords;
+        vertex_builder.AppendVertex(data);
+      });
+
+  return GeometryResult{
+      .type = PrimitiveType::kTriangleStrip,
+      .vertex_buffer = vertex_builder.CreateVertexBuffer(host_buffer),
       .transform = Matrix::MakeOrthographic(pass.GetRenderTargetSize()) *
                    entity.GetTransformation(),
       .prevent_overdraw = true,
@@ -515,6 +640,18 @@ GeometryResult CoverGeometry::GetPositionBuffer(const ContentContext& renderer,
   };
 }
 
+// |Geometry|
+GeometryResult CoverGeometry::GetPositionUVBuffer(
+    Rect texture_coverage,
+    Matrix effect_transform,
+    const ContentContext& renderer,
+    const Entity& entity,
+    RenderPass& pass) {
+  auto rect = Rect(Size(pass.GetRenderTargetSize()));
+  return ComputeUVGeometryForRect(rect, texture_coverage, effect_transform,
+                                  renderer, entity, pass);
+}
+
 GeometryVertexType CoverGeometry::GetVertexType() const {
   return GeometryVertexType::kPosition;
 }
@@ -551,6 +688,16 @@ GeometryResult RectGeometry::GetPositionBuffer(const ContentContext& renderer,
   };
 }
 
+// |Geometry|
+GeometryResult RectGeometry::GetPositionUVBuffer(Rect texture_coverage,
+                                                 Matrix effect_transform,
+                                                 const ContentContext& renderer,
+                                                 const Entity& entity,
+                                                 RenderPass& pass) {
+  return ComputeUVGeometryForRect(rect_, texture_coverage, effect_transform,
+                                  renderer, entity, pass);
+}
+
 GeometryVertexType RectGeometry::GetVertexType() const {
   return GeometryVertexType::kPosition;
 }