Small cleanups after GrDrawState/GrOptDrawState base class elimination.

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
 
 
 #include "GrBlend.h"
 #include "GrDrawTargetCaps.h"
 #include "GrGeometryProcessor.h"
 #include "GrGpuResourceRef.h"
 #include "GrFragmentStage.h"
 #include "GrProcOptInfo.h"
 #include "GrRenderTarget.h"
 #include "GrStencil.h"
 #include "SkMatrix.h"
 #include "effects/GrSimpleTextureEffect.h"
 
 class GrDrawTargetCaps;
-class GrOptDrawState;
 class GrPaint;
 class GrTexture;
 
 class GrDrawState {
 public:
     GrDrawState() {
         SkDEBUGCODE(fBlockEffectRemovalCnt = 0;)
         this->reset();
     }
 
@@ skipping 375 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) {
-        if (srcCoeff != fSrcBlend || dstCoeff != fDstBlend) {
-            fSrcBlend = srcCoeff;
-            fDstBlend = dstCoeff;
-        }
+        fSrcBlend = srcCoeff;
+        fDstBlend = dstCoeff;
     #ifdef SK_DEBUG
         if (GrBlendCoeffRefsDst(dstCoeff)) {
             SkDebugf("Unexpected dst blend coeff. Won't work correctly with coverage stages.\n");
         }
         if (GrBlendCoeffRefsSrc(srcCoeff)) {
             SkDebugf("Unexpected src blend coeff. Won't work correctly with coverage stages.\n");
         }
     #endif
     }
 
     /**
      * 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) {
-        if (constant != fBlendConstant) {
-            fBlendConstant = constant;
-        }
-    }
+    void setBlendConstant(GrColor constant) { fBlendConstant = constant; }
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name View Matrix
     ////
 
     /**
      * Retrieves the current view matrix
      * @return the current view matrix.
@@ skipping 91 matching lines @@
 
     const GrStencilSettings& getStencil() const { return fStencilSettings; }
 
     /**
      * 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) {
-        if (settings != fStencilSettings) {
-            fStencilSettings = settings;
-        }
-    }
+    void setStencil(const GrStencilSettings& settings) { fStencilSettings = settings; }
 
     /**
      * Shortcut to disable stencil testing and ops.
      */
-    void disableStencil() {
-        if (!fStencilSettings.isDisabled()) {
-            fStencilSettings.setDisabled();
-        }
-    }
+    void disableStencil() { fStencilSettings.setDisabled(); }
 
     GrStencilSettings* stencil() { return &fStencilSettings; }
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name State Flags
     ////
 
     /**
@@ skipping 26 matching lines @@
          * specified by setBlendFunc(). The blended color is then combined with dst using coeffs
          * of src_coverage, 1-src_coverage. Sometimes we are explicitly drawing a coverage mask. In
          * this case there is no distinction between coverage and color and the caller needs direct
          * control over the blend coeffs. When set, there will be a single blend step controlled by
          * setBlendFunc() which will use coverage*color as the src color.
          */
          kCoverageDrawing_StateBit = 0x10,
          kLast_StateBit = kCoverageDrawing_StateBit,
     };
 
-    uint32_t getFlagBits() const { return fFlagBits; }
-
-    bool isStateFlagEnabled(uint32_t stateBit) const { return 0 != (stateBit & fFlagBits); }
-
     bool isClipState() const { return 0 != (fFlagBits & kClip_StateBit); }
     bool isColorWriteDisabled() const { return 0 != (fFlagBits & kNoColorWrites_StateBit); }
     bool isCoverageDrawing() const { return 0 != (fFlagBits & kCoverageDrawing_StateBit); }
-
-    void resetStateFlags() {
-        if (0 != fFlagBits) {
-            fFlagBits = 0;
-        }
-    }
+    bool isDither() const { return 0 != (fFlagBits & kDither_StateBit); }
+    bool isHWAntialias() const { return 0 != (fFlagBits & kHWAntialias_StateBit); }
 
     /**
      * Enable render state settings.
      *
      * @param stateBits bitfield of StateBits specifying the states to enable
      */
-    void enableState(uint32_t stateBits) {
-        if (stateBits & ~fFlagBits) {
-            fFlagBits |= stateBits;
-        }
-    }
+    void enableState(uint32_t stateBits) { fFlagBits |= stateBits; }
 
     /**
      * Disable render state settings.
      *
      * @param stateBits bitfield of StateBits specifying the states to disable
      */
-    void disableState(uint32_t stateBits) {
-        if (stateBits & fFlagBits) {
-            fFlagBits &= ~(stateBits);
-        }
-    }
+    void disableState(uint32_t 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);
@@ skipping 53 matching lines @@
     ///////////////////////////////////////////////////////////////////////////
 
     GrDrawState& operator= (const GrDrawState& that);
 
 private:
     bool isEqual(const GrDrawState& that) const;
 
     /**
      * Optimizations for blending / coverage to that can be applied based on the current state.
      */
-    enum BlendOptFlags {
+    enum BlendOpt {
         /**
          * No optimization
          */
-        kNone_BlendOpt                  = 0,
+        kNone_BlendOpt,
         /**
          * Don't draw at all
          */
-        kSkipDraw_BlendOptFlag          = 0x1,
+        kSkipDraw_BlendOpt,
         /**
          * The coverage value does not have to be computed separately from alpha, the the output
          * color can be the modulation of the two.
          */
-        kCoverageAsAlpha_BlendOptFlag   = 0x2,
+        kCoverageAsAlpha_BlendOpt,
         /**
          * Instead of emitting a src color, emit coverage in the alpha channel and r,g,b are
          * "don't cares".
          */
-        kEmitCoverage_BlendOptFlag      = 0x4,
+        kEmitCoverage_BlendOpt,
         /**
          * Emit transparent black instead of the src color, no need to compute coverage.
          */
-        kEmitTransBlack_BlendOptFlag    = 0x8,
+        kEmitTransBlack_BlendOpt
     };
-    GR_DECL_BITFIELD_OPS_FRIENDS(BlendOptFlags);
 
     /**
      * Determines what optimizations can be applied based on the blend. The coefficients may have
      * to be tweaked in order for the optimization to work. srcCoeff and dstCoeff are optional
      * params that receive the tweaked coefficients. Normally the function looks at the current
      * state to see if coverage is enabled. By setting forceCoverage the caller can speculatively
      * determine the blend optimizations that would be used if there was partial pixel coverage.
      *
-     * Subclasses of GrDrawTarget that actually draw (as opposed to those that just buffer for
-     * playback) must call this function and respect the flags that replace the output color.
-     *
-     * If the cached BlendOptFlags does not have the invalidate bit set, then getBlendOpts will
-     * simply returned the cached flags and coefficients. Otherwise it will calculate the values. 
+     * This is used internally and when constructing a GrOptDrawState.
      */
-    BlendOptFlags getBlendOpts(bool forceCoverage = false,
-                               GrBlendCoeff* srcCoeff = NULL,
-                               GrBlendCoeff* dstCoeff = NULL) const;
+    BlendOpt getBlendOpt(bool forceCoverage = false,
+                         GrBlendCoeff* srcCoeff = NULL,
+                         GrBlendCoeff* dstCoeff = NULL) const;
 
     const GrProcOptInfo& colorProcInfo() const { 
         this->calcColorInvariantOutput();
         return fColorProcInfo;
     }
 
     const GrProcOptInfo& coverageProcInfo() const {
         this->calcCoverageInvariantOutput();
         return fCoverageProcInfo;
     }
@@ skipping 48 matching lines @@
     int fFixedFunctionVertexAttribIndices[kGrFixedFunctionVertexAttribBindingCnt];
 
     mutable GrProcOptInfo fColorProcInfo;
     mutable GrProcOptInfo fCoverageProcInfo;
     mutable bool fColorProcInfoValid;
     mutable bool fCoverageProcInfoValid;
 
     friend class GrOptDrawState;
 };
 
-GR_MAKE_BITFIELD_OPS(GrDrawState::BlendOptFlags);
-
 #endif