Revert of Fix Assert for gpu ConicalTwoPointGradient edgecase to be correct bounds.

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.00001f;
-static const SkScalar kEdgeErrorTol = 5.f * kErrorTol;
 
 /**
  * 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 60 matching lines @@
 
     Edge2PtConicalEffect(GrContext* ctx,
                          const SkTwoPointConicalGradient& shader,
                          const SkMatrix& matrix,
                          SkShader::TileMode tm)
         : INHERITED(ctx, shader, matrix, tm),
         fCenterX1(shader.getCenterX1()),
         fRadius0(shader.getStartRadius()),
         fDiffRadius(shader.getDiffRadius()){
         // We should only be calling this shader if we are degenerate case with touching circles
-        SkASSERT(SkScalarAbs(SkScalarAbs(fDiffRadius) - SkScalarAbs(fCenterX1)) <
-                 fRadius0 * kEdgeErrorTol);
+        SkASSERT(SkScalarAbs(fDiffRadius) - SkScalarAbs(fCenterX1) < kErrorTol) ;
 
         // We pass the linear part of the quadratic as a varying.
         //    float b = -2.0 * (fCenterX1 * x + fRadius0 * fDiffRadius * z)
         fBTransform = this->getCoordTransform();
         SkMatrix& bMatrix = *fBTransform.accessMatrix();
         SkScalar r0dr = SkScalarMul(fRadius0, fDiffRadius);
         bMatrix[SkMatrix::kMScaleX] = -2 * (SkScalarMul(fCenterX1, bMatrix[SkMatrix::kMScaleX]) +
                                             SkScalarMul(r0dr, bMatrix[SkMatrix::kMPersp0]));
         bMatrix[SkMatrix::kMSkewX] = -2 * (SkScalarMul(fCenterX1, bMatrix[SkMatrix::kMSkewX]) +
                                            SkScalarMul(r0dr, bMatrix[SkMatrix::kMPersp1]));
@@ skipping 211 matching lines @@
         SkMatrix rot;
         rot.setSinCos(-SkScalarMul(invFocalX, focalTrans.fY),
                       SkScalarMul(invFocalX, focalTrans.fX));
         matrix.postConcat(rot);
     }
 
     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
-    // kEdgeErrorTol = 5 * kErrorTol was picked after manual testing the
-    // stability trade off versus the linear approx used in the Edge Shader
-    if (SkScalarAbs(1.f - (*focalX)) < kEdgeErrorTol) {
+    // 5 * kErrorTol was picked after manual testing the stability trade off
+    // versus the linear approx used in the Edge Shader
+    if (SkScalarAbs(1.f - (*focalX)) < 5 *  kErrorTol) {
         return kEdge_ConicalType;
     }
 
     // Scale factor 1 / (1 - focalX * focalX)
     SkScalar oneMinusF2 = 1.f - SkScalarMul(*focalX, *focalX);
     SkScalar s = SkScalarDiv(1.f, oneMinusF2);
 
 
     if (s >= 0.f) {
         conicalType = kInside_ConicalType;
@@ skipping 420 matching lines @@
     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. kEdgeErrorTol = 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) < kEdgeErrorTol) {
+    // 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.f / A;
     SkScalar B = (radiusEnd - 1.f) * C;
 
     matrix.postScale(C, C);
 
     invLMatrix->postConcat(matrix);
 
@@ skipping 514 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