remove SK_SCALAR_IS_[FLOAT,FIXED] and assume floats

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 50 matching lines @@
     SkScalar b = pts[0].fY - SkScalarMul(slope, pts[0].fX);
     // Solve for x coordinate at y = pt.fY
     SkScalar x = SkScalarDiv(pt.fY - b, slope);
     return pt.fX <= x;
 }
 
 /** If defined, this makes eval_quad and eval_cubic do more setup (sometimes
     involving integer multiplies by 2 or 3, but fewer calls to SkScalarMul.
     May also introduce overflow of fixed when we compute our setup.
 */
-#ifdef SK_SCALAR_IS_FIXED
-    #define DIRECT_EVAL_OF_POLYNOMIALS
-#endif
+//    #define DIRECT_EVAL_OF_POLYNOMIALS
 
 ////////////////////////////////////////////////////////////////////////
 
-#ifdef SK_SCALAR_IS_FIXED
-    static int is_not_monotonic(int a, int b, int c, int d)
-    {
-        return (((a - b) | (b - c) | (c - d)) & ((b - a) | (c - b) | (d - c))) >> 31;
+static int is_not_monotonic(float a, float b, float c) {
+    float ab = a - b;
+    float bc = b - c;
+    if (ab < 0) {
+        bc = -bc;
     }
-
-    static int is_not_monotonic(int a, int b, int c)
-    {
-        return (((a - b) | (b - c)) & ((b - a) | (c - b))) >> 31;
-    }
-#else
-    static int is_not_monotonic(float a, float b, float c)
-    {
-        float ab = a - b;
-        float bc = b - c;
-        if (ab < 0)
-            bc = -bc;
-        return ab == 0 || bc < 0;
-    }
-#endif
+    return ab == 0 || bc < 0;
+}
 
 ////////////////////////////////////////////////////////////////////////
 
 static bool is_unit_interval(SkScalar x)
 {
     return x > 0 && x < SK_Scalar1;
 }
 
 static int valid_unit_divide(SkScalar numer, SkScalar denom, SkScalar* ratio)
 {
@@ skipping 27 matching lines @@
 */
 int SkFindUnitQuadRoots(SkScalar A, SkScalar B, SkScalar C, SkScalar roots[2])
 {
     SkASSERT(roots);
 
     if (A == 0)
         return valid_unit_divide(-C, B, roots);
 
     SkScalar* r = roots;
 
-#ifdef SK_SCALAR_IS_FLOAT
     float R = B*B - 4*A*C;
     if (R < 0 || SkScalarIsNaN(R)) {  // complex roots
         return 0;
     }
     R = sk_float_sqrt(R);
-#else
-    Sk64    RR, tmp;
-
-    RR.setMul(B,B);
-    tmp.setMul(A,C);
-    tmp.shiftLeft(2);
-    RR.sub(tmp);
-    if (RR.isNeg())
-        return 0;
-    SkFixed R = RR.getSqrt();
-#endif
 
     SkScalar Q = (B < 0) ? -(B-R)/2 : -(B+R)/2;
     r += valid_unit_divide(Q, A, r);
     r += valid_unit_divide(C, Q, r);
     if (r - roots == 2)
     {
         if (roots[0] > roots[1])
             SkTSwap<SkScalar>(roots[0], roots[1]);
         else if (roots[0] == roots[1])  // nearly-equal?
             r -= 1; // skip the double root
     }
     return (int)(r - roots);
 }
 
-#ifdef SK_SCALAR_IS_FIXED
-/** Trim A/B/C down so that they are all <= 32bits
-    and then call SkFindUnitQuadRoots()
-*/
-static int Sk64FindFixedQuadRoots(const Sk64& A, const Sk64& B, const Sk64& C, SkFixed roots[2])
-{
-    int na = A.shiftToMake32();
-    int nb = B.shiftToMake32();
-    int nc = C.shiftToMake32();
-
-    int shift = SkMax32(na, SkMax32(nb, nc));
-    SkASSERT(shift >= 0);
-
-    return SkFindUnitQuadRoots(A.getShiftRight(shift), B.getShiftRight(shift), C.getShiftRight(shift), roots);
-}
-#endif
-
-/////////////////////////////////////////////////////////////////////////////////////
-/////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
 
 static SkScalar eval_quad(const SkScalar src[], SkScalar t)
 {
     SkASSERT(src);
     SkASSERT(t >= 0 && t <= SK_Scalar1);
 
 #ifdef DIRECT_EVAL_OF_POLYNOMIALS
     SkScalar    C = src[0];
     SkScalar    A = src[4] - 2 * src[2] + C;
     SkScalar    B = 2 * (src[2] - C);
@@ skipping 86 matching lines @@
 /** Quad'(t) = At + B, where
     A = 2(a - 2b + c)
     B = 2(b - a)
     Solve for t, only if it fits between 0 < t < 1
 */
 int SkFindQuadExtrema(SkScalar a, SkScalar b, SkScalar c, SkScalar tValue[1])
 {
     /*  At + B == 0
         t = -B / A
     */
-#ifdef SK_SCALAR_IS_FIXED
-    return is_not_monotonic(a, b, c) && valid_unit_divide(a - b, a - b - b + c, tValue);
-#else
     return valid_unit_divide(a - b, a - b - b + c, tValue);
-#endif
 }
 
 static inline void flatten_double_quad_extrema(SkScalar coords[14])
 {
     coords[2] = coords[6] = coords[4];
 }
 
 /*  Returns 0 for 1 quad, and 1 for two quads, either way the answer is
  stored in dst[]. Guarantees that the 1/2 quads will be monotonic.
  */
@@ skipping 79 matching lines @@
 //
 //  t = - (Ax Bx + Ay By) / (Bx ^ 2 + By ^ 2)
 //
 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
-    Sk64    numer, denom, tmp;
-
-    numer.setMul(Ax, -Bx);
-    tmp.setMul(Ay, -By);
-    numer.add(tmp);
-
-    if (numer.isPos())  // do nothing if numer <= 0
-    {
-        denom.setMul(Bx, Bx);
-        tmp.setMul(By, By);
-        denom.add(tmp);
-        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;
 }
 
 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 {
         SkChopQuadAt(src, dst, t);
         return 2;
     }
 }
 
-#ifdef SK_SCALAR_IS_FLOAT
-    #define SK_ScalarTwoThirds  (0.666666666f)
-#else
-    #define SK_ScalarTwoThirds  ((SkFixed)(43691))
-#endif
+#define SK_ScalarTwoThirds  (0.666666666f)
 
 void SkConvertQuadToCubic(const SkPoint src[3], SkPoint dst[4]) {
     const SkScalar scale = SK_ScalarTwoThirds;
     dst[0] = src[0];
     dst[1].set(src[0].fX + SkScalarMul(src[1].fX - src[0].fX, scale),
                src[0].fY + SkScalarMul(src[1].fY - src[0].fY, scale));
     dst[2].set(src[2].fX + SkScalarMul(src[1].fX - src[2].fX, scale),
                src[2].fY + SkScalarMul(src[1].fY - src[2].fY, scale));
     dst[3] = src[2];
 }
@@ skipping 87 matching lines @@
 }
 
 /** Cubic'(t) = At^2 + Bt + C, where
     A = 3(-a + 3(b - c) + d)
     B = 6(a - 2b + c)
     C = 3(b - a)
     Solve for t, keeping only those that fit betwee 0 < t < 1
 */
 int SkFindCubicExtrema(SkScalar a, SkScalar b, SkScalar c, SkScalar d, SkScalar tValues[2])
 {
-#ifdef SK_SCALAR_IS_FIXED
-    if (!is_not_monotonic(a, b, c, d))
-        return 0;
-#endif
-
     // we divide A,B,C by 3 to simplify
     SkScalar A = d - a + 3*(b - c);
     SkScalar B = 2*(a - b - b + c);
     SkScalar C = b - a;
 
     return SkFindUnitQuadRoots(A, B, C, tValues);
 }
 
 static void interp_cubic_coords(const SkScalar* src, SkScalar* dst, SkScalar t)
 {
@@ skipping 169 matching lines @@
     (BxCy - ByCx)t^2 + (AxCy - AyCx)t + AxBy - AyBx == 0
 */
 int SkFindCubicInflections(const SkPoint src[4], SkScalar tValues[])
 {
     SkScalar    Ax = src[1].fX - src[0].fX;
     SkScalar    Ay = src[1].fY - src[0].fY;
     SkScalar    Bx = src[2].fX - 2 * src[1].fX + src[0].fX;
     SkScalar    By = src[2].fY - 2 * src[1].fY + src[0].fY;
     SkScalar    Cx = src[3].fX + 3 * (src[1].fX - src[2].fX) - src[0].fX;
     SkScalar    Cy = src[3].fY + 3 * (src[1].fY - src[2].fY) - src[0].fY;
-    int         count;
 
-#ifdef SK_SCALAR_IS_FLOAT
-    count = SkFindUnitQuadRoots(Bx*Cy - By*Cx, Ax*Cy - Ay*Cx, Ax*By - Ay*Bx, tValues);
-#else
-    Sk64    A, B, C, tmp;
-
-    A.setMul(Bx, Cy);
-    tmp.setMul(By, Cx);
-    A.sub(tmp);
-
-    B.setMul(Ax, Cy);
-    tmp.setMul(Ay, Cx);
-    B.sub(tmp);
-
-    C.setMul(Ax, By);
-    tmp.setMul(Ay, Bx);
-    C.sub(tmp);
-
-    count = Sk64FindFixedQuadRoots(A, B, C, tValues);
-#endif
-
-    return count;
+    return SkFindUnitQuadRoots(Bx*Cy - By*Cx, Ax*Cy - Ay*Cx, Ax*By - Ay*Bx, tValues);
 }
 
 int SkChopCubicAtInflections(const SkPoint src[], SkPoint dst[10])
 {
     SkScalar    tValues[2];
     int         count = SkFindCubicInflections(src, tValues);
 
     if (dst)
     {
         if (count == 0)
@@ skipping 101 matching lines @@
         memcpy(dst, data[i].fData, data[i].fCount * sizeof(dst[0]));
         int count = collaps_duplicates(dst, data[i].fCount);
         SkASSERT(data[i].fCollapsedCount == count);
         for (int j = 1; j < count; ++j) {
             SkASSERT(dst[j-1] < dst[j]);
         }
     }
 }
 #endif
 
-#if defined _WIN32 && _MSC_VER >= 1300  && defined SK_SCALAR_IS_FIXED // disable warning : unreachable code if building fixed point for windows desktop
-#pragma warning ( disable : 4702 )
-#endif
-
 static SkScalar SkScalarCubeRoot(SkScalar x) {
     return sk_float_pow(x, 0.3333333f);
 }
 
 /*  Solve coeff(t) == 0, returning the number of roots that
     lie withing 0 < t < 1.
     coeff[0]t^3 + coeff[1]t^2 + coeff[2]t + coeff[3]
 
     Eliminates repeated roots (so that all tValues are distinct, and are always
     in increasing order.
@@ skipping 720 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);
 }