perpendicular round rects; fuzzy convexity

src/core/SkGeometry.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 "SkGeometry.h"
@@ skipping 1238 matching lines @@
             (base[0] > base[4] && value < base[2]))   // should root have been 1
         {
             dest[0] = quad[1];
             dest[1].set(x, y);
             return true;
         }
     }
     return false;
 }
 
-#ifdef SK_SCALAR_IS_FLOAT
+static const SkPoint gQuadCirclePts[kSkBuildQuadArcStorage] = {
+// The mid point of the quadratic arc approximation is half way between the two
+// control points. The float epsilon adjustment moves the on curve point out by
+// two bits, distributing the convex test error between the round rect approximation
+// and the convex cross product sign equality test.
+#define SK_MID_RRECT_OFFSET (SK_Scalar1 + SK_ScalarTanPIOver8 + FLT_EPSILON * 4) / 2

[reed1, 2013/10/29 20:50:06]

static const SkScalar gMidRRectOffset = ...;

is that just as efficient? If so, it might be more readable than a #define
(followed by an undef).

+    { SK_Scalar1,            0                      },
+    { SK_Scalar1,            SK_ScalarTanPIOver8    },
+    { SK_MID_RRECT_OFFSET,   SK_MID_RRECT_OFFSET    },
+    { SK_ScalarTanPIOver8,   SK_Scalar1             },
 
-// Due to floating point issues (i.e., 1.0f - SK_ScalarRoot2Over2 !=
-// SK_ScalarRoot2Over2 - SK_ScalarTanPIOver8), the "correct" off curve
-// control points cause the quadratic circle approximation to be concave.
-// SK_OffEps is used to pull in the off-curve control points a bit
-// to make the quadratic approximation convex.
-// Pulling the off-curve controls points in is preferable to pushing some
-// of the on-curve points off.
-#define SK_OffEps 0.0001f
-#else
-#define SK_OffEps 0
-#endif
+    { 0,                     SK_Scalar1             },
+    { -SK_ScalarTanPIOver8,  SK_Scalar1             },
+    { -SK_MID_RRECT_OFFSET,  SK_MID_RRECT_OFFSET    },
+    { -SK_Scalar1,           SK_ScalarTanPIOver8    },
 
+    { -SK_Scalar1,           0                      },
+    { -SK_Scalar1,           -SK_ScalarTanPIOver8   },
+    { -SK_MID_RRECT_OFFSET,  -SK_MID_RRECT_OFFSET   },
+    { -SK_ScalarTanPIOver8,  -SK_Scalar1            },
 
-static const SkPoint gQuadCirclePts[kSkBuildQuadArcStorage] = {
-    { SK_Scalar1,                      0                                  },
-    { SK_Scalar1 - SK_OffEps,          SK_ScalarTanPIOver8 - SK_OffEps    },
-    { SK_ScalarRoot2Over2,             SK_ScalarRoot2Over2                },
-    { SK_ScalarTanPIOver8 - SK_OffEps, SK_Scalar1 - SK_OffEps             },
+    { 0,                     -SK_Scalar1            },
+    { SK_ScalarTanPIOver8,   -SK_Scalar1            },
+    { SK_MID_RRECT_OFFSET,   -SK_MID_RRECT_OFFSET   },
+    { SK_Scalar1,            -SK_ScalarTanPIOver8   },
 
-    { 0,                               SK_Scalar1                         },
-    { -SK_ScalarTanPIOver8 + SK_OffEps,SK_Scalar1 - SK_OffEps             },
-    { -SK_ScalarRoot2Over2,            SK_ScalarRoot2Over2                },
-    { -SK_Scalar1 + SK_OffEps,         SK_ScalarTanPIOver8 - SK_OffEps    },
-
-    { -SK_Scalar1,                     0                                  },
-    { -SK_Scalar1 + SK_OffEps,         -SK_ScalarTanPIOver8 + SK_OffEps   },
-    { -SK_ScalarRoot2Over2,            -SK_ScalarRoot2Over2               },
-    { -SK_ScalarTanPIOver8 + SK_OffEps,-SK_Scalar1 + SK_OffEps            },
-
-    { 0,                               -SK_Scalar1                        },
-    { SK_ScalarTanPIOver8 - SK_OffEps, -SK_Scalar1 + SK_OffEps            },
-    { SK_ScalarRoot2Over2,             -SK_ScalarRoot2Over2               },
-    { SK_Scalar1 - SK_OffEps,          -SK_ScalarTanPIOver8 + SK_OffEps   },
-
-    { SK_Scalar1,                      0                                  }
+    { SK_Scalar1,            0                      }
+#undef SK_MID_RRECT_OFFSET
 };
 
 int SkBuildQuadArc(const SkVector& uStart, const SkVector& uStop,
                    SkRotationDirection dir, const SkMatrix* userMatrix,
                    SkPoint quadPoints[])
 {
     // rotate by x,y so that uStart is (1.0)
     SkScalar x = SkPoint::DotProduct(uStart, uStop);
     SkScalar y = SkPoint::CrossProduct(uStart, uStop);
 
@@ skipping 344 matching lines @@
     }
     if (this->findYExtrema(&t)) {
         this->evalAt(t, &pts[count++]);
     }
     bounds->set(pts, count);
 }
 
 void SkConic::computeFastBounds(SkRect* bounds) const {
     bounds->set(fPts, 3);
 }