[Impeller] Polyline generation optimization.

impeller/entity/contents/clip_contents.cc

@@ -121,7 +121,8 @@ bool ClipContents::Render(const ContentContext& renderer,
   auto allocator = renderer.GetContext()->GetResourceAllocator();
   auto geometry_result = geometry_->GetPositionBuffer(
       allocator, host_buffer, renderer.GetTessellator(),
-      pass.GetRenderTargetSize());
+      pass.GetRenderTargetSize(),
+      entity.GetTransformation().GetMaxBasisLength());
   cmd.BindVertices(geometry_result.vertex_buffer);
   cmd.primitive_type = geometry_result.type;
   info.mvp = Matrix::MakeOrthographic(pass.GetRenderTargetSize()) *

impeller/entity/contents/linear_gradient_contents.cc

@@ -80,7 +80,8 @@ bool LinearGradientContents::Render(const ContentContext& renderer,
   auto allocator = renderer.GetContext()->GetResourceAllocator();
   auto geometry_result = GetGeometry()->GetPositionBuffer(
       allocator, host_buffer, renderer.GetTessellator(),
-      pass.GetRenderTargetSize());
+      pass.GetRenderTargetSize(),
+      entity.GetTransformation().GetMaxBasisLength());
   cmd.BindVertices(geometry_result.vertex_buffer);
   cmd.primitive_type = geometry_result.type;
   FS::BindGradientInfo(

impeller/entity/contents/radial_gradient_contents.cc

@@ -79,7 +79,8 @@ bool RadialGradientContents::Render(const ContentContext& renderer,
   auto allocator = renderer.GetContext()->GetResourceAllocator();
   auto geometry_result = GetGeometry()->GetPositionBuffer(
       allocator, host_buffer, renderer.GetTessellator(),
-      pass.GetRenderTargetSize());
+      pass.GetRenderTargetSize(),
+      entity.GetTransformation().GetMaxBasisLength());
   cmd.BindVertices(geometry_result.vertex_buffer);
   cmd.primitive_type = geometry_result.type;
   FS::BindGradientInfo(

impeller/entity/contents/solid_color_contents.cc

@@ -63,7 +63,8 @@ bool SolidColorContents::Render(const ContentContext& renderer,
   auto allocator = renderer.GetContext()->GetResourceAllocator();
   auto geometry_result = geometry_->GetPositionBuffer(
       allocator, host_buffer, renderer.GetTessellator(),
-      pass.GetRenderTargetSize());
+      pass.GetRenderTargetSize(),
+      entity.GetTransformation().GetMaxBasisLength());
   cmd.BindVertices(geometry_result.vertex_buffer);
   cmd.primitive_type = geometry_result.type;
 

impeller/entity/contents/solid_stroke_contents.cc

@@ -72,7 +72,7 @@ static VertexBuffer CreateSolidStrokeVertices(
     const SolidStrokeContents::CapProc& cap_proc,
     const SolidStrokeContents::JoinProc& join_proc,
     Scalar miter_limit,
-    const SmoothingApproximation& smoothing) {
+    Scalar tolerance) {
   using VS = SolidFillVertexShader;
 
   VertexBufferBuilder<VS::PerVertexData> vtx_builder;
@@ -101,8 +101,8 @@ static VertexBuffer CreateSolidStrokeVertices(
     switch (contour_end_point_i - contour_start_point_i) {
       case 1: {
         Point p = polyline.points[contour_start_point_i];
-        cap_proc(vtx_builder, p, {-stroke_width * 0.5f, 0}, smoothing);
-        cap_proc(vtx_builder, p, {stroke_width * 0.5f, 0}, smoothing);
+        cap_proc(vtx_builder, p, {-stroke_width * 0.5f, 0}, tolerance);
+        cap_proc(vtx_builder, p, {stroke_width * 0.5f, 0}, tolerance);
         continue;
       }
       case 0:
@@ -140,7 +140,7 @@ static VertexBuffer CreateSolidStrokeVertices(
     // Generate start cap.
     if (!polyline.contours[contour_i].is_closed) {
       cap_proc(vtx_builder, polyline.points[contour_start_point_i], -offset,
-               smoothing);
+               tolerance);
     }
 
     // Generate contour geometry.
@@ -162,18 +162,18 @@ static VertexBuffer CreateSolidStrokeVertices(
 
           // Generate join from the current line to the next line.
           join_proc(vtx_builder, polyline.points[point_i], previous_offset,
-                    offset, miter_limit, smoothing);
+                    offset, miter_limit, tolerance);
         }
       }
     }
 
     // Generate end cap or join.
     if (!polyline.contours[contour_i].is_closed) {
       cap_proc(vtx_builder, polyline.points[contour_end_point_i - 1], offset,
-               smoothing);
+               tolerance);
     } else {
       join_proc(vtx_builder, polyline.points[contour_start_point_i], offset,
-                contour_first_offset, miter_limit, smoothing);
+                contour_first_offset, miter_limit, tolerance);
     }
   }
 
@@ -209,15 +209,15 @@ bool SolidStrokeContents::Render(const ContentContext& renderer,
   cmd.pipeline = renderer.GetSolidFillPipeline(options);
   cmd.stencil_reference = entity.GetStencilDepth();
 
-  auto smoothing = SmoothingApproximation(
-      60.0 / (stroke_size_ * entity.GetTransformation().GetMaxBasisLength()),
-      0.0, 0.0);
+  auto tolerance =
+      kDefaultCurveTolerance /
+      (stroke_size_ * entity.GetTransformation().GetMaxBasisLength());
 
   Scalar min_size = 1.0f / sqrt(std::abs(determinant));
   Scalar stroke_width = std::max(stroke_size_, min_size);
   cmd.BindVertices(CreateSolidStrokeVertices(
       path_, pass.GetTransientsBuffer(), stroke_width, cap_proc_, join_proc_,
-      miter_limit_ * stroke_width * 0.5, smoothing));
+      miter_limit_ * stroke_width * 0.5, tolerance));
   VS::BindVertInfo(cmd, pass.GetTransientsBuffer().EmplaceUniform(vert_info));
   FS::BindFragInfo(cmd, pass.GetTransientsBuffer().EmplaceUniform(frag_info));
 
@@ -256,12 +256,12 @@ void SolidStrokeContents::SetStrokeCap(Cap cap) {
     case Cap::kButt:
       cap_proc_ = [](VertexBufferBuilder<VS::PerVertexData>& vtx_builder,
                      const Point& position, const Point& offset,
-                     const SmoothingApproximation& smoothing) {};
+                     Scalar tolerance) {};
       break;
     case Cap::kRound:
       cap_proc_ = [](VertexBufferBuilder<VS::PerVertexData>& vtx_builder,
                      const Point& position, const Point& offset,
-                     const SmoothingApproximation& smoothing) {
+                     Scalar tolerance) {
         VS::PerVertexData vtx;
 
         Point forward(offset.y, -offset.x);
@@ -271,7 +271,7 @@ void SolidStrokeContents::SetStrokeCap(Cap cap) {
             CubicPathComponent(
                 offset, offset + forward * PathBuilder::kArcApproximationMagic,
                 forward + offset * PathBuilder::kArcApproximationMagic, forward)
-                .CreatePolyline(smoothing);
+                .CreatePolyline(tolerance);
 
         vtx.position = position + offset;
         vtx_builder.AppendVertex(vtx);
@@ -288,7 +288,7 @@ void SolidStrokeContents::SetStrokeCap(Cap cap) {
     case Cap::kSquare:
       cap_proc_ = [](VertexBufferBuilder<VS::PerVertexData>& vtx_builder,
                      const Point& position, const Point& offset,
-                     const SmoothingApproximation& smoothing) {
+                     Scalar tolerance) {
         VS::PerVertexData vtx;
         vtx.position = position;
 
@@ -337,7 +337,7 @@ void SolidStrokeContents::SetStrokeJoin(Join join) {
       join_proc_ = [](VertexBufferBuilder<VS::PerVertexData>& vtx_builder,
                       const Point& position, const Point& start_offset,
                       const Point& end_offset, Scalar miter_limit,
-                      const SmoothingApproximation& smoothing) {
+                      Scalar tolerance) {
         CreateBevelAndGetDirection(vtx_builder, position, start_offset,
                                    end_offset);
       };
@@ -346,7 +346,7 @@ void SolidStrokeContents::SetStrokeJoin(Join join) {
       join_proc_ = [](VertexBufferBuilder<VS::PerVertexData>& vtx_builder,
                       const Point& position, const Point& start_offset,
                       const Point& end_offset, Scalar miter_limit,
-                      const SmoothingApproximation& smoothing) {
+                      Scalar tolerance) {
         Point start_normal = start_offset.Normalize();
         Point end_normal = end_offset.Normalize();
 
@@ -375,7 +375,7 @@ void SolidStrokeContents::SetStrokeJoin(Join join) {
       join_proc_ = [](VertexBufferBuilder<VS::PerVertexData>& vtx_builder,
                       const Point& position, const Point& start_offset,
                       const Point& end_offset, Scalar miter_limit,
-                      const SmoothingApproximation& smoothing) {
+                      Scalar tolerance) {
         Point start_normal = start_offset.Normalize();
         Point end_normal = end_offset.Normalize();
 
@@ -402,7 +402,7 @@ void SolidStrokeContents::SetStrokeJoin(Join join) {
 
         auto arc_points = CubicPathComponent(start_offset, start_handle,
                                              middle_handle, middle)
-                              .CreatePolyline(smoothing);
+                              .CreatePolyline(tolerance);
 
         VS::PerVertexData vtx;
         for (const auto& point : arc_points) {

impeller/entity/contents/solid_stroke_contents.h

@@ -40,14 +40,14 @@ class SolidStrokeContents final : public Contents {
       std::function<void(VertexBufferBuilder<VS::PerVertexData>& vtx_builder,
                          const Point& position,
                          const Point& offset,
-                         const SmoothingApproximation& smoothing)>;
+                         Scalar tolerance)>;
   using JoinProc =
       std::function<void(VertexBufferBuilder<VS::PerVertexData>& vtx_builder,
                          const Point& position,
                          const Point& start_offset,
                          const Point& end_offset,
                          Scalar miter_limit,
-                         const SmoothingApproximation& smoothing)>;
+                         Scalar tolerance)>;
 
   SolidStrokeContents();
 

impeller/entity/contents/sweep_gradient_contents.cc

@@ -85,7 +85,8 @@ bool SweepGradientContents::Render(const ContentContext& renderer,
   auto allocator = renderer.GetContext()->GetResourceAllocator();
   auto geometry_result = GetGeometry()->GetPositionBuffer(
       allocator, host_buffer, renderer.GetTessellator(),
-      pass.GetRenderTargetSize());
+      pass.GetRenderTargetSize(),
+      entity.GetTransformation().GetMaxBasisLength());
   cmd.BindVertices(geometry_result.vertex_buffer);
   cmd.primitive_type = geometry_result.type;
   FS::BindGradientInfo(

impeller/entity/contents/tiled_texture_contents.cc

@@ -70,7 +70,8 @@ bool TiledTextureContents::Render(const ContentContext& renderer,
   auto allocator = renderer.GetContext()->GetResourceAllocator();
   auto geometry_result = GetGeometry()->GetPositionBuffer(
       allocator, host_buffer, renderer.GetTessellator(),
-      pass.GetRenderTargetSize());
+      pass.GetRenderTargetSize(),
+      entity.GetTransformation().GetMaxBasisLength());
   cmd.BindVertices(geometry_result.vertex_buffer);
   cmd.primitive_type = geometry_result.type;
   VS::BindVertInfo(cmd, host_buffer.EmplaceUniform(vert_info));

impeller/entity/contents/vertices_contents.cc

@@ -72,7 +72,8 @@ bool VerticesContents::Render(const ContentContext& renderer,
 
       auto geometry_result = geometry_->GetPositionBuffer(
           allocator, host_buffer, renderer.GetTessellator(),
-          pass.GetRenderTargetSize());
+          pass.GetRenderTargetSize(),
+          entity.GetTransformation().GetMaxBasisLength());
       cmd.pipeline = renderer.GetGeometryPositionPipeline(
           OptionsFromPassAndEntity(pass, entity));
       cmd.primitive_type = geometry_result.type;

impeller/entity/geometry.cc

@@ -48,7 +48,8 @@ GeometryResult VerticesGeometry::GetPositionBuffer(
     std::shared_ptr<Allocator> device_allocator,
     HostBuffer& host_buffer,
     std::shared_ptr<Tessellator> tessellator,
-    ISize render_target_size) {
+    ISize render_target_size,
+    Scalar max_basis_length) {
   if (!vertices_.IsValid()) {
     return {};
   }
@@ -182,10 +183,12 @@ GeometryResult PathGeometry::GetPositionBuffer(
     std::shared_ptr<Allocator> device_allocator,
     HostBuffer& host_buffer,
     std::shared_ptr<Tessellator> tessellator,
-    ISize render_target_size) {
+    ISize render_target_size,
+    Scalar max_basis_length) {
   VertexBuffer vertex_buffer;
   auto tesselation_result = tessellator->Tessellate(
-      path_.GetFillType(), path_.CreatePolyline(),
+      path_.GetFillType(),
+      path_.CreatePolyline(kDefaultCurveTolerance / max_basis_length),
       [&vertex_buffer, &host_buffer](
           const float* vertices, size_t vertices_count, const uint16_t* indices,
           size_t indices_count) {
@@ -244,7 +247,8 @@ GeometryResult CoverGeometry::GetPositionBuffer(
     std::shared_ptr<Allocator> device_allocator,
     HostBuffer& host_buffer,
     std::shared_ptr<Tessellator> tessellator,
-    ISize render_target_size) {
+    ISize render_target_size,
+    Scalar max_basis_length) {
   auto rect = Rect(Size(render_target_size));
   constexpr uint16_t kRectIndicies[4] = {0, 1, 2, 3};
   return GeometryResult{

impeller/entity/geometry.h

@@ -43,7 +43,8 @@ class Geometry {
       std::shared_ptr<Allocator> device_allocator,
       HostBuffer& host_buffer,
       std::shared_ptr<Tessellator> tessellator,
-      ISize render_target_size) = 0;
+      ISize render_target_size,
+      Scalar max_basis_length) = 0;
 
   virtual GeometryResult GetPositionColorBuffer(
       std::shared_ptr<Allocator> device_allocator,
@@ -75,7 +76,8 @@ class VerticesGeometry : public Geometry {
   GeometryResult GetPositionBuffer(std::shared_ptr<Allocator> device_allocator,
                                    HostBuffer& host_buffer,
                                    std::shared_ptr<Tessellator> tessellator,
-                                   ISize render_target_size) override;
+                                   ISize render_target_size,
+                                   Scalar max_basis_length) override;
 
   // |Geometry|
   GeometryResult GetPositionColorBuffer(
@@ -115,7 +117,8 @@ class PathGeometry : public Geometry {
   GeometryResult GetPositionBuffer(std::shared_ptr<Allocator> device_allocator,
                                    HostBuffer& host_buffer,
                                    std::shared_ptr<Tessellator> tessellator,
-                                   ISize render_target_size) override;
+                                   ISize render_target_size,
+                                   Scalar max_basis_length) override;
 
   // |Geometry|
   GeometryResult GetPositionColorBuffer(
@@ -156,7 +159,8 @@ class CoverGeometry : public Geometry {
   GeometryResult GetPositionBuffer(std::shared_ptr<Allocator> device_allocator,
                                    HostBuffer& host_buffer,
                                    std::shared_ptr<Tessellator> tessellator,
-                                   ISize render_target_size) override;
+                                   ISize render_target_size,
+                                   Scalar max_basis_length) override;
 
   // |Geometry|
   GeometryResult GetPositionColorBuffer(

impeller/geometry/geometry_unittests.cc

@@ -17,6 +17,7 @@
 #include "impeller/geometry/rect.h"
 #include "impeller/geometry/scalar.h"
 #include "impeller/geometry/size.h"
+#include "path_component.h"
 
 namespace impeller {
 namespace testing {
@@ -1426,8 +1427,7 @@ TEST(GeometryTest, RectGetPositive) {
 
 TEST(GeometryTest, CubicPathComponentPolylineDoesNotIncludePointOne) {
   CubicPathComponent component({10, 10}, {20, 35}, {35, 20}, {40, 40});
-  SmoothingApproximation approximation;
-  auto polyline = component.CreatePolyline(approximation);
+  auto polyline = component.CreatePolyline();
   ASSERT_NE(polyline.front().x, 10);
   ASSERT_NE(polyline.front().y, 10);
   ASSERT_EQ(polyline.back().x, 40);

impeller/geometry/path.cc

@@ -221,8 +221,7 @@ bool Path::UpdateContourComponentAtIndex(size_t index,
   return true;
 }
 
-Path::Polyline Path::CreatePolyline(
-    const SmoothingApproximation& approximation) const {
+Path::Polyline Path::CreatePolyline(Scalar tolerance) const {
   Polyline polyline;
 
   std::optional<Point> previous_contour_point;
@@ -251,10 +250,10 @@ Path::Polyline Path::CreatePolyline(
         collect_points(linears_[component.index].CreatePolyline());
         break;
       case ComponentType::kQuadratic:
-        collect_points(quads_[component.index].CreatePolyline(approximation));
+        collect_points(quads_[component.index].CreatePolyline(tolerance));
         break;
       case ComponentType::kCubic:
-        collect_points(cubics_[component.index].CreatePolyline(approximation));
+        collect_points(cubics_[component.index].CreatePolyline(tolerance));
         break;
       case ComponentType::kContour:
         if (component_i == components_.size() - 1) {

impeller/geometry/path.h

@@ -117,8 +117,7 @@ class Path {
   bool UpdateContourComponentAtIndex(size_t index,
                                      const ContourComponent& contour);
 
-  Polyline CreatePolyline(
-      const SmoothingApproximation& approximation = {}) const;
+  Polyline CreatePolyline(Scalar tolerance = kDefaultCurveTolerance) const;
 
   std::optional<Rect> GetBoundingBox() const;