Apply coverage in XP base class when using dst reads

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 288 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class PorterDuffXferProcessor : public GrXferProcessor {
 public:
     static GrXferProcessor* Create(BlendFormula blendFormula) {
         return SkNEW_ARGS(PorterDuffXferProcessor, (blendFormula));
     }
 
     const char* name() const override { return "Porter Duff"; }
-    bool hasSecondaryOutput() const override { return fBlendFormula.hasSecondaryOutput(); }
 
     GrGLXferProcessor* createGLInstance() const override;
 
     BlendFormula getBlendFormula() const { return fBlendFormula; }
 
 private:
     PorterDuffXferProcessor(BlendFormula blendFormula) : fBlendFormula(blendFormula) {
         this->initClassID<PorterDuffXferProcessor>();
     }
 
     GrXferProcessor::OptFlags onGetOptimizations(const GrProcOptInfo& colorPOI,
                                                  const GrProcOptInfo& coveragePOI,
                                                  bool doesStencilWrite,
                                                  GrColor* overrideColor,
                                                  const GrCaps& caps) override;
 
     void onGetGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override;
 
+    bool onHasSecondaryOutput() const override { return fBlendFormula.hasSecondaryOutput(); }
+
     void onGetBlendInfo(GrXferProcessor::BlendInfo* blendInfo) const override {
         blendInfo->fEquation = fBlendFormula.fBlendEquation;
         blendInfo->fSrcBlend = fBlendFormula.fSrcCoeff;
         blendInfo->fDstBlend = fBlendFormula.fDstCoeff;
         blendInfo->fWriteColor = fBlendFormula.modifiesDst();
     }
 
     bool onIsEqual(const GrXferProcessor& xpBase) const override {
         const PorterDuffXferProcessor& xp = xpBase.cast<PorterDuffXferProcessor>();
         return fBlendFormula == xp.fBlendFormula;
@@ skipping 48 matching lines @@
 public:
     static void GenKey(const GrProcessor& processor, GrProcessorKeyBuilder* b) {
         const PorterDuffXferProcessor& xp = processor.cast<PorterDuffXferProcessor>();
         b->add32(SkToInt(xp.readsCoverage()) |
                  (xp.getBlendFormula().fPrimaryOutputType << 1) |
                  (xp.getBlendFormula().fSecondaryOutputType << 4));
         GR_STATIC_ASSERT(BlendFormula::kLast_OutputType < 8);
     };
 
 private:
-    void onEmitCode(const EmitArgs& args) override {
+    void emitOutputsForBlendState(const EmitArgs& args) override {
         const PorterDuffXferProcessor& xp = args.fXP.cast<PorterDuffXferProcessor>();
         GrGLXPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
 
         BlendFormula blendFormula = xp.getBlendFormula();
         if (blendFormula.hasSecondaryOutput()) {
             append_color_output(xp, fsBuilder, blendFormula.fSecondaryOutputType,
                                 args.fOutputSecondary, args.fInputColor, args.fInputCoverage);
         }
         append_color_output(xp, fsBuilder, blendFormula.fPrimaryOutputType,
                             args.fOutputPrimary, args.fInputColor, args.fInputCoverage);
@@ skipping 45 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class ShaderPDXferProcessor : public GrXferProcessor {
 public:
     static GrXferProcessor* Create(SkXfermode::Mode xfermode, const DstTexture* dstTexture) {
         return SkNEW_ARGS(ShaderPDXferProcessor, (xfermode, dstTexture));
     }
 
     const char* name() const override { return "Porter Duff Shader"; }
-    bool hasSecondaryOutput() const override { return false; }
 
     GrGLXferProcessor* createGLInstance() const override;
 
     SkXfermode::Mode getXfermode() const { return fXfermode; }
 
 private:
     ShaderPDXferProcessor(SkXfermode::Mode xfermode, const DstTexture* dstTexture)
         : INHERITED(dstTexture, true)
         , fXfermode(xfermode) {
         this->initClassID<ShaderPDXferProcessor>();
@@ skipping 63 matching lines @@
 }
 
 class GLShaderPDXferProcessor : public GrGLXferProcessor {
 public:
     static void GenKey(const GrProcessor& processor, GrProcessorKeyBuilder* b) {
         const ShaderPDXferProcessor& xp = processor.cast<ShaderPDXferProcessor>();
         b->add32(xp.getXfermode());
     }
 
 private:
-    void onEmitCode(const EmitArgs& args) override {
-        const ShaderPDXferProcessor& xp = args.fXP.cast<ShaderPDXferProcessor>();
-        GrGLXPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
+    void emitBlendCodeForDstRead(GrGLXPBuilder* pb, const char* srcColor, const char* dstColor,
+                                 const char* outColor, const GrXferProcessor& proc) override {
+        const ShaderPDXferProcessor& xp = proc.cast<ShaderPDXferProcessor>();
+        GrGLXPFragmentBuilder* fsBuilder = pb->getFragmentShaderBuilder();
 
         SkXfermode::Coeff srcCoeff, dstCoeff;
         SkXfermode::ModeAsCoeff(xp.getXfermode(), &srcCoeff, &dstCoeff);
 
-        const char* dstColor = fsBuilder->dstColor();
-
-        fsBuilder->codeAppend("vec4 colorBlend =");
+        fsBuilder->codeAppendf("%s =", outColor);
         // append src blend
-        bool didAppend = append_porterduff_term(fsBuilder, srcCoeff,
-                                                args.fInputColor, args.fInputColor,
-                                                dstColor, false);
+        bool didAppend = append_porterduff_term(fsBuilder, srcCoeff, srcColor, srcColor, dstColor,
+                                                false);
         // append dst blend
-        SkAssertResult(append_porterduff_term(fsBuilder, dstCoeff,
-                                              dstColor, args.fInputColor,
-                                              dstColor, didAppend));
+        SkAssertResult(append_porterduff_term(fsBuilder, dstCoeff, dstColor, srcColor, dstColor,
+                                              didAppend));
         fsBuilder->codeAppend(";");
-
-        fsBuilder->codeAppendf("%s = %s * colorBlend + (vec4(1.0) - %s) * %s;",
-                               args.fOutputPrimary, args.fInputCoverage, args.fInputCoverage,
-                               dstColor);
     }
 
     void onSetData(const GrGLProgramDataManager&, const GrXferProcessor&) override {}
 
     typedef GrGLXferProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void ShaderPDXferProcessor::onGetGLProcessorKey(const GrGLSLCaps&,
@@ skipping 10 matching lines @@
 class PDLCDXferProcessor : public GrXferProcessor {
 public:
     static GrXferProcessor* Create(SkXfermode::Mode xfermode, const GrProcOptInfo& colorPOI);
 
     ~PDLCDXferProcessor() override;
 
     const char* name() const override { return "Porter Duff LCD"; }
 
     GrGLXferProcessor* createGLInstance() const override;
 
-    bool hasSecondaryOutput() const override { return false; }
-
 private:
     PDLCDXferProcessor(GrColor blendConstant, uint8_t alpha);
 
     GrXferProcessor::OptFlags onGetOptimizations(const GrProcOptInfo& colorPOI,
                                                  const GrProcOptInfo& coveragePOI,
                                                  bool doesStencilWrite,
                                                  GrColor* overrideColor,
                                                  const GrCaps& caps) override;
 
     void onGetGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override;
@@ skipping 24 matching lines @@
 class GLPDLCDXferProcessor : public GrGLXferProcessor {
 public:
     GLPDLCDXferProcessor(const GrProcessor&) {}
 
     virtual ~GLPDLCDXferProcessor() {}
 
     static void GenKey(const GrProcessor& processor, const GrGLSLCaps& caps,
                        GrProcessorKeyBuilder* b) {}
 
 private:
-    void onEmitCode(const EmitArgs& args) override {
+    void emitOutputsForBlendState(const EmitArgs& args) override {
         GrGLXPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
 
         fsBuilder->codeAppendf("%s = %s * %s;", args.fOutputPrimary, args.fInputColor,
                                args.fInputCoverage);
     }
 
     void onSetData(const GrGLProgramDataManager&, const GrXferProcessor&) override {};
 
     typedef GrGLXferProcessor INHERITED;
 };
@@ skipping 174 matching lines @@
                                                  int* outSecondary) {
     if (!!strcmp(xp->name(), "Porter Duff")) {
         *outPrimary = *outSecondary = -1;
         return;
     }
     BlendFormula blendFormula = static_cast<const PorterDuffXferProcessor*>(xp)->getBlendFormula();
     *outPrimary = blendFormula.fPrimaryOutputType;
     *outSecondary = blendFormula.fSecondaryOutputType;
 }