Bin circular blur profile textures by scale and blur to radius ratio

src/effects/GrCircleBlurFragmentProcessor.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrCircleBlurFragmentProcessor_DEFINED
 #define GrCircleBlurFragmentProcessor_DEFINED
 
@@ skipping 10 matching lines @@
 // This FP handles the special case of a blurred circle. It uses a 1D
 // profile that is just rotated about the origin of the circle.
 class GrCircleBlurFragmentProcessor : public GrFragmentProcessor {
 public:
     ~GrCircleBlurFragmentProcessor() override {};
 
     const char* name() const override { return "CircleBlur"; }
 
     SkString dumpInfo() const override {
         SkString str;
-        str.appendf("Rect [L: %.2f, T: %.2f, R: %.2f, B: %.2f], Sigma %.2f, Offset: %.2f",
+        str.appendf("Rect [L: %.2f, T: %.2f, R: %.2f, B: %.2f], Sigma %.2f, solidR: %.2f, "
+                    "textureR: %.2f",
                     fCircle.fLeft, fCircle.fTop, fCircle.fRight, fCircle.fBottom,
-                    fSigma, fOffset);
+                    fSigma, fSolidRadius, fTextureRadius);
         return str;
     }
 
     static sk_sp<GrFragmentProcessor> Make(GrTextureProvider*textureProvider,
                                            const SkRect& circle, float sigma) {
-        float offset;
+        float solidRadius;
+        float textureRadius;
 
-        SkAutoTUnref<GrTexture> blurProfile(CreateCircleBlurProfileTexture(textureProvider,
-                                                                           circle,
-                                                                           sigma,
-                                                                           &offset));
-        if (!blurProfile) {
+        SkAutoTUnref<GrTexture> profile(CreateCircleBlurProfileTexture(textureProvider,
+                                                                       circle,
+                                                                       sigma,
+                                                                       &solidRadius,
+                                                                       &textureRadius));
+        if (!profile) {
            return nullptr;
         }
         return sk_sp<GrFragmentProcessor>(
-            new GrCircleBlurFragmentProcessor(circle, sigma, offset, blurProfile));
+            new GrCircleBlurFragmentProcessor(circle, sigma, solidRadius, textureRadius, profile));
     }
 
-    const SkRect& circle() const { return fCircle; }
-    float sigma() const { return fSigma; }
-    float offset() const { return fOffset; }
-    int profileSize() const { return fBlurProfileAccess.getTexture()->width(); }
+private:
+    // This nested GLSL processor implementation is defined in the cpp file.
+    class GLSLProcessor;
 
-private:
+    /**
+     * Creates a profile texture for the circle and sigma. The texture will have a height of 1.
+     * The x texture coord should map from 0 to 1 across the radius range of solidRadius to
+     * solidRadius + textureRadius.
+     */
     GrCircleBlurFragmentProcessor(const SkRect& circle, float sigma,
-                                  float offset, GrTexture* blurProfile);
+                                  float solidRadius, float textureRadius, GrTexture* blurProfile);
 
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
 
     void onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override;
 
     bool onIsEqual(const GrFragmentProcessor& other) const override {
         const GrCircleBlurFragmentProcessor& cbfp = other.cast<GrCircleBlurFragmentProcessor>();
         // fOffset is computed from the circle width and the sigma
-        return this->circle() == cbfp.circle() && fSigma == cbfp.fSigma;
+        return this->fCircle == cbfp.fCircle && fSigma == cbfp.fSigma;
     }
 
     void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
 
     static GrTexture* CreateCircleBlurProfileTexture(GrTextureProvider*,
                                                      const SkRect& circle,
-                                                     float sigma, float* offset);
+                                                     float sigma,
+                                                     float* solidRadius,
+                                                     float* textureRadius);
 
     SkRect              fCircle;
     float               fSigma;
-    float               fOffset;
+    float               fSolidRadius;
+    float               fTextureRadius;
     GrTextureAccess     fBlurProfileAccess;
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     typedef GrFragmentProcessor INHERITED;
 };
 
 #endif
 #endif