Added GrGLFragmentProcessor::EmitArgs struct for use with emitCode()

src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp

 
 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkTwoPointConicalGradient_gpu.h"
 
@@ skipping 126 matching lines @@
     // @}
 
     typedef GrGradientEffect INHERITED;
 };
 
 class GLEdge2PtConicalEffect : public GrGLGradientEffect {
 public:
     GLEdge2PtConicalEffect(const GrProcessor&);
     virtual ~GLEdge2PtConicalEffect() { }
 
-    virtual void emitCode(GrGLFPBuilder*,
-                          const GrFragmentProcessor&,
-                          const char* outputColor,
-                          const char* inputColor,
-                          const TransformedCoordsArray&,
-                          const TextureSamplerArray&) override;
+    virtual void emitCode(EmitArgs&) override;
     void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
 
     static void GenKey(const GrProcessor&, const GrGLSLCaps& caps, GrProcessorKeyBuilder* b);
 
 protected:
     UniformHandle fParamUni;
 
     const char* fVSVaryingName;
     const char* fFSVaryingName;
 
@@ skipping 58 matching lines @@
                                                &paintColor, d->fProcDataManager, &fp));
     return fp;
 }
 
 GLEdge2PtConicalEffect::GLEdge2PtConicalEffect(const GrProcessor&)
     : fVSVaryingName(NULL)
     , fFSVaryingName(NULL)
     , fCachedRadius(-SK_ScalarMax)
     , fCachedDiffRadius(-SK_ScalarMax) {}
 
-void GLEdge2PtConicalEffect::emitCode(GrGLFPBuilder* builder,
-                                      const GrFragmentProcessor& fp,
-                                      const char* outputColor,
-                                      const char* inputColor,
-                                      const TransformedCoordsArray& coords,
-                                      const TextureSamplerArray& samplers) {
-    const Edge2PtConicalEffect& ge = fp.cast<Edge2PtConicalEffect>();
-    this->emitUniforms(builder, ge);
-    fParamUni = builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibility,
+void GLEdge2PtConicalEffect::emitCode(EmitArgs& args) {
+    const Edge2PtConicalEffect& ge = args.fFp.cast<Edge2PtConicalEffect>();
+    this->emitUniforms(args.fBuilder, ge);
+    fParamUni = args.fBuilder->addUniformArray(GrGLProgramBuilder::kFragment_Visibility,
                                          kFloat_GrSLType, kDefault_GrSLPrecision,
                                          "Conical2FSParams", 3);
 
     SkString cName("c");
     SkString tName("t");
     SkString p0; // start radius
     SkString p1; // start radius squared
     SkString p2; // difference in radii (r1 - r0)
 
-    builder->getUniformVariable(fParamUni).appendArrayAccess(0, &p0);
-    builder->getUniformVariable(fParamUni).appendArrayAccess(1, &p1);
-    builder->getUniformVariable(fParamUni).appendArrayAccess(2, &p2);
+    args.fBuilder->getUniformVariable(fParamUni).appendArrayAccess(0, &p0);
+    args.fBuilder->getUniformVariable(fParamUni).appendArrayAccess(1, &p1);
+    args.fBuilder->getUniformVariable(fParamUni).appendArrayAccess(2, &p2);
 
     // We interpolate the linear component in coords[1].
-    SkASSERT(coords[0].getType() == coords[1].getType());
+    SkASSERT(args.fCoords[0].getType() == args.fCoords[1].getType());
     const char* coords2D;
     SkString bVar;
-    GrGLFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();
-    if (kVec3f_GrSLType == coords[0].getType()) {
+    GrGLFragmentBuilder* fsBuilder = args.fBuilder->getFragmentShaderBuilder();
+    if (kVec3f_GrSLType == args.fCoords[0].getType()) {
         fsBuilder->codeAppendf("\tvec3 interpolants = vec3(%s.xy / %s.z, %s.x / %s.z);\n",
-                               coords[0].c_str(), coords[0].c_str(), coords[1].c_str(),
-                               coords[1].c_str());
+                               args.fCoords[0].c_str(), args.fCoords[0].c_str(),
+                               args.fCoords[1].c_str(), args.fCoords[1].c_str());
         coords2D = "interpolants.xy";
         bVar = "interpolants.z";
     } else {
-        coords2D = coords[0].c_str();
-        bVar.printf("%s.x", coords[1].c_str());
+        coords2D = args.fCoords[0].c_str();
+        bVar.printf("%s.x", args.fCoords[1].c_str());
     }
 
     // output will default to transparent black (we simply won't write anything
     // else to it if invalid, instead of discarding or returning prematurely)
-    fsBuilder->codeAppendf("\t%s = vec4(0.0,0.0,0.0,0.0);\n", outputColor);
+    fsBuilder->codeAppendf("\t%s = vec4(0.0,0.0,0.0,0.0);\n", args.fOutputColor);
 
     // c = (x^2)+(y^2) - params[1]
     fsBuilder->codeAppendf("\tfloat %s = dot(%s, %s) - %s;\n",
                            cName.c_str(), coords2D, coords2D, p1.c_str());
 
     // linear case: t = -c/b
     fsBuilder->codeAppendf("\tfloat %s = -(%s / %s);\n", tName.c_str(),
                            cName.c_str(), bVar.c_str());
 
     // if r(t) > 0, then t will be the x coordinate
     fsBuilder->codeAppendf("\tif (%s * %s + %s > 0.0) {\n", tName.c_str(),
                            p2.c_str(), p0.c_str());
     fsBuilder->codeAppend("\t");
-    this->emitColor(builder, ge, tName.c_str(), outputColor, inputColor, samplers);
+    this->emitColor(args.fBuilder, ge, tName.c_str(), args.fOutputColor, args.fInputColor,
+                    args.fSamplers);
     fsBuilder->codeAppend("\t}\n");
 }
 
 void GLEdge2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,
                                      const GrProcessor& processor) {
     INHERITED::setData(pdman, processor);
     const Edge2PtConicalEffect& data = processor.cast<Edge2PtConicalEffect>();
     SkScalar radius0 = data.radius();
     SkScalar diffRadius = data.diffRadius();
 
@@ skipping 131 matching lines @@
     bool             fIsFlipped;
 
     typedef GrGradientEffect INHERITED;
 };
 
 class GLFocalOutside2PtConicalEffect : public GrGLGradientEffect {
 public:
     GLFocalOutside2PtConicalEffect(const GrProcessor&);
     virtual ~GLFocalOutside2PtConicalEffect() { }
 
-    virtual void emitCode(GrGLFPBuilder*,
-                          const GrFragmentProcessor&,
-                          const char* outputColor,
-                          const char* inputColor,
-                          const TransformedCoordsArray&,
-                          const TextureSamplerArray&) override;
+    virtual void emitCode(EmitArgs&) override;
     void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
 
     static void GenKey(const GrProcessor&, const GrGLSLCaps& caps, GrProcessorKeyBuilder* b);
 
 protected:
     UniformHandle fParamUni;
 
     const char* fVSVaryingName;
     const char* fFSVaryingName;
 
@@ skipping 60 matching lines @@
 }
 
 GLFocalOutside2PtConicalEffect::GLFocalOutside2PtConicalEffect(const GrProcessor& processor)
     : fVSVaryingName(NULL)
     , fFSVaryingName(NULL)
     , fCachedFocal(SK_ScalarMax) {
     const FocalOutside2PtConicalEffect& data = processor.cast<FocalOutside2PtConicalEffect>();
     fIsFlipped = data.isFlipped();
 }
 
-void GLFocalOutside2PtConicalEffect::emitCode(GrGLFPBuilder* builder,
-                                              const GrFragmentProcessor& fp,
-                                              const char* outputColor,
-                                              const char* inputColor,
-                                              const TransformedCoordsArray& coords,
-                                              const TextureSamplerArray& samplers) {
-    const FocalOutside2PtConicalEffect& ge = fp.cast<FocalOutside2PtConicalEffect>();
-    this->emitUniforms(builder, ge);
-    fParamUni = builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibility,
+void GLFocalOutside2PtConicalEffect::emitCode(EmitArgs& args) {
+    const FocalOutside2PtConicalEffect& ge = args.fFp.cast<FocalOutside2PtConicalEffect>();
+    this->emitUniforms(args.fBuilder, ge);
+    fParamUni = args.fBuilder->addUniformArray(GrGLProgramBuilder::kFragment_Visibility,
                                          kFloat_GrSLType, kDefault_GrSLPrecision,
                                          "Conical2FSParams", 2);
     SkString tName("t");
     SkString p0; // focalX
     SkString p1; // 1 - focalX * focalX
 
-    builder->getUniformVariable(fParamUni).appendArrayAccess(0, &p0);
-    builder->getUniformVariable(fParamUni).appendArrayAccess(1, &p1);
+    args.fBuilder->getUniformVariable(fParamUni).appendArrayAccess(0, &p0);
+    args.fBuilder->getUniformVariable(fParamUni).appendArrayAccess(1, &p1);
 
     // if we have a vec3 from being in perspective, convert it to a vec2 first
-    GrGLFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();
-    SkString coords2DString = fsBuilder->ensureFSCoords2D(coords, 0);
+    GrGLFragmentBuilder* fsBuilder = args.fBuilder->getFragmentShaderBuilder();
+    SkString coords2DString = fsBuilder->ensureFSCoords2D(args.fCoords, 0);
     const char* coords2D = coords2DString.c_str();
 
     // t = p.x * focal.x +/- sqrt(p.x^2 + (1 - focal.x^2) * p.y^2)
 
     // output will default to transparent black (we simply won't write anything
     // else to it if invalid, instead of discarding or returning prematurely)
-    fsBuilder->codeAppendf("\t%s = vec4(0.0,0.0,0.0,0.0);\n", outputColor);
+    fsBuilder->codeAppendf("\t%s = vec4(0.0,0.0,0.0,0.0);\n", args.fOutputColor);
 
     fsBuilder->codeAppendf("\tfloat xs = %s.x * %s.x;\n", coords2D, coords2D);
     fsBuilder->codeAppendf("\tfloat ys = %s.y * %s.y;\n", coords2D, coords2D);
     fsBuilder->codeAppendf("\tfloat d = xs + %s * ys;\n", p1.c_str());
 
     // Must check to see if we flipped the circle order (to make sure start radius < end radius)
     // If so we must also flip sign on sqrt
     if (!fIsFlipped) {
         fsBuilder->codeAppendf("\tfloat %s = %s.x * %s  + sqrt(d);\n", tName.c_str(),
                                coords2D, p0.c_str());
     } else {
         fsBuilder->codeAppendf("\tfloat %s = %s.x * %s  - sqrt(d);\n", tName.c_str(),
                                coords2D, p0.c_str());
     }
 
     fsBuilder->codeAppendf("\tif (%s >= 0.0 && d >= 0.0) {\n", tName.c_str());
     fsBuilder->codeAppend("\t\t");
-    this->emitColor(builder, ge, tName.c_str(), outputColor, inputColor, samplers);
+    this->emitColor(args.fBuilder, ge, tName.c_str(), args.fOutputColor, args.fInputColor,
+                    args.fSamplers);
     fsBuilder->codeAppend("\t}\n");
 }
 
 void GLFocalOutside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,
                                              const GrProcessor& processor) {
     INHERITED::setData(pdman, processor);
     const FocalOutside2PtConicalEffect& data = processor.cast<FocalOutside2PtConicalEffect>();
     SkASSERT(data.isFlipped() == fIsFlipped);
     SkScalar focal = data.focal();
 
@@ skipping 70 matching lines @@
     SkScalar         fFocalX;
 
     typedef GrGradientEffect INHERITED;
 };
 
 class GLFocalInside2PtConicalEffect : public GrGLGradientEffect {
 public:
     GLFocalInside2PtConicalEffect(const GrProcessor&);
     virtual ~GLFocalInside2PtConicalEffect() {}
 
-    virtual void emitCode(GrGLFPBuilder*,
-                          const GrFragmentProcessor&,
-                          const char* outputColor,
-                          const char* inputColor,
-                          const TransformedCoordsArray&,
-                          const TextureSamplerArray&) override;
+    virtual void emitCode(EmitArgs&) override;
     void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
 
     static void GenKey(const GrProcessor&, const GrGLSLCaps& caps, GrProcessorKeyBuilder* b);
 
 protected:
     UniformHandle fFocalUni;
 
     const char* fVSVaryingName;
     const char* fFSVaryingName;
 
@@ skipping 55 matching lines @@
                                                GrTest::TestMatrix(d->fRandom), NULL,
                                                &paintColor, d->fProcDataManager, &fp));
     return fp;
 }
 
 GLFocalInside2PtConicalEffect::GLFocalInside2PtConicalEffect(const GrProcessor&)
     : fVSVaryingName(NULL)
     , fFSVaryingName(NULL)
     , fCachedFocal(SK_ScalarMax) {}
 
-void GLFocalInside2PtConicalEffect::emitCode(GrGLFPBuilder* builder,
-                                             const GrFragmentProcessor& fp,
-                                             const char* outputColor,
-                                             const char* inputColor,
-                                             const TransformedCoordsArray& coords,
-                                             const TextureSamplerArray& samplers) {
-    const FocalInside2PtConicalEffect& ge = fp.cast<FocalInside2PtConicalEffect>();
-    this->emitUniforms(builder, ge);
-    fFocalUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
+void GLFocalInside2PtConicalEffect::emitCode(EmitArgs& args) {
+    const FocalInside2PtConicalEffect& ge = args.fFp.cast<FocalInside2PtConicalEffect>();
+    this->emitUniforms(args.fBuilder, ge);
+    fFocalUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                     kFloat_GrSLType, kDefault_GrSLPrecision,
                                     "Conical2FSParams");
     SkString tName("t");
 
     // this is the distance along x-axis from the end center to focal point in
     // transformed coordinates
-    GrGLShaderVar focal = builder->getUniformVariable(fFocalUni);
+    GrGLShaderVar focal = args.fBuilder->getUniformVariable(fFocalUni);
 
     // if we have a vec3 from being in perspective, convert it to a vec2 first
-    GrGLFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();
-    SkString coords2DString = fsBuilder->ensureFSCoords2D(coords, 0);
+    GrGLFragmentBuilder* fsBuilder = args.fBuilder->getFragmentShaderBuilder();
+    SkString coords2DString = fsBuilder->ensureFSCoords2D(args.fCoords, 0);
     const char* coords2D = coords2DString.c_str();
 
     // t = p.x * focalX + length(p)
     fsBuilder->codeAppendf("\tfloat %s = %s.x * %s  + length(%s);\n", tName.c_str(),
                            coords2D, focal.c_str(), coords2D);
 
-    this->emitColor(builder, ge, tName.c_str(), outputColor, inputColor, samplers);
+    this->emitColor(args.fBuilder, ge, tName.c_str(), args.fOutputColor, args.fInputColor,
+                    args.fSamplers);
 }
 
 void GLFocalInside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,
                                             const GrProcessor& processor) {
     INHERITED::setData(pdman, processor);
     const FocalInside2PtConicalEffect& data = processor.cast<FocalInside2PtConicalEffect>();
     SkScalar focal = data.focal();
 
     if (fCachedFocal != focal) {
         pdman.set1f(fFocalUni, SkScalarToFloat(focal));
@@ skipping 123 matching lines @@
     const CircleConicalInfo fInfo;
 
     typedef GrGradientEffect INHERITED;
 };
 
 class GLCircleInside2PtConicalEffect : public GrGLGradientEffect {
 public:
     GLCircleInside2PtConicalEffect(const GrProcessor&);
     virtual ~GLCircleInside2PtConicalEffect() {}
 
-    virtual void emitCode(GrGLFPBuilder*,
-                          const GrFragmentProcessor&,
-                          const char* outputColor,
-                          const char* inputColor,
-                          const TransformedCoordsArray&,
-                          const TextureSamplerArray&) override;
+    virtual void emitCode(EmitArgs&) override;
     void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
 
     static void GenKey(const GrProcessor&, const GrGLSLCaps& caps, GrProcessorKeyBuilder* b);
 
 protected:
     UniformHandle fCenterUni;
     UniformHandle fParamUni;
 
     const char* fVSVaryingName;
     const char* fFSVaryingName;
@@ skipping 64 matching lines @@
 
 GLCircleInside2PtConicalEffect::GLCircleInside2PtConicalEffect(const GrProcessor& processor)
     : fVSVaryingName(NULL)
     , fFSVaryingName(NULL)
     , fCachedCenterX(SK_ScalarMax)
     , fCachedCenterY(SK_ScalarMax)
     , fCachedA(SK_ScalarMax)
     , fCachedB(SK_ScalarMax)
     , fCachedC(SK_ScalarMax) {}
 
-void GLCircleInside2PtConicalEffect::emitCode(GrGLFPBuilder* builder,
-                                              const GrFragmentProcessor& fp,
-                                              const char* outputColor,
-                                              const char* inputColor,
-                                              const TransformedCoordsArray& coords,
-                                              const TextureSamplerArray& samplers) {
-    const CircleInside2PtConicalEffect& ge = fp.cast<CircleInside2PtConicalEffect>();
-    this->emitUniforms(builder, ge);
-    fCenterUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
+void GLCircleInside2PtConicalEffect::emitCode(EmitArgs& args) {
+    const CircleInside2PtConicalEffect& ge = args.fFp.cast<CircleInside2PtConicalEffect>();
+    this->emitUniforms(args.fBuilder, ge);
+    fCenterUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                      kVec2f_GrSLType, kDefault_GrSLPrecision,
                                      "Conical2FSCenter");
-    fParamUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
+    fParamUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                     kVec3f_GrSLType, kDefault_GrSLPrecision,
                                     "Conical2FSParams");
     SkString tName("t");
 
-    GrGLShaderVar center = builder->getUniformVariable(fCenterUni);
+    GrGLShaderVar center = args.fBuilder->getUniformVariable(fCenterUni);
     // params.x = A
     // params.y = B
     // params.z = C
-    GrGLShaderVar params = builder->getUniformVariable(fParamUni);
+    GrGLShaderVar params = args.fBuilder->getUniformVariable(fParamUni);
 
     // if we have a vec3 from being in perspective, convert it to a vec2 first
-    GrGLFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();
-    SkString coords2DString = fsBuilder->ensureFSCoords2D(coords, 0);
+    GrGLFragmentBuilder* fsBuilder = args.fBuilder->getFragmentShaderBuilder();
+    SkString coords2DString = fsBuilder->ensureFSCoords2D(args.fCoords, 0);
     const char* coords2D = coords2DString.c_str();
 
     // p = coords2D
     // e = center end
     // r = radius end
     // A = dot(e, e) - r^2 + 2 * r - 1
     // B = (r -1) / A
     // C = 1 / A
     // d = dot(e, p) + B
     // t = d +/- sqrt(d^2 - A * dot(p, p) + C)
     fsBuilder->codeAppendf("\tfloat pDotp = dot(%s,  %s);\n", coords2D, coords2D);
     fsBuilder->codeAppendf("\tfloat d = dot(%s,  %s) + %s.y;\n", coords2D, center.c_str(),
                            params.c_str());
     fsBuilder->codeAppendf("\tfloat %s = d + sqrt(d * d - %s.x * pDotp + %s.z);\n",
                            tName.c_str(), params.c_str(), params.c_str());
 
-    this->emitColor(builder, ge, tName.c_str(), outputColor, inputColor, samplers);
+    this->emitColor(args.fBuilder, ge, tName.c_str(), args.fOutputColor, args.fInputColor,
+                    args.fSamplers);
 }
 
 void GLCircleInside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,
                                              const GrProcessor& processor) {
     INHERITED::setData(pdman, processor);
     const CircleInside2PtConicalEffect& data = processor.cast<CircleInside2PtConicalEffect>();
     SkScalar centerX = data.centerX();
     SkScalar centerY = data.centerY();
     SkScalar A = data.A();
     SkScalar B = data.B();
@@ skipping 85 matching lines @@
     bool fIsFlipped;
 
     typedef GrGradientEffect INHERITED;
 };
 
 class GLCircleOutside2PtConicalEffect : public GrGLGradientEffect {
 public:
     GLCircleOutside2PtConicalEffect(const GrProcessor&);
     virtual ~GLCircleOutside2PtConicalEffect() {}
 
-    virtual void emitCode(GrGLFPBuilder*,
-                          const GrFragmentProcessor&,
-                          const char* outputColor,
-                          const char* inputColor,
-                          const TransformedCoordsArray&,
-                          const TextureSamplerArray&) override;
+    virtual void emitCode(EmitArgs&) override;
     void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
 
     static void GenKey(const GrProcessor&, const GrGLSLCaps& caps, GrProcessorKeyBuilder* b);
 
 protected:
     UniformHandle fCenterUni;
     UniformHandle fParamUni;
 
     const char* fVSVaryingName;
     const char* fFSVaryingName;
@@ skipping 71 matching lines @@
     , fCachedCenterX(SK_ScalarMax)
     , fCachedCenterY(SK_ScalarMax)
     , fCachedA(SK_ScalarMax)
     , fCachedB(SK_ScalarMax)
     , fCachedC(SK_ScalarMax)
     , fCachedTLimit(SK_ScalarMax) {
     const CircleOutside2PtConicalEffect& data = processor.cast<CircleOutside2PtConicalEffect>();
     fIsFlipped = data.isFlipped();
     }
 
-void GLCircleOutside2PtConicalEffect::emitCode(GrGLFPBuilder* builder,
-                                               const GrFragmentProcessor& fp,
-                                               const char* outputColor,
-                                               const char* inputColor,
-                                               const TransformedCoordsArray& coords,
-                                               const TextureSamplerArray& samplers) {
-    const CircleOutside2PtConicalEffect& ge = fp.cast<CircleOutside2PtConicalEffect>();
-    this->emitUniforms(builder, ge);
-    fCenterUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
+void GLCircleOutside2PtConicalEffect::emitCode(EmitArgs& args) {
+    const CircleOutside2PtConicalEffect& ge = args.fFp.cast<CircleOutside2PtConicalEffect>();
+    this->emitUniforms(args.fBuilder, ge);
+    fCenterUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                      kVec2f_GrSLType, kDefault_GrSLPrecision,
                                      "Conical2FSCenter");
-    fParamUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
+    fParamUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                     kVec4f_GrSLType, kDefault_GrSLPrecision,
                                     "Conical2FSParams");
     SkString tName("t");
 
-    GrGLShaderVar center = builder->getUniformVariable(fCenterUni);
+    GrGLShaderVar center = args.fBuilder->getUniformVariable(fCenterUni);
     // params.x = A
     // params.y = B
     // params.z = C
-    GrGLShaderVar params = builder->getUniformVariable(fParamUni);
+    GrGLShaderVar params = args.fBuilder->getUniformVariable(fParamUni);
 
     // if we have a vec3 from being in perspective, convert it to a vec2 first
-    GrGLFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();
-    SkString coords2DString = fsBuilder->ensureFSCoords2D(coords, 0);
+    GrGLFragmentBuilder* fsBuilder = args.fBuilder->getFragmentShaderBuilder();
+    SkString coords2DString = fsBuilder->ensureFSCoords2D(args.fCoords, 0);
     const char* coords2D = coords2DString.c_str();
 
     // output will default to transparent black (we simply won't write anything
     // else to it if invalid, instead of discarding or returning prematurely)
-    fsBuilder->codeAppendf("\t%s = vec4(0.0,0.0,0.0,0.0);\n", outputColor);
+    fsBuilder->codeAppendf("\t%s = vec4(0.0,0.0,0.0,0.0);\n", args.fOutputColor);
 
     // p = coords2D
     // e = center end
     // r = radius end
     // A = dot(e, e) - r^2 + 2 * r - 1
     // B = (r -1) / A
     // C = 1 / A
     // d = dot(e, p) + B
     // t = d +/- sqrt(d^2 - A * dot(p, p) + C)
 
     fsBuilder->codeAppendf("\tfloat pDotp = dot(%s,  %s);\n", coords2D, coords2D);
     fsBuilder->codeAppendf("\tfloat d = dot(%s,  %s) + %s.y;\n", coords2D, center.c_str(),
                            params.c_str());
     fsBuilder->codeAppendf("\tfloat deter = d * d - %s.x * pDotp + %s.z;\n", params.c_str(),
                            params.c_str());
 
     // Must check to see if we flipped the circle order (to make sure start radius < end radius)
     // If so we must also flip sign on sqrt
     if (!fIsFlipped) {
         fsBuilder->codeAppendf("\tfloat %s = d + sqrt(deter);\n", tName.c_str());
     } else {
         fsBuilder->codeAppendf("\tfloat %s = d - sqrt(deter);\n", tName.c_str());
     }
 
     fsBuilder->codeAppendf("\tif (%s >= %s.w && deter >= 0.0) {\n", tName.c_str(), params.c_str());
     fsBuilder->codeAppend("\t\t");
-    this->emitColor(builder, ge, tName.c_str(), outputColor, inputColor, samplers);
+    this->emitColor(args.fBuilder, ge, tName.c_str(), args.fOutputColor, args.fInputColor,
+                    args.fSamplers);
     fsBuilder->codeAppend("\t}\n");
 }
 
 void GLCircleOutside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,
                                               const GrProcessor& processor) {
     INHERITED::setData(pdman, processor);
     const CircleOutside2PtConicalEffect& data = processor.cast<CircleOutside2PtConicalEffect>();
     SkASSERT(data.isFlipped() == fIsFlipped);
     SkScalar centerX = data.centerX();
     SkScalar centerY = data.centerY();
@@ skipping 68 matching lines @@
     } else if (type == kEdge_ConicalType) {
         set_matrix_edge_conical(shader, &matrix);
         return Edge2PtConicalEffect::Create(ctx, procDataManager, shader, matrix, tm);
     } else {
         return CircleOutside2PtConicalEffect::Create(ctx, procDataManager, shader, matrix, tm,
                                                      info);
     }
 }
 
 #endif