Draft change to start pulling uniform color into GP

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"
@@ skipping 48 matching lines @@
                 case GrPorterDuffXferProcessor::kCoverageISC_SecondaryOutputType:
                     fsBuilder->codeAppendf("%s = (vec4(1.0) - %s) * %s;",
                                            args.fOutputSecondary, args.fInputColor,
                                            args.fInputCoverage);
                     break;
                 default:
                     SkFAIL("Unexpected Secondary Output");
             }
         }
         
-        fsBuilder->codeAppendf("%s = %s * %s;", args.fOutputPrimary, args.fInputColor,
-                               args.fInputCoverage);
-        if (GrPorterDuffXferProcessor::kCombineWithDst_PrimaryOutputType == xp.primaryOutputType()){
-            fsBuilder->codeAppendf("%s += (vec4(1.0) - %s) * %s;", args.fOutputPrimary,
-                                   args.fInputCoverage, fsBuilder->dstColor());
+        switch (xp.primaryOutputType()) {
+            case GrPorterDuffXferProcessor::kNone_PrimaryOutputType:
+                fsBuilder->codeAppendf("%s = vec4(0);", args.fOutputPrimary);
+                break;
+            case GrPorterDuffXferProcessor::kColor_PrimaryOutputType:
+                fsBuilder->codeAppendf("%s = %s;", args.fOutputPrimary, args.fInputColor);
+                break;
+            case GrPorterDuffXferProcessor::kCoverage_PrimaryOutputType:
+                fsBuilder->codeAppendf("%s = %s;", args.fOutputPrimary, args.fInputCoverage);
+                break;
+            case GrPorterDuffXferProcessor::kModulate_PrimaryOutputType:
+            case GrPorterDuffXferProcessor::kCombineWithDst_PrimaryOutputType:
+                fsBuilder->codeAppendf("%s = %s * %s;", args.fOutputPrimary, args.fInputColor,
+                                       args.fInputCoverage);
+                if (GrPorterDuffXferProcessor::kCombineWithDst_PrimaryOutputType ==
+                    xp.primaryOutputType()){
+                    fsBuilder->codeAppendf("%s += (vec4(1.0) - %s) * %s;", args.fOutputPrimary,
+                                           args.fInputCoverage, fsBuilder->dstColor());
+                }
+                break;
+            default:
+                SkFAIL("Unexpected Primary Output");
         }
     }
 
     virtual void setData(const GrGLProgramDataManager&, const GrXferProcessor&) SK_OVERRIDE {};
 
     static void GenKey(const GrProcessor& processor, const GrGLCaps& caps,
                        GrProcessorKeyBuilder* b) {
         const GrPorterDuffXferProcessor& xp = processor.cast<GrPorterDuffXferProcessor>();
         b->add32(xp.primaryOutputType());
         b->add32(xp.secondaryOutputType());
@@ skipping 31 matching lines @@
     inout->setToUnknown(GrInvariantOutput::kWill_ReadInput);
 }
 
 GrXferProcessor::OptFlags
 GrPorterDuffXferProcessor::getOptimizations(const GrProcOptInfo& colorPOI,
                                             const GrProcOptInfo& coveragePOI,
                                             bool isCoverageDrawing,
                                             bool colorWriteDisabled,
                                             bool doesStencilWrite,
                                             GrColor* overrideColor,
-                                            uint8_t* overrideCoverage,
                                             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,
-                                                  overrideColor,
-                                                  overrideCoverage);
+                                                  doesStencilWrite);
     }
     this->calcOutputTypes(optFlags, caps, isCoverageDrawing || 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;
+            return;
+        } else {
+            fPrimaryOutputType = kCoverage_PrimaryOutputType;
+            return;
+        }
+    } else if (optFlags & kIgnoreCoverage_OptFlag) {
+        fPrimaryOutputType = kColor_PrimaryOutputType;
+        return;
+    }
+
     // 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.
     if (!(optFlags & kSetCoverageDrawing_OptFlag) && !hasSolidCoverage) {
         if (caps.dualSourceBlendingSupport()) {
             if (kZero_GrBlendCoeff == fDstBlend) {
                 // write the coverage value to second color
                 fSecondaryOutputType = kCoverage_SecondaryOutputType;
                 fDstBlend = (GrBlendCoeff)GrGpu::kIS2C_GrBlendCoeff;
@@ skipping 12 matching lines @@
             fPrimaryOutputType = kCombineWithDst_PrimaryOutputType;
         }
     }
 }
 
 GrXferProcessor::OptFlags
 GrPorterDuffXferProcessor::internalGetOptimizations(const GrProcOptInfo& colorPOI,
                                                     const GrProcOptInfo& coveragePOI,
                                                     bool isCoverageDrawing,
                                                     bool colorWriteDisabled,
-                                                    bool doesStencilWrite,
-                                                    GrColor* overrideColor,
-                                                    uint8_t* overrideCoverage) {
+                                                    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();
     }
 
     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)) {
         if (doesStencilWrite) {
-            *overrideColor = 0xffffffff;
-            return GrXferProcessor::kClearColorStages_OptFlag |
+            return GrXferProcessor::kIgnoreColor_OptFlag |
                    GrXferProcessor::kSetCoverageDrawing_OptFlag;
         } else {
             fDstBlend = kOne_GrBlendCoeff;
             return GrXferProcessor::kSkipDraw_OptFlag;
         }
     }
 
     // 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 == fSrcBlend) {
                 // 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
                 fDstBlend = kZero_GrBlendCoeff;
                 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;
-                *overrideColor = 0;
-                *overrideCoverage = 0xff;
-                return GrXferProcessor::kClearColorStages_OptFlag |
-                       GrXferProcessor::kClearCoverageStages_OptFlag;
+                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 {
         // 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)) {
             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;
-                *overrideColor = 0xffffffff;
-                return GrXferProcessor::kClearColorStages_OptFlag |
+                return GrXferProcessor::kIgnoreColor_OptFlag |
                        GrXferProcessor::kSetCoverageDrawing_OptFlag;
             } else if (srcAIsOne) {
                 // the dst coeff is effectively zero so blend works out to:
                 // cS + (c)(0)D + (1-c)D = cS + (1-c)D.
                 // If Sa is 1 then we can replace Sa with c
                 // and set dst coeff to 1-Sa.
                 fDstBlend = kISA_GrBlendCoeff;
                 return GrXferProcessor::kSetCoverageDrawing_OptFlag;
             }
         } else if (dstCoeffIsOne) {
@@ skipping 281 matching lines @@
     } while (GrBlendCoeffRefsSrc(src));
 
     GrBlendCoeff dst;
     do {
         dst = GrBlendCoeff(random->nextRangeU(kFirstPublicGrBlendCoeff, kLastPublicGrBlendCoeff));
     } while (GrBlendCoeffRefsDst(dst));
 
     return GrPorterDuffXPFactory::Create(src, dst);
 }