Make GPU coord transforms automatic

src/gpu/gl/GrGLCoordTransform.cpp

Index: src/gpu/gl/GrGLCoordTransform.cpp
diff --git a/src/gpu/gl/GrGLEffectMatrix.cpp b/src/gpu/gl/GrGLCoordTransform.cpp
similarity index 64%
rename from src/gpu/gl/GrGLEffectMatrix.cpp
rename to src/gpu/gl/GrGLCoordTransform.cpp
index 880df12acffb0e8850c7b647d43e0b4a87aa8c55..53f89529d99fb4df672691baac6a747585cc7372 100644
--- a/src/gpu/gl/GrGLEffectMatrix.cpp
+++ b/src/gpu/gl/GrGLCoordTransform.cpp
@@ -5,18 +5,19 @@
  * found in the LICENSE file.
  */
 
-#include "GrGLEffectMatrix.h"
+#include "GrGLCoordTransform.h"
 #include "GrDrawEffect.h"
 #include "GrTexture.h"
+#include "GrGLShaderBuilder.h"
 
-GrGLEffect::EffectKey GrGLEffectMatrix::GenKey(const SkMatrix& effectMatrix,
-                                               const GrDrawEffect& drawEffect,
-                                               CoordsType coordsType,
-                                               const GrTexture* texture) {
+GrGLCoordTransform::EffectKey GrGLCoordTransform::GenKey(const SkMatrix& effectMatrix,
+                                                         const GrDrawEffect& drawEffect,
+                                                         GrCoordSet coordSet,
+                                                         bool reverseY) {
     EffectKey key = 0;
     SkMatrix::TypeMask type0 = effectMatrix.getType();
     SkMatrix::TypeMask type1;
-    if (GrEffect::kLocal_CoordsType == coordsType) {
+    if (kLocal_GrCoordSet == coordSet) {
         type1 = drawEffect.getCoordChangeMatrix().getType();
     } else {
         if (drawEffect.programHasExplicitLocalCoords()) {
@@ -29,8 +30,6 @@ GrGLEffect::EffectKey GrGLEffectMatrix::GenKey(const SkMatrix& effectMatrix,
 
     int combinedTypes = type0 | type1;
 
-    bool reverseY = (NULL != texture) && kBottomLeft_GrSurfaceOrigin == texture->origin();
-
     if (SkMatrix::kPerspective_Mask & combinedTypes) {
         key |= kGeneral_MatrixType;
     } else if (((SkMatrix::kAffine_Mask | SkMatrix::kScale_Mask) & combinedTypes) || reverseY) {
@@ -43,17 +42,15 @@ GrGLEffect::EffectKey GrGLEffectMatrix::GenKey(const SkMatrix& effectMatrix,
     return key;
 }
 
-GrSLType GrGLEffectMatrix::emitCode(GrGLShaderBuilder* builder,
-                                    EffectKey key,
-                                    SkString* fsCoordName,
-                                    SkString* vsCoordName,
-                                    const char* suffix) {
+void GrGLCoordTransform::emitCode(GrGLShaderBuilder* builder,
+                                  EffectKey key,
+                                  TransformedCoords* transformedCoords,
+                                  int suffix) {
     GrGLShaderBuilder::VertexBuilder* vertexBuilder = builder->getVertexBuilder();
     SkASSERT(NULL != vertexBuilder);
 
     GrSLType varyingType = kVoid_GrSLType;
     const char* uniName;
-    key &= kKeyMask;
     switch (key & kMatrixTypeKeyMask) {
         case kIdentity_MatrixType:
             fUniType = kVoid_GrSLType;
@@ -80,9 +77,9 @@ GrSLType GrGLEffectMatrix::emitCode(GrGLShaderBuilder* builder,
     }
     SkString suffixedUniName;
     if (kVoid_GrSLType != fUniType) {
-        if (NULL != suffix) {
+        if (0 != suffix) {
             suffixedUniName.append(uniName);
-            suffixedUniName.append(suffix);
+            suffixedUniName.appendf("_%i", suffix);
             uniName = suffixedUniName.c_str();
         }
         fUni = builder->addUniform(GrGLShaderBuilder::kVertex_Visibility,
@@ -93,9 +90,9 @@ GrSLType GrGLEffectMatrix::emitCode(GrGLShaderBuilder* builder,
 
     const char* varyingName = "MatrixCoord";
     SkString suffixedVaryingName;
-    if (NULL != suffix) {
+    if (0 != suffix) {
         suffixedVaryingName.append(varyingName);
-        suffixedVaryingName.append(suffix);
+        suffixedVaryingName.appendf("_%i", suffix);
         varyingName = suffixedVaryingName.c_str();
     }
     const char* vsVaryingName;
@@ -103,12 +100,12 @@ GrSLType GrGLEffectMatrix::emitCode(GrGLShaderBuilder* builder,
     vertexBuilder->addVarying(varyingType, varyingName, &vsVaryingName, &fsVaryingName);
 
     const GrGLShaderVar* coords;
-    switch (fCoordsType) {
-        case GrEffect::kLocal_CoordsType:
+    switch (fCoordSet) {
+        case kLocal_GrCoordSet:
             SkASSERT(!(kPositionCoords_Flag & key));
             coords = &vertexBuilder->localCoordsAttribute();
             break;
-        case GrEffect::kPosition_CoordsType:
+        case kPosition_GrCoordSet:
             SkASSERT((kPositionCoords_Flag & key) || !vertexBuilder->hasExplicitLocalCoords());
             coords = &vertexBuilder->positionAttribute();
             break;
@@ -141,71 +138,29 @@ GrSLType GrGLEffectMatrix::emitCode(GrGLShaderBuilder* builder,
         default:
             GrCrash("Unexpected uniform type.");
     }
-    if (NULL != vsCoordName) {
-        *vsCoordName = vsVaryingName;
-    }
-    if (NULL != fsCoordName) {
-        *fsCoordName = fsVaryingName;
-    }
-    return varyingType;
-}
-
-/**
-    * This is similar to emitCode except that it performs perspective division in the FS if the
-    * texture coordinates have a w coordinate. The fsCoordName always refers to a vec2f.
-    */
-void GrGLEffectMatrix::emitCodeMakeFSCoords2D(GrGLShaderBuilder* builder,
-                                              EffectKey key,
-                                              SkString* fsCoordName,
-                                              SkString* vsVaryingName,
-                                              GrSLType* vsVaryingType,
-                                              const char* suffix) {
-    SkString fsVaryingName;
-
-    GrSLType varyingType = this->emitCode(builder,
-                                          key,
-                                          &fsVaryingName,
-                                          vsVaryingName,
-                                          suffix);
-    if (kVec3f_GrSLType == varyingType) {
-
-        const char* coordName = "coords2D";
-        SkString suffixedCoordName;
-        if (NULL != suffix) {
-            suffixedCoordName.append(coordName);
-            suffixedCoordName.append(suffix);
-            coordName = suffixedCoordName.c_str();
-        }
-        builder->fsCodeAppendf("\tvec2 %s = %s.xy / %s.z;",
-                               coordName, fsVaryingName.c_str(), fsVaryingName.c_str());
-        if (NULL != fsCoordName) {
-            *fsCoordName = coordName;
-        }
-    } else if(NULL != fsCoordName) {
-        *fsCoordName = fsVaryingName;
-    }
-    if (NULL != vsVaryingType) {
-        *vsVaryingType = varyingType;
-    }
+    SkASSERT(NULL != transformedCoords);
+    transformedCoords->fName = fsVaryingName;
+    transformedCoords->fType = varyingType;
+    transformedCoords->fVSName = vsVaryingName;
 }
 
-void GrGLEffectMatrix::setData(const GrGLUniformManager& uniformManager,
-                               const SkMatrix& matrix,
-                               const GrDrawEffect& drawEffect,
-                               const GrTexture* texture) {
+void GrGLCoordTransform::setData(const GrGLUniformManager& uniformManager,
+                                 const SkMatrix& matrix,
+                                 const GrDrawEffect& drawEffect,
+                                 bool reverseY) {
     SkASSERT(fUni.isValid() != (kVoid_GrSLType == fUniType));
-    const SkMatrix& coordChangeMatrix = GrEffect::kLocal_CoordsType == fCoordsType ?
+    const SkMatrix& coordChangeMatrix = kLocal_GrCoordSet == fCoordSet ?
                                             drawEffect.getCoordChangeMatrix() :
                                             SkMatrix::I();
     switch (fUniType) {
         case kVoid_GrSLType:
             SkASSERT(matrix.isIdentity());
             SkASSERT(coordChangeMatrix.isIdentity());
-            SkASSERT(NULL == texture || kTopLeft_GrSurfaceOrigin == texture->origin());
+            SkASSERT(!reverseY);
             return;
         case kVec2f_GrSLType: {
             SkASSERT(SkMatrix::kTranslate_Mask == (matrix.getType() | coordChangeMatrix.getType()));
-            SkASSERT(NULL == texture || kTopLeft_GrSurfaceOrigin == texture->origin());
+            SkASSERT(!reverseY);
             SkScalar tx = matrix[SkMatrix::kMTransX] + (coordChangeMatrix)[SkMatrix::kMTransX];
             SkScalar ty = matrix[SkMatrix::kMTransY] + (coordChangeMatrix)[SkMatrix::kMTransY];
             if (fPrevMatrix.get(SkMatrix::kMTransX) != tx ||
@@ -219,7 +174,7 @@ void GrGLEffectMatrix::setData(const GrGLUniformManager& uniformManager,
         case kMat33f_GrSLType: {
             SkMatrix combined;
             combined.setConcat(matrix, coordChangeMatrix);
-            if (NULL != texture && kBottomLeft_GrSurfaceOrigin == texture->origin()) {
+            if (reverseY) {
                 // combined.postScale(1,-1);
                 // combined.postTranslate(0,1);
                 combined.set(SkMatrix::kMSkewY,