Add GrProcOptInfo class to track various output information for color and coverage stages.

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 "GrProcessorStage.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;
 
@@ skipping 147 matching lines @@
     GrColor getColor() const { return fColor; }
 
     /**
      *  Sets color for next draw to a premultiplied-alpha color.
      *
      *  @param color    the color to set.
      */
     void setColor(GrColor color) {
         if (color != fColor) {
             fColor = color;
+            fColorProcInfoValid = false;
         }
     }
 
     /**
      *  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 11 matching lines @@
     }
 
     /**
      * 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) {
         if (coverage != fCoverage) {
             fCoverage = coverage;
+            fCoverageProcInfoValid = false;
         }
     }
 
     /// @}
 
     /**
      * The geometry processor is the sole element of the skia pipeline which can use the vertex,
      * geometry, and tesselation shaders.  The GP may also compute a coverage in its fragment shader
      * but is never put in the color processing pipeline.
      */
 
     const GrGeometryProcessor* setGeometryProcessor(const GrGeometryProcessor* geometryProcessor) {
         SkASSERT(geometryProcessor);
         SkASSERT(!this->hasGeometryProcessor());
         fGeometryProcessor.reset(SkRef(geometryProcessor));
+        fCoverageProcInfoValid = false;
         return geometryProcessor;
     }
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name Effect Stages
     /// Each stage hosts a GrProcessor. 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 23 matching lines @@
     const GrFragmentStage& getCoverageStage(int idx) const { return fCoverageStages[idx]; }
 
     /**
      * Checks whether any of the effects will read the dst pixel color.
      */
     bool willEffectReadDstColor() const;
 
     const GrFragmentProcessor* addColorProcessor(const GrFragmentProcessor* effect) {
         SkASSERT(effect);
         SkNEW_APPEND_TO_TARRAY(&fColorStages, GrFragmentStage, (effect));
+        fColorProcInfoValid = false;
         return effect;
     }
 
     const GrFragmentProcessor* addCoverageProcessor(const GrFragmentProcessor* effect) {
         SkASSERT(effect);
         SkNEW_APPEND_TO_TARRAY(&fCoverageStages, GrFragmentStage, (effect));
+        fCoverageProcInfoValid = false;
         return effect;
     }
 
     /**
      * Creates a GrSimpleTextureEffect that uses local coords as texture coordinates.
      */
     void addColorTextureProcessor(GrTexture* texture, const SkMatrix& matrix) {
         this->addColorProcessor(GrSimpleTextureEffect::Create(texture, matrix))->unref();
     }
 
@@ skipping 506 matching lines @@
      */
     BlendOptFlags getBlendOpts(bool forceCoverage = false,
                                GrBlendCoeff* srcCoeff = NULL,
                                GrBlendCoeff* dstCoeff = NULL) const;
 
     /**
      * Determines whether src alpha is guaranteed to be one for all src pixels
      */
     bool srcAlphaWillBeOne() const;
 
+    /**
+     * If fColorProcInfoValid is false, function calculates the invariant output for the color
+     * stages and results are stored in fColorProcInfo.
+     */
+    void calcColorInvariantOutput() const;
+
+    /**
+     * If fCoverageProcInfoValid is false, function calculates the invariant output for the coverage
+     * stages and results are stored in fCoverageProcInfo.
+     */
+    void calcCoverageInvariantOutput() const;
+
     void onReset(const SkMatrix* initialViewMatrix);
 
     // 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;)
 
     void internalSetVertexAttribs(const GrVertexAttrib attribs[], int count, size_t stride);
 
     typedef GrTGpuResourceRef<GrRenderTarget> ProgramRenderTarget;
     // These fields are roughly sorted by decreasing likelihood of being different in op==
@@ skipping 16 matching lines @@
     ProgramGeometryProcessor            fGeometryProcessor;
     FragmentStageArray                  fColorStages;
     FragmentStageArray                  fCoverageStages;
 
     uint32_t                            fHints;
 
     // This is simply a different representation of info in fVertexAttribs and thus does
     // not need to be compared in op==.
     int fFixedFunctionVertexAttribIndices[kGrFixedFunctionVertexAttribBindingCnt];
 
+    mutable GrProcOptInfo fColorProcInfo;
+    mutable GrProcOptInfo fCoverageProcInfo;
+    mutable bool fColorProcInfoValid;
+    mutable bool fCoverageProcInfoValid;
+
     friend class GrOptDrawState;
 
     typedef SkRefCnt INHERITED;
 };
 
 GR_MAKE_BITFIELD_OPS(GrDrawState::BlendOptFlags);
 
 #endif