Add support for transformedLocalCoords to GrDefaultGeoProc

src/gpu/GrDefaultGeoProcFactory.cpp

Index: src/gpu/GrDefaultGeoProcFactory.cpp
diff --git a/src/gpu/GrDefaultGeoProcFactory.cpp b/src/gpu/GrDefaultGeoProcFactory.cpp
index 639a593220c68fbf56b099517084e373434597bc..963cffab60f1302ad2dd9ec8a8762a7c6c4af63c 100644
--- a/src/gpu/GrDefaultGeoProcFactory.cpp
+++ b/src/gpu/GrDefaultGeoProcFactory.cpp
@@ -16,6 +16,16 @@
  * matrix. It also leaves coverage untouched.  Behind the scenes, we may add per vertex color or
  * local coords.
  */
+
+enum GPType {

[bsalomon, 2015/08/05 15:17:02]

This looks like a set of flags for a bitfield rather than distinct types

+    kPosition_GPType = 0x0, // we ALWAYS have position
+    kColor_GPType = 0x01,
+    kLocalCoord_GPType = 0x02,
+    kCoverage_GPType= 0x04,
+    kTransformedLocalCoord_GPType = 0x08,
+    kLastGPType = kTransformedLocalCoord_GPType
+};
+
 class DefaultGeoProc : public GrGeometryProcessor {
 public:
     static GrGeometryProcessor* Create(uint32_t gpTypeFlags,
@@ -77,10 +87,14 @@ public:
             this->setupPosition(pb, gpArgs, gp.inPosition()->fName, gp.viewMatrix(),
                                 &fViewMatrixUniform);
 
-            if (gp.inLocalCoords()) {
+            if (gp.hasExplicitLocalCoords()) {
                 // emit transforms with explicit local coords
                 this->emitTransforms(pb, gpArgs->fPositionVar, gp.inLocalCoords()->fName,
                                      gp.localMatrix(), args.fTransformsIn, args.fTransformsOut);
+            } else if(gp.hasTransformedLocalCoords()) {
+                // transforms have already been applied to vertex attributes on the cpu
+                this->emitTransforms(pb, gp.inLocalCoords()->fName,
+                                     args.fTransformsIn, args.fTransformsOut);
             } else {
                 // emit transforms with position
                 this->emitTransforms(pb, gpArgs->fPositionVar, gp.inPosition()->fName,
@@ -199,9 +213,11 @@ private:
         , fLocalCoordsWillBeRead(localCoordsWillBeRead)
         , fCoverageWillBeIgnored(coverageWillBeIgnored) {
         this->initClassID<DefaultGeoProc>();
-        bool hasColor = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kColor_GPType);
-        bool hasLocalCoord = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kLocalCoord_GPType);
-        bool hasCoverage = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kCoverage_GPType);
+        bool hasColor = SkToBool(gpTypeFlags & kColor_GPType);
+        bool hasExplicitLocalCoords = SkToBool(gpTypeFlags & kLocalCoord_GPType);
+        bool hasTransformedLocalCoords = SkToBool(gpTypeFlags & kTransformedLocalCoord_GPType);
+        bool hasLocalCoord = hasExplicitLocalCoords || hasTransformedLocalCoords;
+        bool hasCoverage = SkToBool(gpTypeFlags & kCoverage_GPType);
         fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType,
                                                        kHigh_GrSLPrecision));
         if (hasColor) {
@@ -210,7 +226,12 @@ private:
         if (hasLocalCoord) {
             fInLocalCoords = &this->addVertexAttrib(Attribute("inLocalCoord",
                                                               kVec2f_GrVertexAttribType));
-            this->setHasLocalCoords();
+            if (hasExplicitLocalCoords) {
+                this->setHasExplicitLocalCoords();
+            } else {
+                SkASSERT(hasTransformedLocalCoords);
+                this->setHasTransformedLocalCoords();
+            }
         }
         if (hasCoverage) {
             fInCoverage = &this->addVertexAttrib(Attribute("inCoverage",
@@ -240,13 +261,16 @@ GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DefaultGeoProc);
 GrGeometryProcessor* DefaultGeoProc::TestCreate(GrProcessorTestData* d) {
     uint32_t flags = 0;
     if (d->fRandom->nextBool()) {
-        flags |= GrDefaultGeoProcFactory::kColor_GPType;
+        flags |= kColor_GPType;
+    }
+    if (d->fRandom->nextBool()) {
+        flags |= kCoverage_GPType;
     }
     if (d->fRandom->nextBool()) {
-        flags |= GrDefaultGeoProcFactory::kCoverage_GPType;
+        flags |= kLocalCoord_GPType;
     }
     if (d->fRandom->nextBool()) {
-        flags |= GrDefaultGeoProcFactory::kLocalCoord_GPType;
+        flags |= kTransformedLocalCoord_GPType;
     }
 
     return DefaultGeoProc::Create(flags,
@@ -266,6 +290,8 @@ const GrGeometryProcessor* GrDefaultGeoProcFactory::Create(const Color& color,
     flags |= color.fType == Color::kAttribute_Type ? kColor_GPType : 0;
     flags |= coverage.fType == Coverage::kAttribute_Type ? kCoverage_GPType : 0;
     flags |= localCoords.fType == LocalCoords::kHasExplicit_Type ? kLocalCoord_GPType : 0;
+    flags |= localCoords.fType == LocalCoords::kHasTransformed_Type ?
+                                  kTransformedLocalCoord_GPType : 0;
 
     uint8_t inCoverage = coverage.fCoverage;
     bool coverageWillBeIgnored = coverage.fType == Coverage::kNone_Type;