Add an opaqueness hint to GrDrawState.

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"
+#include "GrDrawTargetCaps.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) {
+    const GrDrawState& a, const GrDrawState& b, const GrDrawTargetCaps& caps) {
 
     bool usingVertexColors = a.hasColorVertexAttribute();
     if (!usingVertexColors && a.fColor != b.fColor) {
         return kIncompatible_CombinedState;
     }
 
     if (a.fRenderTarget.get() != b.fRenderTarget.get() ||
         !a.fViewMatrix.cheapEqualTo(b.fViewMatrix) ||
         a.fBlendConstant != b.fBlendConstant ||
         a.fFlagBits != b.fFlagBits ||
@@ skipping 10 matching lines @@
     }
 
     bool explicitLocalCoords = a.hasLocalCoordAttribute();
 
     SkASSERT(0 == memcmp(a.fFixedFunctionVertexAttribIndices,
                             b.fFixedFunctionVertexAttribIndices,
                             sizeof(a.fFixedFunctionVertexAttribIndices)));
     if (!State::HaveCompatibleState(a.fState, b.fState, explicitLocalCoords)) {
         return kIncompatible_CombinedState;
     }
+
+    if (usingVertexColors) {
+        // If one is opaque and the other is not then the combined state is not opaque. Moreover,
+        // if the opaqueness affects the ability to get color/coverage blending correct then we
+        // don't combine the draw states.
+        bool aIsOpaque = (kVertexColorsAreOpaque_Hint & a.fHints);
+        bool bIsOpaque = (kVertexColorsAreOpaque_Hint & b.fHints);
+        if (aIsOpaque != bIsOpaque) {
+            const GrDrawState* opaque;
+            const GrDrawState* nonOpaque;
+            if (aIsOpaque) {
+                opaque = &a;
+                nonOpaque = &b;
+            } else {
+                opaque = &b;
+                nonOpaque = &a;
+            }
+            if (!opaque->hasSolidCoverage() && opaque->couldApplyCoverage(caps)) {
+                SkASSERT(!nonOpaque->hasSolidCoverage());
+                if (!nonOpaque->couldApplyCoverage(caps)) {
+                    return kIncompatible_CombinedState;
+                }
+            }
+            return aIsOpaque ? kB_CombinedState : kA_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 < this->numColorStages(); ++i) {
             fState.fColorStages[i].localCoordChange(preConcatMatrix);
         }
         for (int i = 0; i < this->numCoverageStages(); ++i) {
@@ skipping 13 matching lines @@
     fVACount = that.fVACount;
     fVAPtr = that.fVAPtr;
     fStencilSettings = that.fStencilSettings;
     fCoverage = that.fCoverage;
     fDrawFace = that.fDrawFace;
     fOptSrcBlend = that.fOptSrcBlend;
     fOptDstBlend = that.fOptDstBlend;
     fBlendOptFlags = that.fBlendOptFlags;
 
     fState = that.fState;
+    fHints = that.fHints;
 
     memcpy(fFixedFunctionVertexAttribIndices,
             that.fFixedFunctionVertexAttribIndices,
             sizeof(fFixedFunctionVertexAttribIndices));
     return *this;
 }
 
 void GrDrawState::onReset(const SkMatrix* initialViewMatrix) {
     SkASSERT(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages());
     fState.reset();
 
     fRenderTarget.reset(NULL);
 
     this->setDefaultVertexAttribs();
 
     fColor = 0xffffffff;
     if (NULL == initialViewMatrix) {
         fViewMatrix.reset();
     } else {
         fViewMatrix = *initialViewMatrix;
     }
     fBlendConstant = 0x0;
     fFlagBits = 0x0;
     fStencilSettings.setDisabled();
     fCoverage = 0xffffffff;
     fDrawFace = kBoth_DrawFace;
 
+    fHints = 0;
+
     this->invalidateBlendOptFlags();
 }
 
 bool GrDrawState::setIdentityViewMatrix()  {
     if (this->numTotalStages()) {
         SkMatrix invVM;
         if (!fViewMatrix.invert(&invVM)) {
             // sad trombone sound
             return false;
         }
@@ skipping 23 matching lines @@
 
     this->setRenderTarget(rt);
 
     fViewMatrix = vm;
 
     // These have no equivalent in GrPaint, set them to defaults
     fBlendConstant = 0x0;
     fDrawFace = kBoth_DrawFace;
     fStencilSettings.setDisabled();
     this->resetStateFlags();
+    fHints = 0;
 
     // Enable the clip bit
     this->enableState(GrDrawState::kClip_StateBit);
 
     this->setColor(paint.getColor());
     this->setState(GrDrawState::kDither_StateBit, paint.isDither());
     this->setState(GrDrawState::kHWAntialias_StateBit, paint.isAntiAlias());
 
     this->setBlendFunc(paint.getSrcBlendCoeff(), paint.getDstBlendCoeff());
     this->setCoverage(paint.getCoverage());
@@ skipping 134 matching lines @@
     for (int s = 0; s < this->numCoverageStages(); ++s) {
         if (this->getCoverageStage(s).getEffect()->willReadDstColor()) {
             return true;
         }
     }
     return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
+bool GrDrawState::couldApplyCoverage(const GrDrawTargetCaps& caps) const {
+    if (caps.dualSourceBlendingSupport()) {
+        return true;
+    }
+    // we can correctly apply coverage if a) we have dual source blending
+    // or b) one of our blend optimizations applies
+    // or c) the src, dst blend coeffs are 1,0 and we will read Dst Color
+    GrBlendCoeff srcCoeff;
+    GrBlendCoeff dstCoeff;
+    GrDrawState::BlendOptFlags flag = this->getBlendOpts(true, &srcCoeff, &dstCoeff);
+    return GrDrawState::kNone_BlendOpt != flag ||
+           (this->willEffectReadDstColor() &&
+            kOne_GrBlendCoeff == srcCoeff && kZero_GrBlendCoeff == dstCoeff);
+}
+
 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.
+        if (fHints & kVertexColorsAreOpaque_Hint) {
+            validComponentFlags = kA_GrColorComponentFlag;
+            color = 0xFF << GrColor_SHIFT_A;            
+        } else {
+            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 < this->numColorStages(); ++s) {
         const GrEffect* effect = this->getColorStage(s).getEffect();
         effect->getConstantColorComponents(&color, &validComponentFlags);
     }
@@ skipping 102 matching lines @@
         *srcCoeff = kZero_GrBlendCoeff;
         *dstCoeff = kOne_GrBlendCoeff;
     }
 
     bool srcAIsOne = this->srcAlphaWillBeOne();
     bool dstCoeffIsOne = kOne_GrBlendCoeff == *dstCoeff ||
                          (kSA_GrBlendCoeff == *dstCoeff && srcAIsOne);
     bool dstCoeffIsZero = kZero_GrBlendCoeff == *dstCoeff ||
                          (kISA_GrBlendCoeff == *dstCoeff && srcAIsOne);
 
-    bool covIsZero = !this->isCoverageDrawing() &&
-                     !this->hasCoverageVertexAttribute() &&
-                     0 == this->getCoverageColor();
     // When coeffs are (0,1) there is no reason to draw at all, unless
     // stenciling is enabled. Having color writes disabled is effectively
-    // (0,1). The same applies when coverage is known to be 0.
-    if ((kZero_GrBlendCoeff == *srcCoeff && dstCoeffIsOne) || covIsZero) {
+    // (0,1).
+    if ((kZero_GrBlendCoeff == *srcCoeff && dstCoeffIsOne)) {
         if (this->getStencil().doesWrite()) {
             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() ||
-                       this->numCoverageStages() > 0;
+    bool hasCoverage = forceCoverage || !this->hasSolidCoverage();
 
     // 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 162 matching lines @@
         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->getCoverageStage(s).saveCoordChange(&fSavedCoordChanges[i]);
         fDrawState->fState.fCoverageStages[s].localCoordChange(coordChangeMatrix);
     }
 }