initial changes to add local matrix to primitive processor

src/gpu/GrGeometryProcessor.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 "GrGeometryProcessor.h"
 
 #include "gl/GrGLGeometryProcessor.h"
@@ skipping 44 matching lines @@
         fs->codeAppendf("%s = vec4(1);", outputName);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 struct PathBatchTracker {
     GrGPInput fInputColorType;
     GrGPInput fInputCoverageType;
     GrColor fColor;
+    bool fUsesLocalCoords;
 };
 
 class GrGLPathProcessor : public GrGLGeometryProcessor {
 public:
     GrGLPathProcessor(const GrPathProcessor&, const GrBatchTracker&)
         : fColor(GrColor_ILLEGAL) {}
 
     void emitCode(const EmitArgs& args) SK_OVERRIDE {
         GrGLGPBuilder* pb = args.fPB;
         GrGLGPFragmentBuilder* fs = args.fPB->getFragmentShaderBuilder();
@@ skipping 36 matching lines @@
         }
     }
 
 private:
     UniformHandle fColorUniform;
     GrColor fColor;
 
     typedef GrGLGeometryProcessor INHERITED;
 };
 
-GrPathProcessor::GrPathProcessor(GrColor color) : fColor(color) {
+GrPathProcessor::GrPathProcessor(GrColor color, const SkMatrix& localMatrix)
+    : INHERITED(localMatrix)
+    , fColor(color) {
     this->initClassID<GrPathProcessor>();
 }
 
 void GrPathProcessor::getInvariantOutputColor(GrInitInvariantOutput* out) const {
     out->setKnownFourComponents(fColor);
 }
 
 void GrPathProcessor::getInvariantOutputCoverage(GrInitInvariantOutput* out) const {
     out->setKnownSingleComponent(0xff);
 }
 
 void GrPathProcessor::initBatchTracker(GrBatchTracker* bt, const InitBT& init) const {
     PathBatchTracker* local = bt->cast<PathBatchTracker>();
     if (init.fColorIgnored) {
         local->fInputColorType = kIgnored_GrGPInput;
         local->fColor = GrColor_ILLEGAL;
     } else {
         local->fInputColorType = kUniform_GrGPInput;
         local->fColor = GrColor_ILLEGAL == init.fOverrideColor ? this->color() :
                                                                  init.fOverrideColor;
     }
 
     local->fInputCoverageType = init.fCoverageIgnored ? kIgnored_GrGPInput : kAllOnes_GrGPInput;
+    local->fUsesLocalCoords = init.fUsesLocalCoords;
 }
 
 bool GrPathProcessor::canMakeEqual(const GrBatchTracker& m,
                                    const GrPrimitiveProcessor& that,
                                    const GrBatchTracker& t) const {
     if (this->classID() != that.classID() || !this->hasSameTextureAccesses(that)) {
         return false;
     }
 
     const PathBatchTracker& mine = m.cast<PathBatchTracker>();
     const PathBatchTracker& theirs = t.cast<PathBatchTracker>();
-    return CanCombineOutput(mine.fInputColorType, mine.fColor,
+    return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords,
+                                   that, theirs.fUsesLocalCoords) &&
+           CanCombineOutput(mine.fInputColorType, mine.fColor,
                             theirs.fInputColorType, theirs.fColor) &&
            CanCombineOutput(mine.fInputCoverageType, 0xff,
                             theirs.fInputCoverageType, 0xff);
 }
 
 void GrPathProcessor::getGLProcessorKey(const GrBatchTracker& bt,
                                         const GrGLCaps& caps,
                                         GrProcessorKeyBuilder* b) const {
     GrGLPathProcessor::GenKey(*this, bt, caps, b);
 }
 
 GrGLGeometryProcessor* GrPathProcessor::createGLInstance(const GrBatchTracker& bt) const {
     return SkNEW_ARGS(GrGLPathProcessor, (*this, bt));
 }