remove separate color from coverage

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 "GrDefaultGeoProcFactory.h"
@@ skipping 26 matching lines @@
 
     memcpy(descInfo.fFixedFunctionVertexAttribIndices,
            drawState.getFixedFunctionVertexAttribIndices(),
            sizeof(descInfo.fFixedFunctionVertexAttribIndices));
 
     descInfo.fInputColorIsUsed = true;
     descInfo.fInputCoverageIsUsed = true;
 
     int firstColorStageIdx = 0;
     int firstCoverageStageIdx = 0;
-    bool separateCoverageFromColor;
 
     uint8_t fixedFunctionVAToRemove = 0;
 
     this->computeEffectiveColorStages(drawState, &descInfo, &firstColorStageIdx,
                                       &fixedFunctionVAToRemove);
     this->computeEffectiveCoverageStages(drawState, &descInfo, &firstCoverageStageIdx);
     this->adjustFromBlendOpts(drawState, &descInfo, &firstColorStageIdx, &firstCoverageStageIdx,
                               &fixedFunctionVAToRemove);
     // Should not be setting any more FFVA to be removed at this point
     if (0 != fixedFunctionVAToRemove) {
         this->removeFixedFunctionVertexAttribs(fixedFunctionVAToRemove, &descInfo);
     }
     this->getStageStats(drawState, firstColorStageIdx, firstCoverageStageIdx, &descInfo);
-    this->setOutputStateInfo(drawState, *gpu->caps(), firstCoverageStageIdx, &descInfo,
-                             &separateCoverageFromColor);
 
     // Copy GeometryProcesssor from DS or ODS
     if (drawState.hasGeometryProcessor()) {
         fGeometryProcessor.initAndRef(drawState.fGeometryProcessor);
     } else if (!GrGpu::IsPathRenderingDrawType(drawType)) {
         // Install default GP, this will be ignored if we are rendering with fragment shader only
         // TODO(joshualitt) rendering code should do this
         fGeometryProcessor.reset(GrDefaultGeoProcFactory::Create());
     } else {
         fGeometryProcessor.reset(NULL);
     }
 
     // Copy Color Stages from DS to ODS
     if (firstColorStageIdx < drawState.numColorStages()) {
         fFragmentStages.reset(&drawState.getColorStage(firstColorStageIdx),
                               drawState.numColorStages() - firstColorStageIdx);
     } else {
         fFragmentStages.reset();
     }
 
     fNumColorStages = fFragmentStages.count();
 
     // Copy Coverage Stages from DS to ODS
     if (firstCoverageStageIdx < drawState.numCoverageStages()) {
         fFragmentStages.push_back_n(drawState.numCoverageStages() - firstCoverageStageIdx,
                                     &drawState.getCoverageStage(firstCoverageStageIdx));
-        if (!separateCoverageFromColor) {
-            fNumColorStages = fFragmentStages.count();
-        }
     }
 
+    this->setOutputStateInfo(drawState, *gpu->caps(), &descInfo);
+
     // now create a key
     gpu->buildProgramDesc(*this, descInfo, drawType, dstCopy, &fDesc);
 };
 
 GrOptDrawState* GrOptDrawState::Create(const GrDrawState& drawState,
                                        GrGpu* gpu,
                                        const GrDeviceCoordTexture* dstCopy,
                                        GrGpu::DrawType drawType) {
     GrBlendCoeff srcCoeff;
     GrBlendCoeff dstCoeff;
     BlendOptFlags blendFlags = (BlendOptFlags) drawState.getBlendOpts(false,
                                                                       &srcCoeff,
                                                                       &dstCoeff);
 
     // If our blend coeffs are set to 0,1 we know we will not end up drawing unless we are
     // stenciling. When path rendering the stencil settings are not always set on the draw state
     // so we must check the draw type. In cases where we will skip drawing we simply return a
     // null GrOptDrawState.
     if (kZero_GrBlendCoeff == srcCoeff && kOne_GrBlendCoeff == dstCoeff &&
         !drawState.getStencil().doesWrite() && GrGpu::kStencilPath_DrawType != drawType) {
         return NULL;
     }
 
     return SkNEW_ARGS(GrOptDrawState, (drawState, blendFlags, srcCoeff,
                                        dstCoeff, gpu, dstCopy, drawType));
 }
 
 void GrOptDrawState::setOutputStateInfo(const GrDrawState& ds,
                                         const GrDrawTargetCaps& caps,
-                                        int firstCoverageStageIdx,
-                                        GrProgramDesc::DescInfo* descInfo,
-                                        bool* separateCoverageFromColor) {
+                                        GrProgramDesc::DescInfo* descInfo) {
     // Set this default and then possibly change our mind if there is coverage.
     descInfo->fPrimaryOutputType = GrProgramDesc::kModulate_PrimaryOutputType;
     descInfo->fSecondaryOutputType = GrProgramDesc::kNone_SecondaryOutputType;
 
-    // If we do have coverage determine whether it matters.
-    *separateCoverageFromColor = this->hasGeometryProcessor();
-    if (!this->isCoverageDrawing() &&
-        (ds.numCoverageStages() - firstCoverageStageIdx > 0 ||
-         ds.hasGeometryProcessor() ||
-         descInfo->hasCoverageVertexAttribute())) {
-
+    // If we do have coverage determine whether it matters.  Dual source blending is expensive so
+    // we don't do it if we are doing coverage drawing.  If we aren't then We always do dual source
+    // blending if we have any effective coverage stages OR the geometry processor doesn't emits
+    // solid coverage.
+    // TODO move the gp logic into the GP base class
+    if (!this->isCoverageDrawing() && !ds.hasSolidCoverage()) {
         if (caps.dualSourceBlendingSupport()) {
             if (kZero_GrBlendCoeff == fDstBlend) {
                 // write the coverage value to second color
                 descInfo->fSecondaryOutputType = GrProgramDesc::kCoverage_SecondaryOutputType;
-                *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.
                 descInfo->fSecondaryOutputType = GrProgramDesc::kCoverageISA_SecondaryOutputType;
-                *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.
                 descInfo->fSecondaryOutputType = GrProgramDesc::kCoverageISC_SecondaryOutputType;
-                *separateCoverageFromColor = true;
                 fDstBlend = (GrBlendCoeff)GrGpu::kIS2C_GrBlendCoeff;
             }
         } else if (descInfo->fReadsDst &&
                    kOne_GrBlendCoeff == fSrcBlend &&
                    kZero_GrBlendCoeff == fDstBlend) {
             descInfo->fPrimaryOutputType = GrProgramDesc::kCombineWithDst_PrimaryOutputType;
-            *separateCoverageFromColor = true;
         }
     }
 }
 
 void GrOptDrawState::adjustFromBlendOpts(const GrDrawState& ds,
                                          GrProgramDesc::DescInfo* descInfo,
                                          int* firstColorStageIdx,
                                          int* firstCoverageStageIdx,
                                          uint8_t* fixedFunctionVAToRemove) {
     switch (fBlendOptFlags) {
@@ skipping 202 matching lines @@
     bool explicitLocalCoords = this->fDesc.header().fLocalCoordAttributeIndex != -1;
     for (int i = 0; i < this->numFragmentStages(); i++) {
         if (!GrFragmentStage::AreCompatible(this->getFragmentStage(i), that.getFragmentStage(i),
                                             explicitLocalCoords)) {
             return false;
         }
     }
     return true;
 }