Fix cubic->quad RR corner regression

src/core/SkPath.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 "SkBuffer.h"
 #include "SkErrorInternals.h"
 #include "SkMath.h"
 #include "SkPath.h"
 #include "SkPathRef.h"
 #include "SkRRect.h"
 #include "SkThread.h"
 
 SK_DEFINE_INST_COUNT(SkPath);
 
-#define SK_IGNORE_QUAD_RR_CORNERS_OPT 1
-
 // This value is just made-up for now. When count is 4, calling memset was much
 // slower than just writing the loop. This seems odd, and hopefully in the
 // future this we appear to have been a fluke...
 #define MIN_COUNT_FOR_MEMSET_TO_BE_FAST 16
 
 ////////////////////////////////////////////////////////////////////////////
 
 /**
  *  Path.bounds is defined to be the bounds of all the control points.
  *  If we called bounds.join(r) we would skip r if r was empty, which breaks
@@ skipping 927 matching lines @@
     matrix.postTranslate(oval.centerX(), oval.centerY());
 
     return SkBuildQuadArc(start, stop,
                           sweepAngle > 0 ? kCW_SkRotationDirection :
                                            kCCW_SkRotationDirection,
                           &matrix, pts);
 }
 
 static void add_corner_arc(SkPath* path, const SkRect& rect,
                            SkScalar rx, SkScalar ry, int startAngle,
-                           SkPath::Direction dir, bool addArcTo,
-                           bool forceMoveTo = false) {
+                           SkPath::Direction dir, bool forceMoveTo) {
     // These two asserts are not sufficient, since really we want to know
     // that the pair of radii (e.g. left and right, or top and bottom) sum
     // to <= dimension, but we don't have that data here, so we just have
     // these conservative asserts.
     SkASSERT(0 <= rx && rx <= rect.width());
     SkASSERT(0 <= ry && ry <= rect.height());
 
     SkRect   r;
     r.set(-rx, -ry, rx, ry);
 
     switch (startAngle) {
         case   0:
             r.offset(rect.fRight - r.fRight, rect.fBottom - r.fBottom);
             break;
         case  90:
             r.offset(rect.fLeft - r.fLeft,   rect.fBottom - r.fBottom);
             break;
         case 180: r.offset(rect.fLeft - r.fLeft,   rect.fTop - r.fTop); break;
         case 270: r.offset(rect.fRight - r.fRight, rect.fTop - r.fTop); break;
         default: SkDEBUGFAIL("unexpected startAngle in add_corner_arc");
     }
 
     SkScalar start = SkIntToScalar(startAngle);
     SkScalar sweep = SkIntToScalar(90);
     if (SkPath::kCCW_Direction == dir) {
         start += sweep;
         sweep = -sweep;
     }
 
-    if (addArcTo) {
-        path->arcTo(r, start, sweep, forceMoveTo);
-    } else {
-        SkPoint pts[kSkBuildQuadArcStorage];
-        int count = build_arc_points(r, start, sweep, pts);
-        for (int i = 1; i < count; i += 2) {
-            path->quadTo(pts[i], pts[i+1]);
-        }
-    }
+    path->arcTo(r, start, sweep, forceMoveTo);
 }
 
 void SkPath::addRoundRect(const SkRect& rect, const SkScalar radii[],
                           Direction dir) {
     SkRRect rrect;
     rrect.setRectRadii(rect, (const SkVector*) radii);
     this->addRRect(rrect, dir);
 }
 
 void SkPath::addRRect(const SkRRect& rrect, Direction dir) {
     assert_known_direction(dir);
 
     if (rrect.isEmpty()) {
         return;
     }
 
     const SkRect& bounds = rrect.getBounds();
 
     if (rrect.isRect()) {
         this->addRect(bounds, dir);
     } else if (rrect.isOval()) {
         this->addOval(bounds, dir);
     } else if (rrect.isSimple()) {
         const SkVector& rad = rrect.getSimpleRadii();
         this->addRoundRect(bounds, rad.x(), rad.y(), dir);
     } else {
         SkAutoPathBoundsUpdate apbu(this, bounds);
 
         if (kCW_Direction == dir) {
-            add_corner_arc(this, bounds, rrect.fRadii[0].fX, rrect.fRadii[0].fY, 180, dir, true, true);
-            add_corner_arc(this, bounds, rrect.fRadii[1].fX, rrect.fRadii[1].fY, 270, dir, true);
-            add_corner_arc(this, bounds, rrect.fRadii[2].fX, rrect.fRadii[2].fY,   0, dir, true);
-            add_corner_arc(this, bounds, rrect.fRadii[3].fX, rrect.fRadii[3].fY,  90, dir, true);
+            add_corner_arc(this, bounds, rrect.fRadii[0].fX, rrect.fRadii[0].fY, 180, dir, true);
+            add_corner_arc(this, bounds, rrect.fRadii[1].fX, rrect.fRadii[1].fY, 270, dir, false);
+            add_corner_arc(this, bounds, rrect.fRadii[2].fX, rrect.fRadii[2].fY,   0, dir, false);
+            add_corner_arc(this, bounds, rrect.fRadii[3].fX, rrect.fRadii[3].fY,  90, dir, false);
         } else {
-            add_corner_arc(this, bounds, rrect.fRadii[0].fX, rrect.fRadii[0].fY, 180, dir, true, true);
-            add_corner_arc(this, bounds, rrect.fRadii[3].fX, rrect.fRadii[3].fY,  90, dir, true);
-            add_corner_arc(this, bounds, rrect.fRadii[2].fX, rrect.fRadii[2].fY,   0, dir, true);
-            add_corner_arc(this, bounds, rrect.fRadii[1].fX, rrect.fRadii[1].fY, 270, dir, true);
+            add_corner_arc(this, bounds, rrect.fRadii[0].fX, rrect.fRadii[0].fY, 180, dir, true);
+            add_corner_arc(this, bounds, rrect.fRadii[3].fX, rrect.fRadii[3].fY,  90, dir, false);
+            add_corner_arc(this, bounds, rrect.fRadii[2].fX, rrect.fRadii[2].fY,   0, dir, false);
+            add_corner_arc(this, bounds, rrect.fRadii[1].fX, rrect.fRadii[1].fY, 270, dir, false);
         }
         this->close();
     }
 }
 
 bool SkPath::hasOnlyMoveTos() const {
     int count = fPathRef->countVerbs();
     const uint8_t* verbs = const_cast<const SkPathRef*>(fPathRef.get())->verbsMemBegin();
     for (int i = 0; i < count; ++i) {
         if (*verbs == kLine_Verb ||
@@ skipping 49 matching lines @@
     } else if (skip_vert) {
         ry = halfH;
     }
 
 #ifdef SK_IGNORE_QUAD_RR_CORNERS_OPT
     SkScalar    sx = SkScalarMul(rx, CUBIC_ARC_FACTOR);
     SkScalar    sy = SkScalarMul(ry, CUBIC_ARC_FACTOR);
 
     this->incReserve(17);
 #else
-    this->incReserve(13);
+    // Please see SkBuildQuadArc for more information but, we need to pull
+    // the off-curve quadratic points in a little bit to make the round
+    // rects convex.
+    static const SkScalar kOffCurveEpsilon = 0.0001f;
+
+    SkScalar    midPtX = rx * SK_ScalarRoot2Over2;
+    SkScalar    midPtY = ry * SK_ScalarRoot2Over2;
+
+    SkScalar    offPtX = rx * SK_ScalarTanPIOver8 - kOffCurveEpsilon;
+    SkScalar    offPtY = ry * SK_ScalarTanPIOver8 - kOffCurveEpsilon;
+
+    this->incReserve(21);
 #endif
-    this->moveTo(rect.fRight - rx, rect.fTop);
+    this->moveTo(rect.fRight - rx, rect.fTop);                  // top-right
     if (dir == kCCW_Direction) {
         if (!skip_hori) {
             this->lineTo(rect.fLeft + rx, rect.fTop);           // top
         }
 #ifdef SK_IGNORE_QUAD_RR_CORNERS_OPT
         this->cubicTo(rect.fLeft + rx - sx, rect.fTop,
                       rect.fLeft, rect.fTop + ry - sy,
                       rect.fLeft, rect.fTop + ry);          // top-left
 #else
-        add_corner_arc(this, rect, rx, ry, 180, dir, false);    // top-left
+        this->quadTo(rect.fLeft + rx - offPtX, rect.fTop + kOffCurveEpsilon,
+                     rect.fLeft + rx - midPtX, rect.fTop + ry - midPtY);
+        this->quadTo(rect.fLeft + kOffCurveEpsilon, rect.fTop + ry - offPtY,
+                     rect.fLeft, rect.fTop + ry);
 #endif
         if (!skip_vert) {
             this->lineTo(rect.fLeft, rect.fBottom - ry);        // left
         }
 #ifdef SK_IGNORE_QUAD_RR_CORNERS_OPT
         this->cubicTo(rect.fLeft, rect.fBottom - ry + sy,
                       rect.fLeft + rx - sx, rect.fBottom,
                       rect.fLeft + rx, rect.fBottom);       // bot-left
 #else
-        add_corner_arc(this, rect, rx, ry, 90, dir, false);     // bot-left
+        this->quadTo(rect.fLeft + kOffCurveEpsilon, rect.fBottom - ry + offPtY,
+                     rect.fLeft + rx - midPtX, rect.fBottom - ry + midPtY);
+        this->quadTo(rect.fLeft + rx - offPtX, rect.fBottom - kOffCurveEpsilon,
+                     rect.fLeft + rx, rect.fBottom);
 #endif
         if (!skip_hori) {
             this->lineTo(rect.fRight - rx, rect.fBottom);       // bottom
         }
 #ifdef SK_IGNORE_QUAD_RR_CORNERS_OPT
         this->cubicTo(rect.fRight - rx + sx, rect.fBottom,
                       rect.fRight, rect.fBottom - ry + sy,
                       rect.fRight, rect.fBottom - ry);      // bot-right
 #else
-        add_corner_arc(this, rect, rx, ry, 0, dir, false);      // bot-right
+        this->quadTo(rect.fRight - rx + offPtX, rect.fBottom - kOffCurveEpsilon,
+                     rect.fRight - rx + midPtX, rect.fBottom - ry + midPtY);
+        this->quadTo(rect.fRight - kOffCurveEpsilon, rect.fBottom - ry + offPtY,
+                     rect.fRight, rect.fBottom - ry);
 #endif
         if (!skip_vert) {
             this->lineTo(rect.fRight, rect.fTop + ry);          // right
         }
 #ifdef SK_IGNORE_QUAD_RR_CORNERS_OPT
         this->cubicTo(rect.fRight, rect.fTop + ry - sy,
                       rect.fRight - rx + sx, rect.fTop,
                       rect.fRight - rx, rect.fTop);         // top-right
 #else
-        add_corner_arc(this, rect, rx, ry, 270, dir, false);    // top-right
+        this->quadTo(rect.fRight - kOffCurveEpsilon, rect.fTop + ry - offPtY,
+                     rect.fRight - rx + midPtX, rect.fTop + ry - midPtY);
+        this->quadTo(rect.fRight - rx + offPtX, rect.fTop + kOffCurveEpsilon,
+                     rect.fRight - rx, rect.fTop);
 #endif
     } else {
 #ifdef SK_IGNORE_QUAD_RR_CORNERS_OPT
         this->cubicTo(rect.fRight - rx + sx, rect.fTop,
                       rect.fRight, rect.fTop + ry - sy,
                       rect.fRight, rect.fTop + ry);         // top-right
 #else
-        add_corner_arc(this, rect, rx, ry, 270, dir, false);    // top-right
+        this->quadTo(rect.fRight - rx + offPtX, rect.fTop + kOffCurveEpsilon,
+                     rect.fRight - rx + midPtX, rect.fTop + ry - midPtY);
+        this->quadTo(rect.fRight - kOffCurveEpsilon, rect.fTop + ry - offPtY,
+                     rect.fRight, rect.fTop + ry);
 #endif
         if (!skip_vert) {
             this->lineTo(rect.fRight, rect.fBottom - ry);       // right
         }
 #ifdef SK_IGNORE_QUAD_RR_CORNERS_OPT
         this->cubicTo(rect.fRight, rect.fBottom - ry + sy,
                       rect.fRight - rx + sx, rect.fBottom,
                       rect.fRight - rx, rect.fBottom);      // bot-right
 #else
-        add_corner_arc(this, rect, rx, ry, 0, dir, false);      // bot-right
+        this->quadTo(rect.fRight - kOffCurveEpsilon, rect.fBottom - ry + offPtY,
+                     rect.fRight - rx + midPtX, rect.fBottom - ry + midPtY);
+        this->quadTo(rect.fRight - rx + offPtX, rect.fBottom - kOffCurveEpsilon,
+                     rect.fRight - rx, rect.fBottom);
 #endif
         if (!skip_hori) {
             this->lineTo(rect.fLeft + rx, rect.fBottom);        // bottom
         }
 #ifdef SK_IGNORE_QUAD_RR_CORNERS_OPT
         this->cubicTo(rect.fLeft + rx - sx, rect.fBottom,
                       rect.fLeft, rect.fBottom - ry + sy,
                       rect.fLeft, rect.fBottom - ry);       // bot-left
 #else
-        add_corner_arc(this, rect, rx, ry, 90, dir, false);     // bot-left
+        this->quadTo(rect.fLeft + rx - offPtX, rect.fBottom - kOffCurveEpsilon,
+                     rect.fLeft + rx - midPtX, rect.fBottom - ry + midPtY);
+        this->quadTo(rect.fLeft + kOffCurveEpsilon, rect.fBottom - ry + offPtY,
+                     rect.fLeft, rect.fBottom - ry);
 #endif
         if (!skip_vert) {
             this->lineTo(rect.fLeft, rect.fTop + ry);           // left
         }
 #ifdef SK_IGNORE_QUAD_RR_CORNERS_OPT
         this->cubicTo(rect.fLeft, rect.fTop + ry - sy,
                       rect.fLeft + rx - sx, rect.fTop,
                       rect.fLeft + rx, rect.fTop);          // top-left
 #else
-        add_corner_arc(this, rect, rx, ry, 180, dir, false);    // top-left
+        this->quadTo(rect.fLeft + kOffCurveEpsilon, rect.fTop + ry - offPtY,
+                     rect.fLeft + rx - midPtX, rect.fTop + ry - midPtY);
+        this->quadTo(rect.fLeft + rx - offPtX, rect.fTop + kOffCurveEpsilon,
+                     rect.fLeft + rx, rect.fTop);
 #endif
         if (!skip_hori) {
             this->lineTo(rect.fRight - rx, rect.fTop);          // top
         }
     }
     this->close();
 }
 
 void SkPath::addOval(const SkRect& oval, Direction dir) {
     assert_known_direction(dir);
@@ skipping 1771 matching lines @@
     switch (this->getFillType()) {
         case SkPath::kEvenOdd_FillType:
         case SkPath::kInverseEvenOdd_FillType:
             w &= 1;
             break;
         default:
             break;
     }
     return SkToBool(w);
 }