remove SK_SCALAR_IS_[FLOAT,FIXED] and assume floats

src/core/SkLineClipper.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkLineClipper.h"
 
 template <typename T> T pin_unsorted(T value, T limit0, T limit1) {
@@ skipping 10 matching lines @@
     }
     return value;
 }
 
 // return X coordinate of intersection with horizontal line at Y
 static SkScalar sect_with_horizontal(const SkPoint src[2], SkScalar Y) {
     SkScalar dy = src[1].fY - src[0].fY;
     if (SkScalarNearlyZero(dy)) {
         return SkScalarAve(src[0].fX, src[1].fX);
     } else {
-#ifdef SK_SCALAR_IS_FLOAT
         // need the extra precision so we don't compute a value that exceeds
         // our original limits
         double X0 = src[0].fX;
         double Y0 = src[0].fY;
         double X1 = src[1].fX;
         double Y1 = src[1].fY;
         double result = X0 + ((double)Y - Y0) * (X1 - X0) / (Y1 - Y0);
 
         // The computed X value might still exceed [X0..X1] due to quantum flux
         // when the doubles were added and subtracted, so we have to pin the
         // answer :(
         return (float)pin_unsorted(result, X0, X1);
-#else
-        return src[0].fX + SkScalarMulDiv(Y - src[0].fY, src[1].fX - src[0].fX,
-                                          dy);
-#endif
     }
 }
 
 // return Y coordinate of intersection with vertical line at X
 static SkScalar sect_with_vertical(const SkPoint src[2], SkScalar X) {
     SkScalar dx = src[1].fX - src[0].fX;
     if (SkScalarNearlyZero(dx)) {
         return SkScalarAve(src[0].fY, src[1].fY);
     } else {
-#ifdef SK_SCALAR_IS_FLOAT
         // need the extra precision so we don't compute a value that exceeds
         // our original limits
         double X0 = src[0].fX;
         double Y0 = src[0].fY;
         double X1 = src[1].fX;
         double Y1 = src[1].fY;
         double result = Y0 + ((double)X - X0) * (Y1 - Y0) / (X1 - X0);
         return (float)result;
-#else
-        return src[0].fY + SkScalarMulDiv(X - src[0].fX, src[1].fY - src[0].fY,
-                                          dx);
-#endif
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static inline bool nestedLT(SkScalar a, SkScalar b, SkScalar dim) {
     return a <= b && (a < b || dim > 0);
 }
 
 // returns true if outer contains inner, even if inner is empty.
@@ skipping 80 matching lines @@
 static bool is_between_unsorted(SkScalar value,
                                 SkScalar limit0, SkScalar limit1) {
     if (limit0 < limit1) {
         return limit0 <= value && value <= limit1;
     } else {
         return limit1 <= value && value <= limit0;
     }
 }
 #endif
 
-#ifdef SK_SCALAR_IS_FLOAT
 #ifdef SK_DEBUG
 // This is an example of why we need to pin the result computed in
 // sect_with_horizontal. If we didn't explicitly pin, is_between_unsorted would
 // fail.
 //
 static void sect_with_horizontal_test_for_pin_results() {
     const SkPoint pts[] = {
         { -540000,    -720000 },
         { -9.10000017e-05f, 9.99999996e-13f }
     };
     float x = sect_with_horizontal(pts, 0);
     SkASSERT(is_between_unsorted(x, pts[0].fX, pts[1].fX));
 }
 #endif
-#endif
 
 int SkLineClipper::ClipLine(const SkPoint pts[], const SkRect& clip,
                             SkPoint lines[]) {
-#ifdef SK_SCALAR_IS_FLOAT
 #ifdef SK_DEBUG
     {
         static bool gOnce;
         if (!gOnce) {
             sect_with_horizontal_test_for_pin_results();
             gOnce = true;
         }
     }
 #endif
-#endif
 
     int index0, index1;
 
     if (pts[0].fY < pts[1].fY) {
         index0 = 0;
         index1 = 1;
     } else {
         index0 = 1;
         index1 = 0;
     }
@@ skipping 78 matching lines @@
     if (reverse) {
         // copy the pts in reverse order to maintain winding order
         for (int i = 0; i <= lineCount; i++) {
             lines[lineCount - i] = result[i];
         }
     } else {
         memcpy(lines, result, (lineCount + 1) * sizeof(SkPoint));
     }
     return lineCount;
 }