Add implicit hairline conic rendering to GPU

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 376 matching lines @@
 //  F''(t)  = 2 (a - 2b + c)
 //
 //  A = 2 (b - a)
 //  B = 2 (a - 2b + c)
 //
 //  Maximum curvature for a quadratic means solving
 //  Fx' Fx'' + Fy' Fy'' = 0
 //
 //  t = - (Ax Bx + Ay By) / (Bx ^ 2 + By ^ 2)
 //
-int SkChopQuadAtMaxCurvature(const SkPoint src[3], SkPoint dst[5])
-{
+float SkFindQuadMaxCurvature(const SkPoint src[3]) {
     SkScalar    Ax = src[1].fX - src[0].fX;
     SkScalar    Ay = src[1].fY - src[0].fY;
     SkScalar    Bx = src[0].fX - src[1].fX - src[1].fX + src[2].fX;
     SkScalar    By = src[0].fY - src[1].fY - src[1].fY + src[2].fY;
     SkScalar    t = 0;  // 0 means don't chop
 
 #ifdef SK_SCALAR_IS_FLOAT
     (void)valid_unit_divide(-(Ax * Bx + Ay * By), Bx * Bx + By * By, &t);
 #else
     // !!! should I use SkFloat here? seems like it
@@ skipping 11 matching lines @@
         SkASSERT(!denom.isNeg());
         if (numer < denom)
         {
             t = numer.getFixedDiv(denom);
             SkASSERT(t >= 0 && t <= SK_Fixed1);     // assert that we're numerically stable (ha!)
             if ((unsigned)t >= SK_Fixed1)           // runtime check for numerical stability
                 t = 0;  // ignore the chop
         }
     }
 #endif
+    return t;
+}
 
-    if (t == 0)
-    {
+int SkChopQuadAtMaxCurvature(const SkPoint src[3], SkPoint dst[5])
+{
+    SkScalar t = SkFindQuadMaxCurvature(src);
+    if (t == 0) {
         memcpy(dst, src, 3 * sizeof(SkPoint));
         return 1;
-    }
-    else
-    {
+    } else {
         SkChopQuadAt(src, dst, t);
         return 2;
     }
 }
 
 #ifdef SK_SCALAR_IS_FLOAT
     #define SK_ScalarTwoThirds  (0.666666666f)
 #else
     #define SK_ScalarTwoThirds  ((SkFixed)(43691))
 #endif
@@ skipping 606 matching lines @@
 
 int SkChopCubicAtMaxCurvature(const SkPoint src[4], SkPoint dst[13], SkScalar tValues[3])
 {
     SkScalar    t_storage[3];
 
     if (tValues == NULL)
         tValues = t_storage;
 
     int count = SkFindCubicMaxCurvature(src, tValues);
 
-    if (dst)
-    {
+    if (dst) {
         if (count == 0)
             memcpy(dst, src, 4 * sizeof(SkPoint));
         else
             SkChopCubicAt(src, dst, tValues, count);
     }
     return count + 1;
 }
 
 bool SkXRayCrossesMonotonicCubic(const SkXRay& pt, const SkPoint cubic[4], bool* ambiguous) {
     if (ambiguous) {
@@ skipping 102 matching lines @@
         *ambiguous |= locally_ambiguous;
     }
     if (num_monotonic_cubics > 1)
         if (SkXRayCrossesMonotonicCubic(pt, &monotonic_cubics[6], &locally_ambiguous))
             ++num_crossings;
     if (ambiguous) {
         *ambiguous |= locally_ambiguous;
     }
     return num_crossings;
 }
-
 ////////////////////////////////////////////////////////////////////////////////
 
 /*  Find t value for quadratic [a, b, c] = d.
     Return 0 if there is no solution within [0, 1)
 */
 static SkScalar quad_solve(SkScalar a, SkScalar b, SkScalar c, SkScalar d)
 {
     // At^2 + Bt + C = d
     SkScalar A = a - 2 * b + c;
     SkScalar B = 2 * (b - a);
@@ skipping 459 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);
 }