addressing comments

Author: chunhtai

impeller/core/formats.h

@@ -351,7 +351,7 @@ enum class PrimitiveType {
   /// [ABC].
   kLineStrip,
 
-  /// Draws a point at each input vertices.
+  /// Draws a point at each input vertex.
   kPoint,
   // Triangle fans are implementation dependent and need extra extensions
   // checks. Hence, they are not supported here.

impeller/entity/geometry/stroke_path_geometry.cc

@@ -253,7 +253,7 @@ StrokePathGeometry::CreateSolidStrokeVertices(
   for (size_t contour_i = 0; contour_i < polyline.contours.size();
        contour_i++) {
     auto contour = polyline.contours[contour_i];
-    size_t contour_section = 0;
+    size_t contour_component_i = 0;
     size_t contour_start_point_i, contour_end_point_i;
     std::tie(contour_start_point_i, contour_end_point_i) =
         polyline.GetContourPointBounds(contour_i);
@@ -309,11 +309,11 @@ StrokePathGeometry::CreateSolidStrokeVertices(
     // Generate contour geometry.
     for (size_t point_i = contour_start_point_i + 1;
          point_i < contour_end_point_i; point_i++) {
-      if ((contour_section + 1 >= contour.sections.size()) &&
-          contour.sections[contour_section + 1].section_start_index <=
+      if ((contour_component_i + 1 >= contour.components.size()) &&
+          contour.components[contour_component_i + 1].component_start_index <=
               point_i) {
-        // The point_i has entered the next section in this contour.
-        contour_section += 1;
+        // The point_i has entered the next component in this contour.
+        contour_component_i += 1;
       }
       // Generate line rect.
       vtx.position = polyline.points[point_i - 1] + offset;
@@ -323,9 +323,9 @@ StrokePathGeometry::CreateSolidStrokeVertices(
 
       auto is_end_of_contour = point_i == contour_end_point_i - 1;
 
-      if (!contour.sections[contour_section].is_curve) {
-        /// Add two end points of the line rect to draw a solid
-        /// straight line.
+      if (!contour.components[contour_component_i].is_curve) {
+        // For line components, two additional points need to be appended prior
+        // to appending a join connecting the next component.
         vtx.position = polyline.points[point_i] + offset;
         vtx_builder.AppendVertex(vtx);
         vtx.position = polyline.points[point_i] - offset;
@@ -338,9 +338,8 @@ StrokePathGeometry::CreateSolidStrokeVertices(
                     offset, scaled_miter_limit, scale);
         }
       } else {
-        // Curve sections don't require the two end points of the line rects
-        // assuming the angles between of a continous two points are close
-        // enough.
+        // For curve components, the polyline is detailed enough such that
+        // it can avoid worrying about joins altogether.
         if (!is_end_of_contour) {
           compute_offset(point_i + 1);
         } else {

impeller/geometry/path.cc

@@ -324,10 +324,10 @@ Path::Polyline Path::CreatePolyline(Scalar scale) const {
         return Vector2(0, -1);
       };
 
-  std::vector<PolylineContour::Section> sections;
+  std::vector<PolylineContour::Component> components;
   std::optional<size_t> previous_path_component_index;
   auto end_contour = [&polyline, &previous_path_component_index,
-                      &get_path_component, &sections]() {
+                      &get_path_component, &components]() {
     // Whenever a contour has ended, extract the exact end direction from the
     // last component.
     if (polyline.contours.empty()) {
@@ -340,8 +340,8 @@ Path::Polyline Path::CreatePolyline(Scalar scale) const {
 
     auto& contour = polyline.contours.back();
     contour.end_direction = Vector2(0, 1);
-    contour.sections = sections;
-    sections.clear();
+    contour.components = components;
+    components.clear();
 
     size_t previous_index = previous_path_component_index.value();
     while (!std::holds_alternative<std::monostate>(
@@ -366,24 +366,24 @@ Path::Polyline Path::CreatePolyline(Scalar scale) const {
     const auto& component = components_[component_i];
     switch (component.type) {
       case ComponentType::kLinear:
-        sections.push_back({
-            .section_start_index = polyline.points.size(),
+        components.push_back({
+            .component_start_index = polyline.points.size(),
             .is_curve = false,
         });
         collect_points(linears_[component.index].CreatePolyline());
         previous_path_component_index = component_i;
         break;
       case ComponentType::kQuadratic:
-        sections.push_back({
-            .section_start_index = polyline.points.size(),
+        components.push_back({
+            .component_start_index = polyline.points.size(),
             .is_curve = true,
         });
         collect_points(quads_[component.index].CreatePolyline(scale));
         previous_path_component_index = component_i;
         break;
       case ComponentType::kCubic:
-        sections.push_back({
-            .section_start_index = polyline.points.size(),
+        components.push_back({
+            .component_start_index = polyline.points.size(),
             .is_curve = true,
         });
         collect_points(cubics_[component.index].CreatePolyline(scale));
@@ -402,7 +402,7 @@ Path::Polyline Path::CreatePolyline(Scalar scale) const {
         polyline.contours.push_back({.start_index = polyline.points.size(),
                                      .is_closed = contour.is_closed,
                                      .start_direction = start_direction,
-                                     .sections = sections});
+                                     .components = components});
         previous_contour_point = std::nullopt;
         collect_points({contour.destination});
         break;

impeller/geometry/path.h

@@ -61,11 +61,11 @@ class Path {
   };
 
   struct PolylineContour {
-    struct Section {
-      size_t section_start_index;
-      /// Denotes whether this section is a curve.
+    struct Component {
+      size_t component_start_index;
+      /// Denotes whether this component is a curve.
       ///
-      /// This is set to true when this section is generated from
+      /// This is set to true when this component is generated from
       /// QuadraticComponent or CubicPathComponent.
       bool is_curve;
     };
@@ -81,11 +81,11 @@ class Path {
     /// The direction of the contour's end cap.
     Vector2 end_direction;
 
-    /// Distinct sections in this contour.
+    /// Distinct components in this contour.
     ///
     /// If this contour is generated from multiple path components, each
-    /// component forms a section.
-    std::vector<Section> sections;
+    /// path component forms a component in this vector.
+    std::vector<Component> components;
   };
 
   /// One or more contours represented as a series of points and indices in

impeller/geometry/path_component.h

@@ -47,7 +47,7 @@ struct LinearPathComponent {
   std::optional<Vector2> GetEndDirection() const;
 };
 
-// A component represets a Quadratic Bézier curve.
+// A component that represets a Quadratic Bézier curve.
 struct QuadraticPathComponent {
   // Start point.
   Point p1;
@@ -91,7 +91,7 @@ struct QuadraticPathComponent {
   std::optional<Vector2> GetEndDirection() const;
 };
 
-// A component represets a Cubic Bézier curve.
+// A component that represets a Cubic Bézier curve.
 struct CubicPathComponent {
   // Start point.
   Point p1;