src/gpu/effects/generated/GrCircleBlurFragmentProcessor.cpp - skia - Git at Google

 /*
  * Copyright 2018 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */

 /**************************************************************************************************
  *** This file was autogenerated from GrCircleBlurFragmentProcessor.fp; do not modify.
  **************************************************************************************************/
 #include "GrCircleBlurFragmentProcessor.h"

 #include "include/gpu/GrRecordingContext.h"
 #include "src/core/SkGpuBlurUtils.h"
 #include "src/gpu/GrProxyProvider.h"
 #include "src/gpu/GrRecordingContextPriv.h"
 #include "src/gpu/GrThreadSafeCache.h"
 #include "src/gpu/SkGr.h"

 // Computes an unnormalized half kernel (right side). Returns the summation of all the half
 // kernel values.
 static float make_unnormalized_half_kernel(float* halfKernel, int halfKernelSize, float sigma) {
     const float invSigma = 1.f / sigma;
     const float b = -0.5f * invSigma * invSigma;
     float tot = 0.0f;
     // Compute half kernel values at half pixel steps out from the center.
     float t = 0.5f;
     for (int i = 0; i < halfKernelSize; ++i) {
         float value = expf(t * t * b);
         tot += value;
         halfKernel[i] = value;
         t += 1.f;
     }
     return tot;
 }

 // Create a Gaussian half-kernel (right side) and a summed area table given a sigma and number
 // of discrete steps. The half kernel is normalized to sum to 0.5.
 static void make_half_kernel_and_summed_table(float* halfKernel,
                                               float* summedHalfKernel,
                                               int halfKernelSize,
                                               float sigma) {
     // The half kernel should sum to 0.5 not 1.0.
     const float tot = 2.f * make_unnormalized_half_kernel(halfKernel, halfKernelSize, sigma);
     float sum = 0.f;
     for (int i = 0; i < halfKernelSize; ++i) {
         halfKernel[i] /= tot;
         sum += halfKernel[i];
         summedHalfKernel[i] = sum;
     }
 }

 // Applies the 1D half kernel vertically at points along the x axis to a circle centered at the
 // origin with radius circleR.
 void apply_kernel_in_y(float* results,
                        int numSteps,
                        float firstX,
                        float circleR,
                        int halfKernelSize,
                        const float* summedHalfKernelTable) {
     float x = firstX;
     for (int i = 0; i < numSteps; ++i, x += 1.f) {
         if (x < -circleR || x > circleR) {
             results[i] = 0;
             continue;
         }
         float y = sqrtf(circleR * circleR - x * x);
         // In the column at x we exit the circle at +y and -y
         // The summed table entry j is actually reflects an offset of j + 0.5.
         y -= 0.5f;
         int yInt = SkScalarFloorToInt(y);
         SkASSERT(yInt >= -1);
         if (y < 0) {
             results[i] = (y + 0.5f) * summedHalfKernelTable[0];
         } else if (yInt >= halfKernelSize - 1) {
             results[i] = 0.5f;
         } else {
             float yFrac = y - yInt;
             results[i] = (1.f - yFrac) * summedHalfKernelTable[yInt] +
                          yFrac * summedHalfKernelTable[yInt + 1];
         }
     }
 }

 // Apply a Gaussian at point (evalX, 0) to a circle centered at the origin with radius circleR.
 // This relies on having a half kernel computed for the Gaussian and a table of applications of
 // the half kernel in y to columns at (evalX - halfKernel, evalX - halfKernel + 1, ..., evalX +
 // halfKernel) passed in as yKernelEvaluations.
 static uint8_t eval_at(float evalX,
                        float circleR,
                        const float* halfKernel,
                        int halfKernelSize,
                        const float* yKernelEvaluations) {
     float acc = 0;

     float x = evalX - halfKernelSize;
     for (int i = 0; i < halfKernelSize; ++i, x += 1.f) {
         if (x < -circleR || x > circleR) {
             continue;
         }
         float verticalEval = yKernelEvaluations[i];
         acc += verticalEval * halfKernel[halfKernelSize - i - 1];
     }
     for (int i = 0; i < halfKernelSize; ++i, x += 1.f) {
         if (x < -circleR || x > circleR) {
             continue;
         }
         float verticalEval = yKernelEvaluations[i + halfKernelSize];
         acc += verticalEval * halfKernel[i];
     }
     // Since we applied a half kernel in y we multiply acc by 2 (the circle is symmetric about
     // the x axis).
     return SkUnitScalarClampToByte(2.f * acc);
 }

 // This function creates a profile of a blurred circle. It does this by computing a kernel for
 // half the Gaussian and a matching summed area table. The summed area table is used to compute
 // an array of vertical applications of the half kernel to the circle along the x axis. The
 // table of y evaluations has 2 * k + n entries where k is the size of the half kernel and n is
 // the size of the profile being computed. Then for each of the n profile entries we walk out k
 // steps in each horizontal direction multiplying the corresponding y evaluation by the half
 // kernel entry and sum these values to compute the profile entry.
 static void create_circle_profile(uint8_t* weights,
                                   float sigma,
                                   float circleR,
                                   int profileTextureWidth) {
     const int numSteps = profileTextureWidth;

     // The full kernel is 6 sigmas wide.
     int halfKernelSize = SkScalarCeilToInt(6.0f * sigma);
     // round up to next multiple of 2 and then divide by 2
     halfKernelSize = ((halfKernelSize + 1) & ~1) >> 1;

     // Number of x steps at which to apply kernel in y to cover all the profile samples in x.
     int numYSteps = numSteps + 2 * halfKernelSize;

     SkAutoTArray<float> bulkAlloc(halfKernelSize + halfKernelSize + numYSteps);
     float* halfKernel = bulkAlloc.get();
     float* summedKernel = bulkAlloc.get() + halfKernelSize;
     float* yEvals = bulkAlloc.get() + 2 * halfKernelSize;
     make_half_kernel_and_summed_table(halfKernel, summedKernel, halfKernelSize, sigma);

     float firstX = -halfKernelSize + 0.5f;
     apply_kernel_in_y(yEvals, numYSteps, firstX, circleR, halfKernelSize, summedKernel);

     for (int i = 0; i < numSteps - 1; ++i) {
         float evalX = i + 0.5f;
         weights[i] = eval_at(evalX, circleR, halfKernel, halfKernelSize, yEvals + i);
     }
     // Ensure the tail of the Gaussian goes to zero.
     weights[numSteps - 1] = 0;
 }

 static void create_half_plane_profile(uint8_t* profile, int profileWidth) {
     SkASSERT(!(profileWidth & 0x1));
     // The full kernel is 6 sigmas wide.
     float sigma = profileWidth / 6.f;
     int halfKernelSize = profileWidth / 2;

     SkAutoTArray<float> halfKernel(halfKernelSize);

     // The half kernel should sum to 0.5.
     const float tot = 2.f * make_unnormalized_half_kernel(halfKernel.get(), halfKernelSize, sigma);
     float sum = 0.f;
     // Populate the profile from the right edge to the middle.
     for (int i = 0; i < halfKernelSize; ++i) {
         halfKernel[halfKernelSize - i - 1] /= tot;
         sum += halfKernel[halfKernelSize - i - 1];
         profile[profileWidth - i - 1] = SkUnitScalarClampToByte(sum);
     }
     // Populate the profile from the middle to the left edge (by flipping the half kernel and
     // continuing the summation).
     for (int i = 0; i < halfKernelSize; ++i) {
         sum += halfKernel[i];
         profile[halfKernelSize - i - 1] = SkUnitScalarClampToByte(sum);
     }
     // Ensure tail goes to 0.
     profile[profileWidth - 1] = 0;
 }

 static std::unique_ptr<GrFragmentProcessor> create_profile_effect(GrRecordingContext* rContext,
                                                                   const SkRect& circle,
                                                                   float sigma,
                                                                   float* solidRadius,
                                                                   float* textureRadius) {
     float circleR = circle.width() / 2.0f;
     if (!sk_float_isfinite(circleR) || circleR < SK_ScalarNearlyZero) {
         return nullptr;
     }

     auto threadSafeCache = rContext->priv().threadSafeCache();

     // Profile textures are cached by the ratio of sigma to circle radius and by the size of the
     // profile texture (binned by powers of 2).
     SkScalar sigmaToCircleRRatio = sigma / circleR;
     // When sigma is really small this becomes a equivalent to convolving a Gaussian with a
     // half-plane. Similarly, in the extreme high ratio cases circle becomes a point WRT to the
     // Guassian and the profile texture is a just a Gaussian evaluation. However, we haven't yet
     // implemented this latter optimization.
     sigmaToCircleRRatio = std::min(sigmaToCircleRRatio, 8.f);
     SkFixed sigmaToCircleRRatioFixed;
     static const SkScalar kHalfPlaneThreshold = 0.1f;
     bool useHalfPlaneApprox = false;
     if (sigmaToCircleRRatio <= kHalfPlaneThreshold) {
         useHalfPlaneApprox = true;
         sigmaToCircleRRatioFixed = 0;
         *solidRadius = circleR - 3 * sigma;
         *textureRadius = 6 * sigma;
     } else {
         // Convert to fixed point for the key.
         sigmaToCircleRRatioFixed = SkScalarToFixed(sigmaToCircleRRatio);
         // We shave off some bits to reduce the number of unique entries. We could probably
         // shave off more than we do.
         sigmaToCircleRRatioFixed &= ~0xff;
         sigmaToCircleRRatio = SkFixedToScalar(sigmaToCircleRRatioFixed);
         sigma = circleR * sigmaToCircleRRatio;
         *solidRadius = 0;
         *textureRadius = circleR + 3 * sigma;
     }

     static constexpr int kProfileTextureWidth = 512;
     // This would be kProfileTextureWidth/textureRadius if it weren't for the fact that we do
     // the calculation of the profile coord in a coord space that has already been scaled by
     // 1 / textureRadius. This is done to avoid overflow in length().
     SkMatrix texM = SkMatrix::Scale(kProfileTextureWidth, 1.f);

     static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
     GrUniqueKey key;
     GrUniqueKey::Builder builder(&key, kDomain, 1, "1-D Circular Blur");
     builder[0] = sigmaToCircleRRatioFixed;
     builder.finish();

     GrSurfaceProxyView profileView = threadSafeCache->find(key);
     if (profileView) {
         SkASSERT(profileView.asTextureProxy());
         SkASSERT(profileView.origin() == kTopLeft_GrSurfaceOrigin);
         return GrTextureEffect::Make(std::move(profileView), kPremul_SkAlphaType, texM);
     }

     SkBitmap bm;
     if (!bm.tryAllocPixels(SkImageInfo::MakeA8(kProfileTextureWidth, 1))) {
         return nullptr;
     }

     if (useHalfPlaneApprox) {
         create_half_plane_profile(bm.getAddr8(0, 0), kProfileTextureWidth);
     } else {
         // Rescale params to the size of the texture we're creating.
         SkScalar scale = kProfileTextureWidth / *textureRadius;
         create_circle_profile(
                 bm.getAddr8(0, 0), sigma * scale, circleR * scale, kProfileTextureWidth);
     }
     bm.setImmutable();

     profileView = std::get<0>(GrMakeUncachedBitmapProxyView(rContext, bm));
     if (!profileView) {
         return nullptr;
     }

     profileView = threadSafeCache->add(key, profileView);
     return GrTextureEffect::Make(std::move(profileView), kPremul_SkAlphaType, texM);
 }

 std::unique_ptr<GrFragmentProcessor> GrCircleBlurFragmentProcessor::Make(
         std::unique_ptr<GrFragmentProcessor> inputFP,
         GrRecordingContext* context,
         const SkRect& circle,
         float sigma) {
     if (SkGpuBlurUtils::IsEffectivelyZeroSigma(sigma)) {
         return inputFP;
     }

     float solidRadius;
     float textureRadius;
     std::unique_ptr<GrFragmentProcessor> profile =
             create_profile_effect(context, circle, sigma, &solidRadius, &textureRadius);
     if (!profile) {
         return nullptr;
     }
     return std::unique_ptr<GrFragmentProcessor>(new GrCircleBlurFragmentProcessor(
             std::move(inputFP), circle, solidRadius, textureRadius, std::move(profile)));
 }
 #include "src/core/SkUtils.h"
 #include "src/gpu/GrTexture.h"
 #include "src/gpu/glsl/GrGLSLFragmentProcessor.h"
 #include "src/gpu/glsl/GrGLSLFragmentShaderBuilder.h"
 #include "src/gpu/glsl/GrGLSLProgramBuilder.h"
 #include "src/sksl/SkSLCPP.h"
 #include "src/sksl/SkSLUtil.h"
 class GrGLSLCircleBlurFragmentProcessor : public GrGLSLFragmentProcessor {
 public:
     GrGLSLCircleBlurFragmentProcessor() {}
     void emitCode(EmitArgs& args) override {
         GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
         const GrCircleBlurFragmentProcessor& _outer =
                 args.fFp.cast<GrCircleBlurFragmentProcessor>();
         (void)_outer;
         auto circleRect = _outer.circleRect;
         (void)circleRect;
         auto solidRadius = _outer.solidRadius;
         (void)solidRadius;
         auto textureRadius = _outer.textureRadius;
         (void)textureRadius;
         circleDataVar = args.fUniformHandler->addUniform(
                 &_outer, kFragment_GrShaderFlag, kHalf4_GrSLType, "circleData");
         fragBuilder->codeAppendf(
                 R"SkSL(half2 vec = half2((sk_FragCoord.xy - float2(%s.xy)) * float(%s.w));
 half dist = length(vec) + (0.5 - %s.z) * %s.w;)SkSL",
                 args.fUniformHandler->getUniformCStr(circleDataVar),
                 args.fUniformHandler->getUniformCStr(circleDataVar),
                 args.fUniformHandler->getUniformCStr(circleDataVar),
                 args.fUniformHandler->getUniformCStr(circleDataVar));
         SkString _sample0 = this->invokeChild(0, args);
         fragBuilder->codeAppendf(
                 R"SkSL(
 half4 inputColor = %s;)SkSL",
                 _sample0.c_str());
         SkString _coords1("float2(half2(dist, 0.5))");
         SkString _sample1 = this->invokeChild(1, args, _coords1.c_str());
         fragBuilder->codeAppendf(
                 R"SkSL(
 return inputColor * %s.w;
 )SkSL",
                 _sample1.c_str());
     }

 private:
     void onSetData(const GrGLSLProgramDataManager& data,
                    const GrFragmentProcessor& _proc) override {
         const GrCircleBlurFragmentProcessor& _outer = _proc.cast<GrCircleBlurFragmentProcessor>();
         auto circleRect = _outer.circleRect;
         (void)circleRect;
         auto solidRadius = _outer.solidRadius;
         (void)solidRadius;
         auto textureRadius = _outer.textureRadius;
         (void)textureRadius;
         UniformHandle& circleData = circleDataVar;
         (void)circleData;

         data.set4f(circleData,
                    circleRect.centerX(),
                    circleRect.centerY(),
                    solidRadius,
                    1.f / textureRadius);
     }
     UniformHandle circleDataVar;
 };
 std::unique_ptr<GrGLSLFragmentProcessor> GrCircleBlurFragmentProcessor::onMakeProgramImpl() const {
     return std::make_unique<GrGLSLCircleBlurFragmentProcessor>();
 }
 void GrCircleBlurFragmentProcessor::onGetGLSLProcessorKey(const GrShaderCaps& caps,
                                                           GrProcessorKeyBuilder* b) const {}
 bool GrCircleBlurFragmentProcessor::onIsEqual(const GrFragmentProcessor& other) const {
     const GrCircleBlurFragmentProcessor& that = other.cast<GrCircleBlurFragmentProcessor>();
     (void)that;
     if (circleRect != that.circleRect) return false;
     if (solidRadius != that.solidRadius) return false;
     if (textureRadius != that.textureRadius) return false;
     return true;
 }
 GrCircleBlurFragmentProcessor::GrCircleBlurFragmentProcessor(
         const GrCircleBlurFragmentProcessor& src)
         : INHERITED(kGrCircleBlurFragmentProcessor_ClassID, src.optimizationFlags())
         , circleRect(src.circleRect)
         , solidRadius(src.solidRadius)
         , textureRadius(src.textureRadius) {
     this->cloneAndRegisterAllChildProcessors(src);
 }
 std::unique_ptr<GrFragmentProcessor> GrCircleBlurFragmentProcessor::clone() const {
     return std::make_unique<GrCircleBlurFragmentProcessor>(*this);
 }
 #if GR_TEST_UTILS
 SkString GrCircleBlurFragmentProcessor::onDumpInfo() const {
     return SkStringPrintf("(circleRect=half4(%f, %f, %f, %f), solidRadius=%f, textureRadius=%f)",
                           circleRect.left(),
                           circleRect.top(),
                           circleRect.right(),
                           circleRect.bottom(),
                           solidRadius,
                           textureRadius);
 }
 #endif
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrCircleBlurFragmentProcessor);
 #if GR_TEST_UTILS
 std::unique_ptr<GrFragmentProcessor> GrCircleBlurFragmentProcessor::TestCreate(
         GrProcessorTestData* testData) {
     SkScalar wh = testData->fRandom->nextRangeScalar(100.f, 1000.f);
     SkScalar sigma = testData->fRandom->nextRangeF(1.f, 10.f);
     SkRect circle = SkRect::MakeWH(wh, wh);
     return GrCircleBlurFragmentProcessor::Make(
             testData->inputFP(), testData->context(), circle, sigma);
 }
 #endif
	/*
	* Copyright 2018 Google Inc.
	*
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	/**************************************************************************************************
	*** This file was autogenerated from GrCircleBlurFragmentProcessor.fp; do not modify.
	**************************************************************************************************/
	#include "GrCircleBlurFragmentProcessor.h"

	#include "include/gpu/GrRecordingContext.h"
	#include "src/core/SkGpuBlurUtils.h"
	#include "src/gpu/GrProxyProvider.h"
	#include "src/gpu/GrRecordingContextPriv.h"
	#include "src/gpu/GrThreadSafeCache.h"
	#include "src/gpu/SkGr.h"

	// Computes an unnormalized half kernel (right side). Returns the summation of all the half
	// kernel values.
	static float make_unnormalized_half_kernel(float* halfKernel, int halfKernelSize, float sigma) {
	const float invSigma = 1.f / sigma;
	const float b = -0.5f * invSigma * invSigma;
	float tot = 0.0f;
	// Compute half kernel values at half pixel steps out from the center.
	float t = 0.5f;
	for (int i = 0; i < halfKernelSize; ++i) {
	float value = expf(t * t * b);
	tot += value;
	halfKernel[i] = value;
	t += 1.f;
	}
	return tot;
	}

	// Create a Gaussian half-kernel (right side) and a summed area table given a sigma and number
	// of discrete steps. The half kernel is normalized to sum to 0.5.
	static void make_half_kernel_and_summed_table(float* halfKernel,
	float* summedHalfKernel,
	int halfKernelSize,
	float sigma) {
	// The half kernel should sum to 0.5 not 1.0.
	const float tot = 2.f * make_unnormalized_half_kernel(halfKernel, halfKernelSize, sigma);
	float sum = 0.f;
	for (int i = 0; i < halfKernelSize; ++i) {
	halfKernel[i] /= tot;
	sum += halfKernel[i];
	summedHalfKernel[i] = sum;
	}
	}

	// Applies the 1D half kernel vertically at points along the x axis to a circle centered at the
	// origin with radius circleR.
	void apply_kernel_in_y(float* results,
	int numSteps,
	float firstX,
	float circleR,
	int halfKernelSize,
	const float* summedHalfKernelTable) {
	float x = firstX;
	for (int i = 0; i < numSteps; ++i, x += 1.f) {
	if (x < -circleR \|\| x > circleR) {
	results[i] = 0;
	continue;
	}
	float y = sqrtf(circleR * circleR - x * x);
	// In the column at x we exit the circle at +y and -y
	// The summed table entry j is actually reflects an offset of j + 0.5.
	y -= 0.5f;
	int yInt = SkScalarFloorToInt(y);
	SkASSERT(yInt >= -1);
	if (y < 0) {
	results[i] = (y + 0.5f) * summedHalfKernelTable[0];
	} else if (yInt >= halfKernelSize - 1) {
	results[i] = 0.5f;
	} else {
	float yFrac = y - yInt;
	results[i] = (1.f - yFrac) * summedHalfKernelTable[yInt] +
	yFrac * summedHalfKernelTable[yInt + 1];
	}
	}
	}

	// Apply a Gaussian at point (evalX, 0) to a circle centered at the origin with radius circleR.
	// This relies on having a half kernel computed for the Gaussian and a table of applications of
	// the half kernel in y to columns at (evalX - halfKernel, evalX - halfKernel + 1, ..., evalX +
	// halfKernel) passed in as yKernelEvaluations.
	static uint8_t eval_at(float evalX,
	float circleR,
	const float* halfKernel,
	int halfKernelSize,
	const float* yKernelEvaluations) {
	float acc = 0;

	float x = evalX - halfKernelSize;
	for (int i = 0; i < halfKernelSize; ++i, x += 1.f) {
	if (x < -circleR \|\| x > circleR) {
	continue;
	}
	float verticalEval = yKernelEvaluations[i];
	acc += verticalEval * halfKernel[halfKernelSize - i - 1];
	}
	for (int i = 0; i < halfKernelSize; ++i, x += 1.f) {
	if (x < -circleR \|\| x > circleR) {
	continue;
	}
	float verticalEval = yKernelEvaluations[i + halfKernelSize];
	acc += verticalEval * halfKernel[i];
	}
	// Since we applied a half kernel in y we multiply acc by 2 (the circle is symmetric about
	// the x axis).
	return SkUnitScalarClampToByte(2.f * acc);
	}

	// This function creates a profile of a blurred circle. It does this by computing a kernel for
	// half the Gaussian and a matching summed area table. The summed area table is used to compute
	// an array of vertical applications of the half kernel to the circle along the x axis. The
	// table of y evaluations has 2 * k + n entries where k is the size of the half kernel and n is
	// the size of the profile being computed. Then for each of the n profile entries we walk out k
	// steps in each horizontal direction multiplying the corresponding y evaluation by the half
	// kernel entry and sum these values to compute the profile entry.
	static void create_circle_profile(uint8_t* weights,
	float sigma,
	float circleR,
	int profileTextureWidth) {
	const int numSteps = profileTextureWidth;

	// The full kernel is 6 sigmas wide.
	int halfKernelSize = SkScalarCeilToInt(6.0f * sigma);
	// round up to next multiple of 2 and then divide by 2
	halfKernelSize = ((halfKernelSize + 1) & ~1) >> 1;

	// Number of x steps at which to apply kernel in y to cover all the profile samples in x.
	int numYSteps = numSteps + 2 * halfKernelSize;

	SkAutoTArray<float> bulkAlloc(halfKernelSize + halfKernelSize + numYSteps);
	float* halfKernel = bulkAlloc.get();
	float* summedKernel = bulkAlloc.get() + halfKernelSize;
	float* yEvals = bulkAlloc.get() + 2 * halfKernelSize;
	make_half_kernel_and_summed_table(halfKernel, summedKernel, halfKernelSize, sigma);

	float firstX = -halfKernelSize + 0.5f;
	apply_kernel_in_y(yEvals, numYSteps, firstX, circleR, halfKernelSize, summedKernel);

	for (int i = 0; i < numSteps - 1; ++i) {
	float evalX = i + 0.5f;
	weights[i] = eval_at(evalX, circleR, halfKernel, halfKernelSize, yEvals + i);
	}
	// Ensure the tail of the Gaussian goes to zero.
	weights[numSteps - 1] = 0;
	}

	static void create_half_plane_profile(uint8_t* profile, int profileWidth) {
	SkASSERT(!(profileWidth & 0x1));
	// The full kernel is 6 sigmas wide.
	float sigma = profileWidth / 6.f;
	int halfKernelSize = profileWidth / 2;

	SkAutoTArray<float> halfKernel(halfKernelSize);

	// The half kernel should sum to 0.5.
	const float tot = 2.f * make_unnormalized_half_kernel(halfKernel.get(), halfKernelSize, sigma);
	float sum = 0.f;
	// Populate the profile from the right edge to the middle.
	for (int i = 0; i < halfKernelSize; ++i) {
	halfKernel[halfKernelSize - i - 1] /= tot;
	sum += halfKernel[halfKernelSize - i - 1];
	profile[profileWidth - i - 1] = SkUnitScalarClampToByte(sum);
	}
	// Populate the profile from the middle to the left edge (by flipping the half kernel and
	// continuing the summation).
	for (int i = 0; i < halfKernelSize; ++i) {
	sum += halfKernel[i];
	profile[halfKernelSize - i - 1] = SkUnitScalarClampToByte(sum);
	}
	// Ensure tail goes to 0.
	profile[profileWidth - 1] = 0;
	}

	static std::unique_ptr<GrFragmentProcessor> create_profile_effect(GrRecordingContext* rContext,
	const SkRect& circle,
	float sigma,
	float* solidRadius,
	float* textureRadius) {
	float circleR = circle.width() / 2.0f;
	if (!sk_float_isfinite(circleR) \|\| circleR < SK_ScalarNearlyZero) {
	return nullptr;
	}

	auto threadSafeCache = rContext->priv().threadSafeCache();

	// Profile textures are cached by the ratio of sigma to circle radius and by the size of the
	// profile texture (binned by powers of 2).
	SkScalar sigmaToCircleRRatio = sigma / circleR;
	// When sigma is really small this becomes a equivalent to convolving a Gaussian with a
	// half-plane. Similarly, in the extreme high ratio cases circle becomes a point WRT to the
	// Guassian and the profile texture is a just a Gaussian evaluation. However, we haven't yet
	// implemented this latter optimization.
	sigmaToCircleRRatio = std::min(sigmaToCircleRRatio, 8.f);
	SkFixed sigmaToCircleRRatioFixed;
	static const SkScalar kHalfPlaneThreshold = 0.1f;
	bool useHalfPlaneApprox = false;
	if (sigmaToCircleRRatio <= kHalfPlaneThreshold) {
	useHalfPlaneApprox = true;
	sigmaToCircleRRatioFixed = 0;
	solidRadius = circleR - 3 sigma;
	textureRadius = 6 sigma;
	} else {
	// Convert to fixed point for the key.
	sigmaToCircleRRatioFixed = SkScalarToFixed(sigmaToCircleRRatio);
	// We shave off some bits to reduce the number of unique entries. We could probably
	// shave off more than we do.
	sigmaToCircleRRatioFixed &= ~0xff;
	sigmaToCircleRRatio = SkFixedToScalar(sigmaToCircleRRatioFixed);
	sigma = circleR * sigmaToCircleRRatio;
	*solidRadius = 0;
	textureRadius = circleR + 3 sigma;
	}

	static constexpr int kProfileTextureWidth = 512;
	// This would be kProfileTextureWidth/textureRadius if it weren't for the fact that we do
	// the calculation of the profile coord in a coord space that has already been scaled by
	// 1 / textureRadius. This is done to avoid overflow in length().
	SkMatrix texM = SkMatrix::Scale(kProfileTextureWidth, 1.f);

	static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
	GrUniqueKey key;
	GrUniqueKey::Builder builder(&key, kDomain, 1, "1-D Circular Blur");
	builder[0] = sigmaToCircleRRatioFixed;
	builder.finish();

	GrSurfaceProxyView profileView = threadSafeCache->find(key);
	if (profileView) {
	SkASSERT(profileView.asTextureProxy());
	SkASSERT(profileView.origin() == kTopLeft_GrSurfaceOrigin);
	return GrTextureEffect::Make(std::move(profileView), kPremul_SkAlphaType, texM);
	}

	SkBitmap bm;
	if (!bm.tryAllocPixels(SkImageInfo::MakeA8(kProfileTextureWidth, 1))) {
	return nullptr;
	}

	if (useHalfPlaneApprox) {
	create_half_plane_profile(bm.getAddr8(0, 0), kProfileTextureWidth);
	} else {
	// Rescale params to the size of the texture we're creating.
	SkScalar scale = kProfileTextureWidth / *textureRadius;
	create_circle_profile(
	bm.getAddr8(0, 0), sigma * scale, circleR * scale, kProfileTextureWidth);
	}
	bm.setImmutable();

	profileView = std::get<0>(GrMakeUncachedBitmapProxyView(rContext, bm));
	if (!profileView) {
	return nullptr;
	}

	profileView = threadSafeCache->add(key, profileView);
	return GrTextureEffect::Make(std::move(profileView), kPremul_SkAlphaType, texM);
	}

	std::unique_ptr<GrFragmentProcessor> GrCircleBlurFragmentProcessor::Make(
	std::unique_ptr<GrFragmentProcessor> inputFP,
	GrRecordingContext* context,
	const SkRect& circle,
	float sigma) {
	if (SkGpuBlurUtils::IsEffectivelyZeroSigma(sigma)) {
	return inputFP;
	}

	float solidRadius;
	float textureRadius;
	std::unique_ptr<GrFragmentProcessor> profile =
	create_profile_effect(context, circle, sigma, &solidRadius, &textureRadius);
	if (!profile) {
	return nullptr;
	}
	return std::unique_ptr<GrFragmentProcessor>(new GrCircleBlurFragmentProcessor(
	std::move(inputFP), circle, solidRadius, textureRadius, std::move(profile)));
	}
	#include "src/core/SkUtils.h"
	#include "src/gpu/GrTexture.h"
	#include "src/gpu/glsl/GrGLSLFragmentProcessor.h"
	#include "src/gpu/glsl/GrGLSLFragmentShaderBuilder.h"
	#include "src/gpu/glsl/GrGLSLProgramBuilder.h"
	#include "src/sksl/SkSLCPP.h"
	#include "src/sksl/SkSLUtil.h"
	class GrGLSLCircleBlurFragmentProcessor : public GrGLSLFragmentProcessor {
	public:
	GrGLSLCircleBlurFragmentProcessor() {}
	void emitCode(EmitArgs& args) override {
	GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
	const GrCircleBlurFragmentProcessor& _outer =
	args.fFp.cast<GrCircleBlurFragmentProcessor>();
	(void)_outer;
	auto circleRect = _outer.circleRect;
	(void)circleRect;
	auto solidRadius = _outer.solidRadius;
	(void)solidRadius;
	auto textureRadius = _outer.textureRadius;
	(void)textureRadius;
	circleDataVar = args.fUniformHandler->addUniform(
	&_outer, kFragment_GrShaderFlag, kHalf4_GrSLType, "circleData");
	fragBuilder->codeAppendf(
	R"SkSL(half2 vec = half2((sk_FragCoord.xy - float2(%s.xy)) * float(%s.w));
	half dist = length(vec) + (0.5 - %s.z) * %s.w;)SkSL",
	args.fUniformHandler->getUniformCStr(circleDataVar),
	args.fUniformHandler->getUniformCStr(circleDataVar),
	args.fUniformHandler->getUniformCStr(circleDataVar),
	args.fUniformHandler->getUniformCStr(circleDataVar));
	SkString _sample0 = this->invokeChild(0, args);
	fragBuilder->codeAppendf(
	R"SkSL(
	half4 inputColor = %s;)SkSL",
	_sample0.c_str());
	SkString _coords1("float2(half2(dist, 0.5))");
	SkString _sample1 = this->invokeChild(1, args, _coords1.c_str());
	fragBuilder->codeAppendf(
	R"SkSL(
	return inputColor * %s.w;
	)SkSL",
	_sample1.c_str());
	}

	private:
	void onSetData(const GrGLSLProgramDataManager& data,
	const GrFragmentProcessor& _proc) override {
	const GrCircleBlurFragmentProcessor& _outer = _proc.cast<GrCircleBlurFragmentProcessor>();
	auto circleRect = _outer.circleRect;
	(void)circleRect;
	auto solidRadius = _outer.solidRadius;
	(void)solidRadius;
	auto textureRadius = _outer.textureRadius;
	(void)textureRadius;
	UniformHandle& circleData = circleDataVar;
	(void)circleData;

	data.set4f(circleData,
	circleRect.centerX(),
	circleRect.centerY(),
	solidRadius,
	1.f / textureRadius);
	}
	UniformHandle circleDataVar;
	};
	std::unique_ptr<GrGLSLFragmentProcessor> GrCircleBlurFragmentProcessor::onMakeProgramImpl() const {
	return std::make_unique<GrGLSLCircleBlurFragmentProcessor>();
	}
	void GrCircleBlurFragmentProcessor::onGetGLSLProcessorKey(const GrShaderCaps& caps,
	GrProcessorKeyBuilder* b) const {}
	bool GrCircleBlurFragmentProcessor::onIsEqual(const GrFragmentProcessor& other) const {
	const GrCircleBlurFragmentProcessor& that = other.cast<GrCircleBlurFragmentProcessor>();
	(void)that;
	if (circleRect != that.circleRect) return false;
	if (solidRadius != that.solidRadius) return false;
	if (textureRadius != that.textureRadius) return false;
	return true;
	}
	GrCircleBlurFragmentProcessor::GrCircleBlurFragmentProcessor(
	const GrCircleBlurFragmentProcessor& src)
	: INHERITED(kGrCircleBlurFragmentProcessor_ClassID, src.optimizationFlags())
	, circleRect(src.circleRect)
	, solidRadius(src.solidRadius)
	, textureRadius(src.textureRadius) {
	this->cloneAndRegisterAllChildProcessors(src);
	}
	std::unique_ptr<GrFragmentProcessor> GrCircleBlurFragmentProcessor::clone() const {
	return std::make_unique<GrCircleBlurFragmentProcessor>(*this);
	}
	#if GR_TEST_UTILS
	SkString GrCircleBlurFragmentProcessor::onDumpInfo() const {
	return SkStringPrintf("(circleRect=half4(%f, %f, %f, %f), solidRadius=%f, textureRadius=%f)",
	circleRect.left(),
	circleRect.top(),
	circleRect.right(),
	circleRect.bottom(),
	solidRadius,
	textureRadius);
	}
	#endif
	GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrCircleBlurFragmentProcessor);
	#if GR_TEST_UTILS
	std::unique_ptr<GrFragmentProcessor> GrCircleBlurFragmentProcessor::TestCreate(
	GrProcessorTestData* testData) {
	SkScalar wh = testData->fRandom->nextRangeScalar(100.f, 1000.f);
	SkScalar sigma = testData->fRandom->nextRangeF(1.f, 10.f);
	SkRect circle = SkRect::MakeWH(wh, wh);
	return GrCircleBlurFragmentProcessor::Make(
	testData->inputFP(), testData->context(), circle, sigma);
	}
	#endif