Remove viewmatrix from GrGeometryProcessor base class

src/gpu/effects/GrBezierEffect.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrBezierEffect.h"
 
 #include "gl/GrGLProcessor.h"
@@ skipping 16 matching lines @@
     void onEmitCode(EmitArgs&, GrGPArgs*) override;
 
     static inline void GenKey(const GrGeometryProcessor&,
                               const GrBatchTracker&,
                               const GrGLSLCaps&,
                               GrProcessorKeyBuilder*);
 
     virtual void setData(const GrGLProgramDataManager& pdman,
                          const GrPrimitiveProcessor& primProc,
                          const GrBatchTracker& bt) override {
-        this->setUniformViewMatrix(pdman, primProc.viewMatrix());
+        const GrConicEffect& ce = primProc.cast<GrConicEffect>();
+        this->setUniformViewMatrix(pdman, ce.viewMatrix());
 
         const ConicBatchTracker& local = bt.cast<ConicBatchTracker>();
         if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) {
             GrGLfloat c[4];
             GrColorToRGBAFloat(local.fColor, c);
             pdman.set4fv(fColorUniform, 1, c);
             fColor = local.fColor;
         }
         if (0xff != local.fCoverageScale && fCoverageScale != local.fCoverageScale) {
             pdman.set1f(fCoverageScaleUniform, GrNormalizeByteToFloat(local.fCoverageScale));
@@ skipping 115 matching lines @@
 void GrGLConicEffect::GenKey(const GrGeometryProcessor& gp,
                              const GrBatchTracker& bt,
                              const GrGLSLCaps&,
                              GrProcessorKeyBuilder* b) {
     const GrConicEffect& ce = gp.cast<GrConicEffect>();
     const ConicBatchTracker& local = bt.cast<ConicBatchTracker>();
     uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2;
     key |= kUniform_GrGPInput == local.fInputColorType ? 0x4 : 0x0;
     key |= 0xff != local.fCoverageScale ? 0x8 : 0x0;
     key |= local.fUsesLocalCoords && gp.localMatrix().hasPerspective() ? 0x10 : 0x0;
-    key |= ComputePosKey(gp.viewMatrix()) << 5;
+    key |= ComputePosKey(ce.viewMatrix()) << 5;
     b->add32(key);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrConicEffect::~GrConicEffect() {}
 
 void GrConicEffect::getGLProcessorKey(const GrBatchTracker& bt,
                                       const GrGLSLCaps& caps,
                                       GrProcessorKeyBuilder* b) const {
     GrGLConicEffect::GenKey(*this, bt, caps, b);
 }
 
 GrGLPrimitiveProcessor* GrConicEffect::createGLInstance(const GrBatchTracker& bt,
                                                         const GrGLSLCaps&) const {
     return SkNEW_ARGS(GrGLConicEffect, (*this, bt));
 }
 
 GrConicEffect::GrConicEffect(GrColor color, const SkMatrix& viewMatrix, uint8_t coverage,
                              GrPrimitiveEdgeType edgeType, const SkMatrix& localMatrix)
-    : INHERITED(viewMatrix, localMatrix)
+    : INHERITED(localMatrix)
     , fColor(color)
+    , fViewMatrix(viewMatrix)
     , fCoverageScale(coverage)
     , fEdgeType(edgeType) {
     this->initClassID<GrConicEffect>();
     fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType));
     fInConicCoeffs = &this->addVertexAttrib(Attribute("inConicCoeffs",
                                                         kVec4f_GrVertexAttribType));
 }
 
 void GrConicEffect::initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const {
     ConicBatchTracker* local = bt->cast<ConicBatchTracker>();
@@ skipping 40 matching lines @@
     void onEmitCode(EmitArgs&, GrGPArgs*) override;
 
     static inline void GenKey(const GrGeometryProcessor&,
                               const GrBatchTracker&,
                               const GrGLSLCaps&,
                               GrProcessorKeyBuilder*);
 
     virtual void setData(const GrGLProgramDataManager& pdman,
                          const GrPrimitiveProcessor& primProc,
                          const GrBatchTracker& bt) override {
-        this->setUniformViewMatrix(pdman, primProc.viewMatrix());
+        const GrQuadEffect& qe = primProc.cast<GrQuadEffect>();
+        this->setUniformViewMatrix(pdman, qe.viewMatrix());
 
         const QuadBatchTracker& local = bt.cast<QuadBatchTracker>();
         if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) {
             GrGLfloat c[4];
             GrColorToRGBAFloat(local.fColor, c);
             pdman.set4fv(fColorUniform, 1, c);
             fColor = local.fColor;
         }
         if (0xff != local.fCoverageScale && local.fCoverageScale != fCoverageScale) {
             pdman.set1f(fCoverageScaleUniform, GrNormalizeByteToFloat(local.fCoverageScale));
@@ skipping 101 matching lines @@
 void GrGLQuadEffect::GenKey(const GrGeometryProcessor& gp,
                             const GrBatchTracker& bt,
                             const GrGLSLCaps&,
                             GrProcessorKeyBuilder* b) {
     const GrQuadEffect& ce = gp.cast<GrQuadEffect>();
     const QuadBatchTracker& local = bt.cast<QuadBatchTracker>();
     uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2;
     key |= kUniform_GrGPInput == local.fInputColorType ? 0x4 : 0x0;
     key |= 0xff != local.fCoverageScale ? 0x8 : 0x0;
     key |= local.fUsesLocalCoords && gp.localMatrix().hasPerspective() ? 0x10 : 0x0;
-    key |= ComputePosKey(gp.viewMatrix()) << 5;
+    key |= ComputePosKey(ce.viewMatrix()) << 5;
     b->add32(key);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrQuadEffect::~GrQuadEffect() {}
 
 void GrQuadEffect::getGLProcessorKey(const GrBatchTracker& bt,
                                      const GrGLSLCaps& caps,
                                      GrProcessorKeyBuilder* b) const {
     GrGLQuadEffect::GenKey(*this, bt, caps, b);
 }
 
 GrGLPrimitiveProcessor* GrQuadEffect::createGLInstance(const GrBatchTracker& bt,
                                                        const GrGLSLCaps&) const {
     return SkNEW_ARGS(GrGLQuadEffect, (*this, bt));
 }
 
 GrQuadEffect::GrQuadEffect(GrColor color, const SkMatrix& viewMatrix, uint8_t coverage,
                            GrPrimitiveEdgeType edgeType, const SkMatrix& localMatrix)
-    : INHERITED(viewMatrix, localMatrix)
+    : INHERITED(localMatrix)
     , fColor(color)
+    , fViewMatrix(viewMatrix)
     , fCoverageScale(coverage)
     , fEdgeType(edgeType) {
     this->initClassID<GrQuadEffect>();
     fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType));
     fInHairQuadEdge = &this->addVertexAttrib(Attribute("inHairQuadEdge",
                                                         kVec4f_GrVertexAttribType));
 }
 
 void GrQuadEffect::initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const {
     QuadBatchTracker* local = bt->cast<QuadBatchTracker>();
@@ skipping 40 matching lines @@
     void onEmitCode(EmitArgs&, GrGPArgs*) override;
 
     static inline void GenKey(const GrGeometryProcessor&,
                               const GrBatchTracker&,
                               const GrGLSLCaps&,
                               GrProcessorKeyBuilder*);
 
     virtual void setData(const GrGLProgramDataManager& pdman,
                          const GrPrimitiveProcessor& primProc,
                          const GrBatchTracker& bt) override {
-        this->setUniformViewMatrix(pdman, primProc.viewMatrix());
+        const GrCubicEffect& ce = primProc.cast<GrCubicEffect>();
+        this->setUniformViewMatrix(pdman, ce.viewMatrix());
 
         const CubicBatchTracker& local = bt.cast<CubicBatchTracker>();
         if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) {
             GrGLfloat c[4];
             GrColorToRGBAFloat(local.fColor, c);
             pdman.set4fv(fColorUniform, 1, c);
             fColor = local.fColor;
         }
     }
 
@@ skipping 124 matching lines @@
 
 void GrGLCubicEffect::GenKey(const GrGeometryProcessor& gp,
                              const GrBatchTracker& bt,
                              const GrGLSLCaps&,
                              GrProcessorKeyBuilder* b) {
     const GrCubicEffect& ce = gp.cast<GrCubicEffect>();
     const CubicBatchTracker& local = bt.cast<CubicBatchTracker>();
     uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2;
     key |= kUniform_GrGPInput == local.fInputColorType ? 0x4 : 0x8;
     key |= local.fUsesLocalCoords && gp.localMatrix().hasPerspective() ? 0x10 : 0x0;
-    key |= ComputePosKey(gp.viewMatrix()) << 5;
+    key |= ComputePosKey(ce.viewMatrix()) << 5;
     b->add32(key);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrCubicEffect::~GrCubicEffect() {}
 
 void GrCubicEffect::getGLProcessorKey(const GrBatchTracker& bt,
                                       const GrGLSLCaps& caps,
                                       GrProcessorKeyBuilder* b) const {
     GrGLCubicEffect::GenKey(*this, bt, caps, b);
 }
 
 GrGLPrimitiveProcessor* GrCubicEffect::createGLInstance(const GrBatchTracker& bt,
                                                         const GrGLSLCaps&) const {
     return SkNEW_ARGS(GrGLCubicEffect, (*this, bt));
 }
 
 GrCubicEffect::GrCubicEffect(GrColor color, const SkMatrix& viewMatrix,
                              GrPrimitiveEdgeType edgeType)
-    : INHERITED(viewMatrix)
-    , fColor(color)
+    : fColor(color)
+    , fViewMatrix(viewMatrix)
     , fEdgeType(edgeType) {
     this->initClassID<GrCubicEffect>();
     fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType));
     fInCubicCoeffs = &this->addVertexAttrib(Attribute("inCubicCoeffs",
                                                         kVec4f_GrVertexAttribType));
 }
 
 void GrCubicEffect::initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const {
     CubicBatchTracker* local = bt->cast<CubicBatchTracker>();
     local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, false);
@@ skipping 11 matching lines @@
     GrGeometryProcessor* gp;
     do {
         GrPrimitiveEdgeType edgeType = static_cast<GrPrimitiveEdgeType>(
                                                     random->nextULessThan(kGrProcessorEdgeTypeCnt));
         gp = GrCubicEffect::Create(GrRandomColor(random),
                                    GrTest::TestMatrix(random), edgeType, caps);
     } while (NULL == gp);
     return gp;
 }