Isolate VertexBuilder from GrGLShaderBuilder

src/effects/gradients/SkTwoPointRadialGradient.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
  #include "SkTwoPointRadialGradient.h"
 
@@ skipping 530 matching lines @@
     // 2 copies of uniform array, 1 for each of vertex & fragment shader,
     // to work around Xoom bug. Doesn't seem to cause performance decrease
     // in test apps, but need to keep an eye on it.
     fVSParamUni = builder->addUniformArray(GrGLShaderBuilder::kVertex_Visibility,
                                            kFloat_GrSLType, "Radial2VSParams", 6);
     fFSParamUni = builder->addUniformArray(GrGLShaderBuilder::kFragment_Visibility,
                                            kFloat_GrSLType, "Radial2FSParams", 6);
 
     // For radial gradients without perspective we can pass the linear
     // part of the quadratic as a varying.
-    if (kVec2f_GrSLType == coordsVaryingType) {
-        builder->addVarying(kFloat_GrSLType, "Radial2BCoeff", &fVSVaryingName, &fFSVaryingName);
+    GrGLShaderBuilder::VertexBuilder* vertexBuilder =
+        (kVec2f_GrSLType == coordsVaryingType) ? builder->getVertexBuilder() : NULL;
+    if (NULL != vertexBuilder) {
+        vertexBuilder->addVarying(kFloat_GrSLType, "Radial2BCoeff",
+                                    &fVSVaryingName, &fFSVaryingName);
     }
 
     // VS
     {
         SkString p2;
         SkString p3;
         builder->getUniformVariable(fVSParamUni).appendArrayAccess(2, &p2);
         builder->getUniformVariable(fVSParamUni).appendArrayAccess(3, &p3);
 
         // For radial gradients without perspective we can pass the linear
         // part of the quadratic as a varying.
-        if (kVec2f_GrSLType == coordsVaryingType) {
+        if (NULL != vertexBuilder) {
             // r2Var = 2 * (r2Parm[2] * varCoord.x - r2Param[3])
-            builder->vsCodeAppendf("\t%s = 2.0 *(%s * %s.x - %s);\n",
-                                   fVSVaryingName, p2.c_str(),
-                                   vsCoordsVarying.c_str(), p3.c_str());
+            vertexBuilder->vsCodeAppendf("\t%s = 2.0 *(%s * %s.x - %s);\n",
+                                           fVSVaryingName, p2.c_str(),
+                                           vsCoordsVarying.c_str(), p3.c_str());
         }
     }
 
     // FS
     {
         SkString cName("c");
         SkString ac4Name("ac4");
         SkString rootName("root");
         SkString t;
         SkString p0;
         SkString p1;
         SkString p2;
         SkString p3;
         SkString p4;
         SkString p5;
         builder->getUniformVariable(fFSParamUni).appendArrayAccess(0, &p0);
         builder->getUniformVariable(fFSParamUni).appendArrayAccess(1, &p1);
         builder->getUniformVariable(fFSParamUni).appendArrayAccess(2, &p2);
         builder->getUniformVariable(fFSParamUni).appendArrayAccess(3, &p3);
         builder->getUniformVariable(fFSParamUni).appendArrayAccess(4, &p4);
         builder->getUniformVariable(fFSParamUni).appendArrayAccess(5, &p5);
 
         // If we we're able to interpolate the linear component,
         // bVar is the varying; otherwise compute it
         SkString bVar;
-        if (kVec2f_GrSLType == coordsVaryingType) {
+        if (NULL != vertexBuilder) {
             bVar = fFSVaryingName;
         } else {
             bVar = "b";
             builder->fsCodeAppendf("\tfloat %s = 2.0 * (%s * %s.x - %s);\n",
                                    bVar.c_str(), p2.c_str(), fsCoords.c_str(), p3.c_str());
         }
 
         // c = (x^2)+(y^2) - params[4]
         builder->fsCodeAppendf("\tfloat %s = dot(%s, %s) - %s;\n",
                                cName.c_str(),
@@ skipping 100 matching lines @@
 }
 
 #else
 
 GrEffectRef* SkTwoPointRadialGradient::asNewEffect(GrContext*, const SkPaint&) const {
     SkDEBUGFAIL("Should not call in GPU-less build");
     return NULL;
 }
 
 #endif