Create struct in GrDrawState to hold key DrawState data.

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 197 matching lines @@
     uint8_t getCoverage() const {
         return GrColorUnpackR(fCoverage);
     }
 
     GrColor getCoverageColor() const {
         return fCoverage;
     }
 
     /// @}
 
+    /**
+     * This struct is here so that the GrDrawState can have multiple instances of state information.
+     * The use of this will come in a future revision when we want to keep track of the original
+     * draw state as well as an optimized version of it.
+     */
+    struct State {
+        State() {
+            this->reset();
+        }
+
+        State(const GrEffectStage* colorArray, int colorCount,
+                      const GrEffectStage* coverageArray, int coverageCount)
+            : fColorStages(colorArray, colorCount), fCoverageStages(coverageArray, coverageCount) {
+                fSrcBlend = kOne_GrBlendCoeff;
+                fDstBlend = kZero_GrBlendCoeff;
+        }
+
+        static bool HaveCompatibleState(const State& a, const State& b, bool explicitLocalCoords);
+
+        void reset() {
+            fSrcBlend = kOne_GrBlendCoeff;
+            fDstBlend = kZero_GrBlendCoeff;
+            fColorStages.reset();
+            fCoverageStages.reset();
+        }
+
+        GrBlendCoeff                        fSrcBlend;
+        GrBlendCoeff                        fDstBlend;
+
+        typedef SkSTArray<4, GrEffectStage> EffectStageArray;
+        EffectStageArray                    fColorStages;
+        EffectStageArray                    fCoverageStages;
+    };
+
     ///////////////////////////////////////////////////////////////////////////
     /// @name Effect Stages
     /// Each stage hosts a GrEffect. The effect produces an output color or coverage in the fragment
     /// shader. Its inputs are the output from the previous stage as well as some variables
     /// available to it in the fragment and vertex shader (e.g. the vertex position, the dst color,
     /// the fragment position, local coordinates).
     ///
     /// The stages are divided into two sets, color-computing and coverage-computing. The final
     /// color stage produces the final pixel color. The coverage-computing stages function exactly
     /// as the color-computing but the output of the final coverage stage is treated as a fractional
     /// pixel coverage rather than as input to the src/dst color blend step.
     ///
     /// The input color to the first color-stage is either the constant color or interpolated
     /// per-vertex colors. The input to the first coverage stage is either a constant coverage
     /// (usually full-coverage) or interpolated per-vertex coverage.
     ///
     /// See the documentation of kCoverageDrawing_StateBit for information about disabling the
     /// the color / coverage distinction.
     ////
 
     const GrEffect* addColorEffect(const GrEffect* effect, int attr0 = -1, int attr1 = -1) {
         SkASSERT(NULL != effect);
-        SkNEW_APPEND_TO_TARRAY(&fColorStages, GrEffectStage, (effect, attr0, attr1));
+        SkNEW_APPEND_TO_TARRAY(&fState.fColorStages, GrEffectStage, (effect, attr0, attr1));
         this->invalidateBlendOptFlags();
         return effect;
     }
 
     const GrEffect* addCoverageEffect(const GrEffect* effect, int attr0 = -1, int attr1 = -1) {
         SkASSERT(NULL != effect);
-        SkNEW_APPEND_TO_TARRAY(&fCoverageStages, GrEffectStage, (effect, attr0, attr1));
+        SkNEW_APPEND_TO_TARRAY(&fState.fCoverageStages, GrEffectStage, (effect, attr0, attr1));
         this->invalidateBlendOptFlags();
         return effect;
     }
 
     /**
      * Creates a GrSimpleTextureEffect that uses local coords as texture coordinates.
      */
     void addColorTextureEffect(GrTexture* texture, const SkMatrix& matrix) {
         this->addColorEffect(GrSimpleTextureEffect::Create(texture, matrix))->unref();
     }
@@ skipping 31 matching lines @@
         void set(GrDrawState* ds);
 
         bool isSet() const { return NULL != fDrawState; }
 
     private:
         GrDrawState* fDrawState;
         int fColorEffectCnt;
         int fCoverageEffectCnt;
     };
 
-    int numColorStages() const { return fColorStages.count(); }
-    int numCoverageStages() const { return fCoverageStages.count(); }
+    int numColorStages() const { return fState.fColorStages.count(); }
+    int numCoverageStages() const { return fState.fCoverageStages.count(); }
     int numTotalStages() const { return this->numColorStages() + this->numCoverageStages(); }
 
-    const GrEffectStage& getColorStage(int stageIdx) const { return fColorStages[stageIdx]; }
-    const GrEffectStage& getCoverageStage(int stageIdx) const { return fCoverageStages[stageIdx]; }
+    const GrEffectStage& getColorStage(int stageIdx) const { return fState.fColorStages[stageIdx]; }
+    const GrEffectStage& getCoverageStage(int stageIdx) const { return fState.fCoverageStages[stageIdx]; }
 
     /**
      * Checks whether any of the effects will read the dst pixel color.
      */
     bool willEffectReadDstColor() const;
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name Blending
     ////
 
     /**
      * Sets the blending function coefficients.
      *
      * The blend function will be:
      *    D' = sat(S*srcCoef + D*dstCoef)
      *
      *   where D is the existing destination color, S is the incoming source
      *   color, and D' is the new destination color that will be written. sat()
      *   is the saturation function.
      *
      * @param srcCoef coefficient applied to the src color.
      * @param dstCoef coefficient applied to the dst color.
      */
     void setBlendFunc(GrBlendCoeff srcCoeff, GrBlendCoeff dstCoeff) {
-        fSrcBlend = srcCoeff;
-        fDstBlend = dstCoeff;
+        fState.fSrcBlend = srcCoeff;
+        fState.fDstBlend = dstCoeff;
         this->invalidateBlendOptFlags();
     #ifdef SK_DEBUG
         if (GrBlendCoeffRefsDst(dstCoeff)) {
             GrPrintf("Unexpected dst blend coeff. Won't work correctly with coverage stages.\n");
         }
         if (GrBlendCoeffRefsSrc(srcCoeff)) {
             GrPrintf("Unexpected src blend coeff. Won't work correctly with coverage stages.\n");
         }
     #endif
     }
 
-    GrBlendCoeff getSrcBlendCoeff() const { return fSrcBlend; }
-    GrBlendCoeff getDstBlendCoeff() const { return fDstBlend; }
+    GrBlendCoeff getSrcBlendCoeff() const { return fState.fSrcBlend; }
+    GrBlendCoeff getDstBlendCoeff() const { return fState.fDstBlend; }
 
     void getDstBlendCoeff(GrBlendCoeff* srcBlendCoeff,
                           GrBlendCoeff* dstBlendCoeff) const {
-        *srcBlendCoeff = fSrcBlend;
-        *dstBlendCoeff = fDstBlend;
+        *srcBlendCoeff = fState.fSrcBlend;
+        *dstBlendCoeff = fState.fDstBlend;
     }
 
     /**
      * Sets the blending function constant referenced by the following blending
      * coefficients:
      *      kConstC_GrBlendCoeff
      *      kIConstC_GrBlendCoeff
      *      kConstA_GrBlendCoeff
      *      kIConstA_GrBlendCoeff
      *
@@ skipping 399 matching lines @@
 
     /** 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);
 
     GrDrawState& operator= (const GrDrawState& that);
 
 private:
-
     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;
-    GrBlendCoeff                        fDstBlend;
     GrColor                             fBlendConstant;
     uint32_t                            fFlagBits;
     const GrVertexAttrib*               fVAPtr;
     int                                 fVACount;
     GrStencilSettings                   fStencilSettings;
     GrColor                             fCoverage;
     DrawFace                            fDrawFace;
 
-    typedef SkSTArray<4, GrEffectStage> EffectStageArray;
-    EffectStageArray                    fColorStages;
-    EffectStageArray                    fCoverageStages;
+    State                               fState;
     
     mutable GrBlendCoeff                        fOptSrcBlend;
     mutable GrBlendCoeff                        fOptDstBlend;
     mutable BlendOptFlags                       fBlendOptFlags;
 
     // This is simply a different representation of info in fVertexAttribs and thus does
     // not need to be compared in op==.
     int fFixedFunctionVertexAttribIndices[kGrFixedFunctionVertexAttribBindingCnt];
 
     // Some of the auto restore objects assume that no effects are removed during their lifetime.
     // This is used to assert that this condition holds.
     SkDEBUGCODE(int fBlockEffectRemovalCnt;)
 
     /**
      *  Sets vertex attributes for next draw.
      *
      *  @param attribs    the array of vertex attributes to set.
      *  @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