Move functions from GrDrawState.h to GrDrawState.cpp and delete unused functions.

src/gpu/GrDrawState.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrDrawState_DEFINED
 #define GrDrawState_DEFINED
 
@@ skipping 31 matching lines @@
      * Copies another draw state.
      **/
     GrDrawState(const GrDrawState& state) : INHERITED() {
         SkDEBUGCODE(fBlockEffectRemovalCnt = 0;)
         *this = state;
     }
 
     /**
      * Copies another draw state with a preconcat to the view matrix.
      **/
-    GrDrawState(const GrDrawState& state, const SkMatrix& preConcatMatrix) {
-        SkDEBUGCODE(fBlockEffectRemovalCnt = 0;)
-        *this = state;
-        if (!preConcatMatrix.isIdentity()) {
-            for (int i = 0; i < fColorStages.count(); ++i) {
-                fColorStages[i].localCoordChange(preConcatMatrix);
-            }
-            for (int i = 0; i < fCoverageStages.count(); ++i) {
-                fCoverageStages[i].localCoordChange(preConcatMatrix);
-            }
-            this->invalidateBlendOptFlags();
-        }
-    }
+    GrDrawState(const GrDrawState& state, const SkMatrix& preConcatMatrix);
 
     virtual ~GrDrawState() { SkASSERT(0 == fBlockEffectRemovalCnt); }
 
     /**
      * Resets to the default state. GrEffects will be removed from all stages.
      */
     void reset() { this->onReset(NULL); }
 
     void reset(const SkMatrix& initialViewMatrix) { this->onReset(&initialViewMatrix); }
 
@@ skipping 69 matching lines @@
         return -1 != fFixedFunctionVertexAttribIndices[kCoverage_GrVertexAttribBinding];
     }
 
     bool validateVertexAttribs() const;
 
     /**
      * Helper to save/restore vertex attribs
      */
      class AutoVertexAttribRestore {
      public:
-         AutoVertexAttribRestore(GrDrawState* drawState) {
-             SkASSERT(NULL != drawState);
-             fDrawState = drawState;
-             fVAPtr = drawState->fVAPtr;
-             fVACount = drawState->fVACount;
-             fDrawState->setDefaultVertexAttribs();
-         }
+         AutoVertexAttribRestore(GrDrawState* drawState);
 
-         ~AutoVertexAttribRestore(){
-             fDrawState->setVertexAttribs(fVAPtr, fVACount);
-         }
+         ~AutoVertexAttribRestore() { fDrawState->setVertexAttribs(fVAPtr, fVACount); }
 
      private:
          GrDrawState*          fDrawState;
          const GrVertexAttrib* fVAPtr;
          int                   fVACount;
      };
 
-    /**
-     * Accessing positions, local coords, or colors, of a vertex within an array is a hassle
-     * involving casts and simple math. These helpers exist to keep GrDrawTarget clients' code a bit
-     * nicer looking.
-     */
-
-    /**
-     * Gets a pointer to a GrPoint of a vertex's position or texture
-     * coordinate.
-     * @param vertices      the vertex array
-     * @param vertexIndex   the index of the vertex in the array
-     * @param vertexSize    the size of each vertex in the array
-     * @param offset        the offset in bytes of the vertex component.
-     *                      Defaults to zero (corresponding to vertex position)
-     * @return pointer to the vertex component as a GrPoint
-     */
-    static SkPoint* GetVertexPoint(void* vertices,
-                                   int vertexIndex,
-                                   int vertexSize,
-                                   int offset = 0) {
-        intptr_t start = GrTCast<intptr_t>(vertices);
-        return GrTCast<SkPoint*>(start + offset +
-                                 vertexIndex * vertexSize);
-    }
-    static const SkPoint* GetVertexPoint(const void* vertices,
-                                         int vertexIndex,
-                                         int vertexSize,
-                                         int offset = 0) {
-        intptr_t start = GrTCast<intptr_t>(vertices);
-        return GrTCast<const SkPoint*>(start + offset +
-                                       vertexIndex * vertexSize);
-    }
-
-    /**
-     * Gets a pointer to a GrColor inside a vertex within a vertex array.
-     * @param vertices      the vetex array
-     * @param vertexIndex   the index of the vertex in the array
-     * @param vertexSize    the size of each vertex in the array
-     * @param offset        the offset in bytes of the vertex color
-     * @return pointer to the vertex component as a GrColor
-     */
-    static GrColor* GetVertexColor(void* vertices,
-                                   int vertexIndex,
-                                   int vertexSize,
-                                   int offset) {
-        intptr_t start = GrTCast<intptr_t>(vertices);
-        return GrTCast<GrColor*>(start + offset +
-                                 vertexIndex * vertexSize);
-    }
-    static const GrColor* GetVertexColor(const void* vertices,
-                                         int vertexIndex,
-                                         int vertexSize,
-                                         int offset) {
-        const intptr_t start = GrTCast<intptr_t>(vertices);
-        return GrTCast<const GrColor*>(start + offset +
-                                       vertexIndex * vertexSize);
-    }
-
     /// @}
 
     /**
      * Determines whether src alpha is guaranteed to be one for all src pixels
      */
     bool srcAlphaWillBeOne() const;
 
     /**
      * Determines whether the output coverage is guaranteed to be one for all pixels hit by a draw.
      */
@@ skipping 117 matching lines @@
     class AutoRestoreEffects : public ::SkNoncopyable {
     public:
         AutoRestoreEffects() : fDrawState(NULL), fColorEffectCnt(0), fCoverageEffectCnt(0) {}
 
         AutoRestoreEffects(GrDrawState* ds) : fDrawState(NULL), fColorEffectCnt(0), fCoverageEffectCnt(0) {
             this->set(ds);
         }
 
         ~AutoRestoreEffects() { this->set(NULL); }
 
-        void set(GrDrawState* ds) {
-            if (NULL != fDrawState) {
-                int m = fDrawState->fColorStages.count() - fColorEffectCnt;
-                SkASSERT(m >= 0);
-                fDrawState->fColorStages.pop_back_n(m);
-
-                int n = fDrawState->fCoverageStages.count() - fCoverageEffectCnt;
-                SkASSERT(n >= 0);
-                fDrawState->fCoverageStages.pop_back_n(n);
-                if (m + n > 0) {
-                    fDrawState->invalidateBlendOptFlags();
-                }
-                SkDEBUGCODE(--fDrawState->fBlockEffectRemovalCnt;)
-            }
-            fDrawState = ds;
-            if (NULL != ds) {
-                fColorEffectCnt = ds->fColorStages.count();
-                fCoverageEffectCnt = ds->fCoverageStages.count();
-                SkDEBUGCODE(++ds->fBlockEffectRemovalCnt;)
-            }
-        }
+        void set(GrDrawState* ds);
 
         bool isSet() const { return NULL != fDrawState; }
 
     private:
         GrDrawState* fDrawState;
         int fColorEffectCnt;
         int fCoverageEffectCnt;
     };
 
     int numColorStages() const { return fColorStages.count(); }
@@ skipping 455 matching lines @@
         /** Use the first draw state. */
         kA_CombinedState,
         /** Use the second draw state. */
         kB_CombinedState,
     };
 
     /** This function determines whether the GrDrawStates used for two draws can be combined into
         a single GrDrawState. This is used to avoid storing redundant GrDrawStates and to determine
         if draws can be batched. The return value indicates whether combining is possible and, if
         so, which of the two inputs should be used. */
-    static CombinedState CombineIfPossible(const GrDrawState& a, const GrDrawState& b) {
-        bool usingVertexColors = a.hasColorVertexAttribute();
-        if (!usingVertexColors && a.fColor != b.fColor) {
-            return kIncompatible_CombinedState;
-        }
+    static CombinedState CombineIfPossible(const GrDrawState& a, const GrDrawState& b);
 
-        if (a.fRenderTarget.get() != b.fRenderTarget.get() ||
-            a.fColorStages.count() != b.fColorStages.count() ||
-            a.fCoverageStages.count() != b.fCoverageStages.count() ||
-            !a.fViewMatrix.cheapEqualTo(b.fViewMatrix) ||
-            a.fSrcBlend != b.fSrcBlend ||
-            a.fDstBlend != b.fDstBlend ||
-            a.fBlendConstant != b.fBlendConstant ||
-            a.fFlagBits != b.fFlagBits ||
-            a.fVACount != b.fVACount ||
-            memcmp(a.fVAPtr, b.fVAPtr, a.fVACount * sizeof(GrVertexAttrib)) ||
-            a.fStencilSettings != b.fStencilSettings ||
-            a.fDrawFace != b.fDrawFace) {
-            return kIncompatible_CombinedState;
-        }
-
-        bool usingVertexCoverage = a.hasCoverageVertexAttribute();
-        if (!usingVertexCoverage && a.fCoverage != b.fCoverage) {
-            return kIncompatible_CombinedState;
-        }
-
-        bool explicitLocalCoords = a.hasLocalCoordAttribute();
-        for (int i = 0; i < a.fColorStages.count(); i++) {
-            if (!GrEffectStage::AreCompatible(a.fColorStages[i], b.fColorStages[i],
-                explicitLocalCoords)) {
-                return kIncompatible_CombinedState;
-            }
-        }
-        for (int i = 0; i < a.fCoverageStages.count(); i++) {
-            if (!GrEffectStage::AreCompatible(a.fCoverageStages[i], b.fCoverageStages[i],
-                explicitLocalCoords)) {
-                return kIncompatible_CombinedState;
-            }
-        }
-        SkASSERT(0 == memcmp(a.fFixedFunctionVertexAttribIndices,
-                             b.fFixedFunctionVertexAttribIndices,
-                             sizeof(a.fFixedFunctionVertexAttribIndices)));
-        return kAOrB_CombinedState;
-    }
-
-    GrDrawState& operator= (const GrDrawState& that) {
-        SkASSERT(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages());
-        this->setRenderTarget(that.fRenderTarget.get());
-        fColor = that.fColor;
-        fViewMatrix = that.fViewMatrix;
-        fSrcBlend = that.fSrcBlend;
-        fDstBlend = that.fDstBlend;
-        fBlendConstant = that.fBlendConstant;
-        fFlagBits = that.fFlagBits;
-        fVACount = that.fVACount;
-        fVAPtr = that.fVAPtr;
-        fStencilSettings = that.fStencilSettings;
-        fCoverage = that.fCoverage;
-        fDrawFace = that.fDrawFace;
-        fColorStages = that.fColorStages;
-        fCoverageStages = that.fCoverageStages;
-        fOptSrcBlend = that.fOptSrcBlend;
-        fOptDstBlend = that.fOptDstBlend;
-        fBlendOptFlags = that.fBlendOptFlags;
-
-        memcpy(fFixedFunctionVertexAttribIndices,
-               that.fFixedFunctionVertexAttribIndices,
-               sizeof(fFixedFunctionVertexAttribIndices));
-        return *this;
-    }
+    GrDrawState& operator= (const GrDrawState& that);
 
 private:
 
-    void onReset(const SkMatrix* initialViewMatrix) {
-        SkASSERT(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages());
-        fColorStages.reset();
-        fCoverageStages.reset();
-
-        fRenderTarget.reset(NULL);
-
-        this->setDefaultVertexAttribs();
-
-        fColor = 0xffffffff;
-        if (NULL == initialViewMatrix) {
-            fViewMatrix.reset();
-        } else {
-            fViewMatrix = *initialViewMatrix;
-        }
-        fSrcBlend = kOne_GrBlendCoeff;
-        fDstBlend = kZero_GrBlendCoeff;
-        fBlendConstant = 0x0;
-        fFlagBits = 0x0;
-        fStencilSettings.setDisabled();
-        fCoverage = 0xffffffff;
-        fDrawFace = kBoth_DrawFace;
-
-        this->invalidateBlendOptFlags();
-    }
+    void onReset(const SkMatrix* initialViewMatrix);
 
     BlendOptFlags calcBlendOpts(bool forceCoverage = false,
                                GrBlendCoeff* srcCoeff = NULL,
                                GrBlendCoeff* dstCoeff = NULL) const;
 
     // These fields are roughly sorted by decreasing likelihood of being different in op==
     SkAutoTUnref<GrRenderTarget>        fRenderTarget;
     GrColor                             fColor;
     SkMatrix                            fViewMatrix;
     GrBlendCoeff                        fSrcBlend;
@@ skipping 29 matching lines @@
      *  @param count      the number of attributes being set, limited to kMaxVertexAttribCnt.
      */
     void setVertexAttribs(const GrVertexAttrib attribs[], int count);
 
     typedef SkRefCnt INHERITED;
 };
 
 GR_MAKE_BITFIELD_OPS(GrDrawState::BlendOptFlags);
 
 #endif