Add support for transformedLocalCoords to GrDefaultGeoProc

src/gpu/GrDefaultGeoProcFactory.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 "GrDefaultGeoProcFactory.h"
 
 #include "GrInvariantOutput.h"
 #include "gl/GrGLGeometryProcessor.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 
 /*
  * The default Geometry Processor simply takes position and multiplies it by the uniform view
  * 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,
                                        GrColor color,
                                        const SkMatrix& viewMatrix,
                                        const SkMatrix& localMatrix,
                                        bool localCoordsWillBeRead,
                                        bool coverageWillBeIgnored,
                                        uint8_t coverage) {
         return SkNEW_ARGS(DefaultGeoProc, (gpTypeFlags,
@@ skipping 41 matching lines @@
                     pb->addPassThroughAttribute(gp.inColor(), args.fOutputColor);
                 } else {
                     this->setupUniformColor(pb, args.fOutputColor, &fColorUniform);
                 }
             }
 
             // Setup position
             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,
                                      gp.localMatrix(), args.fTransformsIn, args.fTransformsOut);
             }
 
             // Setup coverage as pass through
             if (!gp.coverageWillBeIgnored()) {
                 if (gp.hasVertexCoverage()) {
                     fs->codeAppendf("float alpha = 1.0;");
@@ skipping 98 matching lines @@
         , fInLocalCoords(NULL)
         , fInCoverage(NULL)
         , fColor(color)
         , fViewMatrix(viewMatrix)
         , fLocalMatrix(localMatrix)
         , fCoverage(coverage)
         , fFlags(gpTypeFlags)
         , 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) {
             fInColor = &this->addVertexAttrib(Attribute("inColor", kVec4ub_GrVertexAttribType));
         }
         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",
                                                            kFloat_GrVertexAttribType));
         }
     }
 
     const Attribute* fInPosition;
     const Attribute* fInColor;
     const Attribute* fInLocalCoords;
     const Attribute* fInCoverage;
     GrColor fColor;
     SkMatrix fViewMatrix;
     SkMatrix fLocalMatrix;
     uint8_t fCoverage;
     uint32_t fFlags;
     bool fLocalCoordsWillBeRead;
     bool fCoverageWillBeIgnored;
 
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
 
     typedef GrGeometryProcessor INHERITED;
 };
 
 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 |= GrDefaultGeoProcFactory::kCoverage_GPType;
+        flags |= kCoverage_GPType;
     }
     if (d->fRandom->nextBool()) {
-        flags |= GrDefaultGeoProcFactory::kLocalCoord_GPType;
+        flags |= kLocalCoord_GPType;
+    }
+    if (d->fRandom->nextBool()) {
+        flags |= kTransformedLocalCoord_GPType;
     }
 
     return DefaultGeoProc::Create(flags,
                                   GrRandomColor(d->fRandom),
                                   GrTest::TestMatrix(d->fRandom),
                                   GrTest::TestMatrix(d->fRandom),
                                   d->fRandom->nextBool(),
                                   d->fRandom->nextBool(),
                                   GrRandomCoverage(d->fRandom));
 }
 
 const GrGeometryProcessor* GrDefaultGeoProcFactory::Create(const Color& color,
                                                            const Coverage& coverage,
                                                            const LocalCoords& localCoords,
                                                            const SkMatrix& viewMatrix) {
     uint32_t flags = 0;
     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;
     bool localCoordsWillBeRead = localCoords.fType != LocalCoords::kUnused_Type;
 
     GrColor inColor = color.fColor;
     return DefaultGeoProc::Create(flags,
                                   inColor,
                                   viewMatrix,
                                   localCoords.fMatrix ? *localCoords.fMatrix : SkMatrix::I(),
@@ skipping 16 matching lines @@
         }
 
         if (localCoords.hasLocalMatrix()) {
             invert.preConcat(*localCoords.fMatrix);
         }
     }
 
     LocalCoords inverted(LocalCoords::kUsePosition_Type, &invert);
     return Create(color, coverage, inverted, SkMatrix::I());
 }