Make GPU coord transforms automatic

src/effects/gradients/SkTwoPointConicalGradient.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 "SkTwoPointConicalGradient.h"
 
 static int valid_divide(float numer, float denom, float* ratio) {
@@ skipping 329 matching lines @@
 public:
 
     GrGLConical2Gradient(const GrBackendEffectFactory& factory, const GrDrawEffect&);
     virtual ~GrGLConical2Gradient() { }
 
     virtual void emitCode(GrGLShaderBuilder*,
                           const GrDrawEffect&,
                           EffectKey,
                           const char* outputColor,
                           const char* inputColor,
+                          const TransformedCoordsArray&,
                           const TextureSamplerArray&) SK_OVERRIDE;
     virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE;
 
     static EffectKey GenKey(const GrDrawEffect&, const GrGLCaps& caps);
 
 protected:
 
     UniformHandle           fVSParamUni;
     UniformHandle           fFSParamUni;
 
@@ skipping 121 matching lines @@
 
     const GrConical2Gradient& data = drawEffect.castEffect<GrConical2Gradient>();
     fIsDegenerate = data.isDegenerate();
 }
 
 void GrGLConical2Gradient::emitCode(GrGLShaderBuilder* builder,
                                     const GrDrawEffect&,
                                     EffectKey key,
                                     const char* outputColor,
                                     const char* inputColor,
+                                    const TransformedCoordsArray& coords,
                                     const TextureSamplerArray& samplers) {
-    SkString fsCoords;
-    SkString vsCoordsVarying;
-    GrSLType coordsVaryingType;
-    this->setupMatrix(builder, key, &fsCoords, &vsCoordsVarying, &coordsVaryingType);
-
     this->emitUniforms(builder, key);
     // 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, "Conical2VSParams", 6);
     fFSParamUni = builder->addUniformArray(GrGLShaderBuilder::kFragment_Visibility,
                                            kFloat_GrSLType, "Conical2FSParams", 6);
 
     // For radial gradients without perspective we can pass the linear
     // part of the quadratic as a varying.
     GrGLShaderBuilder::VertexBuilder* vertexBuilder =
-        (kVec2f_GrSLType == coordsVaryingType) ? builder->getVertexBuilder() : NULL;
+        (kVec2f_GrSLType == coords[0].type()) ? builder->getVertexBuilder() : NULL;
     if (NULL != vertexBuilder) {
         vertexBuilder->addVarying(kFloat_GrSLType, "Conical2BCoeff",
                                      &fVSVaryingName, &fFSVaryingName);
     }
 
     // VS
     {
         SkString p2; // distance between centers
         SkString p3; // start radius
         SkString p5; // difference in radii (r1 - r0)
         builder->getUniformVariable(fVSParamUni).appendArrayAccess(2, &p2);
         builder->getUniformVariable(fVSParamUni).appendArrayAccess(3, &p3);
         builder->getUniformVariable(fVSParamUni).appendArrayAccess(5, &p5);
 
         // For radial gradients without perspective we can pass the linear
         // part of the quadratic as a varying.
         if (NULL != vertexBuilder) {
             // r2Var = -2 * (r2Parm[2] * varCoord.x - r2Param[3] * r2Param[5])
             vertexBuilder->vsCodeAppendf("\t%s = -2.0 * (%s * %s.x + %s * %s);\n",
                                             fVSVaryingName, p2.c_str(),
-                                            vsCoordsVarying.c_str(), p3.c_str(), p5.c_str());
+                                            coords[0].getVSName().c_str(), p3.c_str(), p5.c_str());
         }
     }
 
     // FS
     {
-
+        SkString coords2D = builder->ensureFSCoords2D(coords, 0);
         SkString cName("c");
         SkString ac4Name("ac4");
         SkString dName("d");
         SkString qName("q");
         SkString r0Name("r0");
         SkString r1Name("r1");
         SkString tName("t");
         SkString p0; // 4a
         SkString p1; // 1/a
         SkString p2; // distance between centers
         SkString p3; // start radius
         SkString p4; // start radius squared
         SkString p5; // difference in radii (r1 - r0)
 
         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 (NULL != vertexBuilder) {
             bVar = fFSVaryingName;
         } else {
             bVar = "b";
             builder->fsCodeAppendf("\tfloat %s = -2.0 * (%s * %s.x + %s * %s);\n",
-                                   bVar.c_str(), p2.c_str(), fsCoords.c_str(),
+                                   bVar.c_str(), p2.c_str(), coords2D.c_str(),
                                    p3.c_str(), p5.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)
         builder->fsCodeAppendf("\t%s = vec4(0.0,0.0,0.0,0.0);\n", outputColor);
 
         // c = (x^2)+(y^2) - params[4]
         builder->fsCodeAppendf("\tfloat %s = dot(%s, %s) - %s;\n", cName.c_str(),
-                               fsCoords.c_str(), fsCoords.c_str(),
+                               coords2D.c_str(), coords2D.c_str(),
                                p4.c_str());
 
         // Non-degenerate case (quadratic)
         if (!fIsDegenerate) {
 
             // ac4 = params[0] * c
             builder->fsCodeAppendf("\tfloat %s = %s * %s;\n", ac4Name.c_str(), p0.c_str(),
                                    cName.c_str());
 
             // d = b^2 - ac4
@@ skipping 167 matching lines @@
     str->appendScalar(fCenter2.fY);
     str->append(") radius2: ");
     str->appendScalar(fRadius2);
     str->append(" ");
 
     this->INHERITED::toString(str);
 
     str->append(")");
 }
 #endif