Refugee from Dead Machine 4: MDB Monster

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 323 matching lines @@
     SkASSERT(xfermode >= 0 && xfermode <= SkXfermode::kLastCoeffMode);
     SkASSERT(coveragePOI.isFourChannelOutput());
 
     return gLCDBlendTable[xfermode];
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class PorterDuffXferProcessor : public GrXferProcessor {
 public:
-    PorterDuffXferProcessor(BlendFormula blendFormula) : fBlendFormula(blendFormula) {
+    PorterDuffXferProcessor(BlendFormula blendFormula, GrRenderTarget* dst) : INHERITED(dst), fBlendFormula(blendFormula) {
         this->initClassID<PorterDuffXferProcessor>();
     }
 
     const char* name() const override { return "Porter Duff"; }
 
     GrGLXferProcessor* createGLInstance() const override;
 
     BlendFormula getBlendFormula() const { return fBlendFormula; }
 
 private:
@@ skipping 117 matching lines @@
 PorterDuffXferProcessor::onGetOptimizations(const GrProcOptInfo& colorPOI,
                                             const GrProcOptInfo& coveragePOI,
                                             bool doesStencilWrite,
                                             GrColor* overrideColor,
                                             const GrCaps& caps) {
     GrXferProcessor::OptFlags optFlags = GrXferProcessor::kNone_OptFlags;
     if (!fBlendFormula.modifiesDst()) {
         if (!doesStencilWrite) {
             optFlags |= GrXferProcessor::kSkipDraw_OptFlag;
         }
-        optFlags |= (GrXferProcessor::kIgnoreColor_OptFlag |
-                     GrXferProcessor::kIgnoreCoverage_OptFlag |
+        optFlags |= (//GrXferProcessor::kIgnoreColor_OptFlag |
+                     //GrXferProcessor::kIgnoreCoverage_OptFlag |
                      GrXferProcessor::kCanTweakAlphaForCoverage_OptFlag);
     } else {
         if (!fBlendFormula.usesInputColor()) {
-            optFlags |= GrXferProcessor::kIgnoreColor_OptFlag;
+            // This optimization winds up having the texture access counted
+            // but the pipe-line access not - this is good but messes up the asserts
+            //optFlags |= GrXferProcessor::kIgnoreColor_OptFlag;
         }
         if (coveragePOI.isSolidWhite()) {
-            optFlags |= GrXferProcessor::kIgnoreCoverage_OptFlag;
+            //optFlags |= GrXferProcessor::kIgnoreCoverage_OptFlag;
         }
         if (colorPOI.allStagesMultiplyInput() &&
             fBlendFormula.canTweakAlphaForCoverage() &&
             !coveragePOI.isFourChannelOutput()) {
             optFlags |= GrXferProcessor::kCanTweakAlphaForCoverage_OptFlag;
         }
     }
     return optFlags;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class ShaderPDXferProcessor : public GrXferProcessor {
 public:
     ShaderPDXferProcessor(const DstTexture* dstTexture,
                           bool hasMixedSamples,
-                          SkXfermode::Mode xfermode)
-        : INHERITED(dstTexture, true, hasMixedSamples)
+                          SkXfermode::Mode xfermode, GrRenderTarget* dst)
+        : INHERITED(dstTexture, true, hasMixedSamples, dst)
         , fXfermode(xfermode) {
         this->initClassID<ShaderPDXferProcessor>();
     }
 
     const char* name() const override { return "Porter Duff Shader"; }
 
     GrGLXferProcessor* createGLInstance() const override;
 
     SkXfermode::Mode getXfermode() const { return fXfermode; }
 
@@ skipping 46 matching lines @@
 }
 
 GrGLXferProcessor* ShaderPDXferProcessor::createGLInstance() const {
     return new GLShaderPDXferProcessor;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class PDLCDXferProcessor : public GrXferProcessor {
 public:
-    static GrXferProcessor* Create(SkXfermode::Mode xfermode, const GrProcOptInfo& colorPOI);
+    static GrXferProcessor* Create(SkXfermode::Mode xfermode, const GrProcOptInfo& colorPOI, GrRenderTarget* dst);
 
     ~PDLCDXferProcessor() override;
 
     const char* name() const override { return "Porter Duff LCD"; }
 
     GrGLXferProcessor* createGLInstance() const override;
 
 private:
-    PDLCDXferProcessor(GrColor blendConstant, uint8_t alpha);
+    PDLCDXferProcessor(GrColor blendConstant, uint8_t alpha, GrRenderTarget* dst);
 
     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;
 
     void onGetBlendInfo(GrXferProcessor::BlendInfo* blendInfo) const override {
@@ skipping 35 matching lines @@
                                args.fInputCoverage);
     }
 
     void onSetData(const GrGLSLProgramDataManager&, const GrXferProcessor&) override {};
 
     typedef GrGLXferProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
-PDLCDXferProcessor::PDLCDXferProcessor(GrColor blendConstant, uint8_t alpha)
-    : fBlendConstant(blendConstant)
+PDLCDXferProcessor::PDLCDXferProcessor(GrColor blendConstant, uint8_t alpha, GrRenderTarget* dst)
+    : INHERITED(dst), fBlendConstant(blendConstant)
     , fAlpha(alpha) {
     this->initClassID<PDLCDXferProcessor>();
 }
 
 GrXferProcessor* PDLCDXferProcessor::Create(SkXfermode::Mode xfermode,
-                                            const GrProcOptInfo& colorPOI) {
+                                            const GrProcOptInfo& colorPOI, GrRenderTarget* dst) {
     if (SkXfermode::kSrcOver_Mode != xfermode) {
         return nullptr;
     }
 
     if (kRGBA_GrColorComponentFlags != colorPOI.validFlags()) {
         return nullptr;
     }
 
     GrColor blendConstant = GrUnpremulColor(colorPOI.color());
     uint8_t alpha = GrColorUnpackA(blendConstant);
     blendConstant |= (0xff << GrColor_SHIFT_A);
 
-    return new PDLCDXferProcessor(blendConstant, alpha);
+    return new PDLCDXferProcessor(blendConstant, alpha, dst);
 }
 
 PDLCDXferProcessor::~PDLCDXferProcessor() {
 }
 
 void PDLCDXferProcessor::onGetGLProcessorKey(const GrGLSLCaps& caps,
                                              GrProcessorKeyBuilder* b) const {
     GLPDLCDXferProcessor::GenKey(*this, caps, b);
 }
 
@@ skipping 51 matching lines @@
         return nullptr;
     }
     return SkRef(gFactories[xfermode]);
 }
 
 GrXferProcessor*
 GrPorterDuffXPFactory::onCreateXferProcessor(const GrCaps& caps,
                                              const GrProcOptInfo& colorPOI,
                                              const GrProcOptInfo& covPOI,
                                              bool hasMixedSamples,
-                                             const DstTexture* dstTexture) const {
+                                             const DstTexture* dstTexture, GrRenderTarget* dst) const {
     BlendFormula blendFormula;
     if (covPOI.isFourChannelOutput()) {
         if (SkXfermode::kSrcOver_Mode == fXfermode &&
             kRGBA_GrColorComponentFlags == colorPOI.validFlags() &&
             !caps.shaderCaps()->dualSourceBlendingSupport() &&
             !caps.shaderCaps()->dstReadInShaderSupport()) {
             // If we don't have dual source blending or in shader dst reads, we fall back to this
             // trick for rendering SrcOver LCD text instead of doing a dst copy.
             SkASSERT(!dstTexture || !dstTexture->texture());
-            return PDLCDXferProcessor::Create(fXfermode, colorPOI);
+            return PDLCDXferProcessor::Create(fXfermode, colorPOI, dst);
         }
         blendFormula = get_lcd_blend_formula(covPOI, fXfermode);
     } else {
         blendFormula = get_blend_formula(colorPOI, covPOI, hasMixedSamples, fXfermode);
     }
 
     if (blendFormula.hasSecondaryOutput() && !caps.shaderCaps()->dualSourceBlendingSupport()) {
-        return new ShaderPDXferProcessor(dstTexture, hasMixedSamples, fXfermode);
+        return new ShaderPDXferProcessor(dstTexture, hasMixedSamples, fXfermode, dst);
     }
 
     SkASSERT(!dstTexture || !dstTexture->texture());
-    return new PorterDuffXferProcessor(blendFormula);
+    return new PorterDuffXferProcessor(blendFormula, dst);
 }
 
 void GrPorterDuffXPFactory::getInvariantBlendedColor(const GrProcOptInfo& colorPOI,
                                                      InvariantBlendedColor* blendedColor) const {
     // Find the blended color info based on the formula that does not have coverage.
     BlendFormula colorFormula = gBlendTable[colorPOI.isOpaque()][0][fXfermode];
     if (colorFormula.usesDstColor()) {
         blendedColor->fWillBlendWithDst = true;
         blendedColor->fKnownColorFlags = kNone_GrColorComponentFlags;
         return;
@@ skipping 55 matching lines @@
                                                  int* outPrimary,
                                                  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;
 }