Use float rather than SkFixed for gradient TileProcs.

src/effects/gradients/SkRadialGradient.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkRadialGradient.h"
 #include "SkNx.h"
 
 namespace {
 
 // GCC doesn't like using static functions as template arguments.  So force these to be non-static.
-inline SkFixed mirror_tileproc_nonstatic(SkFixed x) {
+inline unsigned mirror_tileproc_nonstatic(float x) {
     return mirror_tileproc(x);
 }
 
-inline SkFixed repeat_tileproc_nonstatic(SkFixed x) {
+inline unsigned repeat_tileproc_nonstatic(float x) {
     return repeat_tileproc(x);
 }
 
 SkMatrix rad_to_unit_matrix(const SkPoint& center, SkScalar radius) {
     SkScalar    inv = SkScalarInvert(radius);
 
     SkMatrix matrix;
     matrix.setTranslate(-center.fX, -center.fY);
     matrix.postScale(inv, inv);
     return matrix;
@@ skipping 122 matching lines @@
                 *dstC++ = cache[toggle + fi[i]];
                 toggle = next_dither_toggle(toggle);
             }
         }
     }
 }
 
 // Unrolling this loop doesn't seem to help (when float); we're stalling to
 // get the results of the sqrt (?), and don't have enough extra registers to
 // have many in flight.
-template <SkFixed (*TileProc)(SkFixed)>
+template <unsigned (*TileProc)(float)>
 void shadeSpan_radial(SkScalar fx, SkScalar dx, SkScalar fy, SkScalar dy,
                       SkPMColor* SK_RESTRICT dstC, const SkPMColor* SK_RESTRICT cache,
                       int count, int toggle) {
     do {
-        const SkFixed dist = SkFloatToFixed(sk_float_sqrt(fx*fx + fy*fy));
+        const float dist = sk_float_sqrt(fx*fx + fy*fy);
         const unsigned fi = TileProc(dist);
         SkASSERT(fi <= 0xFFFF);
         *dstC++ = cache[toggle + (fi >> SkGradientShaderBase::kCache32Shift)];
         toggle = next_dither_toggle(toggle);
         fx += dx;
         fy += dy;
     } while (--count != 0);
 }
 
 void shadeSpan_radial_mirror(SkScalar fx, SkScalar dx, SkScalar fy, SkScalar dy,
@@ skipping 43 matching lines @@
             shadeProc = shadeSpan_radial_mirror;
         } else {
             SkASSERT(SkShader::kRepeat_TileMode == radialGradient.fTileMode);
         }
         (*shadeProc)(srcPt.fX, sdx, srcPt.fY, sdy, dstC, cache, count, toggle);
     } else {    // perspective case
         SkScalar dstX = SkIntToScalar(x);
         SkScalar dstY = SkIntToScalar(y);
         do {
             dstProc(fDstToIndex, dstX, dstY, &srcPt);
-            unsigned fi = proc(SkScalarToFixed(srcPt.length()));
+            unsigned fi = proc(SkScalarToFloat(srcPt.length()));
             SkASSERT(fi <= 0xFFFF);
             *dstC++ = cache[fi >> SkGradientShaderBase::kCache32Shift];
             dstX += SK_Scalar1;
         } while (--count != 0);
     }
 }
 
 /////////////////////////////////////////////////////////////////////
 
 #if SK_SUPPORT_GPU
@@ skipping 135 matching lines @@
     str->appendScalar(fCenter.fY);
     str->append(") radius: ");
     str->appendScalar(fRadius);
     str->append(" ");
 
     this->INHERITED::toString(str);
 
     str->append(")");
 }
 #endif