Implement support for KHR_blend_equation_advanced

src/gpu/effects/GrCustomXfermode.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "effects/GrCustomXfermode.h"
 #include "effects/GrCustomXfermodePriv.h"
 
 #include "GrCoordTransform.h"
 #include "GrContext.h"
 #include "GrFragmentProcessor.h"
 #include "GrInvariantOutput.h"
 #include "GrProcessor.h"
 #include "GrTexture.h"
 #include "GrTextureAccess.h"
 #include "SkXfermode.h"
 #include "gl/GrGLCaps.h"
+#include "gl/GrGLGpu.h"
 #include "gl/GrGLProcessor.h"
 #include "gl/GrGLProgramDataManager.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 
 bool GrCustomXfermode::IsSupportedMode(SkXfermode::Mode mode) {
     return mode > SkXfermode::kLastCoeffMode && mode <= SkXfermode::kLastMode;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Static helpers
@@ skipping 473 matching lines @@
 
     bool hasSecondaryOutput() const override { return false; }
 
     GrXferProcessor::OptFlags getOptimizations(const GrProcOptInfo& colorPOI,
                                                const GrProcOptInfo& coveragePOI,
                                                bool doesStencilWrite,
                                                GrColor* overrideColor,
                                                const GrDrawTargetCaps& caps) override;
 
     SkXfermode::Mode mode() const { return fMode; }
+    bool hasCoverage() const { return fHasCoverage; }
+    bool hasHWBlendEquation() const { return kInvalid_GrBlendEquation != fHWBlendEquation; }
+
+    GrBlendEquation hwBlendEquation() const {
+        SkASSERT(this->hasHWBlendEquation());
+        return fHWBlendEquation;
+    }
 
 private:
     CustomXP(SkXfermode::Mode mode, const GrDeviceCoordTexture* dstCopy, bool willReadDstColor);
 
     void onGetGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override;
 
+    bool onWillNeedXferBarrier(const GrRenderTarget* rt,
+                               const GrDrawTargetCaps& caps,
+                               GrXferBarrierType* outBarrierType) const override;
+
+    void onGetBlendInfo(BlendInfo*) const override;
+
     bool onIsEqual(const GrXferProcessor& xpBase) const override;
 
     SkXfermode::Mode fMode;
+    bool             fHasCoverage;
+    GrBlendEquation  fHWBlendEquation;
 
     typedef GrXferProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrXPFactory* GrCustomXfermode::CreateXPFactory(SkXfermode::Mode mode) {
     if (!GrCustomXfermode::IsSupportedMode(mode)) {
         return NULL;
     } else {
         return SkNEW_ARGS(GrCustomXPFactory, (mode));
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GLCustomXP : public GrGLXferProcessor {
 public:
     GLCustomXP(const GrXferProcessor&) {}
     ~GLCustomXP() override {}
 
-    static void GenKey(const GrXferProcessor& proc, const GrGLSLCaps&, GrProcessorKeyBuilder* b) {
-        uint32_t key = proc.numTextures();
+    static void GenKey(const GrXferProcessor& p, const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) {
+        const CustomXP& xp = p.cast<CustomXP>();
+        uint32_t key = xp.numTextures();
         SkASSERT(key <= 1);
-        key |= proc.cast<CustomXP>().mode() << 1;
+        key |= xp.hasCoverage() << 1;
+        if (!xp.hasHWBlendEquation() || caps.mustEnableAdvancedBlendEquations()) {

[egdaniel, 2015/05/04 19:51:21]

just to confirm, mustEnableAdvBE() means that we need to add the layout
qualifier into the shader right? And the NV version of the extension does not
need this right?

[Chris Dalton, 2015/05/04 20:33:12]

Yes, that's correct. And we need this check because there are drivers that
support NVbea but not KHRbea, meaning a KHRbea layout qualifier would fail to
compile on those platforms. It also makes it so we don't compile new shaders for
every blend equation on NVIDIA.

+            key |= 1 << 2; // Differentiate the shaders that take this branch.
+            key |= xp.hasHWBlendEquation() << 3;
+            key |= xp.mode() << 4;

[egdaniel, 2015/05/04 19:51:21]

When adding the case to switch between all and individual ones we should make
sure that gets put into this key so that we don't build any extra programs when
using all.

[Chris Dalton, 2015/05/05 18:57:58]

Done.

+        }
         b->add32(key);
     }
 
 private:
     void onEmitCode(const EmitArgs& args) override {
-        SkXfermode::Mode mode = args.fXP.cast<CustomXP>().mode();
+        const CustomXP& xp = args.fXP.cast<CustomXP>();
         GrGLXPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
-        const char* dstColor = fsBuilder->dstColor();
 
-        emit_custom_xfermode_code(mode, fsBuilder, args.fOutputPrimary, args.fInputColor, dstColor);
+        if (xp.hasHWBlendEquation()) {
+            // The blend mode will be implemented in hardware; only output the src color.
+            if (args.fPB->gpu()->glCaps().glslCaps()->mustEnableAdvancedBlendEquations()) {
+                fsBuilder->enableAdvancedBlendEquation(xp.hwBlendEquation());
+            }
+            if (xp.hasCoverage()) {
+                // Do coverage modulation by multiplying it into the src color before blending.
+                // (See canTweakAlphaForCoverage())
+                fsBuilder->codeAppendf("%s = %s * %s;",
+                                       args.fOutputPrimary, args.fInputCoverage, args.fInputColor);
+            } else {
+                fsBuilder->codeAppendf("%s = %s;", args.fOutputPrimary, args.fInputColor);
+            }
+        } else {
+            SkXfermode::Mode mode = xp.mode();
+            const char* dstColor = fsBuilder->dstColor();
 
-        fsBuilder->codeAppendf("%s = %s * %s + (vec4(1.0) - %s) * %s;",
-                               args.fOutputPrimary, args.fOutputPrimary, args.fInputCoverage,
-                               args.fInputCoverage, dstColor);
+            emit_custom_xfermode_code(mode, fsBuilder, args.fOutputPrimary, args.fInputColor, dstColor);

[egdaniel, 2015/05/04 19:51:21]

100 chars

[Chris Dalton, 2015/05/04 20:33:12]

Oops :)

[Chris Dalton, 2015/05/05 18:57:58]

Done.

+
+            if (xp.hasCoverage()) {
+                fsBuilder->codeAppendf("%s = %s * %s + (vec4(1.0) - %s) * %s;",
+                                       args.fOutputPrimary, args.fOutputPrimary,
+                                       args.fInputCoverage, args.fInputCoverage, dstColor);
+            }
+        }
     }
 
     void onSetData(const GrGLProgramDataManager&, const GrXferProcessor&) override {}
 
     typedef GrGLFragmentProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 CustomXP::CustomXP(SkXfermode::Mode mode, const GrDeviceCoordTexture* dstCopy,
                    bool willReadDstColor)
-    : INHERITED(dstCopy, willReadDstColor), fMode(mode) {
+    : INHERITED(dstCopy, willReadDstColor),
+      fMode(mode),
+      fHasCoverage(true),
+      fHWBlendEquation(kInvalid_GrBlendEquation) {
     this->initClassID<CustomXP>();
 }
 
 void CustomXP::onGetGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const {
     GLCustomXP::GenKey(*this, caps, b);
 }
 
 GrGLXferProcessor* CustomXP::createGLInstance() const {
+    SkASSERT(this->willReadDstColor() != this->hasHWBlendEquation());
     return SkNEW_ARGS(GLCustomXP, (*this));
 }
 
 bool CustomXP::onIsEqual(const GrXferProcessor& other) const {
     const CustomXP& s = other.cast<CustomXP>();
-    return fMode == s.fMode;
+    return fMode == s.fMode &&
+           fHasCoverage == s.fHasCoverage &&
+           fHWBlendEquation == s.fHWBlendEquation;
 }
 
 GrXferProcessor::OptFlags CustomXP::getOptimizations(const GrProcOptInfo& colorPOI,
                                                        const GrProcOptInfo& coveragePOI,
                                                        bool doesStencilWrite,
                                                        GrColor* overrideColor,
                                                        const GrDrawTargetCaps& caps) {
-   return GrXferProcessor::kNone_Opt;
+    OptFlags flags = kNone_Opt;
+    if (colorPOI.allStagesMultiplyInput()) {
+        flags = flags | kCanTweakAlphaForCoverage_OptFlag;
+    }
+    if (coveragePOI.isSolidWhite()) {
+        flags = flags | kIgnoreCoverage_OptFlag;
+        fHasCoverage = false;
+    }
+    if (caps.advancedBlendEquationSupport() && !coveragePOI.isFourChannelOutput()) {
+        // This blend mode can be implemented in hardware.
+        enum { kOffset = kOverlay_GrBlendEquation - SkXfermode::kOverlay_Mode };
+        fHWBlendEquation = static_cast<GrBlendEquation>(fMode + kOffset);
+
+        GR_STATIC_ASSERT(kOverlay_GrBlendEquation == SkXfermode::kOverlay_Mode + kOffset);
+        GR_STATIC_ASSERT(kDarken_GrBlendEquation == SkXfermode::kDarken_Mode + kOffset);
+        GR_STATIC_ASSERT(kLighten_GrBlendEquation == SkXfermode::kLighten_Mode + kOffset);
+        GR_STATIC_ASSERT(kColorDodge_GrBlendEquation == SkXfermode::kColorDodge_Mode + kOffset);
+        GR_STATIC_ASSERT(kColorBurn_GrBlendEquation == SkXfermode::kColorBurn_Mode + kOffset);
+        GR_STATIC_ASSERT(kHardLight_GrBlendEquation == SkXfermode::kHardLight_Mode + kOffset);
+        GR_STATIC_ASSERT(kSoftLight_GrBlendEquation == SkXfermode::kSoftLight_Mode + kOffset);
+        GR_STATIC_ASSERT(kDifference_GrBlendEquation == SkXfermode::kDifference_Mode + kOffset);
+        GR_STATIC_ASSERT(kExclusion_GrBlendEquation == SkXfermode::kExclusion_Mode + kOffset);
+        GR_STATIC_ASSERT(kMultiply_GrBlendEquation == SkXfermode::kMultiply_Mode + kOffset);
+        GR_STATIC_ASSERT(kHSLHue_GrBlendEquation == SkXfermode::kHue_Mode + kOffset);
+        GR_STATIC_ASSERT(kHSLSaturation_GrBlendEquation == SkXfermode::kSaturation_Mode + kOffset);
+        GR_STATIC_ASSERT(kHSLColor_GrBlendEquation == SkXfermode::kColor_Mode + kOffset);
+        GR_STATIC_ASSERT(kHSLLuminosity_GrBlendEquation == SkXfermode::kLuminosity_Mode + kOffset);
+        GR_STATIC_ASSERT(kTotalGrBlendEquationCount == SkXfermode::kLastMode + 1 + kOffset);
+    }
+    return flags;
+}
+
+bool CustomXP::onWillNeedXferBarrier(const GrRenderTarget* rt,
+                                     const GrDrawTargetCaps& caps,
+                                     GrXferBarrierType* outBarrierType) const {
+    if (this->hasHWBlendEquation() &&
+        GrDrawTargetCaps::kAdvancedCoherent_BlendEquationSupport != caps.blendEquationSupport()) {
+        *outBarrierType = kBlend_GrXferBarrierType;
+        return true;
+    }
+    return false;
+}
+
+void CustomXP::onGetBlendInfo(BlendInfo* blendInfo) const {
+    if (this->hasHWBlendEquation()) {
+        blendInfo->fEquation = this->hwBlendEquation();
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrCustomXPFactory::GrCustomXPFactory(SkXfermode::Mode mode)
     : fMode(mode) {
     this->initClassID<GrCustomXPFactory>();
 }
 
 GrXferProcessor*
 GrCustomXPFactory::onCreateXferProcessor(const GrDrawTargetCaps& caps,
                                          const GrProcOptInfo& colorPOI,
                                          const GrProcOptInfo& coveragePOI,
                                          const GrDeviceCoordTexture* dstCopy) const {
     return CustomXP::Create(fMode, dstCopy, this->willReadDstColor(caps, colorPOI, coveragePOI));
 }
 
+bool GrCustomXPFactory::canTweakAlphaForCoverage() const {

[egdaniel, 2015/05/04 19:51:21]

so we actually just removed this function since with our new batch world we only
looked at the flag returned from getOptimizations. So I guess move this proof
somewhere up there.

[Chris Dalton, 2015/05/05 18:57:58]

Done.

+   /*
+    The general SVG blend equation is defined in the spec as follows:
+
+      Dca' = B(Sc, Dc) * Sa * Da + Y * Sca * (1-Da) + Z * Dca * (1-Sa)
+      Da'  = X * Sa * Da + Y * Sa * (1-Da) + Z * Da * (1-Sa)
+
+    (Note that Sca, Dca indicate RGB vectors that are premultiplied by alpha,
+     and that B(Sc, Dc) is a mode-specific function that accepts non-multiplied
+     RGB colors.)
+
+    For every blend mode supported by this class, i.e. the "advanced" blend
+    modes, X=Y=Z=1 and this equation reduces to the PDF blend equation.
+
+    It can be shown that when X=Y=Z=1, canTweakAlphaForCoverage() is true.
+
+
+    == Color ==
+
+    We substitute Y=Z=1 and define a blend() function that calculates Dca' in
+    terms of premultiplied alpha only:
+
+      blend(Sca, Dca, Sa, Da) = {Dca : if Sa == 0,
+                                 Sca : if Da == 0,
+                                 B(Sca/Sa, Dca/Da) * Sa * Da + Sca * (1-Da) + Dca * (1-Sa) : if Sa,Da != 0}
+
+    And for coverage modulation, we use a post blend src-over model:
+
+      Dca'' = f * blend(Sca, Dca, Sa, Da) + (1-f) * Dca
+
+    (Where f is the fractional coverage.)
+
+    Next we show that canTweakAlphaForCoverage() is true by proving the
+    following relationship:
+
+      blend(f*Sca, Dca, f*Sa, Da) == f * blend(Sca, Dca, Sa, Da) + (1-f) * Dca
+
+    General case (f,Sa,Da != 0):
+
+      f * blend(Sca, Dca, Sa, Da) + (1-f) * Dca
+        = f * (B(Sca/Sa, Dca/Da) * Sa * Da + Sca * (1-Da) + Dca * (1-Sa)) + (1-f) * Dca  [Sa,Da != 0, definition of blend()]
+        = B(Sca/Sa, Dca/Da) * f*Sa * Da + f*Sca * (1-Da) + f*Dca * (1-Sa) + Dca - f*Dca
+        = B(Sca/Sa, Dca/Da) * f*Sa * Da + f*Sca - f*Sca * Da + f*Dca - f*Dca * Sa + Dca - f*Dca
+        = B(Sca/Sa, Dca/Da) * f*Sa * Da + f*Sca - f*Sca * Da - f*Dca * Sa + Dca
+        = B(Sca/Sa, Dca/Da) * f*Sa * Da + f*Sca * (1-Da) - f*Dca * Sa + Dca
+        = B(Sca/Sa, Dca/Da) * f*Sa * Da + f*Sca * (1-Da) + Dca * (1 - f*Sa)
+        = B(f*Sca/f*Sa, Dca/Da) * f*Sa * Da + f*Sca * (1-Da) + Dca * (1 - f*Sa)  [f!=0]
+        = blend(f*Sca, Dca, f*Sa, Da)  [definition of blend()]
+
+    Corner cases (Sa=0, Da=0, and f=0):
+
+      Sa=0: f * blend(Sca, Dca, Sa, Da) + (1-f) * Dca
+              = f * Dca + (1-f) * Dca  [Sa=0, definition of blend()]
+              = Dca
+              = blend(0, Dca, 0, Da)  [definition of blend()]
+              = blend(f*Sca, Dca, f*Sa, Da)  [Sa=0]
+
+      Da=0: f * blend(Sca, Dca, Sa, Da) + (1-f) * Dca
+              = f * Sca + (1-f) * Dca  [Da=0, definition of blend()]
+              = f * Sca  [Da=0]
+              = blend(f*Sca, 0, f*Sa, 0)  [definition of blend()]
+              = blend(f*Sca, Dca, f*Sa, Da)  [Da=0]
+
+      f=0: f * blend(Sca, Dca, Sa, Da) + (1-f) * Dca
+             = Dca  [f=0]
+             = blend(0, Dca, 0, Da)  [definition of blend()]
+             = blend(f*Sca, Dca, f*Sa, Da)  [f=0]
+
+    == Alpha ==
+
+    We substitute X=Y=Z=1 and define a blend() function that calculates Da':
+
+      blend(Sa, Da) = Sa * Da + Sa * (1-Da) + Da * (1-Sa)
+                    = Sa * Da + Sa - Sa * Da + Da - Da * Sa
+                    = Sa + Da - Sa * Da
+
+    We use the same model for coverage modulation as we did with color:
+
+      Da'' = f * blend(Sa, Da) + (1-f) * Da
+
+    And show that canTweakAlphaForCoverage() is true by proving the following
+    relationship:
+
+      blend(f*Sa, Da) == f * blend(Sa, Da) + (1-f) * Da
+
+
+      f * blend(Sa, Da) + (1-f) * Da
+        = f * (Sa + Da - Sa * Da) + (1-f) * Da
+        = f*Sa + f*Da - f*Sa * Da + Da - f*Da
+        = f*Sa - f*Sa * Da + Da
+        = f*Sa + Da - f*Sa * Da
+        = blend(f*Sa, Da)
+   */
+
+    return true;

[egdaniel, 2015/05/04 19:51:21]

so I read through the proof on your first path. Off the top of my head I think
this proof works for the dst copy version as well. Is this true? Does it work
for the dst read if RGB coverage?

[Chris Dalton, 2015/05/04 20:33:12]

Yes, it works for the dst read version because it proves the two formulas are
equivalent. i.e:

  blend(f * S, D) == f * blend(S, D) + (1-f) * D

So you get the same result if you modulate coverage into the src color before
(KHRbea mode), mix it into the dst after (dst read mode), and even if you do
some before and some after.

canTweakAlphaForCoverage() must imply the coverage is scalar, since there is
only one alpha channel, but I suppose we can say this also works for the RGB
coverage version (whatever that means, when there is per-channel coverage and
per-pixel coverage being mixed together ;) ).

Any coverage modulated into alpha will work since it's scalar. And the RGB
coverage will also work even though it's not scalar because the dst read modes
mix it in after the blend.

+}
+
+bool GrCustomXPFactory::willReadDstColor(const GrDrawTargetCaps& caps,
+                                         const GrProcOptInfo& colorPOI,
+                                         const GrProcOptInfo& coveragePOI) const {
+    if (!caps.advancedBlendEquationSupport()) {
+        // No hardware support for advanced blend modes; we will need to do it in the shader.
+        return true;
+    }
+    if (coveragePOI.isFourChannelOutput()) {
+        // Hardware blend modes won't work with RGB coverage. For these modes we multiply coverage
+        // into the src color before the blend, but this only works if coverage is a scalar.
+        return true;
+    }
+    return false;
+}
 
 void GrCustomXPFactory::getInvariantOutput(const GrProcOptInfo& colorPOI,
                                                const GrProcOptInfo& coveragePOI,
                                                GrXPFactory::InvariantOutput* output) const {
     output->fWillBlendWithDst = true;
     output->fBlendedColorFlags = 0;
 }
 
 GR_DEFINE_XP_FACTORY_TEST(GrCustomXPFactory);
 GrXPFactory* GrCustomXPFactory::TestCreate(SkRandom* rand,
                                            GrContext*,
                                            const GrDrawTargetCaps&,
                                            GrTexture*[]) {
     int mode = rand->nextRangeU(SkXfermode::kLastCoeffMode + 1, SkXfermode::kLastSeparableMode);
 
     return SkNEW_ARGS(GrCustomXPFactory, (static_cast<SkXfermode::Mode>(mode)));
 }