Remove GrPrimitiveProcessor::hasTransformedLocalCoords

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 "SkRefCnt.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
 #include "glsl/GrGLSLGeometryProcessor.h"
 #include "glsl/GrGLSLVertexShaderBuilder.h"
 #include "glsl/GrGLSLVarying.h"
 #include "glsl/GrGLSLUniformHandler.h"
 #include "glsl/GrGLSLUtil.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 GPFlag {
     kColor_GPFlag =                 0x1,
     kLocalCoord_GPFlag =            0x2,
     kCoverage_GPFlag=               0x4,
-    kTransformedLocalCoord_GPFlag = 0x8,
 };
 
 class DefaultGeoProc : public GrGeometryProcessor {
 public:
     static sk_sp<GrGeometryProcessor> Make(uint32_t gpTypeFlags,
                                              GrColor color,
                                              const SkMatrix& viewMatrix,
                                              const SkMatrix& localMatrix,
                                              bool localCoordsWillBeRead,
                                              bool coverageWillBeIgnored,
@@ skipping 55 matching lines @@
             if (gp.hasExplicitLocalCoords()) {
                 // emit transforms with explicit local coords
                 this->emitTransforms(vertBuilder,
                                      varyingHandler,
                                      uniformHandler,
                                      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(vertBuilder,
-                                     varyingHandler,
-                                     gp.inLocalCoords()->fName,
-                                     args.fTransformsIn,
-                                     args.fTransformsOut);
             } else {
                 // emit transforms with position
                 this->emitTransforms(vertBuilder,
                                      varyingHandler,
                                      uniformHandler,
                                      gpArgs->fPositionVar,
                                      gp.inPosition()->fName,
                                      gp.localMatrix(),
                                      args.fTransformsIn,
                                      args.fTransformsOut);
@@ skipping 102 matching lines @@
         , fColor(color)
         , fViewMatrix(viewMatrix)
         , fLocalMatrix(localMatrix)
         , fCoverage(coverage)
         , fFlags(gpTypeFlags)
         , fLocalCoordsWillBeRead(localCoordsWillBeRead)
         , fCoverageWillBeIgnored(coverageWillBeIgnored) {
         this->initClassID<DefaultGeoProc>();
         bool hasColor = SkToBool(gpTypeFlags & kColor_GPFlag);
         bool hasExplicitLocalCoords = SkToBool(gpTypeFlags & kLocalCoord_GPFlag);
-        bool hasTransformedLocalCoords = SkToBool(gpTypeFlags & kTransformedLocalCoord_GPFlag);
-        bool hasLocalCoord = hasExplicitLocalCoords || hasTransformedLocalCoords;
         bool hasCoverage = SkToBool(gpTypeFlags & kCoverage_GPFlag);
         fInPosition = &this->addVertexAttrib("inPosition", kVec2f_GrVertexAttribType,
                                              kHigh_GrSLPrecision);
         if (hasColor) {
             fInColor = &this->addVertexAttrib("inColor", kVec4ub_GrVertexAttribType);
         }
-        if (hasLocalCoord) {
+        if (hasExplicitLocalCoords) {
             fInLocalCoords = &this->addVertexAttrib("inLocalCoord", kVec2f_GrVertexAttribType);
-            if (hasExplicitLocalCoords) {
-                this->setHasExplicitLocalCoords();
-            } else {
-                SkASSERT(hasTransformedLocalCoords);
-                this->setHasTransformedLocalCoords();
-            }
+            this->setHasExplicitLocalCoords();
         }
         if (hasCoverage) {
             fInCoverage = &this->addVertexAttrib("inCoverage", kFloat_GrVertexAttribType);
         }
     }
 
     const Attribute* fInPosition;
     const Attribute* fInColor;
     const Attribute* fInLocalCoords;
     const Attribute* fInCoverage;
@@ skipping 16 matching lines @@
     uint32_t flags = 0;
     if (d->fRandom->nextBool()) {
         flags |= kColor_GPFlag;
     }
     if (d->fRandom->nextBool()) {
         flags |= kCoverage_GPFlag;
     }
     if (d->fRandom->nextBool()) {
         flags |= kLocalCoord_GPFlag;
     }
-    if (d->fRandom->nextBool()) {
-        flags |= kTransformedLocalCoord_GPFlag;
-    }
 
     return DefaultGeoProc::Make(flags,
                                 GrRandomColor(d->fRandom),
                                 GrTest::TestMatrix(d->fRandom),
                                 GrTest::TestMatrix(d->fRandom),
                                 d->fRandom->nextBool(),
                                 d->fRandom->nextBool(),
                                 GrRandomCoverage(d->fRandom));
 }
 
 sk_sp<GrGeometryProcessor> GrDefaultGeoProcFactory::Make(const Color& color,
                                                          const Coverage& coverage,
                                                          const LocalCoords& localCoords,
                                                          const SkMatrix& viewMatrix) {
     uint32_t flags = 0;
     flags |= color.fType == Color::kAttribute_Type ? kColor_GPFlag : 0;
     flags |= coverage.fType == Coverage::kAttribute_Type ? kCoverage_GPFlag : 0;
     flags |= localCoords.fType == LocalCoords::kHasExplicit_Type ? kLocalCoord_GPFlag : 0;
-    flags |= localCoords.fType == LocalCoords::kHasTransformed_Type ?
-                                  kTransformedLocalCoord_GPFlag : 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::Make(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 Make(color, coverage, inverted, SkMatrix::I());
 }