Fix color bug in SkRRectsGaussianEdgeShader

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"
 
  /** \class SkRRectsGaussianEdgeShaderImpl
   * This shader applies a gaussian edge to the intersection of two round rects.
   * The round rects must have the same radii at each corner and the x&y radii
   * must also be equal.
   */
 class SkRRectsGaussianEdgeShaderImpl : public SkShader {
 public:
-    SkRRectsGaussianEdgeShaderImpl(const SkRRect& first, const SkRRect& second,
-                                   SkScalar radius, SkScalar pad)
+    SkRRectsGaussianEdgeShaderImpl(const SkRRect& first, const SkRRect& second, SkScalar radius)
         : fFirst(first)
         , fSecond(second)
-        , fRadius(radius)
-        , fPad(pad) {
+        , fRadius(radius) {
     }
 
     bool isOpaque() const override { return false; }
 
 #if SK_SUPPORT_GPU
     sk_sp<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const override;
 #endif
 
     class GaussianEdgeShaderContext : public SkShader::Context {
     public:
@@ skipping 16 matching lines @@
 
 protected:
     void flatten(SkWriteBuffer&) const override;
     size_t onContextSize(const ContextRec&) const override;
     Context* onCreateContext(const ContextRec&, void*) const override;
 
 private:
     SkRRect  fFirst;
     SkRRect  fSecond;
     SkScalar fRadius;
-    SkScalar fPad;
 
     friend class SkRRectsGaussianEdgeShader; // for serialization registration system
 
     typedef SkShader INHERITED;
 };
 
 ////////////////////////////////////////////////////////////////////////////
 
 #if SK_SUPPORT_GPU
 
 #include "GrCoordTransform.h"
 #include "GrFragmentProcessor.h"
 #include "GrInvariantOutput.h"
 #include "glsl/GrGLSLFragmentProcessor.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
 #include "glsl/GrGLSLProgramDataManager.h"
 #include "glsl/GrGLSLUniformHandler.h"
 #include "SkGr.h"
 #include "SkGrPriv.h"
 
 class RRectsGaussianEdgeFP : public GrFragmentProcessor {
 public:
     enum Mode {
         kCircle_Mode,
         kRect_Mode,
         kSimpleCircular_Mode,
     };
 
-    RRectsGaussianEdgeFP(const SkRRect& first, const SkRRect& second,
-                         SkScalar radius, SkScalar pad)
+    RRectsGaussianEdgeFP(const SkRRect& first, const SkRRect& second, SkScalar radius)
         : fFirst(first)
         , fSecond(second)
-        , fRadius(radius)
-        , fPad(pad) {
+        , fRadius(radius) {
         this->initClassID<RRectsGaussianEdgeFP>();
         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* radName,
                           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);
 
             switch (mode) {
             case kCircle_Mode:
-                fragBuilder->codeAppendf("%s = clamp((%s.%c - length(delta))/%s.y, 0.0, 1.0);",
-                                         outputName, sizesName, indices[0], padRadName);
+                fragBuilder->codeAppendf("%s = clamp((%s.%c - length(delta))/%s, 0.0, 1.0);",
+                                         outputName, sizesName, indices[0], radName);
                 break;
             case kRect_Mode:
                 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);
+                    "vec2 rectDist = vec2(1.0 - clamp((%s.%c - abs(delta.x))/%s, 0.0, 1.0),"
+                                         "1.0 - clamp((%s.%c - abs(delta.y))/%s, 0.0, 1.0));",
+                    sizesName, indices[0], radName,
+                    sizesName, indices[1], radName);
                 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 = clamp((%s.%c - abs(delta.x))/%s.y,"
+                fragBuilder->codeAppendf("float xDist = clamp((%s.%c - abs(delta.x))/%s,"
                                                              " 0.0, 1.0);",
-                                         sizesName, indices[0], padRadName);
-                fragBuilder->codeAppendf("float yDist = clamp((%s.%c - abs(delta.y))/%s.y,"
+                                         sizesName, indices[0], radName);
+                fragBuilder->codeAppendf("float yDist = clamp((%s.%c - abs(delta.y))/%s,"
                                                              "0.0, 1.0);",
-                                         sizesName, indices[1], padRadName);
+                                         sizesName, indices[1], radName);
                 fragBuilder->codeAppend("float rectDist = min(xDist, yDist);");
 
                 fragBuilder->codeAppendf("vec2 cornerCenter = %s.%s - %s.%s;",
                                          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->codeAppend("float cornerDist = min(xDist, yDist);");
                 fragBuilder->codeAppend("float multiplier = step(0.0, cornerDist);");
 
                 fragBuilder->codeAppendf("delta += %s.%s;", radiiName, indices);
 
-                fragBuilder->codeAppendf("cornerDist = clamp((2.0 * %s.%c - length(delta))/%s.y,"
+                fragBuilder->codeAppendf("cornerDist = clamp((2.0 * %s.%c - length(delta))/%s,"
                                                              "0.0, 1.0);",
-                                         radiiName, indices[0], padRadName);
+                                         radiiName, indices[0], radName);
 
                 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;
             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);
+            const char* radUniName = nullptr;
+            fRadiusUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
+                                                    kFloat_GrSLType, kDefault_GrSLPrecision,
+                                                    "Radius", &radUniName);
 
             fragBuilder->codeAppend("float firstDist;");
             fragBuilder->codeAppend("{");
             this->emitModeCode(fp.firstMode(), fragBuilder,
                                positionsUniName, sizesUniName, radiiUniName,
-                               padRadUniName, "firstDist", "xy");
+                               radUniName, "firstDist", "xy");
             fragBuilder->codeAppend("}");
 
             fragBuilder->codeAppend("float secondDist;");
             fragBuilder->codeAppend("{");
             this->emitModeCode(fp.secondMode(), fragBuilder,
                                positionsUniName, sizesUniName, radiiUniName,
-                               padRadUniName, "secondDist", "zw");
+                               radUniName, "secondDist", "zw");
             fragBuilder->codeAppend("}");
 
-            fragBuilder->codeAppendf("float dist = %s.y * firstDist * secondDist;",
-                                     padRadUniName);
+            fragBuilder->codeAppendf("float dist = %s * firstDist * secondDist;", radUniName);
 
             // 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->codeAppendf("float factor = 1.0 - clamp(dist/%s, 0.0, 1.0);", radUniName);
             fragBuilder->codeAppend("factor = exp(-factor * factor * 4.0) - 0.018;");
-            fragBuilder->codeAppendf("%s = vec4(%s.rgb, factor);",
+            fragBuilder->codeAppendf("%s = factor*%s;",
                                      args.fOutputColor, args.fInputColor);
         }
 
         static void GenKey(const GrProcessor& proc, const GrGLSLCaps&,
                            GrProcessorKeyBuilder* b) {
             const RRectsGaussianEdgeFP& fp = proc.cast<RRectsGaussianEdgeFP>();
 
             b->add32(fp.firstMode() | (fp.secondMode() << 4));
         }
 
@@ skipping 20 matching lines @@
                 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());
+            pdman.set1f(fRadiusUni, 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
         GrGLSLProgramDataManager::UniformHandle fSizesUni;
 
         // The half corner radii of the two round rects (rx1/2, ry1/2, rx2/2, ry2/2)
         // We upload both the x&y radii (although they are currently always the same) to make
         // the indexing in the shader code simpler. In some future world we could also support
         // non-circular corner round rects & ellipses.
         GrGLSLProgramDataManager::UniformHandle fRadiiUni;
 
-        // The pad and radius parameters (padding, radius)
-        GrGLSLProgramDataManager::UniformHandle fPadRadUni;
+        // The radius parameters (radius)
+        GrGLSLProgramDataManager::UniformHandle fRadiusUni;
 
         typedef GrGLSLFragmentProcessor INHERITED;
     };
 
     void onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override {
         GLSLRRectsGaussianEdgeFP::GenKey(*this, caps, b);
     }
 
     const char* name() const override { return "RRectsGaussianEdgeFP"; }
 
     void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
         inout->setToUnknown(GrInvariantOutput::kWill_ReadInput);
     }
 
     const SkRRect& first() const { return fFirst; }
     Mode firstMode() const { return fFirstMode; }
     const SkRRect& second() const { return fSecond; }
     Mode secondMode() const { return fSecondMode; }
     SkScalar radius() const { return fRadius; }
-    SkScalar pad() const { return fPad; }
 
 private:
     static Mode ComputeMode(const SkRRect& rr) {
         if (rr.isCircle()) {
             return kCircle_Mode;
         } else if (rr.isRect()) {
             return kRect_Mode;
         } else {
             SkASSERT(rr.isSimpleCircular());
             return kSimpleCircular_Mode;
         }
     }
 
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
         return new GLSLRRectsGaussianEdgeFP;
     }
 
     bool onIsEqual(const GrFragmentProcessor& proc) const override {
         const RRectsGaussianEdgeFP& edgeFP = proc.cast<RRectsGaussianEdgeFP>();
-        return fFirst  == edgeFP.fFirst && fSecond == edgeFP.fSecond && 
-               fRadius == edgeFP.fRadius && fPad == edgeFP.fPad;
+        return fFirst  == edgeFP.fFirst &&
+               fSecond == edgeFP.fSecond && 
+               fRadius == edgeFP.fRadius;
     }
 
     SkRRect  fFirst;
     Mode     fFirstMode;
     SkRRect  fSecond;
     Mode     fSecondMode;
     SkScalar fRadius;
-    SkScalar fPad;
 
     typedef GrFragmentProcessor INHERITED;
 };
 
 ////////////////////////////////////////////////////////////////////////////
 
 sk_sp<GrFragmentProcessor> SkRRectsGaussianEdgeShaderImpl::asFragmentProcessor(
                                                                     const AsFPArgs& args) const {
-    return sk_make_sp<RRectsGaussianEdgeFP>(fFirst, fSecond, fRadius, fPad);
+    return sk_make_sp<RRectsGaussianEdgeFP>(fFirst, fSecond, fRadius);
 }
 
 #endif
 
 ////////////////////////////////////////////////////////////////////////////
 
 SkRRectsGaussianEdgeShaderImpl::GaussianEdgeShaderContext::GaussianEdgeShaderContext(
                                                     const SkRRectsGaussianEdgeShaderImpl& shader,
                                                     const ContextRec& rec)
     : INHERITED(shader, rec) {
@@ skipping 27 matching lines @@
 
     buf.readRect(&rect1);
     SkScalar xRad1 = buf.readScalar();
     SkScalar yRad1 = buf.readScalar();
 
     buf.readRect(&rect2);
     SkScalar xRad2 = buf.readScalar();
     SkScalar yRad2 = buf.readScalar();
 
     SkScalar radius = buf.readScalar();
-    SkScalar pad = buf.readScalar();
 
     return sk_make_sp<SkRRectsGaussianEdgeShaderImpl>(SkRRect::MakeRectXY(rect1, xRad1, yRad1),
                                                       SkRRect::MakeRectXY(rect2, xRad2, yRad2),
-                                                      radius, pad);
+                                                      radius);
 }
 
 void SkRRectsGaussianEdgeShaderImpl::flatten(SkWriteBuffer& buf) const {
     INHERITED::flatten(buf);
 
     SkASSERT(fFirst.isRect() || fFirst.isCircle() || fFirst.isSimpleCircular());
     buf.writeRect(fFirst.rect());
     const SkVector& radii1 = fFirst.getSimpleRadii();
     buf.writeScalar(radii1.fX);
     buf.writeScalar(radii1.fY);
 
     SkASSERT(fSecond.isRect() || fSecond.isCircle() || fSecond.isSimpleCircular());
     buf.writeRect(fSecond.rect());
     const SkVector& radii2 = fSecond.getSimpleRadii();
     buf.writeScalar(radii2.fX);
     buf.writeScalar(radii2.fY);
 
     buf.writeScalar(fRadius);
-    buf.writeScalar(fPad);
 }
 
 size_t SkRRectsGaussianEdgeShaderImpl::onContextSize(const ContextRec& rec) const {
     return sizeof(GaussianEdgeShaderContext);
 }
 
 SkShader::Context* SkRRectsGaussianEdgeShaderImpl::onCreateContext(const ContextRec& rec,
                                                                    void* storage) const {
     return new (storage) GaussianEdgeShaderContext(*this, rec);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 sk_sp<SkShader> SkRRectsGaussianEdgeShader::Make(const SkRRect& first,
                                                  const SkRRect& second,
-                                                 SkScalar radius,
-                                                 SkScalar pad) {
+                                                 SkScalar radius) {
     if ((!first.isRect()  && !first.isCircle()  && !first.isSimpleCircular()) || 
         (!second.isRect() && !second.isCircle() && !second.isSimpleCircular())) {
         // we only deal with the shapes where the x & y radii are equal 
         // and the same for all four corners
         return nullptr;
     }
 
-    return sk_make_sp<SkRRectsGaussianEdgeShaderImpl>(first, second, radius, pad);
+    return sk_make_sp<SkRRectsGaussianEdgeShaderImpl>(first, second, radius);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkRRectsGaussianEdgeShader)
 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkRRectsGaussianEdgeShaderImpl)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
 
 ///////////////////////////////////////////////////////////////////////////////