Added SkComposeShader GPU implementation

src/core/SkComposeShader.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkComposeShader.h"
@@ skipping 176 matching lines @@
                 }
             }
 
             result += n;
             x += n;
             count -= n;
         } while (count > 0);
     }
 }
 
+#if SK_SUPPORT_GPU
+
+#include "SkGr.h"
+#include "GrProcessor.h"
+#include "gl/GrGLBlend.h"
+#include "gl/builders/GrGLProgramBuilder.h"
+#include "effects/GrConstColorProcessor.h"
+
+/////////////////////////////////////////////////////////////////////
+
+class GrComposeEffect : public GrFragmentProcessor {
+public:
+
+    static GrFragmentProcessor* Create(const GrFragmentProcessor* fpA,
+                                       const GrFragmentProcessor* fpB, SkXfermode::Mode mode) {
+        return SkNEW_ARGS(GrComposeEffect, (fpA, fpB, mode));
+    }
+    const char* name() const override { return "ComposeShader"; }
+    void onGetGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override;
+
+    SkXfermode::Mode getMode() const { return fMode; }
+    int getShaderAChildIndex() const { return fShaderAChildIndex; }
+    int getShaderBChildIndex() const { return fShaderBChildIndex; }
+
+protected:
+    bool onIsEqual(const GrFragmentProcessor&) const override;
+    void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
+
+private:
+    GrComposeEffect(const GrFragmentProcessor* fpA, const GrFragmentProcessor* fpB,
+                    SkXfermode::Mode mode)
+        : fMode(mode) {
+        this->initClassID<GrComposeEffect>();
+        fShaderAChildIndex = this->registerChildProcessor(fpA);

[bsalomon, 2015/08/31 18:51:37]

Maybe just assert that indices are 0 and 1 rather than store them?

[wangyix, 2015/08/31 20:12:31]

Done.

+        fShaderBChildIndex = this->registerChildProcessor(fpB);
+    }
+
+    GrGLFragmentProcessor* onCreateGLInstance() const override;
+
+    int fShaderAChildIndex;
+    int fShaderBChildIndex;
+    SkXfermode::Mode fMode;
+
+    typedef GrFragmentProcessor INHERITED;
+};
+
+/////////////////////////////////////////////////////////////////////
+
+class GrGLComposeEffect : public GrGLFragmentProcessor {
+public:
+    GrGLComposeEffect(const GrProcessor& processor) {
+        const GrComposeEffect& cs = processor.cast<GrComposeEffect>();
+        fShaderAChildIndex = cs.getShaderAChildIndex();
+        fShaderBChildIndex = cs.getShaderBChildIndex();
+        fMode = cs.getMode();
+    }
+
+    void emitCode(EmitArgs&) override;
+
+private:
+    int fShaderAChildIndex;

[bsalomon, 2015/08/31 18:51:37]

Does this guy really need any members? emitCode has access to the
GrComposeEffect that generated the GrGLComposeEffect and can read these values
off it.

[wangyix, 2015/08/31 20:12:31]

Done.

+    int fShaderBChildIndex;
+    SkXfermode::Mode fMode;
+
+    typedef GrGLFragmentProcessor INHERITED;
+};
+
+bool GrComposeEffect::onIsEqual(const GrFragmentProcessor& other) const {
+    const GrComposeEffect& cs = other.cast<GrComposeEffect>();
+    return fMode == cs.fMode;
+}
+
+void GrComposeEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
+    inout->setToUnknown(GrInvariantOutput::kWill_ReadInput);
+}
+
+void GrComposeEffect::onGetGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const {
+    b->add32(fMode);
+}
+
+GrGLFragmentProcessor* GrComposeEffect::onCreateGLInstance() const{
+    return SkNEW_ARGS(GrGLComposeEffect, (*this));
+}
+
+/////////////////////////////////////////////////////////////////////
+
+void GrGLComposeEffect::emitCode(EmitArgs& args) {
+
+    GrGLFragmentBuilder* fsBuilder = args.fBuilder->getFragmentShaderBuilder();
+
+    // Store alpha of input color and un-premultiply the input color by its alpha. We will
+    // re-multiply by this alpha after blending the output colors of the two child procs.
+    // This is because we don't want the paint's alpha to affect either child proc's output
+    // before the blend; we want to apply the paint's alpha AFTER the blend. This mirrors the
+    // software implementation of SkComposeShader.
+    SkString inputAlpha("inputAlpha");
+    fsBuilder->codeAppendf("float %s = %s.a;\n", inputAlpha.c_str(), args.fInputColor);
+    fsBuilder->codeAppendf("%s /= %s.a;\n", args.fInputColor, args.fInputColor);
+
+    // emit the code of the two child shaders
+    SkString mangledOutputColorA;
+    this->emitChild(fShaderAChildIndex, args.fInputColor, &mangledOutputColorA, args);
+    SkString mangledOutputColorB;
+    this->emitChild(fShaderBChildIndex, args.fInputColor, &mangledOutputColorB, args);
+
+    // emit blend code
+    fsBuilder->codeAppend("{\n");
+    fsBuilder->codeAppendf("// Compose Xfer Mode: %s\n", SkXfermode::ModeName(fMode));
+    GrGLBlend::AppendPorterDuffBlend(fsBuilder, mangledOutputColorB.c_str(),
+                                     mangledOutputColorA.c_str(), args.fOutputColor, fMode);
+    fsBuilder->codeAppend("}\n");
+
+    // re-multiply the output color by the input color's alpha
+    fsBuilder->codeAppendf("%s *= %s;\n", args.fOutputColor, inputAlpha.c_str());
+}
+
+/////////////////////////////////////////////////////////////////////
+
+const GrFragmentProcessor* SkComposeShader::asFragmentProcessor(GrContext* context,
+                                                            const SkMatrix& viewM,
+                                                            const SkMatrix* localMatrix,
+                                                            SkFilterQuality fq,
+                                                            GrProcessorDataManager* procDataManager
+                                                            ) const {
+    // Fragment processor will only support coefficient modes. This is because
+    // GrGLBlend::AppendPorterDuffBlend(), which emits the blend code in the shader,
+    // only supports those modes.
+    SkXfermode::Mode mode;
+    if (!(SkXfermode::AsMode(fMode, &mode) && mode <= SkXfermode::kLastCoeffMode)) {
+        return nullptr;
+    }
+
+    switch (mode) {
+        case SkXfermode::kClear_Mode:
+            return GrConstColorProcessor::Create(GrColor_TRANS_BLACK,
+                                                 GrConstColorProcessor::kIgnore_InputMode);
+            break;
+        case SkXfermode::kSrc_Mode:
+            return fShaderB->asFragmentProcessor(context, viewM, localMatrix, fq, procDataManager);
+            break;
+        case SkXfermode::kDst_Mode:
+            return fShaderA->asFragmentProcessor(context, viewM, localMatrix, fq, procDataManager);
+            break;
+        default:
+            SkAutoTUnref<const GrFragmentProcessor> fpA(fShaderA->asFragmentProcessor(context,
+                                                          viewM, localMatrix, fq, procDataManager));
+            if (!fpA.get()) {
+                return nullptr;
+            }
+            SkAutoTUnref<const GrFragmentProcessor> fpB(fShaderB->asFragmentProcessor(context,
+                                                          viewM, localMatrix, fq, procDataManager));
+            if (!fpB.get()) {
+                return nullptr;
+            }
+            return GrComposeEffect::Create(fpA, fpB, mode);
+    }
+}
+#endif
+
 #ifndef SK_IGNORE_TO_STRING
 void SkComposeShader::toString(SkString* str) const {
     str->append("SkComposeShader: (");
 
     str->append("ShaderA: ");
     fShaderA->toString(str);
     str->append(" ShaderB: ");
     fShaderB->toString(str);
     if (fMode) {
         str->append(" Xfermode: ");
         fMode->toString(str);
     }
 
     this->INHERITED::toString(str);
 
     str->append(")");
 }
 #endif