Store color and coverage stages in a single array in GrOptDrawState.

src/gpu/GrOptDrawState.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrOptDrawState.h"
 
 #include "GrDrawState.h"
@@ skipping 43 matching lines @@
 
     // Copy GeometryProcesssor from DS or ODS
     if (drawState.hasGeometryProcessor()) {
         fGeometryProcessor.reset(SkNEW_ARGS(GrGeometryStage, (*drawState.getGeometryProcessor())));
     } else {
         fGeometryProcessor.reset(NULL);
     }
 
     // Copy Color Stages from DS to ODS
     if (firstColorStageIdx < drawState.numColorStages()) {
-        fColorStages.reset(&drawState.getColorStage(firstColorStageIdx),
-                           drawState.numColorStages() - firstColorStageIdx);
+        fFragmentStages.reset(&drawState.getColorStage(firstColorStageIdx),
+                              drawState.numColorStages() - firstColorStageIdx);
     } else {
-        fColorStages.reset();
+        fFragmentStages.reset();
     }
 
+    fNumColorStages = fFragmentStages.count();
+
     // Copy Coverage Stages from DS to ODS
-    if (firstCoverageStageIdx < drawState.numCoverageStages() && separateCoverageFromColor) {
-        fCoverageStages.reset(&drawState.getCoverageStage(firstCoverageStageIdx),
-                              drawState.numCoverageStages() - firstCoverageStageIdx);
-    } else {
-        fCoverageStages.reset();
-        if (firstCoverageStageIdx < drawState.numCoverageStages()) {
-            // TODO: Once we have flag to know if we only multiply on stages, only push coverage
-            // into color stages if everything is multiply
-            fColorStages.push_back_n(drawState.numCoverageStages() - firstCoverageStageIdx,
-                                     &drawState.getCoverageStage(firstCoverageStageIdx));
+    if (firstCoverageStageIdx < drawState.numCoverageStages()) {
+        fFragmentStages.push_back_n(drawState.numCoverageStages() - firstCoverageStageIdx,
+                                    &drawState.getCoverageStage(firstCoverageStageIdx));
+        if (!separateCoverageFromColor) {
+            fNumColorStages = fFragmentStages.count();
         }
     }
 };
 
 GrOptDrawState* GrOptDrawState::Create(const GrDrawState& drawState, const GrDrawTargetCaps& caps,
                                        GrGpu::DrawType drawType) {
     if (NULL == drawState.fCachedOptState || caps.getUniqueID() != drawState.fCachedCapsID) {
         GrBlendCoeff srcCoeff;
         GrBlendCoeff dstCoeff;
         BlendOptFlags blendFlags = (BlendOptFlags) drawState.getBlendOpts(false,
@@ skipping 228 matching lines @@
     return this->isEqual(that);
 }
 
 bool GrOptDrawState::isEqual(const GrOptDrawState& that) const {
     bool usingVertexColors = this->hasColorVertexAttribute();
     if (!usingVertexColors && this->fColor != that.fColor) {
         return false;
     }
 
     if (this->getRenderTarget() != that.getRenderTarget() ||
-        this->fColorStages.count() != that.fColorStages.count() ||
-        this->fCoverageStages.count() != that.fCoverageStages.count() ||
+        this->fFragmentStages.count() != that.fFragmentStages.count() ||
+        this->fNumColorStages != that.fNumColorStages ||
         !this->fViewMatrix.cheapEqualTo(that.fViewMatrix) ||
         this->fSrcBlend != that.fSrcBlend ||
         this->fDstBlend != that.fDstBlend ||
         this->fBlendConstant != that.fBlendConstant ||
         this->fFlagBits != that.fFlagBits ||
         this->fVACount != that.fVACount ||
         this->fVAStride != that.fVAStride ||
         memcmp(this->fVAPtr, that.fVAPtr, this->fVACount * sizeof(GrVertexAttrib)) ||
         this->fStencilSettings != that.fStencilSettings ||
         this->fDrawFace != that.fDrawFace ||
@@ skipping 18 matching lines @@
             return false;
         } else if (!GrProcessorStage::AreCompatible(*this->getGeometryProcessor(),
                                                     *that.getGeometryProcessor(),
                                                     explicitLocalCoords)) {
             return false;
         }
     } else if (that.hasGeometryProcessor()) {
         return false;
     }
 
-    for (int i = 0; i < this->numColorStages(); i++) {
-        if (!GrProcessorStage::AreCompatible(this->getColorStage(i), that.getColorStage(i),
+    for (int i = 0; i < this->numFragmentStages(); i++) {
+        if (!GrProcessorStage::AreCompatible(this->getFragmentStage(i), that.getFragmentStage(i),
                                              explicitLocalCoords)) {
             return false;
         }
-    }
-    for (int i = 0; i < this->numCoverageStages(); i++) {
-        if (!GrProcessorStage::AreCompatible(this->getCoverageStage(i), that.getCoverageStage(i),
-                                             explicitLocalCoords)) {
-            return false;
-        }
     }
 
     SkASSERT(0 == memcmp(this->fFixedFunctionVertexAttribIndices,
                          that.fFixedFunctionVertexAttribIndices,
                          sizeof(this->fFixedFunctionVertexAttribIndices)));
 
     return true;
 }