Delay copying effects from DS or ODS till end of creating ODS

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 17 matching lines @@
     fStencilSettings = drawState.getStencil();
     fDrawFace = (DrawFace)drawState.getDrawFace();
     fBlendOptFlags = blendOptFlags;
     fSrcBlend = optSrcCoeff;
     fDstBlend = optDstCoeff;
 
     memcpy(fFixedFunctionVertexAttribIndices,
            drawState.getFixedFunctionVertexAttribIndices(),
            sizeof(fFixedFunctionVertexAttribIndices));
 
-
     fInputColorIsUsed = true;
     fInputCoverageIsUsed = true;
 
+    int firstColorStageIdx = 0;
+    int firstCoverageStageIdx = 0;
+    bool separateCoverageFromColor;
+
+    uint8_t fixedFunctionVAToRemove = 0;
+
+    this->computeEffectiveColorStages(drawState, &firstColorStageIdx, &fixedFunctionVAToRemove);
+    this->computeEffectiveCoverageStages(drawState, &firstCoverageStageIdx);
+    this->adjustFromBlendOpts(drawState, &firstColorStageIdx, &firstCoverageStageIdx,
+                              &fixedFunctionVAToRemove);
+    // Should not be setting any more FFVA to be removed at this point
+    this->removeFixedFunctionVertexAttribs(fixedFunctionVAToRemove);
+    this->getStageStats(drawState, firstColorStageIdx, firstCoverageStageIdx);
+    this->setOutputStateInfo(drawState, caps, firstCoverageStageIdx, &separateCoverageFromColor);
+
+    // Copy GeometryProcesssor from DS or ODS
     if (drawState.hasGeometryProcessor()) {
         fGeometryProcessor.reset(SkNEW_ARGS(GrGeometryStage, (*drawState.getGeometryProcessor())));
     } else {
         fGeometryProcessor.reset(NULL);
     }
 
-    this->copyEffectiveColorStages(drawState);
-    this->copyEffectiveCoverageStages(drawState);
-    this->adjustFromBlendOpts();
-    this->getStageStats();
-    this->setOutputStateInfo(caps);
+    // Copy Color Stages from DS to ODS
+    if (firstColorStageIdx < drawState.numColorStages()) {
+        fColorStages.reset(&drawState.getColorStage(firstColorStageIdx),
+                           drawState.numColorStages() - firstColorStageIdx);
+    } else {
+        fColorStages.reset();
+    }
+
+    // Copy Coverage Stages from DS to ODS
+    if (drawState.numCoverageStages() > 0 && separateCoverageFromColor) {
+        fCoverageStages.reset(&drawState.getCoverageStage(firstCoverageStageIdx),
+                              drawState.numCoverageStages() - firstCoverageStageIdx);
+    } else {
+        fCoverageStages.reset();
+        if (drawState.numCoverageStages() > 0) {
+            // 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));
+        }
+    }
 };
 
 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,
                                                                           &srcCoeff,
                                                                           &dstCoeff);
@@ skipping 18 matching lines @@
                                                                           &srcCoeff,
                                                                           &dstCoeff);
         SkASSERT(GrOptDrawState(drawState, blendFlags, srcCoeff, dstCoeff, caps) ==
                  *drawState.fCachedOptState);
 #endif
     }
     drawState.fCachedOptState->ref();
     return drawState.fCachedOptState;
 }
 
-void GrOptDrawState::setOutputStateInfo(const GrDrawTargetCaps& caps) {
+void GrOptDrawState::setOutputStateInfo(const GrDrawState& ds,
+                                        const GrDrawTargetCaps& caps,
+                                        int firstCoverageStageIdx,
+                                        bool* separateCoverageFromColor) {
     // Set this default and then possibly change our mind if there is coverage.
     fPrimaryOutputType = kModulate_PrimaryOutputType;
     fSecondaryOutputType = kNone_SecondaryOutputType;
 
     // If we do have coverage determine whether it matters.
-    bool separateCoverageFromColor = this->hasGeometryProcessor();
+    *separateCoverageFromColor = this->hasGeometryProcessor();
     if (!this->isCoverageDrawing() &&
-        (this->numCoverageStages() > 0 ||
-         this->hasGeometryProcessor() ||
+        (ds.numCoverageStages() - firstCoverageStageIdx > 0 ||
+         ds.hasGeometryProcessor() ||
          this->hasCoverageVertexAttribute())) {
 
         if (caps.dualSourceBlendingSupport()) {
             if (kZero_GrBlendCoeff == fDstBlend) {
                 // write the coverage value to second color
                 fSecondaryOutputType =  kCoverage_SecondaryOutputType;
-                separateCoverageFromColor = true;
+                *separateCoverageFromColor = true;
                 fDstBlend = (GrBlendCoeff)GrGpu::kIS2C_GrBlendCoeff;
             } else if (kSA_GrBlendCoeff == fDstBlend) {
                 // SA dst coeff becomes 1-(1-SA)*coverage when dst is partially covered.
                 fSecondaryOutputType = kCoverageISA_SecondaryOutputType;
-                separateCoverageFromColor = true;
+                *separateCoverageFromColor = true;
                 fDstBlend = (GrBlendCoeff)GrGpu::kIS2C_GrBlendCoeff;
             } else if (kSC_GrBlendCoeff == fDstBlend) {
                 // SA dst coeff becomes 1-(1-SA)*coverage when dst is partially covered.
                 fSecondaryOutputType = kCoverageISC_SecondaryOutputType;
-                separateCoverageFromColor = true;
+                *separateCoverageFromColor = true;
                 fDstBlend = (GrBlendCoeff)GrGpu::kIS2C_GrBlendCoeff;
             }
         } else if (fReadsDst &&
                    kOne_GrBlendCoeff == fSrcBlend &&
                    kZero_GrBlendCoeff == fDstBlend) {
             fPrimaryOutputType = kCombineWithDst_PrimaryOutputType;
-            separateCoverageFromColor = true;
+            *separateCoverageFromColor = true;
         }
     }
-
-    // TODO: Once we have flag to know if we only multiply on stages, only push coverage into color
-    // stages if everything is multipy
-    if (!separateCoverageFromColor) {
-        for (int s = 0; s < this->numCoverageStages(); ++s) {
-            fColorStages.push_back(this->getCoverageStage(s));
-        }
-        fCoverageStages.reset();
-    }
 }
 
-void GrOptDrawState::adjustFromBlendOpts() {
-
+void GrOptDrawState::adjustFromBlendOpts(const GrDrawState& ds,
+                                         int* firstColorStageIdx,
+                                         int* firstCoverageStageIdx,
+                                         uint8_t* fixedFunctionVAToRemove) {
     switch (fBlendOptFlags) {
         case kNone_BlendOpt:
         case kSkipDraw_BlendOptFlag:
             break;
         case kCoverageAsAlpha_BlendOptFlag:
             fFlagBits |= kCoverageDrawing_StateBit;
             break;
         case kEmitCoverage_BlendOptFlag:
             fColor = 0xffffffff;
             fInputColorIsUsed = true;
-            fColorStages.reset();
-            this->removeFixedFunctionVertexAttribs(0x1 << kColor_GrVertexAttribBinding);
+            *firstColorStageIdx = ds.numColorStages();
+            *fixedFunctionVAToRemove |= 0x1 << kColor_GrVertexAttribBinding;
             break;
         case kEmitTransBlack_BlendOptFlag:
             fColor = 0;
             fCoverage = 0xff;
             fInputColorIsUsed = true;
             fInputCoverageIsUsed = true;
-            fColorStages.reset();
-            fCoverageStages.reset();
-            this->removeFixedFunctionVertexAttribs(0x1 << kColor_GrVertexAttribBinding |
-                                                   0x1 << kCoverage_GrVertexAttribBinding);
+            *firstColorStageIdx = ds.numColorStages();
+            *firstCoverageStageIdx = ds.numCoverageStages();
+            *fixedFunctionVAToRemove |= (0x1 << kColor_GrVertexAttribBinding |
+                                         0x1 << kCoverage_GrVertexAttribBinding);
             break;
         default:
             SkFAIL("Unknown BlendOptFlag");
-
     }
 }
 
 void GrOptDrawState::removeFixedFunctionVertexAttribs(uint8_t removeVAFlag) {
     int numToRemove = 0;
     uint8_t maskCheck = 0x1;
     // Count the number of vertex attributes that we will actually remove
     for (int i = 0; i < kGrFixedFunctionVertexAttribBindingCnt; ++i) {
         if ((maskCheck & removeVAFlag) && -1 != fFixedFunctionVertexAttribIndices[i]) {
             ++numToRemove;
@@ skipping 18 matching lines @@
             fFixedFunctionVertexAttribIndices[currAttrib.fBinding] = newIdx;
         }
         memcpy(dst, src, sizeof(GrVertexAttrib));
         ++newIdx;
         ++dst;
     }
     fVACount -= numToRemove;
     fVAPtr = fOptVA.get();
 }
 
-void GrOptDrawState::copyEffectiveColorStages(const GrDrawState& ds) {
-    int firstColorStage = 0;
-
+void GrOptDrawState::computeEffectiveColorStages(const GrDrawState& ds, int* firstColorStageIdx,
+                                                 uint8_t* fixedFunctionVAToRemove) {
     // Set up color and flags for ConstantColorComponent checks
     GrProcessor::InvariantOutput inout;
     inout.fIsSingleComponent = false;
     if (!this->hasColorVertexAttribute()) {
         inout.fColor = ds.getColor();
         inout.fValidFlags = kRGBA_GrColorComponentFlags;
     } else {
         if (ds.vertexColorsAreOpaque()) {
             inout.fColor = 0xFF << GrColor_SHIFT_A;
             inout.fValidFlags = kA_GrColorComponentFlag;
         } else {
             inout.fValidFlags = 0;
             // not strictly necessary but we get false alarms from tools about uninit.
             inout.fColor = 0;
         }
     }
 
     for (int i = 0; i < ds.numColorStages(); ++i) {
         const GrFragmentProcessor* fp = ds.getColorStage(i).getProcessor();
         if (!fp->willUseInputColor()) {
-            firstColorStage = i;
+            *firstColorStageIdx = i;
             fInputColorIsUsed = false;
         }
         fp->computeInvariantOutput(&inout);
         if (kRGBA_GrColorComponentFlags == inout.fValidFlags) {
-            firstColorStage = i + 1;
+            *firstColorStageIdx = i + 1;
             fColor = inout.fColor;
             fInputColorIsUsed = true;
-            this->removeFixedFunctionVertexAttribs(0x1 << kColor_GrVertexAttribBinding);
+            *fixedFunctionVAToRemove |= 0x1 << kColor_GrVertexAttribBinding;
         }
     }
-    if (firstColorStage < ds.numColorStages()) {
-        fColorStages.reset(&ds.getColorStage(firstColorStage),
-                           ds.numColorStages() - firstColorStage);
-    } else {
-        fColorStages.reset();
-    }
 }
 
-void GrOptDrawState::copyEffectiveCoverageStages(const GrDrawState& ds) {
-    int firstCoverageStage = 0;
-
+void GrOptDrawState::computeEffectiveCoverageStages(const GrDrawState& ds,
+                                                    int* firstCoverageStageIdx) {
     // We do not try to optimize out constantColor coverage effects here. It is extremely rare
     // to have a coverage effect that returns a constant value for all four channels. Thus we
     // save having to make extra virtual calls by not checking for it.
 
     // Don't do any optimizations on coverage stages. It should not be the case where we do not use
     // input coverage in an effect
 #ifdef OptCoverageStages
     for (int i = 0; i < ds.numCoverageStages(); ++i) {
         const GrProcessor* processor = ds.getCoverageStage(i).getProcessor();
         if (!processor->willUseInputColor()) {
-            firstCoverageStage = i;
+            *firstCoverageStageIdx = i;
             fInputCoverageIsUsed = false;
         }
     }
 #endif
-    if (ds.numCoverageStages() > 0) {
-        fCoverageStages.reset(&ds.getCoverageStage(firstCoverageStage),
-                              ds.numCoverageStages() - firstCoverageStage);
-    } else {
-        fCoverageStages.reset();
-    }
 }
 
 static void get_stage_stats(const GrFragmentStage& stage, bool* readsDst, bool* readsFragPosition) {
     if (stage.getProcessor()->willReadDstColor()) {
         *readsDst = true;
     }
     if (stage.getProcessor()->willReadFragmentPosition()) {
         *readsFragPosition = true;
     }
 }
 
-void GrOptDrawState::getStageStats() {
+void GrOptDrawState::getStageStats(const GrDrawState& ds, int firstColorStageIdx,
+                                   int firstCoverageStageIdx) {
     // We will need a local coord attrib if there is one currently set on the optState and we are
     // actually generating some effect code
-    fRequiresLocalCoordAttrib = this->hasLocalCoordAttribute() && this->numTotalStages() > 0;
+    fRequiresLocalCoordAttrib = this->hasLocalCoordAttribute() &&
+        ds.numTotalStages() - firstColorStageIdx - firstCoverageStageIdx > 0;
 
     fReadsDst = false;
     fReadsFragPosition = false;
 
-    for (int s = 0; s < this->numColorStages(); ++s) {
-        const GrFragmentStage& stage = this->getColorStage(s);
+    for (int s = firstColorStageIdx; s < ds.numColorStages(); ++s) {
+        const GrFragmentStage& stage = ds.getColorStage(s);
         get_stage_stats(stage, &fReadsDst, &fReadsFragPosition);
     }
-    for (int s = 0; s < this->numCoverageStages(); ++s) {
-        const GrFragmentStage& stage = this->getCoverageStage(s);
+    for (int s = firstCoverageStageIdx; s < ds.numCoverageStages(); ++s) {
+        const GrFragmentStage& stage = ds.getCoverageStage(s);
         get_stage_stats(stage, &fReadsDst, &fReadsFragPosition);
     }
-    if (this->hasGeometryProcessor()) {
-        const GrGeometryStage& stage = *this->getGeometryProcessor();
+    if (ds.hasGeometryProcessor()) {
+        const GrGeometryStage& stage = *ds.getGeometryProcessor();
         fReadsFragPosition = fReadsFragPosition || stage.getProcessor()->willReadFragmentPosition();
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 bool GrOptDrawState::operator== (const GrOptDrawState& that) const {
     return this->isEqual(that);
 }
 
@@ skipping 57 matching lines @@
         }
     }
 
     SkASSERT(0 == memcmp(this->fFixedFunctionVertexAttribIndices,
                          that.fFixedFunctionVertexAttribIndices,
                          sizeof(this->fFixedFunctionVertexAttribIndices)));
 
     return true;
 }