Implement support for mixed sampled render targets

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 "GrDrawTargetCaps.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) {

[Chris Dalton, 2015/03/17 00:39:35]

This looks like the magic function that tells us if coverage modulation will
work :)

     /*
      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.
      */
     return kOne_GrBlendCoeff == dstCoeff ||
@@ skipping 364 matching lines @@
         } 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 (kOne_GrBlendCoeff == fSrcBlend &&
+                !colorPOI.needsCoverageModulation()) {
                 // 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;
                 return GrXferProcessor::kIgnoreColor_OptFlag |
@@ skipping 284 matching lines @@
 GR_DEFINE_XP_FACTORY_TEST(GrPorterDuffXPFactory);
 
 GrXPFactory* GrPorterDuffXPFactory::TestCreate(SkRandom* random,
                                                GrContext*,
                                                const GrDrawTargetCaps&,
                                                GrTexture*[]) {
     SkXfermode::Mode mode = SkXfermode::Mode(random->nextULessThan(SkXfermode::kLastCoeffMode));
     return GrPorterDuffXPFactory::Create(mode);
 }