Remove GrDrawState::CommonState

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 85 matching lines @@
      */
 
     /**
      *  Sets vertex attributes for next draw. The object driving the templatization
      *  should be a global GrVertexAttrib array that is never changed.
      */
     template <const GrVertexAttrib A[]> void setVertexAttribs(int count) {
         this->setVertexAttribs(A, count);
     }
 
-    const GrVertexAttrib* getVertexAttribs() const { return fCommon.fVAPtr; }
-    int getVertexAttribCount() const { return fCommon.fVACount; }
+    const GrVertexAttrib* getVertexAttribs() const { return fVAPtr; }
+    int getVertexAttribCount() const { return fVACount; }
 
     size_t getVertexSize() const;
 
     /**
      *  Sets default vertex attributes for next draw. The default is a single attribute:
      *  {kVec2f_GrVertexAttribType, 0, kPosition_GrVertexAttribType}
      */
     void setDefaultVertexAttribs();
 
     /**
      * Getters for index into getVertexAttribs() for particular bindings. -1 is returned if the
      * binding does not appear in the current attribs. These bindings should appear only once in
      * the attrib array.
      */
 
     int positionAttributeIndex() const {
-        return fCommon.fFixedFunctionVertexAttribIndices[kPosition_GrVertexAttribBinding];
+        return fFixedFunctionVertexAttribIndices[kPosition_GrVertexAttribBinding];
     }
     int localCoordAttributeIndex() const {
-        return fCommon.fFixedFunctionVertexAttribIndices[kLocalCoord_GrVertexAttribBinding];
+        return fFixedFunctionVertexAttribIndices[kLocalCoord_GrVertexAttribBinding];
     }
     int colorVertexAttributeIndex() const {
-        return fCommon.fFixedFunctionVertexAttribIndices[kColor_GrVertexAttribBinding];
+        return fFixedFunctionVertexAttribIndices[kColor_GrVertexAttribBinding];
     }
     int coverageVertexAttributeIndex() const {
-        return fCommon.fFixedFunctionVertexAttribIndices[kCoverage_GrVertexAttribBinding];
+        return fFixedFunctionVertexAttribIndices[kCoverage_GrVertexAttribBinding];
     }
 
     bool hasLocalCoordAttribute() const {
-        return -1 != fCommon.fFixedFunctionVertexAttribIndices[kLocalCoord_GrVertexAttribBinding];
+        return -1 != fFixedFunctionVertexAttribIndices[kLocalCoord_GrVertexAttribBinding];
     }
     bool hasColorVertexAttribute() const {
-        return -1 != fCommon.fFixedFunctionVertexAttribIndices[kColor_GrVertexAttribBinding];
+        return -1 != fFixedFunctionVertexAttribIndices[kColor_GrVertexAttribBinding];
     }
     bool hasCoverageVertexAttribute() const {
-        return -1 != fCommon.fFixedFunctionVertexAttribIndices[kCoverage_GrVertexAttribBinding];
+        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->fCommon.fVAPtr;
-             fVACount = drawState->fCommon.fVACount;
+             fVAPtr = drawState->fVAPtr;
+             fVACount = drawState->fVACount;
              fDrawState->setDefaultVertexAttribs();
          }
 
          ~AutoVertexAttribRestore(){
              fDrawState->setVertexAttribs(fVAPtr, fVACount);
          }
 
      private:
          GrDrawState*          fDrawState;
          const GrVertexAttrib* fVAPtr;
@@ skipping 74 matching lines @@
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name Color
     ////
 
     /**
      *  Sets color for next draw to a premultiplied-alpha color.
      *
      *  @param color    the color to set.
      */
-    void setColor(GrColor color) { fCommon.fColor = color; }
+    void setColor(GrColor color) { fColor = color; }
 
-    GrColor getColor() const { return fCommon.fColor; }
+    GrColor getColor() const { return fColor; }
 
     /**
      *  Sets the color to be used for the next draw to be
      *  (r,g,b,a) = (alpha, alpha, alpha, alpha).
      *
      *  @param alpha The alpha value to set as the color.
      */
     void setAlpha(uint8_t a) {
         this->setColor((a << 24) | (a << 16) | (a << 8) | a);
     }
@@ skipping 35 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) {
-        fCommon.fCoverage = GrColorPackRGBA(coverage, coverage, coverage, coverage);
+        fCoverage = GrColorPackRGBA(coverage, coverage, coverage, coverage);
     }
 
     uint8_t getCoverage() const {
-        return GrColorUnpackR(fCommon.fCoverage);
+        return GrColorUnpackR(fCoverage);
     }
 
     GrColor getCoverageColor() const {
-        return fCommon.fCoverage;
+        return fCoverage;
     }
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @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).
@@ skipping 115 matching lines @@
      *    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) {
-        fCommon.fSrcBlend = srcCoeff;
-        fCommon.fDstBlend = dstCoeff;
+        fSrcBlend = srcCoeff;
+        fDstBlend = dstCoeff;
     #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 fCommon.fSrcBlend; }
-    GrBlendCoeff getDstBlendCoeff() const { return fCommon.fDstBlend; }
+    GrBlendCoeff getSrcBlendCoeff() const { return fSrcBlend; }
+    GrBlendCoeff getDstBlendCoeff() const { return fDstBlend; }
 
     void getDstBlendCoeff(GrBlendCoeff* srcBlendCoeff,
                           GrBlendCoeff* dstBlendCoeff) const {
-        *srcBlendCoeff = fCommon.fSrcBlend;
-        *dstBlendCoeff = fCommon.fDstBlend;
+        *srcBlendCoeff = fSrcBlend;
+        *dstBlendCoeff = fDstBlend;
     }
 
     /**
      * Sets the blending function constant referenced by the following blending
      * coefficients:
      *      kConstC_GrBlendCoeff
      *      kIConstC_GrBlendCoeff
      *      kConstA_GrBlendCoeff
      *      kIConstA_GrBlendCoeff
      *
      * @param constant the constant to set
      */
-    void setBlendConstant(GrColor constant) { fCommon.fBlendConstant = constant; }
+    void setBlendConstant(GrColor constant) { fBlendConstant = constant; }
 
     /**
      * Retrieves the last value set by setBlendConstant()
      * @return the blending constant value
      */
-    GrColor getBlendConstant() const { return fCommon.fBlendConstant; }
+    GrColor getBlendConstant() const { return fBlendConstant; }
 
     /**
      * Determines whether multiplying the computed per-pixel color by the pixel's fractional
      * coverage before the blend will give the correct final destination color. In general it
      * will not as coverage is applied after blending.
      */
     bool canTweakAlphaForCoverage() const;
 
     /**
      * Optimizations for blending / coverage to that can be applied based on the current state.
@@ skipping 51 matching lines @@
     /**
      * Sets the view matrix to identity and updates any installed effects to compensate for the
      * coord system change.
      */
     bool setIdentityViewMatrix();
 
     /**
      * Retrieves the current view matrix
      * @return the current view matrix.
      */
-    const SkMatrix& getViewMatrix() const { return fCommon.fViewMatrix; }
+    const SkMatrix& getViewMatrix() const { return fViewMatrix; }
 
     /**
      *  Retrieves the inverse of the current view matrix.
      *
      *  If the current view matrix is invertible, return true, and if matrix
      *  is non-null, copy the inverse into it. If the current view matrix is
      *  non-invertible, return false and ignore the matrix parameter.
      *
      * @param matrix if not null, will receive a copy of the current inverse.
      */
     bool getViewInverse(SkMatrix* matrix) const {
         // TODO: determine whether we really need to leave matrix unmodified
         // at call sites when inversion fails.
         SkMatrix inverse;
-        if (fCommon.fViewMatrix.invert(&inverse)) {
+        if (fViewMatrix.invert(&inverse)) {
             if (matrix) {
                 *matrix = inverse;
             }
             return true;
         }
         return false;
     }
 
     ////////////////////////////////////////////////////////////////////////////
 
@@ skipping 96 matching lines @@
     ////
 
     /**
      * Sets the stencil settings to use for the next draw.
      * Changing the clip has the side-effect of possibly zeroing
      * out the client settable stencil bits. So multipass algorithms
      * using stencil should not change the clip between passes.
      * @param settings  the stencil settings to use.
      */
     void setStencil(const GrStencilSettings& settings) {
-        fCommon.fStencilSettings = settings;
+        fStencilSettings = settings;
     }
 
     /**
      * Shortcut to disable stencil testing and ops.
      */
     void disableStencil() {
-        fCommon.fStencilSettings.setDisabled();
+        fStencilSettings.setDisabled();
     }
 
-    const GrStencilSettings& getStencil() const { return fCommon.fStencilSettings; }
+    const GrStencilSettings& getStencil() const { return fStencilSettings; }
 
-    GrStencilSettings* stencil() { return &fCommon.fStencilSettings; }
+    GrStencilSettings* stencil() { return &fStencilSettings; }
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name State Flags
     ////
 
     /**
      *  Flags that affect rendering. Controlled using enable/disableState(). All
      *  default to disabled.
@@ skipping 28 matching lines @@
          * setBlendFunc() which will use coverage*color as the src color.
          */
          kCoverageDrawing_StateBit = 0x10,
 
         // Users of the class may add additional bits to the vector
         kDummyStateBit,
         kLastPublicStateBit = kDummyStateBit-1,
     };
 
     void resetStateFlags() {
-        fCommon.fFlagBits = 0;
+        fFlagBits = 0;
     }
 
     /**
      * Enable render state settings.
      *
      * @param stateBits bitfield of StateBits specifying the states to enable
      */
     void enableState(uint32_t stateBits) {
-        fCommon.fFlagBits |= stateBits;
+        fFlagBits |= stateBits;
     }
 
     /**
      * Disable render state settings.
      *
      * @param stateBits bitfield of StateBits specifying the states to disable
      */
     void disableState(uint32_t stateBits) {
-        fCommon.fFlagBits &= ~(stateBits);
+        fFlagBits &= ~(stateBits);
     }
 
     /**
      * Enable or disable stateBits based on a boolean.
      *
      * @param stateBits bitfield of StateBits to enable or disable
      * @param enable    if true enable stateBits, otherwise disable
      */
     void setState(uint32_t stateBits, bool enable) {
         if (enable) {
             this->enableState(stateBits);
         } else {
             this->disableState(stateBits);
         }
     }
 
     bool isDitherState() const {
-        return 0 != (fCommon.fFlagBits & kDither_StateBit);
+        return 0 != (fFlagBits & kDither_StateBit);
     }
 
     bool isHWAntialiasState() const {
-        return 0 != (fCommon.fFlagBits & kHWAntialias_StateBit);
+        return 0 != (fFlagBits & kHWAntialias_StateBit);
     }
 
     bool isClipState() const {
-        return 0 != (fCommon.fFlagBits & kClip_StateBit);
+        return 0 != (fFlagBits & kClip_StateBit);
     }
 
     bool isColorWriteDisabled() const {
-        return 0 != (fCommon.fFlagBits & kNoColorWrites_StateBit);
+        return 0 != (fFlagBits & kNoColorWrites_StateBit);
     }
 
     bool isCoverageDrawing() const {
-        return 0 != (fCommon.fFlagBits & kCoverageDrawing_StateBit);
+        return 0 != (fFlagBits & kCoverageDrawing_StateBit);
     }
 
     bool isStateFlagEnabled(uint32_t stateBit) const {
-        return 0 != (stateBit & fCommon.fFlagBits);
+        return 0 != (stateBit & fFlagBits);
     }
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name Face Culling
     ////
 
     enum DrawFace {
         kInvalid_DrawFace = -1,
 
         kBoth_DrawFace,
         kCCW_DrawFace,
         kCW_DrawFace,
     };
 
     /**
      * Controls whether clockwise, counterclockwise, or both faces are drawn.
      * @param face  the face(s) to draw.
      */
     void setDrawFace(DrawFace face) {
         SkASSERT(kInvalid_DrawFace != face);
-        fCommon.fDrawFace = face;
+        fDrawFace = face;
     }
 
     /**
      * Gets whether the target is drawing clockwise, counterclockwise,
      * or both faces.
      * @return the current draw face(s).
      */
-    DrawFace getDrawFace() const { return fCommon.fDrawFace; }
+    DrawFace getDrawFace() const { return fDrawFace; }
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
 
-    bool operator ==(const GrDrawState& s) const {
-        if (fRenderTarget.get() != s.fRenderTarget.get() ||
-            fColorStages.count() != s.fColorStages.count() ||
-            fCoverageStages.count() != s.fCoverageStages.count() ||
-            fCommon != s.fCommon) {
+    bool operator ==(const GrDrawState& that) const {
+        if (fRenderTarget.get() != that.fRenderTarget.get() ||
+            fColorStages.count() != that.fColorStages.count() ||
+            fCoverageStages.count() != that.fCoverageStages.count() ||
+            fColor != that.fColor ||
+            !fViewMatrix.cheapEqualTo(that.fViewMatrix) ||
+            fSrcBlend != that.fSrcBlend ||
+            fDstBlend != that.fDstBlend ||
+            fBlendConstant != that.fBlendConstant ||
+            fFlagBits != that.fFlagBits ||
+            fVACount != that.fVACount ||
+            memcmp(fVAPtr, that.fVAPtr, fVACount * sizeof(GrVertexAttrib)) ||
+            fStencilSettings != that.fStencilSettings ||
+            fCoverage != that.fCoverage ||
+            fDrawFace != that.fDrawFace) {
             return false;
         }
         for (int i = 0; i < fColorStages.count(); i++) {
-            if (fColorStages[i] != s.fColorStages[i]) {
+            if (fColorStages[i] != that.fColorStages[i]) {
                 return false;
             }
         }
         for (int i = 0; i < fCoverageStages.count(); i++) {
-            if (fCoverageStages[i] != s.fCoverageStages[i]) {
+            if (fCoverageStages[i] != that.fCoverageStages[i]) {
                 return false;
             }
         }
+        SkASSERT(0 == memcmp(fFixedFunctionVertexAttribIndices,
+                             that.fFixedFunctionVertexAttribIndices,
+                             sizeof(fFixedFunctionVertexAttribIndices)));
         return true;
     }
     bool operator !=(const GrDrawState& s) const { return !(*this == s); }
 
-    GrDrawState& operator= (const GrDrawState& s) {
+    GrDrawState& operator= (const GrDrawState& that) {
         SkASSERT(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages());
-        this->setRenderTarget(s.fRenderTarget.get());
-        fCommon = s.fCommon;
-        fColorStages = s.fColorStages;
-        fCoverageStages = s.fCoverageStages;
+        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;
+
+        memcpy(fFixedFunctionVertexAttribIndices,
+               that.fFixedFunctionVertexAttribIndices,
+               sizeof(fFixedFunctionVertexAttribIndices));
         return *this;
     }
 
 private:
 
     void onReset(const SkMatrix* initialViewMatrix) {
         SkASSERT(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages());
         fColorStages.reset();
         fCoverageStages.reset();
 
         fRenderTarget.reset(NULL);
 
         this->setDefaultVertexAttribs();
 
-        fCommon.fColor = 0xffffffff;
+        fColor = 0xffffffff;
         if (NULL == initialViewMatrix) {
-            fCommon.fViewMatrix.reset();
+            fViewMatrix.reset();
         } else {
-            fCommon.fViewMatrix = *initialViewMatrix;
+            fViewMatrix = *initialViewMatrix;
         }
-        fCommon.fSrcBlend = kOne_GrBlendCoeff;
-        fCommon.fDstBlend = kZero_GrBlendCoeff;
-        fCommon.fBlendConstant = 0x0;
-        fCommon.fFlagBits = 0x0;
-        fCommon.fStencilSettings.setDisabled();
-        fCommon.fCoverage = 0xffffffff;
-        fCommon.fDrawFace = kBoth_DrawFace;
+        fSrcBlend = kOne_GrBlendCoeff;
+        fDstBlend = kZero_GrBlendCoeff;
+        fBlendConstant = 0x0;
+        fFlagBits = 0x0;
+        fStencilSettings.setDisabled();
+        fCoverage = 0xffffffff;
+        fDrawFace = kBoth_DrawFace;
     }
 
-    /** This will be removed soon. The fields will become members of GrDrawState. */
-    struct CommonState {
-        // These fields are roughly sorted by decreasing likelihood of being different in op==
-        GrColor               fColor;
-        SkMatrix              fViewMatrix;
-        GrBlendCoeff          fSrcBlend;
-        GrBlendCoeff          fDstBlend;
-        GrColor               fBlendConstant;
-        uint32_t              fFlagBits;
-        const GrVertexAttrib* fVAPtr;
-        int                   fVACount;
-        GrStencilSettings     fStencilSettings;
-        GrColor               fCoverage;
-        DrawFace              fDrawFace;
 
-        // This is simply a different representation of info in fVertexAttribs and thus does
-        // not need to be compared in op==.
-        int fFixedFunctionVertexAttribIndices[kGrFixedFunctionVertexAttribBindingCnt];
-
-        bool operator== (const CommonState& other) const {
-            bool result = fColor == other.fColor &&
-                          fViewMatrix.cheapEqualTo(other.fViewMatrix) &&
-                          fSrcBlend == other.fSrcBlend &&
-                          fDstBlend == other.fDstBlend &&
-                          fBlendConstant == other.fBlendConstant &&
-                          fFlagBits == other.fFlagBits &&
-                          fVACount == other.fVACount &&
-                          !memcmp(fVAPtr, other.fVAPtr, fVACount * sizeof(GrVertexAttrib)) &&
-                          fStencilSettings == other.fStencilSettings &&
-                          fCoverage == other.fCoverage &&
-                          fDrawFace == other.fDrawFace;
-            SkASSERT(!result || 0 == memcmp(fFixedFunctionVertexAttribIndices,
-                                            other.fFixedFunctionVertexAttribIndices,
-                                            sizeof(fFixedFunctionVertexAttribIndices)));
-            return result;
-        }
-        bool operator!= (const CommonState& other) const { return !(*this == other); }
-    };
-
+    // These fields are roughly sorted by decreasing likelihood of being different in op==
     SkAutoTUnref<GrRenderTarget>        fRenderTarget;
-    CommonState                         fCommon;
+    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;
 
+    // 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