Implement support for KHR_blend_equation_advanced

include/gpu/effects/GrAdvancedEquationXferProcessor.h

+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrAdvancedEquationXferProcessor_DEFINED
+#define GrAdvancedEquationXferProcessor_DEFINED
+
+#include "GrTypes.h"
+#include "GrXferProcessor.h"
+
+/**
+ * Provides Xfer processors that implement advanced blend modes in hardware,
+ * without the need for a dst texture. Can only be used if supported by the GPU.
+ */
+class GrAdvancedEquationXPFactory : public GrXPFactory {
+public:
+    static bool IsSupported(const GrContext*, SkXfermode::Mode);
+    static GrXPFactory* Create(const GrContext*, SkXfermode::Mode);
+
+    bool canTweakAlphaForCoverage() const override;
+    bool supportsRGBCoverage(GrColor = 0, uint32_t = 0) const override;
+
+    void getInvariantOutput(const GrProcOptInfo&, const GrProcOptInfo&,
+                            GrXPFactory::InvariantOutput* output) const override {
+        output->fWillBlendWithDst = true;
+        output->fBlendedColorFlags = 0;

[egdaniel, 2015/04/21 18:59:12]

I'm assuming there are cases where these are not always the true? Can we ever
tell what the output color is? Are there cases we don't blend with the dst
color? Any additional information can be beneficial since it may allow us to
apply other optimizations later on. Maybe look at the PorterDuffXPFactory and
some of the things we check there?

[Chris Dalton, 2015/04/21 20:39:31]

The KHR_blend_equation_advanced extension only adds support for the "advanced"
blend modes (the ones that can't be broken down to coefficients, plus screen).
These blend modes all use the dst color, even if the src alpha is 1, so we can't
make any conclusions about the output without knowing something about the dst.
(I copied this implementation from GrCustomXPFactory::getInvariantOutput.)

I'll try and summarize this into a comment.

[egdaniel, 2015/04/21 20:53:49]

Okay that makes sense. Yeah since this is implementing the same functions as
Custom was, of course they should have same known outputs.

+    }
+
+private:
+    template<GrBlendEquation> static GrXPFactory* RefFactory();
+
+    GrAdvancedEquationXPFactory(GrBlendEquation equation);
+    ~GrAdvancedEquationXPFactory() override;
+
+    GrXferProcessor* onCreateXferProcessor(const GrDrawTargetCaps& caps,
+                                           const GrProcOptInfo& colorPOI,
+                                           const GrProcOptInfo& coveragePOI,
+                                           const GrDeviceCoordTexture* dstCopy) const override;
+
+    bool willReadDstColor(const GrDrawTargetCaps&, const GrProcOptInfo&,
+                          const GrProcOptInfo&) const override {
+        return false;
+    }
+
+    bool onIsEqual(const GrXPFactory& xpfBase) const override {
+        const GrAdvancedEquationXPFactory& xpf = xpfBase.cast<GrAdvancedEquationXPFactory>();
+        return fEquation == xpf.fEquation;
+    }
+
+    const GrBlendEquation           fEquation;
+    SkAutoTUnref<GrXferProcessor>   fXferProcessor;
+    SkAutoTUnref<GrXferProcessor>   fXferProcessorWithCoverage;
+
+    GR_DECLARE_XP_FACTORY_TEST;
+
+    typedef GrXPFactory INHERITED;
+};
+
+#endif