added support for PLS path rendering

src/gpu/effects/GrCoverageSetOpXP.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/GrCoverageSetOpXP.h"
 #include "GrCaps.h"
 #include "GrColor.h"
+#include "GrPipeline.h"
 #include "GrProcessor.h"
 #include "GrProcOptInfo.h"
 #include "glsl/GrGLSLBlend.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
 #include "glsl/GrGLSLUniformHandler.h"
 #include "glsl/GrGLSLXferProcessor.h"
 
 class CoverageSetOpXP : public GrXferProcessor {
 public:
     static GrXferProcessor* Create(SkRegion::Op regionOp, bool invertCoverage) {
@@ skipping 122 matching lines @@
     }
     blendInfo->fBlendConstant = 0;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class ShaderCSOXferProcessor : public GrXferProcessor {
 public:
     ShaderCSOXferProcessor(const DstTexture* dstTexture,
                            bool hasMixedSamples,
-                           SkXfermode::Mode xfermode,
                            SkRegion::Op regionOp,
                            bool invertCoverage)
         : INHERITED(dstTexture, true, hasMixedSamples)
         , fRegionOp(regionOp)
         , fInvertCoverage(invertCoverage) {
         this->initClassID<ShaderCSOXferProcessor>();
     }
 
     const char* name() const override { return "Coverage Set Op Shader"; }
 
@@ skipping 138 matching lines @@
                 static GrCoverageSetOpXPFactory gRevDiffCDXPF(regionOp, invertCoverage);
                 return SkRef(&gRevDiffCDXPF);
             }
             break;
         }
         default:
             return nullptr;
     }
 }
 
+bool GrCoverageSetOpXPFactory::willReadDstColor(const GrCaps& caps,
+                                                const GrPipelineOptimizations& optimizations,
+                                                bool hasMixedSamples) const {
+    return optimizations.fOverrides.fUsePLSDstRead;

[egdaniel, 2016/01/13 21:47:19]

I am slightly worried about the need to check PLS in each XPFs willReadDst since
it is not an obvious thing to need to check for if we ever make a new XP.
However it can't really go in the base class since each XP does handle it
slightly different.

Maybe at least on the base class virtual lets add or update the comment to make
it clear the subclass needs to respect the optimizations, specifically pls.

+}
+
 GrXferProcessor*
 GrCoverageSetOpXPFactory::onCreateXferProcessor(const GrCaps& caps,
                                                 const GrPipelineOptimizations& optimizations,
                                                 bool hasMixedSamples,
-                                                const DstTexture* dst) const {
+                                                const DstTexture* dst) const {    

[egdaniel, 2016/01/13 21:47:19]

extra spaces

     // We don't support inverting coverage with mixed samples. We don't expect to ever want this in
     // the future, however we could at some point make this work using an inverted coverage
     // modulation table. Note that an inverted table still won't work if there are coverage procs.
     if (fInvertCoverage && hasMixedSamples) {
         SkASSERT(false);
         return nullptr;
     }
 
+    if (optimizations.fOverrides.fUsePLSDstRead) {
+        return new ShaderCSOXferProcessor(dst, hasMixedSamples, fRegionOp, fInvertCoverage);
+    }
     return CoverageSetOpXP::Create(fRegionOp, fInvertCoverage);
 }
 
 void GrCoverageSetOpXPFactory::getInvariantBlendedColor(const GrProcOptInfo& colorPOI,
                                                         InvariantBlendedColor* blendedColor) const {
     blendedColor->fWillBlendWithDst = SkRegion::kReplace_Op != fRegionOp;
     blendedColor->fKnownColorFlags = kNone_GrColorComponentFlags;
 }
 
 GR_DEFINE_XP_FACTORY_TEST(GrCoverageSetOpXPFactory);
 
 const GrXPFactory* GrCoverageSetOpXPFactory::TestCreate(GrProcessorTestData* d) {
     SkRegion::Op regionOp = SkRegion::Op(d->fRandom->nextULessThan(SkRegion::kLastOp + 1));
     bool invertCoverage = !d->fRenderTarget->hasMixedSamples() && d->fRandom->nextBool();
     return GrCoverageSetOpXPFactory::Create(regionOp, invertCoverage);
 }