Fix double to SkScalar issues in SkTwoPointConicalGradient_gpu.cpp

src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp

 
 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkTwoPointConicalGradient_gpu.h"
 
 #include "SkTwoPointConicalGradient.h"
 
 #if SK_SUPPORT_GPU
 #include "GrTBackendEffectFactory.h"
 // For brevity
 typedef GrGLUniformManager::UniformHandle UniformHandle;
 
-static const SkScalar kErrorTol = 0.00001;
+static const SkScalar kErrorTol = 0.00001f;
 
 /**
  * We have three general cases for 2pt conical gradients. First we always assume that
  * the start radius <= end radius. Our first case (kInside_) is when the start circle
  * is completely enclosed by the end circle. The second case (kOutside_) is the case
  * when the start circle is either completely outside the end circle or the circles
  * overlap. The final case (kEdge_) is when the start circle is inside the end one,
  * but the two are just barely touching at 1 point along their edges.
  */
 enum ConicalType {
@@ skipping 269 matching lines @@
 
 static ConicalType set_matrix_focal_conical(const SkTwoPointConicalGradient& shader,
                                             SkMatrix* invLMatrix, SkScalar* focalX) {
     // Inverse of the current local matrix is passed in then,
     // translate, scale, and rotate such that endCircle is unit circle on x-axis,
     // and focal point is at the origin.
     ConicalType conicalType;
     const SkPoint& focal = shader.getStartCenter();
     const SkPoint& centerEnd = shader.getEndCenter();
     SkScalar radius = shader.getEndRadius();
-    SkScalar invRadius = 1.0 / radius;
+    SkScalar invRadius = 1.f / radius;
 
     SkMatrix matrix;
 
     matrix.setTranslate(-centerEnd.fX, -centerEnd.fY);
     matrix.postScale(invRadius, invRadius);
 
     SkPoint focalTrans;
     matrix.mapPoints(&focalTrans, &focal, 1);
     *focalX = focalTrans.length();
 
-    if (0.0 != *focalX) {
+    if (0.f != *focalX) {
         SkScalar invFocalX = SkScalarInvert(*focalX);
         SkMatrix rot;
         rot.setSinCos(-SkScalarMul(invFocalX, focalTrans.fY),
                       SkScalarMul(invFocalX, focalTrans.fX));
         matrix.postConcat(rot);
     }
 
-    matrix.postTranslate(-(*focalX), 0.0);
+    matrix.postTranslate(-(*focalX), 0.f);
 
     // If the focal point is touching the edge of the circle it will
     // cause a degenerate case that must be handled separately
     // 5 * kErrorTol was picked after manual testing the stability trade off
     // versus the linear approx used in the Edge Shader
-    if (SkScalarAbs(1.0 - (*focalX)) < 5 *  kErrorTol) {
+    if (SkScalarAbs(1.f - (*focalX)) < 5 *  kErrorTol) {
         return kEdge_ConicalType;
     }
 
     // Scale factor 1 / (1 - focalX * focalX)
-    SkScalar oneMinusF2 = 1.0 - SkScalarMul(*focalX, *focalX);
-    SkScalar s = SkScalarDiv(1.0, oneMinusF2);
+    SkScalar oneMinusF2 = 1.f - SkScalarMul(*focalX, *focalX);
+    SkScalar s = SkScalarDiv(1.f, oneMinusF2);
 
 
-    if (s >= 0.0) {
+    if (s >= 0.f) {
         conicalType = kInside_ConicalType;
         matrix.postScale(s, s * SkScalarSqrt(oneMinusF2));
     } else {
         conicalType = kOutside_ConicalType;
         matrix.postScale(s, s);
     }
 
     invLMatrix->postConcat(matrix);
 
     return conicalType;
@@ skipping 88 matching lines @@
     return GrTBackendEffectFactory<FocalOutside2PtConicalEffect>::getInstance();
 }
 
 GR_DEFINE_EFFECT_TEST(FocalOutside2PtConicalEffect);
 
 GrEffectRef* FocalOutside2PtConicalEffect::TestCreate(SkRandom* random,
                                                       GrContext* context,
                                                       const GrDrawTargetCaps&,
                                                       GrTexture**) {
     SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()};
-    SkScalar radius1 = 0.0;
+    SkScalar radius1 = 0.f;
     SkPoint center2;
     SkScalar radius2;
     do {
         center2.set(random->nextUScalar1(), random->nextUScalar1());
         // Need to make sure the centers are not the same or else focal point will be inside 
     } while (center1 == center2);
         SkPoint diff = center2 - center1;
         SkScalar diffLen = diff.length();
         // Below makes sure that the focal point is not contained within circle two
-        radius2 = random->nextRangeF(0.0, diffLen);
+        radius2 = random->nextRangeF(0.f, diffLen);
 
     SkColor colors[kMaxRandomGradientColors];
     SkScalar stopsArray[kMaxRandomGradientColors];
     SkScalar* stops = stopsArray;
     SkShader::TileMode tm;
     int colorCount = RandomGradientParams(random, colors, &stops, &tm);
     SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center1, radius1,
                                                                           center2, radius2,
                                                                           colors, stops, colorCount,
                                                                           tm));
@@ skipping 59 matching lines @@
 }
 
 void GLFocalOutside2PtConicalEffect::setData(const GrGLUniformManager& uman,
                                              const GrDrawEffect& drawEffect) {
     INHERITED::setData(uman, drawEffect);
     const FocalOutside2PtConicalEffect& data = drawEffect.castEffect<FocalOutside2PtConicalEffect>();
     SkASSERT(data.isFlipped() == fIsFlipped);
     SkScalar focal = data.focal();
 
     if (fCachedFocal != focal) {
-        SkScalar oneMinus2F = 1.0 - SkScalarMul(focal, focal);
+        SkScalar oneMinus2F = 1.f - SkScalarMul(focal, focal);
 
         float values[2] = {
             SkScalarToFloat(focal),
             SkScalarToFloat(oneMinus2F),
         };
 
         uman.set1fv(fParamUni, 2, values);
         fCachedFocal = focal;
     }
 }
@@ skipping 96 matching lines @@
     return GrTBackendEffectFactory<FocalInside2PtConicalEffect>::getInstance();
 }
 
 GR_DEFINE_EFFECT_TEST(FocalInside2PtConicalEffect);
 
 GrEffectRef* FocalInside2PtConicalEffect::TestCreate(SkRandom* random,
                                                      GrContext* context,
                                                      const GrDrawTargetCaps&,
                                                      GrTexture**) {
     SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()};
-    SkScalar radius1 = 0.0;
+    SkScalar radius1 = 0.f;
     SkPoint center2;
     SkScalar radius2;
     do {
         center2.set(random->nextUScalar1(), random->nextUScalar1());
         // Below makes sure radius2 is larger enouch such that the focal point
         // is inside the end circle
         SkScalar increase = random->nextUScalar1();
         SkPoint diff = center2 - center1;
         SkScalar diffLen = diff.length();
         radius2 = diffLen + increase;
@@ skipping 82 matching lines @@
     // translate and scale such that start circle is on the origin and has radius 1
     const SkPoint& centerStart = shader.getStartCenter();
     const SkPoint& centerEnd = shader.getEndCenter();
     SkScalar radiusStart = shader.getStartRadius();
     SkScalar radiusEnd = shader.getEndRadius();
 
     SkMatrix matrix;
 
     matrix.setTranslate(-centerStart.fX, -centerStart.fY);
 
-    SkScalar invStartRad = 1.0 / radiusStart;
+    SkScalar invStartRad = 1.f / radiusStart;
     matrix.postScale(invStartRad, invStartRad);
 
     radiusEnd /= radiusStart;
 
     SkPoint centerEndTrans;
     matrix.mapPoints(&centerEndTrans, &centerEnd, 1);
 
     SkScalar A = centerEndTrans.fX * centerEndTrans.fX + centerEndTrans.fY * centerEndTrans.fY
                  - radiusEnd * radiusEnd + 2 * radiusEnd - 1;
 
     // Check to see if start circle is inside end circle with edges touching.
     // If touching we return that it is of kEdge_ConicalType, and leave the matrix setting
     // to the edge shader. 5 * kErrorTol was picked after manual testing so that C = 1 / A
     // is stable, and the linear approximation used in the Edge shader is still accurate.
     if (SkScalarAbs(A) < 5 * kErrorTol) {
         return kEdge_ConicalType;
     }
 
-    SkScalar C = 1.0 / A;
-    SkScalar B = (radiusEnd - 1.0) * C;
+    SkScalar C = 1.f / A;
+    SkScalar B = (radiusEnd - 1.f) * C;
 
     matrix.postScale(C, C);
 
     invLMatrix->postConcat(matrix);
 
     info->fCenterEnd = centerEndTrans;
     info->fA = A;
     info->fB = B;
     info->fC = C;
 
     // if A ends up being negative, the start circle is contained completely inside the end cirlce
-    if (A < 0.0) {
+    if (A < 0.f) {
         return kInside_ConicalType;
     }
     return kOutside_ConicalType;
 }
 
 class GLCircleInside2PtConicalEffect;
 
 class CircleInside2PtConicalEffect : public GrGradientEffect {
 public:
 
@@ skipping 86 matching lines @@
     return GrTBackendEffectFactory<CircleInside2PtConicalEffect>::getInstance();
 }
 
 GR_DEFINE_EFFECT_TEST(CircleInside2PtConicalEffect);
 
 GrEffectRef* CircleInside2PtConicalEffect::TestCreate(SkRandom* random,
                                                       GrContext* context,
                                                       const GrDrawTargetCaps&,
                                                       GrTexture**) {
     SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()};
-    SkScalar radius1 = random->nextUScalar1() + 0.0001; // make sure radius1 != 0
+    SkScalar radius1 = random->nextUScalar1() + 0.0001f; // make sure radius1 != 0
     SkPoint center2;
     SkScalar radius2;
     do {
         center2.set(random->nextUScalar1(), random->nextUScalar1());
         // Below makes sure that circle one is contained within circle two
         SkScalar increase = random->nextUScalar1();
         SkPoint diff = center2 - center1;
         SkScalar diffLen = diff.length();
         radius2 = radius1 + diffLen + increase;
         // If the circles are identical the factory will give us an empty shader.
@@ skipping 206 matching lines @@
     return GrTBackendEffectFactory<CircleOutside2PtConicalEffect>::getInstance();
 }
 
 GR_DEFINE_EFFECT_TEST(CircleOutside2PtConicalEffect);
 
 GrEffectRef* CircleOutside2PtConicalEffect::TestCreate(SkRandom* random,
                                                        GrContext* context,
                                                        const GrDrawTargetCaps&,
                                                        GrTexture**) {
     SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()};
-    SkScalar radius1 = random->nextUScalar1() + 0.0001; // make sure radius1 != 0
+    SkScalar radius1 = random->nextUScalar1() + 0.0001f; // make sure radius1 != 0
     SkPoint center2;
     SkScalar radius2;
     SkScalar diffLen;
     do {
         center2.set(random->nextUScalar1(), random->nextUScalar1());
         // If the circles share a center than we can't be in the outside case
     } while (center1 == center2);
         SkPoint diff = center2 - center1;
         diffLen = diff.length();
         // Below makes sure that circle one is not contained within circle two
         // and have radius2 >= radius to match sorting on cpu side
-        radius2 = radius1 + random->nextRangeF(0.0, diffLen);
+        radius2 = radius1 + random->nextRangeF(0.f, diffLen);
 
     SkColor colors[kMaxRandomGradientColors];
     SkScalar stopsArray[kMaxRandomGradientColors];
     SkScalar* stops = stopsArray;
     SkShader::TileMode tm;
     int colorCount = RandomGradientParams(random, colors, &stops, &tm);
     SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center1, radius1,
                                                                           center2, radius2,
                                                                           colors, stops, colorCount,
                                                                           tm));
@@ skipping 143 matching lines @@
         return CircleInside2PtConicalEffect::Create(ctx, shader, matrix, tm, info);
     } else if (type == kEdge_ConicalType) {
         set_matrix_edge_conical(shader, &matrix);
         return Edge2PtConicalEffect::Create(ctx, shader, matrix, tm);
     } else {
         return CircleOutside2PtConicalEffect::Create(ctx, shader, matrix, tm, info);
     }
 }
 
 #endif