Program key coverage/discard fixes.

src/gpu/gl/GrGLProgram.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLProgram.h"
 
 #include "GrAllocator.h"
@@ skipping 99 matching lines @@
     } else if (covIsSolidWhite) {
         desc->fCoverageInput = Desc::kSolidWhite_ColorInput;
     } else if (GR_GL_NO_CONSTANT_ATTRIBUTES && !requiresAttributeCoverage) {
         desc->fCoverageInput = Desc::kUniform_ColorInput;
     } else {
         desc->fCoverageInput = Desc::kAttribute_ColorInput;
     }
 
     int lastEnabledStage = -1;
 
-    if (!skipCoverage) {
-        desc->fDiscardIfOutsideEdge = drawState.getStencil().doesWrite();
-    } else {
-        // Use canonical values when edge-aa is not enabled to avoid program cache misses.
-        desc->fDiscardIfOutsideEdge = false;
-    }
-
     for (int s = 0; s < GrDrawState::kNumStages; ++s) {
 
         bool skip = s < drawState.getFirstCoverageStage() ? skipColor : skipCoverage;
         if (!skip && drawState.isStageEnabled(s)) {
             lastEnabledStage = s;
             const GrEffectRef& effect = *drawState.getStage(s).getEffect();
             const GrBackendEffectFactory& factory = effect->getFactory();
             bool explicitLocalCoords = (drawState.getAttribBindings() &
                                         GrDrawState::kLocalCoords_AttribBindingsBit);
             GrDrawEffect drawEffect(drawState.getStage(s), explicitLocalCoords);
             desc->fEffectKeys[s] = factory.glEffectKey(drawEffect, gpu->glCaps());
         } else {
             desc->fEffectKeys[s] = 0;
         }
     }
 
     desc->fDualSrcOutput = Desc::kNone_DualSrcOutput;
 
     // Currently the experimental GS will only work with triangle prims (and it doesn't do anything
     // other than pass through values from the VS to the FS anyway).
 #if GR_GL_EXPERIMENTAL_GS
 #if 0
     desc->fExperimentalGS = gpu->caps().geometryShaderSupport();
 #else
     desc->fExperimentalGS = false;
 #endif
 #endif
 
-    // We want to avoid generating programs with different "first cov stage" values when they would
-    // compute the same result. We set field in the desc to kNumStages when either there are no
-    // coverage stages or the distinction between coverage and color is immaterial.
+    // We leave this set to kNumStages until we discover that the coverage/color distinction is
+    // material to the generated program. We do this to avoid distinct keys that generate equivalent
+    // programs.
+    desc->fFirstCoverageStage = GrDrawState::kNumStages;
+    // This tracks the actual first coverage stage.
     int firstCoverageStage = GrDrawState::kNumStages;
-    desc->fFirstCoverageStage = GrDrawState::kNumStages;
-    bool hasCoverage = drawState.getFirstCoverageStage() <= lastEnabledStage;
-    if (hasCoverage) {
-        firstCoverageStage = drawState.getFirstCoverageStage();
+    desc->fDiscardIfZeroCoverage = false; // Enabled below if stenciling and there is coverage.
+    bool hasCoverage = false;
+    // If we're rendering coverage-as-color then its as though there are no coverage stages.
+    if (!drawState.isCoverageDrawing()) {
+        // We can have coverage either through a stage or coverage vertex attributes.
+        if (drawState.getFirstCoverageStage() <= lastEnabledStage) {
+            firstCoverageStage = drawState.getFirstCoverageStage();
+            hasCoverage = true;
+        } else {
+            hasCoverage = requiresAttributeCoverage;
+        }
     }
-
-    // other coverage inputs
-    if (!hasCoverage) {
-        hasCoverage = requiresAttributeCoverage;
-    }
-
+    
     if (hasCoverage) {
         // color filter is applied between color/coverage computation
         if (SkXfermode::kDst_Mode != desc->fColorFilterXfermode) {
             desc->fFirstCoverageStage = firstCoverageStage;
         }
+        
+        // If we're stenciling then we want to discard samples that have zero coverage
+        if (drawState.getStencil().doesWrite()) {
+            desc->fDiscardIfZeroCoverage = true;
+            desc->fFirstCoverageStage = firstCoverageStage;
+        }
 
         if (gpu->caps()->dualSourceBlendingSupport() &&
             !(blendOpts & (GrDrawState::kEmitCoverage_BlendOptFlag |
                            GrDrawState::kCoverageAsAlpha_BlendOptFlag))) {
             if (kZero_GrBlendCoeff == dstCoeff) {
                 // write the coverage value to second color
                 desc->fDualSrcOutput =  Desc::kCoverage_DualSrcOutput;
                 desc->fFirstCoverageStage = firstCoverageStage;
             } else if (kSA_GrBlendCoeff == dstCoeff) {
                 // SA dst coeff becomes 1-(1-SA)*coverage when dst is partially covered.
@@ skipping 605 matching lines @@
                                                     fDesc.fEffectKeys[s],
                                                     inCoverage.size() ? inCoverage.c_str() : NULL,
                                                     outCoverage.c_str(),
                                                     &fUniformHandles.fSamplerUnis[s]);
                     builder.setNonStage();
                     inCoverage = outCoverage;
                 }
             }
 
             // discard if coverage is zero
-            if (fDesc.fDiscardIfOutsideEdge && !outCoverage.isEmpty()) {
+            if (fDesc.fDiscardIfZeroCoverage && !outCoverage.isEmpty()) {
                 builder.fsCodeAppendf(
                     "\tif (all(lessThanEqual(%s, vec4(0.0)))) {\n\t\tdiscard;\n\t}\n",
                     outCoverage.c_str());
             }
         }
 
         if (Desc::kNone_DualSrcOutput != fDesc.fDualSrcOutput) {
             builder.fFSOutputs.push_back().set(kVec4f_GrSLType,
                                                GrGLShaderVar::kOut_TypeModifier,
                                                dual_source_output_name());
@@ skipping 297 matching lines @@
             SkScalarToFloat(m[SkMatrix::kMTransX]),
             SkScalarToFloat(m[SkMatrix::kMTransY]),
             SkScalarToFloat(m[SkMatrix::kMPersp2])
         };
         fUniformManager.setMatrix3f(fUniformHandles.fViewMatrixUni, mt);
         fMatrixState.fViewMatrix = drawState.getViewMatrix();
         fMatrixState.fRenderTargetSize = size;
         fMatrixState.fRenderTargetOrigin = rt->origin();
     }
 }