Proposed fix for small bug in gpu conical gradients

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"
 
@@ skipping 80 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
         // When deciding if we are in edge case, we scaled by the end radius for cases when the
-        // start radius was close to zero, otherwise we scaled by the start radius
-        SkASSERT(SkScalarAbs(SkScalarAbs(fDiffRadius) - SkScalarAbs(fCenterX1)) <
-                 kEdgeErrorTol * (fRadius0 < kErrorTol ? shader.getEndRadius() : fRadius0));
+        // start radius was close to zero, otherwise we scaled by the start radius.  In addition
+        // Our test for the edge case in set_matrix_circle_conical has a higher tolerance so we
+        // need the sqrt value below
+        SkASSERT(SkScalarAbs(SkScalarAbs(fDiffRadius) - fCenterX1) <
+                 (fRadius0 < kErrorTol ? shader.getEndRadius() * kEdgeErrorTol :
+                                         fRadius0 * sqrt(kEdgeErrorTol)));
 
         // 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 52 matching lines @@
     typedef GrGLGradientEffect INHERITED;
 
 };
 
 const GrBackendEffectFactory& Edge2PtConicalEffect::getFactory() const {
     return GrTBackendEffectFactory<Edge2PtConicalEffect>::getInstance();
 }
 
 GR_DEFINE_EFFECT_TEST(Edge2PtConicalEffect);
 
+/*
+ * All Two point conical gradient test create functions may occasionally create edge case shaders
+ */
 GrEffect* Edge2PtConicalEffect::TestCreate(SkRandom* random,
                                            GrContext* context,
                                            const GrDrawTargetCaps&,
                                            GrTexture**) {
     SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()};
     SkScalar radius1 = random->nextUScalar1();
     SkPoint center2;
     SkScalar radius2;
     do {
         center2.set(random->nextUScalar1(), random->nextUScalar1());
@@ skipping 259 matching lines @@
     typedef GrGLGradientEffect INHERITED;
 
 };
 
 const GrBackendEffectFactory& FocalOutside2PtConicalEffect::getFactory() const {
     return GrTBackendEffectFactory<FocalOutside2PtConicalEffect>::getInstance();
 }
 
 GR_DEFINE_EFFECT_TEST(FocalOutside2PtConicalEffect);
 
+/*
+ * All Two point conical gradient test create functions may occasionally create edge case shaders
+ */
 GrEffect* FocalOutside2PtConicalEffect::TestCreate(SkRandom* random,
                                                    GrContext* context,
                                                    const GrDrawTargetCaps&,
                                                    GrTexture**) {
     SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()};
     SkScalar radius1 = 0.f;
     SkPoint center2;
     SkScalar radius2;
     do {
         center2.set(random->nextUScalar1(), random->nextUScalar1());
@@ skipping 184 matching lines @@
     typedef GrGLGradientEffect INHERITED;
 
 };
 
 const GrBackendEffectFactory& FocalInside2PtConicalEffect::getFactory() const {
     return GrTBackendEffectFactory<FocalInside2PtConicalEffect>::getInstance();
 }
 
 GR_DEFINE_EFFECT_TEST(FocalInside2PtConicalEffect);
 
+/*
+ * All Two point conical gradient test create functions may occasionally create edge case shaders
+ */
 GrEffect* FocalInside2PtConicalEffect::TestCreate(SkRandom* random,
                                                   GrContext* context,
                                                   const GrDrawTargetCaps&,
                                                   GrTexture**) {
     SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()};
     SkScalar radius1 = 0.f;
     SkPoint center2;
     SkScalar radius2;
     do {
         center2.set(random->nextUScalar1(), random->nextUScalar1());
@@ skipping 227 matching lines @@
     typedef GrGLGradientEffect INHERITED;
 
 };
 
 const GrBackendEffectFactory& CircleInside2PtConicalEffect::getFactory() const {
     return GrTBackendEffectFactory<CircleInside2PtConicalEffect>::getInstance();
 }
 
 GR_DEFINE_EFFECT_TEST(CircleInside2PtConicalEffect);
 
+/*
+ * All Two point conical gradient test create functions may occasionally create edge case shaders
+ */
 GrEffect* CircleInside2PtConicalEffect::TestCreate(SkRandom* random,
                                                    GrContext* context,
                                                    const GrDrawTargetCaps&,
                                                    GrTexture**) {
     SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()};
     SkScalar radius1 = random->nextUScalar1() + 0.0001f; // make sure radius1 != 0
     SkPoint center2;
     SkScalar radius2;
     do {
         center2.set(random->nextUScalar1(), random->nextUScalar1());
@@ skipping 212 matching lines @@
     typedef GrGLGradientEffect INHERITED;
 
 };
 
 const GrBackendEffectFactory& CircleOutside2PtConicalEffect::getFactory() const {
     return GrTBackendEffectFactory<CircleOutside2PtConicalEffect>::getInstance();
 }
 
 GR_DEFINE_EFFECT_TEST(CircleOutside2PtConicalEffect);
 
+/*
+ * All Two point conical gradient test create functions may occasionally create edge case shaders
+ */
 GrEffect* CircleOutside2PtConicalEffect::TestCreate(SkRandom* random,
                                                     GrContext* context,
                                                     const GrDrawTargetCaps&,
                                                     GrTexture**) {
     SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()};
     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.f, diffLen);
+    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.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 151 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