Create struct in GrDrawState to hold key DrawState data.

src/gpu/GrDrawState.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrDrawState.h"
 #include "GrPaint.h"
 
 //////////////////////////////////////////////////////////////////////////////s
 
+bool GrDrawState::State::HaveCompatibleState(const State& a, const State& b,
+                                             bool explicitLocalCoords) {
+    if (a.fColorStages.count() != b.fColorStages.count() ||
+        a.fCoverageStages.count() != b.fCoverageStages.count() ||
+        a.fSrcBlend != b.fSrcBlend ||
+        a.fDstBlend != b.fDstBlend) {
+        return false;
+    }
+    for (int i = 0; i < a.fColorStages.count(); i++) {
+        if (!GrEffectStage::AreCompatible(a.fColorStages[i], b.fColorStages[i],
+                                          explicitLocalCoords)) {
+            return false;
+        }
+    }
+    for (int i = 0; i < a.fCoverageStages.count(); i++) {
+        if (!GrEffectStage::AreCompatible(a.fCoverageStages[i], b.fCoverageStages[i],
+                                          explicitLocalCoords)) {
+            return false;
+        }
+    }
+    return true;
+}
+//////////////////////////////////////////////////////////////////////////////s
 GrDrawState::CombinedState GrDrawState::CombineIfPossible(
     const GrDrawState& a, const GrDrawState& b) {
 
     bool usingVertexColors = a.hasColorVertexAttribute();
     if (!usingVertexColors && a.fColor != b.fColor) {
         return kIncompatible_CombinedState;
     }
 
     if (a.fRenderTarget.get() != b.fRenderTarget.get() ||
-        a.fColorStages.count() != b.fColorStages.count() ||
-        a.fCoverageStages.count() != b.fCoverageStages.count() ||
         !a.fViewMatrix.cheapEqualTo(b.fViewMatrix) ||
-        a.fSrcBlend != b.fSrcBlend ||
-        a.fDstBlend != b.fDstBlend ||
         a.fBlendConstant != b.fBlendConstant ||
         a.fFlagBits != b.fFlagBits ||
         a.fVACount != b.fVACount ||
         memcmp(a.fVAPtr, b.fVAPtr, a.fVACount * sizeof(GrVertexAttrib)) ||
         a.fStencilSettings != b.fStencilSettings ||
         a.fDrawFace != b.fDrawFace) {
         return kIncompatible_CombinedState;
     }
 
     bool usingVertexCoverage = a.hasCoverageVertexAttribute();
     if (!usingVertexCoverage && a.fCoverage != b.fCoverage) {
         return kIncompatible_CombinedState;
     }
 
     bool explicitLocalCoords = a.hasLocalCoordAttribute();
-    for (int i = 0; i < a.fColorStages.count(); i++) {
-        if (!GrEffectStage::AreCompatible(a.fColorStages[i], b.fColorStages[i],
-            explicitLocalCoords)) {
-            return kIncompatible_CombinedState;
-        }
-    }
-    for (int i = 0; i < a.fCoverageStages.count(); i++) {
-        if (!GrEffectStage::AreCompatible(a.fCoverageStages[i], b.fCoverageStages[i],
-            explicitLocalCoords)) {
-            return kIncompatible_CombinedState;
-        }
-    }
+
     SkASSERT(0 == memcmp(a.fFixedFunctionVertexAttribIndices,
                             b.fFixedFunctionVertexAttribIndices,
                             sizeof(a.fFixedFunctionVertexAttribIndices)));
+    if (!State::HaveCompatibleState(a.fState, b.fState, explicitLocalCoords)) {
+        return kIncompatible_CombinedState;
+    }
     return kAOrB_CombinedState;
 }
 
 
 //////////////////////////////////////////////////////////////////////////////s
 
 GrDrawState::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 < this->numColorStages(); ++i) {
+            fState.fColorStages[i].localCoordChange(preConcatMatrix);
         }
-        for (int i = 0; i < fCoverageStages.count(); ++i) {
-            fCoverageStages[i].localCoordChange(preConcatMatrix);
+        for (int i = 0; i < this->numCoverageStages(); ++i) {
+            fState.fCoverageStages[i].localCoordChange(preConcatMatrix);
         }
         this->invalidateBlendOptFlags();
     }
 }
 
 GrDrawState& GrDrawState::operator=(const GrDrawState& that) {
     SkASSERT(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages());
     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;
     fOptSrcBlend = that.fOptSrcBlend;
     fOptDstBlend = that.fOptDstBlend;
     fBlendOptFlags = that.fBlendOptFlags;
 
+    fState = that.fState;
+
     memcpy(fFixedFunctionVertexAttribIndices,
             that.fFixedFunctionVertexAttribIndices,
             sizeof(fFixedFunctionVertexAttribIndices));
     return *this;
 }
 
 void GrDrawState::onReset(const SkMatrix* initialViewMatrix) {
     SkASSERT(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages());
-    fColorStages.reset();
-    fCoverageStages.reset();
+    fState.reset();
 
     fRenderTarget.reset(NULL);
 
     this->setDefaultVertexAttribs();
 
     fColor = 0xffffffff;
     if (NULL == initialViewMatrix) {
         fViewMatrix.reset();
     } else {
         fViewMatrix = *initialViewMatrix;
     }
-    fSrcBlend = kOne_GrBlendCoeff;
-    fDstBlend = kZero_GrBlendCoeff;
     fBlendConstant = 0x0;
     fFlagBits = 0x0;
     fStencilSettings.setDisabled();
     fCoverage = 0xffffffff;
     fDrawFace = kBoth_DrawFace;
 
     this->invalidateBlendOptFlags();
 }
 
 bool GrDrawState::setIdentityViewMatrix()  {
-    if (fColorStages.count() || fCoverageStages.count()) {
+    if (this->numTotalStages()) {
         SkMatrix invVM;
         if (!fViewMatrix.invert(&invVM)) {
             // sad trombone sound
             return false;
         }
-        for (int s = 0; s < fColorStages.count(); ++s) {
-            fColorStages[s].localCoordChange(invVM);
+        for (int s = 0; s < this->numColorStages(); ++s) {
+            fState.fColorStages[s].localCoordChange(invVM);
         }
-        for (int s = 0; s < fCoverageStages.count(); ++s) {
-            fCoverageStages[s].localCoordChange(invVM);
+        for (int s = 0; s < this->numCoverageStages(); ++s) {
+            fState.fCoverageStages[s].localCoordChange(invVM);
         }
     }
     fViewMatrix.reset();
     return true;
 }
 
 void GrDrawState::setFromPaint(const GrPaint& paint, const SkMatrix& vm, GrRenderTarget* rt) {
     SkASSERT(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages());
 
-    fColorStages.reset();
-    fCoverageStages.reset();
+    fState.reset();
 
     for (int i = 0; i < paint.numColorStages(); ++i) {
-        fColorStages.push_back(paint.getColorStage(i));
+        fState.fColorStages.push_back(paint.getColorStage(i));
     }
 
     for (int i = 0; i < paint.numCoverageStages(); ++i) {
-        fCoverageStages.push_back(paint.getCoverageStage(i));
+        fState.fCoverageStages.push_back(paint.getCoverageStage(i));
     }
 
     this->setRenderTarget(rt);
 
     fViewMatrix = vm;
 
     // These have no equivalent in GrPaint, set them to defaults
     fBlendConstant = 0x0;
     fDrawFace = kBoth_DrawFace;
     fStencilSettings.setDisabled();
@@ skipping 92 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 bool GrDrawState::validateVertexAttribs() const {
     // check consistency of effects and attributes
     GrSLType slTypes[kMaxVertexAttribCnt];
     for (int i = 0; i < kMaxVertexAttribCnt; ++i) {
         slTypes[i] = static_cast<GrSLType>(-1);
     }
-    int totalStages = fColorStages.count() + fCoverageStages.count();
+    int totalStages = this->numTotalStages();
     for (int s = 0; s < totalStages; ++s) {
-        int covIdx = s - fColorStages.count();
-        const GrEffectStage& stage = covIdx < 0 ? fColorStages[s] : fCoverageStages[covIdx];
+        int covIdx = s - this->numColorStages();
+        const GrEffectStage& stage = covIdx < 0 ? this->getColorStage(s) :
+                                                  this->getCoverageStage(covIdx);
         const GrEffect* effect = stage.getEffect();
         SkASSERT(NULL != effect);
         // make sure that any attribute indices have the correct binding type, that the attrib
         // type and effect's shader lang type are compatible, and that attributes shared by
         // multiple effects use the same shader lang type.
         const int* attributeIndices = stage.getVertexAttribIndices();
         int numAttributes = stage.getVertexAttribIndexCount();
         for (int i = 0; i < numAttributes; ++i) {
             int attribIndex = attributeIndices[i];
             if (attribIndex >= fVACount ||
@@ skipping 12 matching lines @@
             }
             slTypes[attribIndex] = effectSLType;
         }
     }
 
     return true;
 }
 
 bool GrDrawState::willEffectReadDstColor() const {
     if (!this->isColorWriteDisabled()) {
-        for (int s = 0; s < fColorStages.count(); ++s) {
-            if (fColorStages[s].getEffect()->willReadDstColor()) {
+        for (int s = 0; s < this->numColorStages(); ++s) {
+            if (this->getColorStage(s).getEffect()->willReadDstColor()) {
                 return true;
             }
         }
     }
-    for (int s = 0; s < fCoverageStages.count(); ++s) {
-        if (fCoverageStages[s].getEffect()->willReadDstColor()) {
+    for (int s = 0; s < this->numCoverageStages(); ++s) {
+        if (this->getCoverageStage(s).getEffect()->willReadDstColor()) {
             return true;
         }
     }
     return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 bool GrDrawState::srcAlphaWillBeOne() const {
     uint32_t validComponentFlags;
     GrColor color;
     // Check if per-vertex or constant color may have partial alpha
     if (this->hasColorVertexAttribute()) {
         validComponentFlags = 0;
         color = 0; // not strictly necessary but we get false alarms from tools about uninit.
     } else {
         validComponentFlags = kRGBA_GrColorComponentFlags;
         color = this->getColor();
     }
 
     // Run through the color stages
-    for (int s = 0; s < fColorStages.count(); ++s) {
-        const GrEffect* effect = fColorStages[s].getEffect();
+    for (int s = 0; s < this->numColorStages(); ++s) {
+        const GrEffect* effect = this->getColorStage(s).getEffect();
         effect->getConstantColorComponents(&color, &validComponentFlags);
     }
 
     // Check whether coverage is treated as color. If so we run through the coverage computation.
     if (this->isCoverageDrawing()) {
         GrColor coverageColor = this->getCoverageColor();
         GrColor oldColor = color;
         color = 0;
         for (int c = 0; c < 4; ++c) {
             if (validComponentFlags & (1 << c)) {
                 U8CPU a = (oldColor >> (c * 8)) & 0xff;
                 U8CPU b = (coverageColor >> (c * 8)) & 0xff;
                 color |= (SkMulDiv255Round(a, b) << (c * 8));
             }
         }
-        for (int s = 0; s < fCoverageStages.count(); ++s) {
-            const GrEffect* effect = fCoverageStages[s].getEffect();
+        for (int s = 0; s < this->numCoverageStages(); ++s) {
+            const GrEffect* effect = this->getCoverageStage(s).getEffect();
             effect->getConstantColorComponents(&color, &validComponentFlags);
         }
     }
     return (kA_GrColorComponentFlag & validComponentFlags) && 0xff == GrColorUnpackA(color);
 }
 
 bool GrDrawState::hasSolidCoverage() const {
     // If we're drawing coverage directly then coverage is effectively treated as color.
     if (this->isCoverageDrawing()) {
         return true;
     }
 
     GrColor coverage;
     uint32_t validComponentFlags;
     // Initialize to an unknown starting coverage if per-vertex coverage is specified.
     if (this->hasCoverageVertexAttribute()) {
         validComponentFlags = 0;
     } else {
         coverage = fCoverage;
         validComponentFlags = kRGBA_GrColorComponentFlags;
     }
 
     // Run through the coverage stages and see if the coverage will be all ones at the end.
-    for (int s = 0; s < fCoverageStages.count(); ++s) {
-        const GrEffect* effect = fCoverageStages[s].getEffect();
+    for (int s = 0; s < this->numCoverageStages(); ++s) {
+        const GrEffect* effect = this->getCoverageStage(s).getEffect();
         effect->getConstantColorComponents(&coverage, &validComponentFlags);
     }
     return (kRGBA_GrColorComponentFlags == validComponentFlags) && (0xffffffff == coverage);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // Some blend modes allow folding a fractional coverage value into the color's alpha channel, while
 // others will blend incorrectly.
 bool GrDrawState::canTweakAlphaForCoverage() const {
     /*
      The fractional coverage is f.
      The src and dst coeffs are Cs and Cd.
      The dst and src colors are S and D.
      We want the blend to compute: f*Cs*S + (f*Cd + (1-f))D. By tweaking the source color's alpha
      we're replacing S with S'=fS. It's obvious that that first term will always be ok. The second
      term can be rearranged as [1-(1-Cd)f]D. By substituting in the various possibilities for Cd we
      find that only 1, ISA, and ISC produce the correct destination when applied to S' and D.
      Also, if we're directly rendering coverage (isCoverageDrawing) then coverage is treated as
      color by definition.
      */
-    return kOne_GrBlendCoeff == fDstBlend ||
-           kISA_GrBlendCoeff == fDstBlend ||
-           kISC_GrBlendCoeff == fDstBlend ||
+    return kOne_GrBlendCoeff == fState.fDstBlend ||
+           kISA_GrBlendCoeff == fState.fDstBlend ||
+           kISC_GrBlendCoeff == fState.fDstBlend ||
            this->isCoverageDrawing();
 }
 
 GrDrawState::BlendOptFlags GrDrawState::getBlendOpts(bool forceCoverage,
                                                      GrBlendCoeff* srcCoeff,
                                                      GrBlendCoeff* dstCoeff) const {
     GrBlendCoeff bogusSrcCoeff, bogusDstCoeff;
     if (NULL == srcCoeff) {
         srcCoeff = &bogusSrcCoeff;
     }
@@ skipping 46 matching lines @@
             return kEmitCoverage_BlendOptFlag;
         } else {
             return kSkipDraw_BlendOptFlag;
         }
     }
 
     // check for coverage due to constant coverage, per-vertex coverage, or coverage stage
     bool hasCoverage = forceCoverage ||
                        0xffffffff != this->getCoverageColor() ||
                        this->hasCoverageVertexAttribute() ||
-                       fCoverageStages.count() > 0;
+                       this->numCoverageStages() > 0;
 
     // if we don't have coverage we can check whether the dst
     // has to read at all. If not, we'll disable blending.
     if (!hasCoverage) {
         if (dstCoeffIsZero) {
             if (kOne_GrBlendCoeff == *srcCoeff) {
                 // if there is no coverage and coeffs are (1,0) then we
                 // won't need to read the dst at all, it gets replaced by src
                 *dstCoeff = kZero_GrBlendCoeff;
                 return kNone_BlendOpt;
@@ skipping 56 matching lines @@
     fDrawState = drawState;
     fVAPtr = drawState->fVAPtr;
     fVACount = drawState->fVACount;
     fDrawState->setDefaultVertexAttribs();
 }
 
 //////////////////////////////////////////////////////////////////////////////s
 
 void GrDrawState::AutoRestoreEffects::set(GrDrawState* ds) {
     if (NULL != fDrawState) {
-        int m = fDrawState->fColorStages.count() - fColorEffectCnt;
+        int m = fDrawState->numColorStages() - fColorEffectCnt;
         SkASSERT(m >= 0);
-        fDrawState->fColorStages.pop_back_n(m);
+        fDrawState->fState.fColorStages.pop_back_n(m);
 
-        int n = fDrawState->fCoverageStages.count() - fCoverageEffectCnt;
+        int n = fDrawState->numCoverageStages() - fCoverageEffectCnt;
         SkASSERT(n >= 0);
-        fDrawState->fCoverageStages.pop_back_n(n);
+        fDrawState->fState.fCoverageStages.pop_back_n(n);
         if (m + n > 0) {
             fDrawState->invalidateBlendOptFlags();
         }
         SkDEBUGCODE(--fDrawState->fBlockEffectRemovalCnt;)
     }
     fDrawState = ds;
     if (NULL != ds) {
-        fColorEffectCnt = ds->fColorStages.count();
-        fCoverageEffectCnt = ds->fCoverageStages.count();
+        fColorEffectCnt = ds->numColorStages();
+        fCoverageEffectCnt = ds->numCoverageStages();
         SkDEBUGCODE(++ds->fBlockEffectRemovalCnt;)
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrDrawState::AutoViewMatrixRestore::restore() {
     if (NULL != fDrawState) {
         SkDEBUGCODE(--fDrawState->fBlockEffectRemovalCnt;)
         fDrawState->fViewMatrix = fViewMatrix;
         SkASSERT(fDrawState->numColorStages() >= fNumColorStages);
         int numCoverageStages = fSavedCoordChanges.count() - fNumColorStages;
         SkASSERT(fDrawState->numCoverageStages() >= numCoverageStages);
 
         int i = 0;
         for (int s = 0; s < fNumColorStages; ++s, ++i) {
-            fDrawState->fColorStages[s].restoreCoordChange(fSavedCoordChanges[i]);
+            fDrawState->fState.fColorStages[s].restoreCoordChange(fSavedCoordChanges[i]);
         }
         for (int s = 0; s < numCoverageStages; ++s, ++i) {
-            fDrawState->fCoverageStages[s].restoreCoordChange(fSavedCoordChanges[i]);
+            fDrawState->fState.fCoverageStages[s].restoreCoordChange(fSavedCoordChanges[i]);
         }
         fDrawState = NULL;
     }
 }
 
 void GrDrawState::AutoViewMatrixRestore::set(GrDrawState* drawState,
                                              const SkMatrix& preconcatMatrix) {
     this->restore();
 
     SkASSERT(NULL == fDrawState);
@@ skipping 40 matching lines @@
         return true;
     }
 }
 
 void GrDrawState::AutoViewMatrixRestore::doEffectCoordChanges(const SkMatrix& coordChangeMatrix) {
     fSavedCoordChanges.reset(fDrawState->numTotalStages());
     int i = 0;
 
     fNumColorStages = fDrawState->numColorStages();
     for (int s = 0; s < fNumColorStages; ++s, ++i) {
-        fDrawState->fColorStages[s].saveCoordChange(&fSavedCoordChanges[i]);
-        fDrawState->fColorStages[s].localCoordChange(coordChangeMatrix);
+        fDrawState->getColorStage(s).saveCoordChange(&fSavedCoordChanges[i]);
+        fDrawState->fState.fColorStages[s].localCoordChange(coordChangeMatrix);
     }
 
     int numCoverageStages = fDrawState->numCoverageStages();
     for (int s = 0; s < numCoverageStages; ++s, ++i) {
-        fDrawState->fCoverageStages[s].saveCoordChange(&fSavedCoordChanges[i]);
-        fDrawState->fCoverageStages[s].localCoordChange(coordChangeMatrix);
+        fDrawState->getCoverageStage(s).saveCoordChange(&fSavedCoordChanges[i]);
+        fDrawState->fState.fCoverageStages[s].localCoordChange(coordChangeMatrix);
     }
 }