Ensure the Gaussian tail of circle blurs goes to zero.

src/effects/GrCircleBlurFragmentProcessor.cpp

 
 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrCircleBlurFragmentProcessor.h"
 
@@ skipping 168 matching lines @@
 }
 
 static inline void compute_profile_offset_and_size(float halfWH, float sigma,
                                                    float* offset, int* size) {
 
     if (3*sigma <= halfWH) {
         // The circle is bigger than the Gaussian. In this case we know the interior of the
         // blurred circle is solid.
         *offset = halfWH - 3 * sigma; // This location maps to 0.5f in the weights texture.
                                       // It should always be 255.
-        *size = SkScalarCeilToInt(6*sigma);
+        *size = SkScalarCeilToInt(6*sigma) + 1;
     } else {
         // The Gaussian is bigger than the circle.
         *offset = 0.0f;
         *size = SkScalarCeilToInt(halfWH + 3*sigma);
     }
 }
 
 static uint8_t* create_profile(float halfWH, float sigma) {
 
     int kernelWH = SkScalarCeilToInt(6.0f*sigma);
     kernelWH = (kernelWH + 1) & ~1; // make it the next even number up
 
     SkAutoTArray<float> halfKernel(kernelWH*kernelWH/2);
 
     make_half_kernel(halfKernel.get(), kernelWH, sigma);
 
     float offset;
     int numSteps;
 
     compute_profile_offset_and_size(halfWH, sigma, &offset, &numSteps);
 
     uint8_t* weights = new uint8_t[numSteps];
     for (int i = 0; i < numSteps; ++i) {
         weights[i] = eval_at(offset+i, halfWH, halfKernel.get(), kernelWH);
     }
 

[robertphillips, 2016/02/24 12:52:56]

Are we guaranteed that weights[numSteps-1] will always be zero?
Should we just have:
  weights[numSteps-1] = 0;
here?

[dogben, 2016/02/24 15:31:22]

sgtm

+    SkASSERT(weights[numSteps-1] == 0);
     return weights;
 }
 
 GrTexture* GrCircleBlurFragmentProcessor::CreateCircleBlurProfileTexture(
                                                                 GrTextureProvider* textureProvider,
                                                                 const SkRect& circle,
                                                                 float sigma,
                                                                 float* offset) {
     float halfWH = circle.width() / 2.0f;
 
@@ skipping 31 matching lines @@
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrCircleBlurFragmentProcessor);
 
 const GrFragmentProcessor* GrCircleBlurFragmentProcessor::TestCreate(GrProcessorTestData* d) {
     SkScalar wh = d->fRandom->nextRangeScalar(100.f, 1000.f);
     SkScalar sigma = d->fRandom->nextRangeF(1.f,10.f);
     SkRect circle = SkRect::MakeWH(wh, wh);
     return GrCircleBlurFragmentProcessor::Create(d->fContext->textureProvider(), circle, sigma);
 }
 
 #endif