remove SK_SCALAR_IS_[FLOAT,FIXED] and assume floats

src/core/SkScan_Antihair.cpp

 
 /*
  * Copyright 2011 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 "SkScan.h"
@@ skipping 584 matching lines @@
     }
 
     SkASSERT(clip == NULL || !clip->getBounds().isEmpty());
 
 #ifdef TEST_GAMMA
     build_gamma_table();
 #endif
 
     SkPoint pts[2] = { pt0, pt1 };
 
-#ifdef SK_SCALAR_IS_FLOAT
     // We have to pre-clip the line to fit in a SkFixed, so we just chop
     // the line. TODO find a way to actually draw beyond that range.
     {
         SkRect fixedBounds;
         const SkScalar max = SkIntToScalar(32767);
         fixedBounds.set(-max, -max, max, max);
         if (!SkLineClipper::IntersectLine(pts, fixedBounds, pts)) {
             return;
         }
     }
-#endif
 
     if (clip) {
         SkRect clipBounds;
         clipBounds.set(clip->getBounds());
         /*  We perform integral clipping later on, but we do a scalar clip first
             to ensure that our coordinates are expressible in fixed/integers.
 
             antialiased hairlines can draw up to 1/2 of a pixel outside of
             their bounds, so we need to outset the clip before calling the
             clipper. To make the numerics safer, we outset by a whole pixel,
@@ skipping 194 matching lines @@
             AntiFillXRect(xr, NULL, blitter);
         } else {
             SkAAClipBlitterWrapper wrapper(clip, blitter);
             blitter = wrapper.getBlitter();
 
             AntiFillXRect(xr, &wrapper.getRgn(), wrapper.getBlitter());
         }
     }
 }
 
-#ifdef SK_SCALAR_IS_FLOAT
-
 /*  This guy takes a float-rect, but with the key improvement that it has
     already been clipped, so we know that it is safe to convert it into a
     XRect (fixedpoint), as it won't overflow.
 */
 static void antifillrect(const SkRect& r, SkBlitter* blitter) {
     SkXRect xr;
 
     XRect_set(&xr, r);
     antifillrect(xr, blitter);
 }
@@ skipping 38 matching lines @@
 void SkScan::AntiFillRect(const SkRect& r, const SkRasterClip& clip,
                           SkBlitter* blitter) {
     if (clip.isBW()) {
         AntiFillRect(r, &clip.bwRgn(), blitter);
     } else {
         SkAAClipBlitterWrapper wrap(clip, blitter);
         AntiFillRect(r, &wrap.getRgn(), wrap.getBlitter());
     }
 }
 
-#endif // SK_SCALAR_IS_FLOAT
-
 ///////////////////////////////////////////////////////////////////////////////
 
 #define SkAlphaMulRound(a, b)   SkMulDiv255Round(a, b)
 
 // calls blitRect() if the rectangle is non-empty
 static void fillcheckrect(int L, int T, int R, int B, SkBlitter* blitter) {
     if (L < R && T < B) {
         blitter->blitRect(L, T, R - L, B - T);
     }
 }
 
 static inline FDot8 SkScalarToFDot8(SkScalar x) {
-#ifdef SK_SCALAR_IS_FLOAT
     return (int)(x * 256);
-#else
-    return x >> 8;
-#endif
 }
 
 static inline int FDot8Floor(FDot8 x) {
     return x >> 8;
 }
 
 static inline int FDot8Ceil(FDot8 x) {
     return (x + 0xFF) >> 8;
 }
 
@@ skipping 135 matching lines @@
 
 void SkScan::AntiFrameRect(const SkRect& r, const SkPoint& strokeSize,
                            const SkRasterClip& clip, SkBlitter* blitter) {
     if (clip.isBW()) {
         AntiFrameRect(r, strokeSize, &clip.bwRgn(), blitter);
     } else {
         SkAAClipBlitterWrapper wrap(clip, blitter);
         AntiFrameRect(r, strokeSize, &wrap.getRgn(), wrap.getBlitter());
     }
 }