Cache the return values of getBlendOpts in 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 41 matching lines @@
     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);
             }
+            fBlendOptFlags = kInvalid_BlendOptFlag;
         }
     }
 
     virtual ~GrDrawState() { SkASSERT(0 == fBlockEffectRemovalCnt); }
 
     /**
      * Resets to the default state. GrEffects will be removed from all stages.
      */
     void reset() { this->onReset(NULL); }
 
@@ skipping 170 matching lines @@
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name Color
     ////
 
     /**
      *  Sets color for next draw to a premultiplied-alpha color.
      *
      *  @param color    the color to set.
      */
-    void setColor(GrColor color) { fColor = color; }
+    void setColor(GrColor color) {
+        fColor = color;
+        fBlendOptFlags = kInvalid_BlendOptFlag;
+    }
 
     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) {
@@ skipping 38 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);
+        fBlendOptFlags = kInvalid_BlendOptFlag;
     }
 
     uint8_t getCoverage() const {
         return GrColorUnpackR(fCoverage);
     }
 
     GrColor getCoverageColor() const {
         return fCoverage;
     }
 
@@ skipping 15 matching lines @@
     /// 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));
+        fBlendOptFlags = kInvalid_BlendOptFlag;
         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));
+        fBlendOptFlags = kInvalid_BlendOptFlag;
         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 25 matching lines @@
             this->set(ds);
         }
 
         ~AutoRestoreEffects() { this->set(NULL); }
 
         void set(GrDrawState* ds) {
             if (NULL != fDrawState) {
                 int n = fDrawState->fColorStages.count() - fColorEffectCnt;
                 SkASSERT(n >= 0);
                 fDrawState->fColorStages.pop_back_n(n);
+                if (n > 0) {
+                    fBlendOptFlags = kInvalid_BlendOptFlag;
+                }
                 n = fDrawState->fCoverageStages.count() - fCoverageEffectCnt;

[bsalomon, 2014/07/17 19:53:50]

int m =

if (n + m > 0)

?

                 SkASSERT(n >= 0);
                 fDrawState->fCoverageStages.pop_back_n(n);
+                if (n > 0) {
+                    fBlendOptFlags = kInvalid_BlendOptFlag;
+                }
                 SkDEBUGCODE(--fDrawState->fBlockEffectRemovalCnt;)
             }
             fDrawState = ds;
             if (NULL != ds) {
                 fColorEffectCnt = ds->fColorStages.count();
                 fCoverageEffectCnt = ds->fCoverageStages.count();
                 SkDEBUGCODE(++ds->fBlockEffectRemovalCnt;)
             }
         }
 
@@ skipping 32 matching lines @@
      *   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;
+        fBlendOptFlags = kInvalid_BlendOptFlag;
     #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; }
 
     void getDstBlendCoeff(GrBlendCoeff* srcBlendCoeff,
                           GrBlendCoeff* dstBlendCoeff) const {
         *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) { fBlendConstant = constant; }
+    void setBlendConstant(GrColor constant) {
+        fBlendConstant = constant;
+        fBlendOptFlags = kInvalid_BlendOptFlag;
+    }
 
     /**
      * Retrieves the last value set by setBlendConstant()
      * @return the blending constant value
      */
     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
@@ skipping 24 matching lines @@
         kCoverageAsAlpha_BlendOptFlag   = 0x4,
         /**
          * Instead of emitting a src color, emit coverage in the alpha channel and r,g,b are
          * "don't cares".
          */
         kEmitCoverage_BlendOptFlag      = 0x8,
         /**
          * Emit transparent black instead of the src color, no need to compute coverage.
          */
         kEmitTransBlack_BlendOptFlag    = 0x10,
+        /**
+         * Flag used to invalidate the cached BlendOptFlags, OptSrcCoeff, and OptDstCoeff cached by
+         * the get BlendOpts function. 
+         */
+        kInvalid_BlendOptFlag        = 0x20,
     };
     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. 
      */
     BlendOptFlags getBlendOpts(bool forceCoverage = false,
                                GrBlendCoeff* srcCoeff = NULL,
                                GrBlendCoeff* dstCoeff = NULL) const;
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name View Matrix
     ////
@@ skipping 134 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) {
         fStencilSettings = settings;
+        fBlendOptFlags = kInvalid_BlendOptFlag;
     }
 
     /**
      * Shortcut to disable stencil testing and ops.
      */
     void disableStencil() {
         fStencilSettings.setDisabled();
+        fBlendOptFlags = kInvalid_BlendOptFlag;
     }
 
     const GrStencilSettings& getStencil() const { return fStencilSettings; }
 
     GrStencilSettings* stencil() { return &fStencilSettings; }
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name State Flags
@@ skipping 34 matching lines @@
          */
          kCoverageDrawing_StateBit = 0x10,
 
         // Users of the class may add additional bits to the vector
         kDummyStateBit,
         kLastPublicStateBit = kDummyStateBit-1,
     };
 
     void resetStateFlags() {
         fFlagBits = 0;
+        fBlendOptFlags = kInvalid_BlendOptFlag;
     }
 
     /**
      * Enable render state settings.
      *
      * @param stateBits bitfield of StateBits specifying the states to enable
      */
     void enableState(uint32_t stateBits) {
         fFlagBits |= stateBits;
+        fBlendOptFlags = kInvalid_BlendOptFlag;
     }
 
     /**
      * Disable render state settings.
      *
      * @param stateBits bitfield of StateBits specifying the states to disable
      */
     void disableState(uint32_t stateBits) {
         fFlagBits &= ~(stateBits);
+        fBlendOptFlags = kInvalid_BlendOptFlag;
     }
 
     /**
      * 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) {
@@ skipping 104 matching lines @@
         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;
     }
 
 private:
 
     void onReset(const SkMatrix* initialViewMatrix) {
@@ skipping 11 matching lines @@
         } else {
             fViewMatrix = *initialViewMatrix;
         }
         fSrcBlend = kOne_GrBlendCoeff;
         fDstBlend = kZero_GrBlendCoeff;
         fBlendConstant = 0x0;
         fFlagBits = 0x0;
         fStencilSettings.setDisabled();
         fCoverage = 0xffffffff;
         fDrawFace = kBoth_DrawFace;
+
+        fBlendOptFlags = kInvalid_BlendOptFlag;
     }
 
+    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;
+    
+    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