Fixup SkRRectsGaussianEdgeShader's shaders

src/effects/SkRRectsGaussianEdgeShader.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkRRectsGaussianEdgeShader.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
@@ skipping 86 matching lines @@
         this->setWillReadFragmentPosition();
 
         fFirstMode = ComputeMode(fFirst);
         fSecondMode = ComputeMode(fSecond);
     }
 
     class GLSLRRectsGaussianEdgeFP : public GrGLSLFragmentProcessor {
     public:
         GLSLRRectsGaussianEdgeFP() { }
 
+        // This method emits code so that, for each shape, the distance from the edge is returned
+        // in 'outputName' clamped to 0..1 with positive distance being towards the center of the
+        // shape. The distance will have been normalized by the radius.
         void emitModeCode(Mode mode,
                           GrGLSLFPFragmentBuilder* fragBuilder,
                           const char* posName,
                           const char* sizesName,
                           const char* radiiName,
+                          const char* padRadName,
                           const char* outputName,
                           const char  indices[2]) { // how to access the params for the 2 rrects
 
             // positive distance is towards the center of the circle
             fragBuilder->codeAppendf("vec2 delta = %s.xy - %s.%s;",
-                                     fragBuilder->fragmentPosition(),
-                                     posName, indices);
+                                     fragBuilder->fragmentPosition(), posName, indices);
 
             switch (mode) {
             case kCircle_Mode:
-                fragBuilder->codeAppendf("%s = %s.%c - length(delta);",
-                                         outputName,
-                                         sizesName, indices[0]);
+                fragBuilder->codeAppendf("%s = clamp((%s.%c - length(delta))/%s.y, 0.0, 1.0);",
+                                         outputName, sizesName, indices[0], padRadName);
                 break;
             case kRect_Mode:
-                fragBuilder->codeAppendf("float xDist = %s.%c - abs(delta.x);",
-                                         sizesName, indices[0]);
-                fragBuilder->codeAppendf("float yDist = %s.%c - abs(delta.y);",
-                                         sizesName, indices[1]);
-                fragBuilder->codeAppendf("%s = min(xDist, yDist);", outputName);
+                fragBuilder->codeAppendf(
+                    "vec2 rectDist = vec2(1.0 - clamp((%s.%c - abs(delta.x))/%s.y, 0.0, 1.0),"
+                                         "1.0 - clamp((%s.%c - abs(delta.y))/%s.y, 0.0, 1.0));",
+                    sizesName, indices[0], padRadName,
+                    sizesName, indices[1], padRadName);
+                fragBuilder->codeAppendf("%s = 1.0 - length(rectDist);", outputName);
                 break;
             case kSimpleCircular_Mode:
                 // For the circular round rect we first compute the distance
                 // to the rect. Then we compute a multiplier that is 1 if the
                 // point is in one of the circular corners. We then compute the
                 // distance from the corner and then use the multiplier to mask
                 // between the two distances.
-                fragBuilder->codeAppendf("float xDist = %s.%c - abs(delta.x);",
-                                         sizesName, indices[0]);
-                fragBuilder->codeAppendf("float yDist = %s.%c - abs(delta.y);",
-                                         sizesName, indices[1]);
+                fragBuilder->codeAppendf("float xDist = clamp((%s.%c - abs(delta.x))/%s.y,"
+                                                             " 0.0, 1.0);",
+                                         sizesName, indices[0], padRadName);
+                fragBuilder->codeAppendf("float yDist = clamp((%s.%c - abs(delta.y))/%s.y,"
+                                                             "0.0, 1.0);",
+                                         sizesName, indices[1], padRadName);
                 fragBuilder->codeAppend("float rectDist = min(xDist, yDist);");
 
                 fragBuilder->codeAppendf("vec2 cornerCenter = %s.%s - %s.%s;",
-                                         sizesName, indices,
-                                         radiiName, indices);
+                                         sizesName, indices, radiiName, indices);
                 fragBuilder->codeAppend("delta = vec2(abs(delta.x) - cornerCenter.x,"
                                                      "abs(delta.y) - cornerCenter.y);");
-                fragBuilder->codeAppendf("xDist = %s.%c - abs(delta.x);",
-                                         radiiName, indices[0]);
-                fragBuilder->codeAppendf("yDist = %s.%c - abs(delta.y);",
-                                         radiiName, indices[1]);
+                fragBuilder->codeAppendf("xDist = %s.%c - abs(delta.x);", radiiName, indices[0]);
+                fragBuilder->codeAppendf("yDist = %s.%c - abs(delta.y);", radiiName, indices[1]);
                 fragBuilder->codeAppend("float cornerDist = min(xDist, yDist);");
                 fragBuilder->codeAppend("float multiplier = step(0.0, cornerDist);");
 
                 fragBuilder->codeAppendf("delta += %s.%s;", radiiName, indices);
 
-                fragBuilder->codeAppendf("cornerDist = 2.0 * %s.%c - length(delta);",
-                                         radiiName, indices[0]);
+                fragBuilder->codeAppendf("cornerDist = clamp((2.0 * %s.%c - length(delta))/%s.y,"
+                                                             "0.0, 1.0);",
+                                         radiiName, indices[0], padRadName);
 
                 fragBuilder->codeAppendf("%s = (multiplier * cornerDist) +"
                                               "((1.0-multiplier) * rectDist);",
                                          outputName);
                 break;
             }
         }
 
         void emitCode(EmitArgs& args) override {
             const RRectsGaussianEdgeFP& fp = args.fFp.cast<RRectsGaussianEdgeFP>();
             GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
             GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
 
             const char* positionsUniName = nullptr;
             fPositionsUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                                        kVec4f_GrSLType, kDefault_GrSLPrecision,
                                                        "Positions", &positionsUniName);
             const char* sizesUniName = nullptr;
             fSizesUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                                    kVec4f_GrSLType, kDefault_GrSLPrecision,
                                                    "Sizes", &sizesUniName);
             const char* radiiUniName = nullptr;
-            fRadiiUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
-                                                   kVec4f_GrSLType, kDefault_GrSLPrecision,
-                                                   "Radii", &radiiUniName);
+            if (fp.fFirstMode == kSimpleCircular_Mode || fp.fSecondMode == kSimpleCircular_Mode) {
+                fRadiiUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
+                                                       kVec4f_GrSLType, kDefault_GrSLPrecision,
+                                                       "Radii", &radiiUniName);
+            }
             const char* padRadUniName = nullptr;
             fPadRadUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                                     kVec2f_GrSLType, kDefault_GrSLPrecision,
                                                     "PadRad", &padRadUniName);
 
             fragBuilder->codeAppend("float firstDist;");
             fragBuilder->codeAppend("{");
             this->emitModeCode(fp.firstMode(), fragBuilder,
-                               positionsUniName, sizesUniName, radiiUniName, "firstDist", "xy");
+                               positionsUniName, sizesUniName, radiiUniName,
+                               padRadUniName, "firstDist", "xy");
             fragBuilder->codeAppend("}");
 
             fragBuilder->codeAppend("float secondDist;");
             fragBuilder->codeAppend("{");
             this->emitModeCode(fp.secondMode(), fragBuilder,
-                               positionsUniName, sizesUniName, radiiUniName, "secondDist", "zw");
+                               positionsUniName, sizesUniName, radiiUniName,
+                               padRadUniName, "secondDist", "zw");
             fragBuilder->codeAppend("}");
 
-            // Here use the sign of the distance to the two round rects to mask off the different
-            // cases.
-            fragBuilder->codeAppend("float in1 = step(0.0f, firstDist);");
-            fragBuilder->codeAppend("float in2 = step(0.0f, secondDist);");
-            fragBuilder->codeAppend("float dist = "
-                                             "in1*in2             * min(firstDist, secondDist);"
-                                             "in1*(1.0-in2)       * firstDist +"
-                                             "(1.0-in1)*in2       * secondDist;");
+            fragBuilder->codeAppendf("float dist = %s.y * firstDist * secondDist;",
+                                     padRadUniName);
 
             // Finally use the distance to apply the Gaussian edge
+            // TODO: we undo the multiply by the radius here - we should just skip both
             fragBuilder->codeAppendf("float factor = 1.0 - clamp((dist - %s.x)/%s.y, 0.0, 1.0);",
                                      padRadUniName, padRadUniName);
             fragBuilder->codeAppend("factor = exp(-factor * factor * 4.0) - 0.018;");
             fragBuilder->codeAppendf("%s = vec4(%s.rgb, factor);",
                                      args.fOutputColor, args.fInputColor);
         }
 
         static void GenKey(const GrProcessor& proc, const GrGLSLCaps&,
                            GrProcessorKeyBuilder* b) {
             const RRectsGaussianEdgeFP& fp = proc.cast<RRectsGaussianEdgeFP>();
@@ skipping 13 matching lines @@
                         first.getBounds().centerY(),
                         second.getBounds().centerX(),
                         second.getBounds().centerY());
 
             pdman.set4f(fSizesUni, 
                         0.5f * first.rect().width(),
                         0.5f * first.rect().height(),
                         0.5f * second.rect().width(),
                         0.5f * second.rect().height());
 
-            // This is a bit of overkill since fX should equal fY for both round rects but it
-            // makes the shader code simpler.
-            pdman.set4f(fRadiiUni, 
-                         0.5f * first.getSimpleRadii().fX,
-                         0.5f * first.getSimpleRadii().fY,
-                         0.5f * second.getSimpleRadii().fX,
-                         0.5f * second.getSimpleRadii().fY);
+            if (edgeFP.firstMode() == kSimpleCircular_Mode ||
+                edgeFP.secondMode() == kSimpleCircular_Mode) {
+                // This is a bit of overkill since fX should equal fY for both round rects but it
+                // makes the shader code simpler.
+                pdman.set4f(fRadiiUni, 
+                             0.5f * first.getSimpleRadii().fX,
+                             0.5f * first.getSimpleRadii().fY,
+                             0.5f * second.getSimpleRadii().fX,
+                             0.5f * second.getSimpleRadii().fY);
+            }
 
             pdman.set2f(fPadRadUni, edgeFP.pad(), edgeFP.radius());
         }
 
     private:
         // The centers of the two round rects (x1, y1, x2, y2)
         GrGLSLProgramDataManager::UniformHandle fPositionsUni;
 
         // The half widths and half heights of the two round rects (w1/2, h1/2, w2/2, h2/2)
         // For circles we still upload both width & height to simplify things
@@ skipping 163 matching lines @@
     return sk_make_sp<SkRRectsGaussianEdgeShaderImpl>(first, second, radius, pad);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkRRectsGaussianEdgeShader)
 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkRRectsGaussianEdgeShaderImpl)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
 
 ///////////////////////////////////////////////////////////////////////////////