[Impeller] use point/line primitve for hairlines.

impeller/display_list/aiks_dl_basic_unittests.cc

@@ -1529,6 +1529,180 @@ TEST_P(AiksTest, PipelineBlendSingleParameter) {
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }
 
+TEST_P(AiksTest, HorizontalHairlinesPixelRegistration) {
+  const DlStrokeCap caps[] = {
+      DlStrokeCap::kButt,
+      DlStrokeCap::kSquare,
+      DlStrokeCap::kRound,
+  };
+
+  DlPaint stroke_paint;
+  stroke_paint.setDrawStyle(DlDrawStyle::kStroke);
+  stroke_paint.setStrokeWidth(0.0f);
+  DlPaint fill_paint;
+  fill_paint.setDrawStyle(DlDrawStyle::kFill);
+
+  const int pad = 5;
+  const int line_length = 20;
+  const int x_pad = line_length + pad;
+  const int y_pad = pad;
+  const int x_test_offset = x_pad * 2 + pad;
+  const int y_test_offset = y_pad + pad * 2;
+
+  auto draw_one = [&stroke_paint, &fill_paint](DlCanvas& canvas,
+                                               DlScalar x_base, DlScalar y_base,
+                                               DlScalar cap_pad) {
+    DlScalar x0 = x_base + cap_pad;
+    DlScalar x1 = x0 + line_length;
+    DlScalar y0 = y_base + 0.5f;
+    DlScalar y1 = y0;
+
+    SkRect expected_rect =
+        SkRect::MakeLTRB(x0 - cap_pad, y0 - 0.5f, x1 + cap_pad, y1 + 0.5f);
+    SkPath expected_path = SkPath::Line({x0, y0}, {x1, y1});
+
+    canvas.DrawLine(DlPoint{x0, y0}, DlPoint{x1, y1}, stroke_paint);
+    if (stroke_paint.getStrokeCap() == DlStrokeCap::kRound) {
+      SkRRect expected_rrect =
+          SkRRect::MakeRectXY(expected_rect, cap_pad, cap_pad);
+      canvas.DrawRRect(expected_rrect.makeOffset(x_pad, 0), fill_paint);
+      canvas.DrawRRect(expected_rrect.makeOffset(0, y_pad), fill_paint);
+    } else {
+      canvas.DrawRect(expected_rect.makeOffset(x_pad, 0), fill_paint);
+      canvas.DrawRect(expected_rect.makeOffset(0, y_pad), fill_paint);
+    }
+    canvas.DrawPath(expected_path.offset(x_pad, y_pad), stroke_paint);
+  };
+
+  DisplayListBuilder builder;
+  builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
+
+  DlScalar x_base = pad;
+  for (auto cap : caps) {
+    DlScalar cap_pad;
+    DlColor color;
+    switch (cap) {
+      case flutter::DlStrokeCap::kButt:
+        color = DlColor::kBlack();
+        cap_pad = 0.0f;
+        break;
+      case flutter::DlStrokeCap::kSquare:
+        color = DlColor::kBlue();
+        cap_pad = 0.5f;
+        break;
+      case flutter::DlStrokeCap::kRound:
+        color = DlColor::kGreen();
+        cap_pad = 0.5f;
+        break;
+    }
+    fill_paint.setColor(color);
+    stroke_paint.setStrokeCap(cap);
+    stroke_paint.setColor(color);
+    DlScalar y_base = pad;
+    for (int i = 0; i <= 10; i++) {
+      DlScalar subpixel_offset = (i / 10.0f);
+
+      DlScalar x = x_base;
+      draw_one(builder, x + subpixel_offset, y_base, cap_pad);
+      x += x_test_offset;
+      draw_one(builder, x, y_base + subpixel_offset, cap_pad);
+
+      y_base += y_test_offset;
+    }
+    x_base += x_test_offset * 2 + pad * 2;
+  }
+
+  auto dl = builder.Build();
+  ASSERT_TRUE(OpenPlaygroundHere(dl));
+}
+
+TEST_P(AiksTest, VerticalHairlinesPixelRegistration) {
+  const DlStrokeCap caps[] = {
+      DlStrokeCap::kButt,
+      DlStrokeCap::kSquare,
+      DlStrokeCap::kRound,
+  };
+
+  DlPaint stroke_paint;
+  stroke_paint.setDrawStyle(DlDrawStyle::kStroke);
+  stroke_paint.setStrokeWidth(0.0f);
+  DlPaint fill_paint;
+  fill_paint.setDrawStyle(DlDrawStyle::kFill);
+
+  const int pad = 5;
+  const int line_length = 20;
+  const int x_pad = pad;
+  const int y_pad = line_length + pad;
+  const int x_test_offset = x_pad + pad * 2;
+  const int y_test_offset = y_pad * 2 + pad;
+
+  auto draw_one = [&stroke_paint, &fill_paint](DlCanvas& canvas,
+                                               DlScalar x_base, DlScalar y_base,
+                                               DlScalar cap_pad) {
+    DlScalar x0 = x_base + 0.5f;
+    DlScalar x1 = x0;
+    DlScalar y0 = y_base + cap_pad;
+    DlScalar y1 = y0 + line_length;
+
+    SkRect expected_rect =
+        SkRect::MakeLTRB(x0 - 0.5f, y0 - cap_pad, x1 + 0.5f, y1 + cap_pad);
+    SkPath expected_path = SkPath::Line({x0, y0}, {x1, y1});
+
+    canvas.DrawLine(DlPoint{x0, y0}, DlPoint{x1, y1}, stroke_paint);
+    if (stroke_paint.getStrokeCap() == DlStrokeCap::kRound) {
+      SkRRect expected_rrect =
+          SkRRect::MakeRectXY(expected_rect, cap_pad, cap_pad);
+      canvas.DrawRRect(expected_rrect.makeOffset(x_pad, 0), fill_paint);
+      canvas.DrawRRect(expected_rrect.makeOffset(0, y_pad), fill_paint);
+    } else {
+      canvas.DrawRect(expected_rect.makeOffset(x_pad, 0), fill_paint);
+      canvas.DrawRect(expected_rect.makeOffset(0, y_pad), fill_paint);
+    }
+    canvas.DrawPath(expected_path.offset(x_pad, y_pad), stroke_paint);
+  };
+
+  DisplayListBuilder builder;
+  builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
+
+  DlScalar y_base = pad;
+  for (auto cap : caps) {
+    DlScalar cap_pad;
+    DlColor color;
+    switch (cap) {
+      case flutter::DlStrokeCap::kButt:
+        color = DlColor::kBlack();
+        cap_pad = 0.0f;
+        break;
+      case flutter::DlStrokeCap::kSquare:
+        color = DlColor::kBlue();
+        cap_pad = 0.5f;
+        break;
+      case flutter::DlStrokeCap::kRound:
+        color = DlColor::kGreen();
+        cap_pad = 0.5f;
+        break;
+    }
+    fill_paint.setColor(color);
+    stroke_paint.setStrokeCap(cap);
+    stroke_paint.setColor(color);
+    DlScalar x_base = pad;
+    for (int i = 0; i <= 10; i++) {
+      DlScalar subpixel_offset = (i / 10.0f);
+
+      DlScalar y = y_base;
+      draw_one(builder, x_base, y + subpixel_offset, cap_pad);
+      y += y_test_offset;
+      draw_one(builder, x_base + subpixel_offset, y, cap_pad);
+
+      x_base += x_test_offset;
+    }
+    y_base += y_test_offset * 2 + pad * 2;
+  }
+
+  auto dl = builder.Build();
+  ASSERT_TRUE(OpenPlaygroundHere(dl));
+}
+
 // Creates an image matrix filter that scales large content such that it would
 // exceed the max texture size. See
 // https://github.com/flutter/flutter/issues/128912

impeller/entity/contents/filters/blend_filter_contents.cc

@@ -27,6 +27,7 @@
 #include "impeller/geometry/color.h"
 #include "impeller/renderer/render_pass.h"
 #include "impeller/renderer/snapshot.h"
+#include "impeller/renderer/vertex_buffer_builder.h"
 
 namespace impeller {
 

impeller/entity/contents/framebuffer_blend_contents.cc

@@ -6,6 +6,7 @@
 
 #include "impeller/entity/contents/content_context.h"
 #include "impeller/renderer/render_pass.h"
+#include "impeller/renderer/vertex_buffer_builder.h"
 
 namespace impeller {
 

impeller/entity/geometry/circle_geometry.cc

@@ -7,7 +7,6 @@
 #include "flutter/impeller/entity/geometry/circle_geometry.h"
 
 #include "flutter/impeller/entity/geometry/line_geometry.h"
-#include "impeller/core/formats.h"
 #include "impeller/entity/geometry/geometry.h"
 
 namespace impeller {
@@ -42,11 +41,12 @@ GeometryResult CircleGeometry::GetPositionBuffer(const ContentContext& renderer,
                                                  RenderPass& pass) const {
   auto& transform = entity.GetTransform();
 
-  Scalar half_width = stroke_width_ < 0
-                          ? 0.0
-                          : LineGeometry::ComputePixelHalfWidth(
-                                transform, stroke_width_,
-                                pass.GetSampleCount() == SampleCount::kCount4);
+  Scalar half_width = 0;
+  if (stroke_width_ > 0) {
+    auto [width, _] = LineGeometry::ComputePixelHalfWidth(
+        transform.GetMaxBasisLengthXY(), stroke_width_);
+    half_width = width;
+  }
 
   const std::shared_ptr<Tessellator>& tessellator = renderer.GetTessellator();
 

impeller/entity/geometry/circle_geometry.h

@@ -9,8 +9,7 @@
 
 namespace impeller {
 
-// Geometry class that can generate vertices (with or without texture
-// coordinates) for either filled or stroked circles
+/// @brief Vertex generator for either filled or stroked circles.
 class CircleGeometry final : public Geometry {
  public:
   explicit CircleGeometry(const Point& center, Scalar radius);

impeller/entity/geometry/geometry.cc

@@ -133,13 +133,11 @@ bool Geometry::CanApplyMaskFilter() const {
 Scalar Geometry::ComputeStrokeAlphaCoverage(const Matrix& transform,
                                             Scalar stroke_width) {
   Scalar scaled_stroke_width = transform.GetMaxBasisLengthXY() * stroke_width;
-  // If the stroke width is 0 or greater than kMinStrokeSizeMSAA, don't apply
-  // any additional alpha. This is intended to match Skia behavior.
-  if (scaled_stroke_width == 0.0 || scaled_stroke_width >= kMinStrokeSizeMSAA) {
+  if (scaled_stroke_width == 0.0 || scaled_stroke_width >= kMinStrokeSize) {
     return 1.0;
   }
   // This scalling is eyeballed from Skia.
-  return std::clamp(scaled_stroke_width * 2.0f, 0.f, 1.f);
+  return std::clamp(scaled_stroke_width, 0.1f, 1.f);
 }
 
 }  // namespace impeller

impeller/entity/geometry/geometry.h

@@ -10,17 +10,11 @@
 #include "impeller/entity/contents/content_context.h"
 #include "impeller/entity/entity.h"
 #include "impeller/renderer/render_pass.h"
-#include "impeller/renderer/vertex_buffer_builder.h"
 
 namespace impeller {
 
 class Tessellator;
 
-/// @brief The minimum stroke size can be less than one physical pixel because
-///        of MSAA, but no less that half a physical pixel otherwise we might
-///        not hit one of the sample positions.
-static constexpr Scalar kMinStrokeSizeMSAA = 0.5f;
-
 static constexpr Scalar kMinStrokeSize = 1.0f;
 
 struct GeometryResult {

impeller/entity/geometry/geometry_unittests.cc

@@ -53,13 +53,13 @@ namespace impeller {
 
 class ImpellerEntityUnitTestAccessor {
  public:
-  static std::vector<SolidFillVertexShader::PerVertexData>
-  GenerateSolidStrokeVertices(const Path::Polyline& polyline,
-                              Scalar stroke_width,
-                              Scalar miter_limit,
-                              Join stroke_join,
-                              Cap stroke_cap,
-                              Scalar scale) {
+  static std::vector<Point> GenerateSolidStrokeVertices(
+      const Path::Polyline& polyline,
+      Scalar stroke_width,
+      Scalar miter_limit,
+      Join stroke_join,
+      Cap stroke_cap,
+      Scalar scale) {
     return StrokePathGeometry::GenerateSolidStrokeVertices(
         polyline, stroke_width, miter_limit, stroke_join, stroke_cap, scale);
   }
@@ -140,14 +140,14 @@ TEST(EntityGeometryTest, AlphaCoverageStrokePaths) {
   auto matrix = Matrix::MakeScale(Vector2{3.0, 3.0});
   EXPECT_EQ(Geometry::MakeStrokePath({}, 0.5)->ComputeAlphaCoverage(matrix), 1);
   EXPECT_NEAR(Geometry::MakeStrokePath({}, 0.1)->ComputeAlphaCoverage(matrix),
-              0.6, 0.05);
-  EXPECT_NEAR(Geometry::MakeStrokePath({}, 0.05)->ComputeAlphaCoverage(matrix),
               0.3, 0.05);
+  EXPECT_NEAR(Geometry::MakeStrokePath({}, 0.05)->ComputeAlphaCoverage(matrix),
+              0.15, 0.05);
   EXPECT_NEAR(Geometry::MakeStrokePath({}, 0.01)->ComputeAlphaCoverage(matrix),
               0.1, 0.1);
   EXPECT_NEAR(
       Geometry::MakeStrokePath({}, 0.0000005)->ComputeAlphaCoverage(matrix),
-      1e-05, 0.001);
+      0.10, 0.001);
   EXPECT_EQ(Geometry::MakeStrokePath({}, 0)->ComputeAlphaCoverage(matrix), 1);
   EXPECT_EQ(Geometry::MakeStrokePath({}, 40)->ComputeAlphaCoverage(matrix), 1);
 }