Use float rather than SkFixed for gradient TileProcs.

src/effects/gradients/SkTwoPointConicalGradient.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 "SkTwoPointConicalGradient.h"
 #include "SkTwoPointConicalGradient_gpu.h"
 
 struct TwoPtRadialContext {
     const TwoPtRadial&  fRec;
     float               fRelX, fRelY;
     const float         fIncX, fIncY;
     float               fB;
     const float         fDB;
 
     TwoPtRadialContext(const TwoPtRadial& rec, SkScalar fx, SkScalar fy,
                        SkScalar dfx, SkScalar dfy);
-    SkFixed nextT();
+    float nextT();
 };
 
 static int valid_divide(float numer, float denom, float* ratio) {
     SkASSERT(ratio);
     if (0 == denom) {
         return 0;
     }
     *ratio = numer / denom;
     return 1;
 }
@@ skipping 39 matching lines @@
     }
     return 2;
 }
 
 static float lerp(float x, float dx, float t) {
     return x + t * dx;
 }
 
 static float sqr(float x) { return x * x; }
 
+const float TwoPtRadial::kDontDrawT = NAN;
+
 void TwoPtRadial::init(const SkPoint& center0, SkScalar rad0,
                        const SkPoint& center1, SkScalar rad1,
                        bool flipped) {
     fCenterX = SkScalarToFloat(center0.fX);
     fCenterY = SkScalarToFloat(center0.fY);
     fDCenterX = SkScalarToFloat(center1.fX) - fCenterX;
     fDCenterY = SkScalarToFloat(center1.fY) - fCenterY;
     fRadius = SkScalarToFloat(rad0);
     fDRadius = SkScalarToFloat(rad1) - fRadius;
 
     fA = sqr(fDCenterX) + sqr(fDCenterY) - sqr(fDRadius);
     fRadius2 = sqr(fRadius);
     fRDR = fRadius * fDRadius;
 
     fFlipped = flipped;
 }
 
 TwoPtRadialContext::TwoPtRadialContext(const TwoPtRadial& rec, SkScalar fx, SkScalar fy,
                                        SkScalar dfx, SkScalar dfy)
     : fRec(rec)
     , fRelX(SkScalarToFloat(fx) - rec.fCenterX)
     , fRelY(SkScalarToFloat(fy) - rec.fCenterY)
     , fIncX(SkScalarToFloat(dfx))
     , fIncY(SkScalarToFloat(dfy))
     , fB(-2 * (rec.fDCenterX * fRelX + rec.fDCenterY * fRelY + rec.fRDR))
     , fDB(-2 * (rec.fDCenterX * fIncX + rec.fDCenterY * fIncY)) {}
 
-SkFixed TwoPtRadialContext::nextT() {
+float TwoPtRadialContext::nextT() {
     float roots[2];
 
     float C = sqr(fRelX) + sqr(fRelY) - fRec.fRadius2;
     int countRoots = find_quad_roots(fRec.fA, fB, C, roots, fRec.fFlipped);
 
     fRelX += fIncX;
     fRelY += fIncY;
     fB += fDB;
 
     if (0 == countRoots) {
         return TwoPtRadial::kDontDrawT;
     }
 
     // Prefer the bigger t value if both give a radius(t) > 0
     // find_quad_roots returns the values sorted, so we start with the last
     float t = roots[countRoots - 1];
     float r = lerp(fRec.fRadius, fRec.fDRadius, t);
     if (r < 0) {
         t = roots[0];   // might be the same as roots[countRoots-1]
         r = lerp(fRec.fRadius, fRec.fDRadius, t);
         if (r < 0) {
             return TwoPtRadial::kDontDrawT;
         }
     }
-    return SkFloatToFixed(t);
+    return t;
 }
 
 typedef void (*TwoPointConicalProc)(TwoPtRadialContext* rec, SkPMColor* dstC,
                                     const SkPMColor* cache, int toggle, int count);
 
 static void twopoint_clamp(TwoPtRadialContext* rec, SkPMColor* SK_RESTRICT dstC,
                            const SkPMColor* SK_RESTRICT cache, int toggle,
                            int count) {
     for (; count > 0; --count) {
-        SkFixed t = rec->nextT();
+        float t = rec->nextT();
         if (TwoPtRadial::DontDrawT(t)) {
             *dstC++ = 0;
         } else {
-            SkFixed index = SkClampMax(t, 0xFFFF);
+            const unsigned index = clamp_tileproc(t);
             SkASSERT(index <= 0xFFFF);
             *dstC++ = cache[toggle +
                             (index >> SkGradientShaderBase::kCache32Shift)];
         }
         toggle = next_dither_toggle(toggle);
     }
 }
 
 static void twopoint_repeat(TwoPtRadialContext* rec, SkPMColor* SK_RESTRICT dstC,
                             const SkPMColor* SK_RESTRICT cache, int toggle,
                             int count) {
     for (; count > 0; --count) {
-        SkFixed t = rec->nextT();
+        float t = rec->nextT();
         if (TwoPtRadial::DontDrawT(t)) {
             *dstC++ = 0;
         } else {
-            SkFixed index = repeat_tileproc(t);
+            const unsigned index = repeat_tileproc(t);
             SkASSERT(index <= 0xFFFF);
             *dstC++ = cache[toggle +
                             (index >> SkGradientShaderBase::kCache32Shift)];
         }
         toggle = next_dither_toggle(toggle);
     }
 }
 
 static void twopoint_mirror(TwoPtRadialContext* rec, SkPMColor* SK_RESTRICT dstC,
                             const SkPMColor* SK_RESTRICT cache, int toggle,
                             int count) {
     for (; count > 0; --count) {
-        SkFixed t = rec->nextT();
+        float t = rec->nextT();
         if (TwoPtRadial::DontDrawT(t)) {
             *dstC++ = 0;
         } else {
-            SkFixed index = mirror_tileproc(t);
+            const unsigned index = mirror_tileproc(t);
             SkASSERT(index <= 0xFFFF);
             *dstC++ = cache[toggle +
                             (index >> SkGradientShaderBase::kCache32Shift)];
         }
         toggle = next_dither_toggle(toggle);
     }
 }
 
 /////////////////////////////////////////////////////////////////////
 
@@ skipping 197 matching lines @@
     str->appendScalar(fCenter2.fY);
     str->append(") radius2: ");
     str->appendScalar(fRadius2);
     str->append(" ");
 
     this->INHERITED::toString(str);
 
     str->append(")");
 }
 #endif