Use conics for round joins and caps

src/core/SkStrokerPriv.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkStrokerPriv.h"
 #include "SkGeometry.h"
 #include "SkPath.h"
 
 static void ButtCapper(SkPath* path, const SkPoint& pivot,
                        const SkVector& normal, const SkPoint& stop,
                        SkPath*)
 {
     path->lineTo(stop.fX, stop.fY);
 }
 
 static void RoundCapper(SkPath* path, const SkPoint& pivot,
                         const SkVector& normal, const SkPoint& stop,
                         SkPath*)
 {
+#ifdef SK_SUPPORT_LEGACY_ARCTO_QUADS
     SkScalar    px = pivot.fX;
     SkScalar    py = pivot.fY;
     SkScalar    nx = normal.fX;
     SkScalar    ny = normal.fY;
     SkScalar    sx = SkScalarMul(nx, CUBIC_ARC_FACTOR);
     SkScalar    sy = SkScalarMul(ny, CUBIC_ARC_FACTOR);
 
     path->cubicTo(px + nx + CWX(sx, sy), py + ny + CWY(sx, sy),
                   px + CWX(nx, ny) + sx, py + CWY(nx, ny) + sy,
                   px + CWX(nx, ny), py + CWY(nx, ny));
     path->cubicTo(px + CWX(nx, ny) - sx, py + CWY(nx, ny) - sy,
                   px - nx + CWX(sx, sy), py - ny + CWY(sx, sy),
                   stop.fX, stop.fY);
+#else
+    SkVector parallel;
+    normal.rotateCW(&parallel);
+
+    SkPoint projectedCenter = pivot + parallel;
+
+    path->conicTo(projectedCenter + normal, projectedCenter, SK_ScalarRoot2Over2);
+    path->conicTo(projectedCenter - normal, stop, SK_ScalarRoot2Over2);
+#endif
 }
 
 static void SquareCapper(SkPath* path, const SkPoint& pivot,
                          const SkVector& normal, const SkPoint& stop,
                          SkPath* otherPath)
 {
     SkVector parallel;
     normal.rotateCW(&parallel);
 
     if (otherPath)
@@ skipping 81 matching lines @@
     SkRotationDirection dir = kCW_SkRotationDirection;
 
     if (!is_clockwise(before, after))
     {
         SkTSwap<SkPath*>(outer, inner);
         before.negate();
         after.negate();
         dir = kCCW_SkRotationDirection;
     }
 
-    SkPoint     pts[kSkBuildQuadArcStorage];
     SkMatrix    matrix;
     matrix.setScale(radius, radius);
     matrix.postTranslate(pivot.fX, pivot.fY);
+#ifdef SK_SUPPORT_LEGACY_ARCTO_QUADS
+    SkPoint     pts[kSkBuildQuadArcStorage];
     int count = SkBuildQuadArc(before, after, dir, &matrix, pts);
     SkASSERT((count & 1) == 1);
-
-    if (count > 1)
-    {
-        for (int i = 1; i < count; i += 2)
+    if (count > 1) {
+        for (int i = 1; i < count; i += 2) {
             outer->quadTo(pts[i].fX, pts[i].fY, pts[i+1].fX, pts[i+1].fY);
-
+        }
         after.scale(radius);
         HandleInnerJoin(inner, pivot, after);
     }
+#else
+    SkConic conics[SkConic::kMaxConicsForArc];
+    int count = SkConic::BuildUnitArc(before, after, dir, &matrix, conics);
+    if (count > 0) {
+        for (int i = 0; i < count; ++i) {
+            outer->conicTo(conics[i].fPts[1], conics[i].fPts[2], conics[i].fW);
+        }
+        after.scale(radius);
+        HandleInnerJoin(inner, pivot, after);
+    }
+#endif
 }
 
 #define kOneOverSqrt2   (0.707106781f)
 
 static void MiterJoiner(SkPath* outer, SkPath* inner, const SkVector& beforeUnitNormal,
                         const SkPoint& pivot, const SkVector& afterUnitNormal,
                         SkScalar radius, SkScalar invMiterLimit,
                         bool prevIsLine, bool currIsLine)
 {
     // negate the dot since we're using normals instead of tangents
@@ skipping 87 matching lines @@
 
 SkStrokerPriv::JoinProc SkStrokerPriv::JoinFactory(SkPaint::Join join)
 {
     static const SkStrokerPriv::JoinProc gJoiners[] = {
         MiterJoiner, RoundJoiner, BluntJoiner
     };
 
     SkASSERT((unsigned)join < SkPaint::kJoinCount);
     return gJoiners[join];
 }