Remove State struct from GrDrawState

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 191 matching lines @@
     ///////////////////////////////////////////////////////////////////////////
     /// @name Coverage
     ////
 
     /**
      * Sets a constant fractional coverage to be applied to the draw. The
      * initial value (after construction or reset()) is 0xff. The constant
      * coverage is ignored when per-vertex coverage is provided.
      */
     void setCoverage(uint8_t coverage) {
-        fCoverage = GrColorPackRGBA(coverage, coverage, coverage, coverage);
+        fCoverage = coverage;
         this->invalidateBlendOptFlags();
     }
 
-    uint8_t getCoverage() const { return GrColorUnpackR(fCoverage); }
+    uint8_t getCoverage() const { return fCoverage; }
 
-    GrColor getCoverageColor() const { return fCoverage; }
+    GrColor getCoverageColor() const {
+        return GrColorPackRGBA(fCoverage, fCoverage, fCoverage, 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(&fState.fColorStages, GrEffectStage, (effect, attr0, attr1));
+        SkNEW_APPEND_TO_TARRAY(&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(&fState.fCoverageStages, GrEffectStage, (effect, attr0, attr1));
+        SkNEW_APPEND_TO_TARRAY(&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 fState.fColorStages.count(); }
-    int numCoverageStages() const { return fState.fCoverageStages.count(); }
+    int numColorStages() const { return fColorStages.count(); }
+    int numCoverageStages() const { return fCoverageStages.count(); }
     int numTotalStages() const { return this->numColorStages() + this->numCoverageStages(); }
 
-    const GrEffectStage& getColorStage(int stageIdx) const { return fState.fColorStages[stageIdx]; }
-    const GrEffectStage& getCoverageStage(int stageIdx) const { return fState.fCoverageStages[stageIdx]; }
+    const GrEffectStage& getColorStage(int stageIdx) const { return fColorStages[stageIdx]; }
+    const GrEffectStage& getCoverageStage(int stageIdx) const { return 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) {
-        fState.fSrcBlend = srcCoeff;
-        fState.fDstBlend = dstCoeff;
+        fSrcBlend = srcCoeff;
+        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 fState.fSrcBlend; }
-    GrBlendCoeff getDstBlendCoeff() const { return fState.fDstBlend; }
+    GrBlendCoeff getSrcBlendCoeff() const { return fSrcBlend; }
+    GrBlendCoeff getDstBlendCoeff() const { return fDstBlend; }
 
     void getDstBlendCoeff(GrBlendCoeff* srcBlendCoeff,
                           GrBlendCoeff* dstBlendCoeff) const {
-        *srcBlendCoeff = fState.fSrcBlend;
-        *dstBlendCoeff = fState.fDstBlend;
+        *srcBlendCoeff = fSrcBlend;
+        *dstBlendCoeff = fDstBlend;
     }
 
     /**
      * Sets the blending function constant referenced by the following blending
      * coefficients:
      *      kConstC_GrBlendCoeff
      *      kIConstC_GrBlendCoeff
      *      kConstA_GrBlendCoeff
      *      kIConstA_GrBlendCoeff
      *
@@ skipping 403 matching lines @@
     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;
+    uint8_t                             fCoverage;
     DrawFace                            fDrawFace;
 
-    State                               fState;
+    typedef SkSTArray<4, GrEffectStage> EffectStageArray;
+    EffectStageArray                    fColorStages;
+    EffectStageArray                    fCoverageStages;
 
     uint32_t                            fHints;
     
     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