Add Coverage Drawing XP

src/gpu/effects/GrPorterDuffXferProcessor.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 "effects/GrPorterDuffXferProcessor.h"
 
 #include "GrBlend.h"
-#include "GrDrawState.h"
 #include "GrDrawTargetCaps.h"
 #include "GrInvariantOutput.h"
 #include "GrProcessor.h"
+#include "GrProcOptInfo.h"
 #include "GrTypes.h"
 #include "GrXferProcessor.h"
 #include "gl/GrGLXferProcessor.h"
 #include "gl/builders/GrGLFragmentShaderBuilder.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 
-static bool can_tweak_alpha_for_coverage(GrBlendCoeff dstCoeff, bool isCoverageDrawing) {
+static bool can_tweak_alpha_for_coverage(GrBlendCoeff dstCoeff) {
     /*
      The fractional coverage is f.
      The src and dst coeffs are Cs and Cd.
      The dst and src colors are S and D.
      We want the blend to compute: f*Cs*S + (f*Cd + (1-f))D. By tweaking the source color's alpha
      we're replacing S with S'=fS. It's obvious that that first term will always be ok. The second
      term can be rearranged as [1-(1-Cd)f]D. By substituting in the various possibilities for Cd we
      find that only 1, ISA, and ISC produce the correct destination when applied to S' and D.
-     Also, if we're directly rendering coverage (isCoverageDrawing) then coverage is treated as
-     color by definition.
      */
-    // TODO: Once we have a CoverageDrawing XP, we don't need to check is CoverageDrawing here
     return kOne_GrBlendCoeff == dstCoeff ||
            kISA_GrBlendCoeff == dstCoeff ||
-           kISC_GrBlendCoeff == dstCoeff ||
-           isCoverageDrawing;
+           kISC_GrBlendCoeff == dstCoeff;
 }
 
 class GrGLPorterDuffXferProcessor : public GrGLXferProcessor {
 public:
     GrGLPorterDuffXferProcessor(const GrProcessor&) {}
 
     virtual ~GrGLPorterDuffXferProcessor() {}
 
     virtual void emitCode(const EmitArgs& args) SK_OVERRIDE {
         const GrPorterDuffXferProcessor& xp = args.fXP.cast<GrPorterDuffXferProcessor>();
@@ skipping 73 matching lines @@
 
 void GrPorterDuffXferProcessor::getGLProcessorKey(const GrGLCaps& caps,
                                                   GrProcessorKeyBuilder* b) const {
     GrGLPorterDuffXferProcessor::GenKey(*this, caps, b);
 }
 
 GrGLXferProcessor* GrPorterDuffXferProcessor::createGLInstance() const {
     return SkNEW_ARGS(GrGLPorterDuffXferProcessor, (*this));
 }
 
-void GrPorterDuffXferProcessor::onComputeInvariantOutput(GrInvariantOutput* inout) const {
-    inout->setToUnknown(GrInvariantOutput::kWill_ReadInput);
-}
-
 GrXferProcessor::OptFlags
 GrPorterDuffXferProcessor::getOptimizations(const GrProcOptInfo& colorPOI,
                                             const GrProcOptInfo& coveragePOI,
-                                            bool isCoverageDrawing,
                                             bool colorWriteDisabled,
                                             bool doesStencilWrite,
                                             GrColor* overrideColor,
                                             const GrDrawTargetCaps& caps) {
     GrXferProcessor::OptFlags optFlags;
     // Optimizations when doing RGB Coverage
     if (coveragePOI.isFourChannelOutput()) {
         // We want to force our primary output to be alpha * Coverage, where alpha is the alpha
         // value of the blend the constant. We should already have valid blend coeff's if we are at
         // a point where we have RGB coverage. We don't need any color stages since the known color
         // output is already baked into the blendConstant.
         uint8_t alpha = GrColorUnpackA(fBlendConstant);
         *overrideColor = GrColorPackRGBA(alpha, alpha, alpha, alpha);
         optFlags = GrXferProcessor::kOverrideColor_OptFlag;
     } else {
         optFlags = this->internalGetOptimizations(colorPOI,
                                                   coveragePOI,
-                                                  isCoverageDrawing,
                                                   colorWriteDisabled,
                                                   doesStencilWrite);
     }
-    this->calcOutputTypes(optFlags, caps, isCoverageDrawing || coveragePOI.isSolidWhite(),
+    this->calcOutputTypes(optFlags, caps, coveragePOI.isSolidWhite(),
                           colorPOI.readsDst() || coveragePOI.readsDst());
     return optFlags;
 }
 
 void GrPorterDuffXferProcessor::calcOutputTypes(GrXferProcessor::OptFlags optFlags,
                                                 const GrDrawTargetCaps& caps,
                                                 bool hasSolidCoverage, bool readsDst) {
     if (optFlags & kIgnoreColor_OptFlag) {
         if (optFlags & kIgnoreCoverage_OptFlag) {
             fPrimaryOutputType = kNone_PrimaryOutputType;
@@ skipping 30 matching lines @@
                    kOne_GrBlendCoeff == fSrcBlend &&
                    kZero_GrBlendCoeff == fDstBlend) {
             fPrimaryOutputType = kCombineWithDst_PrimaryOutputType;
         }
     }
 }
 
 GrXferProcessor::OptFlags
 GrPorterDuffXferProcessor::internalGetOptimizations(const GrProcOptInfo& colorPOI,
                                                     const GrProcOptInfo& coveragePOI,
-                                                    bool isCoverageDrawing,
                                                     bool colorWriteDisabled,
                                                     bool doesStencilWrite) {
     if (colorWriteDisabled) {
         fSrcBlend = kZero_GrBlendCoeff;
         fDstBlend = kOne_GrBlendCoeff;
     }
 
     bool srcAIsOne;
     bool hasCoverage;
-    if (isCoverageDrawing) {
-        srcAIsOne = colorPOI.isOpaque() && coveragePOI.isOpaque();
-        hasCoverage = false;
-    } else {
-        srcAIsOne = colorPOI.isOpaque();
-        hasCoverage = !coveragePOI.isSolidWhite();
-    }
+
+    srcAIsOne = colorPOI.isOpaque();
+    hasCoverage = !coveragePOI.isSolidWhite();
 
     bool dstCoeffIsOne = kOne_GrBlendCoeff == fDstBlend ||
                          (kSA_GrBlendCoeff == fDstBlend && srcAIsOne);
     bool dstCoeffIsZero = kZero_GrBlendCoeff == fDstBlend ||
                          (kISA_GrBlendCoeff == fDstBlend && srcAIsOne);
 
     // 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).
     if ((kZero_GrBlendCoeff == fSrcBlend && dstCoeffIsOne)) {
@@ skipping 17 matching lines @@
                 return GrXferProcessor::kNone_Opt;
             } else if (kZero_GrBlendCoeff == fSrcBlend) {
                 // if the op is "clear" then we don't need to emit a color
                 // or blend, just write transparent black into the dst.
                 fSrcBlend = kOne_GrBlendCoeff;
                 fDstBlend = kZero_GrBlendCoeff;
                 return GrXferProcessor::kIgnoreColor_OptFlag |
                        GrXferProcessor::kIgnoreCoverage_OptFlag;
             }
         }
-    } else if (isCoverageDrawing) {
-        // we have coverage but we aren't distinguishing it from alpha by request.
-        return GrXferProcessor::kSetCoverageDrawing_OptFlag;
-    } else {
+    }  else {
         // check whether coverage can be safely rolled into alpha
         // of if we can skip color computation and just emit coverage
-        if (can_tweak_alpha_for_coverage(fDstBlend, isCoverageDrawing)) {
+        if (can_tweak_alpha_for_coverage(fDstBlend)) {
             return GrXferProcessor::kSetCoverageDrawing_OptFlag;
         }
         if (dstCoeffIsZero) {
             if (kZero_GrBlendCoeff == fSrcBlend) {
                 // the source color is not included in the blend
                 // the dst coeff is effectively zero so blend works out to:
                 // (c)(0)D + (1-c)D = (1-c)D.
                 fDstBlend = kISA_GrBlendCoeff;
                 return GrXferProcessor::kIgnoreColor_OptFlag |
                        GrXferProcessor::kSetCoverageDrawing_OptFlag;
@@ skipping 129 matching lines @@
                                                 uint32_t knownColorFlags) const {
     if (kOne_GrBlendCoeff == fSrcCoeff && kISA_GrBlendCoeff == fDstCoeff &&
         kRGBA_GrColorComponentFlags == knownColorFlags) {
         return true;
     }
     return false;
 }
 
 bool GrPorterDuffXPFactory::canApplyCoverage(const GrProcOptInfo& colorPOI,
                                              const GrProcOptInfo& coveragePOI,
-                                             bool isCoverageDrawing,
                                              bool colorWriteDisabled) const {
-    bool srcAIsOne = colorPOI.isOpaque() && (!isCoverageDrawing || coveragePOI.isOpaque());
+    bool srcAIsOne = colorPOI.isOpaque();
 
     if (colorWriteDisabled) {
         return true;
     }
 
     bool dstCoeffIsOne = kOne_GrBlendCoeff == fDstCoeff ||
                          (kSA_GrBlendCoeff == fDstCoeff && srcAIsOne);
     bool dstCoeffIsZero = kZero_GrBlendCoeff == fDstCoeff ||
                          (kISA_GrBlendCoeff == fDstCoeff && srcAIsOne);
 
     if ((kZero_GrBlendCoeff == fSrcCoeff && dstCoeffIsOne)) {
         return true;
     }
 
     // if we don't have coverage we can check whether the dst
     // has to read at all.
-    if (isCoverageDrawing) {
-        // we have coverage but we aren't distinguishing it from alpha by request.
+    // check whether coverage can be safely rolled into alpha
+    // of if we can skip color computation and just emit coverage
+    if (this->canTweakAlphaForCoverage()) {
         return true;
-    } else {
-        // check whether coverage can be safely rolled into alpha
-        // of if we can skip color computation and just emit coverage
-        if (this->canTweakAlphaForCoverage(isCoverageDrawing)) {
+    }
+    if (dstCoeffIsZero) {
+        if (kZero_GrBlendCoeff == fSrcCoeff) {
             return true;
+        } else if (srcAIsOne) {
+            return  true;
         }
-        if (dstCoeffIsZero) {
-            if (kZero_GrBlendCoeff == fSrcCoeff) {
-                return true;
-            } else if (srcAIsOne) {
-                return  true;
-            }
-        } else if (dstCoeffIsOne) {
-            return true;
-        }
+    } else if (dstCoeffIsOne) {
+        return true;
     }
 
     // TODO: once all SkXferEffects are XP's then we will never reads dst here since only XP's
     // will readDst and PD XP's don't read dst.
     if ((colorPOI.readsDst() || coveragePOI.readsDst()) &&
         kOne_GrBlendCoeff == fSrcCoeff && kZero_GrBlendCoeff == fDstCoeff) {
         return true;
     }
 
     return false;
 }
 
 bool GrPorterDuffXPFactory::willBlendWithDst(const GrProcOptInfo& colorPOI,
                                              const GrProcOptInfo& coveragePOI,
-                                             bool isCoverageDrawing,
                                              bool colorWriteDisabled) const {
-    if (!(isCoverageDrawing || coveragePOI.isSolidWhite())) {
+    if (!coveragePOI.isSolidWhite()) {
         return true;
     }
 
     // TODO: once all SkXferEffects are XP's then we will never reads dst here since only XP's
     // will readDst and PD XP's don't read dst.
     if ((!colorWriteDisabled && colorPOI.readsDst()) || coveragePOI.readsDst()) {
         return true;
     }
 
     if (GrBlendCoeffRefsDst(fSrcCoeff)) {
         return true;
     }
 
-    bool srcAIsOne = colorPOI.isOpaque() && (!isCoverageDrawing || coveragePOI.isOpaque());
+    bool srcAIsOne = colorPOI.isOpaque();
 
     if (!(kZero_GrBlendCoeff == fDstCoeff ||
           (kISA_GrBlendCoeff == fDstCoeff && srcAIsOne))) {
         return true;
     }
 
     return false;
 }
 
-bool GrPorterDuffXPFactory::canTweakAlphaForCoverage(bool isCoverageDrawing) const {
-    return can_tweak_alpha_for_coverage(fDstCoeff, isCoverageDrawing);
+bool GrPorterDuffXPFactory::canTweakAlphaForCoverage() const {
+    return can_tweak_alpha_for_coverage(fDstCoeff);
 }
 
 bool GrPorterDuffXPFactory::getOpaqueAndKnownColor(const GrProcOptInfo& colorPOI,
                                                    const GrProcOptInfo& coveragePOI,
                                                    GrColor* solidColor,
                                                    uint32_t* solidColorKnownComponents) const {
     if (!coveragePOI.isSolidWhite()) {
         return false;
     }
 
@@ skipping 62 matching lines @@
     } while (GrBlendCoeffRefsSrc(src));
 
     GrBlendCoeff dst;
     do {
         dst = GrBlendCoeff(random->nextRangeU(kFirstPublicGrBlendCoeff, kLastPublicGrBlendCoeff));
     } while (GrBlendCoeffRefsDst(dst));
 
     return GrPorterDuffXPFactory::Create(src, dst);
 }