| /* |
| * Copyright 2011 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "SkPixelXorXfermode.h" |
| #include "SkColorPriv.h" |
| #include "SkReadBuffer.h" |
| #include "SkWriteBuffer.h" |
| #include "SkString.h" |
| |
| // we always return an opaque color, 'cause I don't know what to do with |
| // the alpha-component and still return a valid premultiplied color. |
| SkPMColor SkPixelXorXfermode::xferColor(SkPMColor src, SkPMColor dst) const { |
| SkPMColor res = src ^ dst ^ fOpColor; |
| |
| res |= (SK_A32_MASK << SK_A32_SHIFT); // force it to be opaque |
| return res; |
| } |
| |
| void SkPixelXorXfermode::flatten(SkWriteBuffer& wb) const { |
| wb.writeColor(SkColorSetRGB(SkGetPackedR32(fOpColor), |
| SkGetPackedG32(fOpColor), |
| SkGetPackedB32(fOpColor))); |
| } |
| |
| SkFlattenable* SkPixelXorXfermode::CreateProc(SkReadBuffer& buffer) { |
| return Create(buffer.readColor()); |
| } |
| |
| #ifndef SK_IGNORE_TO_STRING |
| void SkPixelXorXfermode::toString(SkString* str) const { |
| str->append("SkPixelXorXfermode: "); |
| str->appendHex(fOpColor); |
| } |
| #endif |
| |
| #if SK_SUPPORT_GPU |
| #include "GrFragmentProcessor.h" |
| #include "GrInvariantOutput.h" |
| #include "GrXferProcessor.h" |
| |
| #include "glsl/GrGLSLFragmentProcessor.h" |
| #include "glsl/GrGLSLFragmentShaderBuilder.h" |
| #include "glsl/GrGLSLProgramDataManager.h" |
| #include "glsl/GrGLSLUniformHandler.h" |
| #include "glsl/GrGLSLXferProcessor.h" |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Fragment Processor |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| static void add_pixelxor_code(GrGLSLFragmentBuilder* fragBuilder, |
| const char* srcColor, |
| const char* dstColor, |
| const char* outputColor, |
| const char* opColor) { |
| static const GrGLSLShaderVar gXorArgs[] = { |
| GrGLSLShaderVar("f1", kFloat_GrSLType), |
| GrGLSLShaderVar("f2", kFloat_GrSLType), |
| GrGLSLShaderVar("f3", kFloat_GrSLType), |
| GrGLSLShaderVar("fPowerOf2Divisor", kFloat_GrSLType), |
| }; |
| SkString xorFuncName; |
| |
| // The xor function checks if the three passed in floats (f1, f2, f3) would |
| // have a bit in the log2(fPowerOf2Divisor)-th position if they were |
| // represented by an int. It then performs an xor of the 3 bits (using |
| // the property that serial xors can be treated as a sum of 0s & 1s mod 2). |
| fragBuilder->emitFunction(kFloat_GrSLType, |
| "xor", |
| SK_ARRAY_COUNT(gXorArgs), |
| gXorArgs, |
| "float bit1 = floor(f1 / fPowerOf2Divisor);" |
| "float bit2 = floor(f2 / fPowerOf2Divisor);" |
| "float bit3 = floor(f3 / fPowerOf2Divisor);" |
| "return mod(bit1 + bit2 + bit3, 2.0);", |
| &xorFuncName); |
| |
| fragBuilder->codeAppend("float red = 0.0, green = 0.0, blue = 0.0;"); |
| |
| if (srcColor) { |
| fragBuilder->codeAppendf("vec3 src = 255.99 * %s.rgb;", srcColor); |
| } else { |
| fragBuilder->codeAppendf("vec3 src = vec3(255.99);"); |
| } |
| fragBuilder->codeAppendf("vec3 dst = 255.99 * %s.rgb;", dstColor); |
| fragBuilder->codeAppendf("vec3 op = 255.99 * %s;", opColor); |
| |
| fragBuilder->codeAppend("float modValue = 128.0;"); |
| |
| fragBuilder->codeAppend("for (int i = 0; i < 8; i++) {"); |
| |
| fragBuilder->codeAppendf("float bit = %s(src.r, dst.r, op.r, modValue);", xorFuncName.c_str()); |
| fragBuilder->codeAppend("red += modValue * bit;"); |
| fragBuilder->codeAppend("src.r = mod(src.r, modValue);"); |
| fragBuilder->codeAppend("dst.r = mod(dst.r, modValue);"); |
| fragBuilder->codeAppend("op.r = mod(op.r, modValue);"); |
| |
| fragBuilder->codeAppendf("bit = %s(src.g, dst.g, op.g, modValue);", xorFuncName.c_str()); |
| fragBuilder->codeAppend("green += modValue * bit;"); |
| fragBuilder->codeAppend("src.g = mod(src.g, modValue);"); |
| fragBuilder->codeAppend("dst.g = mod(dst.g, modValue);"); |
| fragBuilder->codeAppend("op.g = mod(op.g, modValue);"); |
| |
| fragBuilder->codeAppendf("bit = %s(src.b, dst.b, op.b, modValue);", xorFuncName.c_str()); |
| fragBuilder->codeAppend("blue += modValue * bit;"); |
| fragBuilder->codeAppend("src.b = mod(src.b, modValue);"); |
| fragBuilder->codeAppend("dst.b = mod(dst.b, modValue);"); |
| fragBuilder->codeAppend("op.b = mod(op.b, modValue);"); |
| |
| fragBuilder->codeAppend("modValue /= 2.0;"); |
| |
| fragBuilder->codeAppend("}"); |
| |
| fragBuilder->codeAppendf("%s = vec4(red/255.0, green/255.0, blue/255.0, 1.0);", outputColor); |
| } |
| |
| class GLPixelXorFP; |
| |
| class PixelXorFP : public GrFragmentProcessor { |
| public: |
| static const GrFragmentProcessor* Create(SkPMColor opColor, const GrFragmentProcessor* dst) { |
| return new PixelXorFP(opColor, dst); |
| } |
| |
| ~PixelXorFP() override {}; |
| |
| const char* name() const override { return "PixelXor"; } |
| |
| SkString dumpInfo() const override { |
| SkString str; |
| str.appendf("Color: 0x%08x", fOpColor); |
| return str; |
| } |
| |
| SkPMColor opColor() const { return fOpColor; } |
| |
| private: |
| GrGLSLFragmentProcessor* onCreateGLSLInstance() const override; |
| |
| void onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override; |
| |
| bool onIsEqual(const GrFragmentProcessor& fpBase) const override { |
| const PixelXorFP& fp = fpBase.cast<PixelXorFP>(); |
| return fOpColor == fp.fOpColor; |
| } |
| |
| void onComputeInvariantOutput(GrInvariantOutput* inout) const override { |
| inout->setToUnknown(GrInvariantOutput::kWill_ReadInput); |
| } |
| |
| PixelXorFP(SkPMColor opColor, const GrFragmentProcessor* dst) |
| : fOpColor(opColor) { |
| this->initClassID<PixelXorFP>(); |
| |
| SkASSERT(dst); |
| SkDEBUGCODE(int dstIndex = )this->registerChildProcessor(dst); |
| SkASSERT(0 == dstIndex); |
| } |
| |
| SkPMColor fOpColor; |
| |
| GR_DECLARE_FRAGMENT_PROCESSOR_TEST; |
| typedef GrFragmentProcessor INHERITED; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| class GLPixelXorFP : public GrGLSLFragmentProcessor { |
| public: |
| void emitCode(EmitArgs& args) override { |
| GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder; |
| SkString dstColor("dstColor"); |
| this->emitChild(0, nullptr, &dstColor, args); |
| |
| fOpColorUni = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, |
| kVec3f_GrSLType, kHigh_GrSLPrecision, |
| "opColor"); |
| const char* kOpColorUni = args.fUniformHandler->getUniformCStr(fOpColorUni); |
| |
| add_pixelxor_code(fragBuilder, args.fInputColor, dstColor.c_str(), |
| args.fOutputColor, kOpColorUni); |
| } |
| |
| static void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*) { } |
| |
| protected: |
| void onSetData(const GrGLSLProgramDataManager& pdman, const GrProcessor& proc) override { |
| const PixelXorFP& pixXor = proc.cast<PixelXorFP>(); |
| pdman.set3f(fOpColorUni, |
| SkGetPackedR32(pixXor.opColor())/255.0f, |
| SkGetPackedG32(pixXor.opColor())/255.0f, |
| SkGetPackedB32(pixXor.opColor())/255.0f); |
| } |
| |
| private: |
| GrGLSLProgramDataManager::UniformHandle fOpColorUni; |
| |
| typedef GrGLSLFragmentProcessor INHERITED; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| GrGLSLFragmentProcessor* PixelXorFP::onCreateGLSLInstance() const { |
| return new GLPixelXorFP; |
| } |
| |
| void PixelXorFP::onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const { |
| GLPixelXorFP::GenKey(*this, caps, b); |
| } |
| |
| const GrFragmentProcessor* PixelXorFP::TestCreate(GrProcessorTestData* d) { |
| SkColor color = d->fRandom->nextU(); |
| |
| SkAutoTUnref<const GrFragmentProcessor> dst(GrProcessorUnitTest::CreateChildFP(d)); |
| return new PixelXorFP(SkPreMultiplyColor(color), dst); |
| } |
| |
| GR_DEFINE_FRAGMENT_PROCESSOR_TEST(PixelXorFP); |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Xfer Processor |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| class PixelXorXP : public GrXferProcessor { |
| public: |
| PixelXorXP(const DstTexture* dstTexture, bool hasMixedSamples, SkPMColor opColor) |
| : INHERITED(dstTexture, true, hasMixedSamples) |
| , fOpColor(opColor) { |
| this->initClassID<PixelXorXP>(); |
| } |
| |
| const char* name() const override { return "PixelXor"; } |
| |
| GrGLSLXferProcessor* createGLSLInstance() const override; |
| |
| SkPMColor opColor() const { return fOpColor; } |
| |
| private: |
| GrXferProcessor::OptFlags onGetOptimizations(const GrPipelineOptimizations& optimizations, |
| bool doesStencilWrite, |
| GrColor* overrideColor, |
| const GrCaps& caps) const override { |
| return GrXferProcessor::kNone_OptFlags; |
| } |
| |
| void onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override; |
| |
| bool onIsEqual(const GrXferProcessor& xpBase) const override { |
| const PixelXorXP& xp = xpBase.cast<PixelXorXP>(); |
| |
| return fOpColor == xp.fOpColor; |
| } |
| |
| SkPMColor fOpColor; |
| |
| typedef GrXferProcessor INHERITED; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| class GLPixelXorXP : public GrGLSLXferProcessor { |
| public: |
| GLPixelXorXP(const PixelXorXP& pixelXorXP) { } |
| |
| ~GLPixelXorXP() override {} |
| |
| static void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*) { } |
| |
| private: |
| void emitBlendCodeForDstRead(GrGLSLXPFragmentBuilder* fragBuilder, |
| GrGLSLUniformHandler* uniformHandler, |
| const char* srcColor, |
| const char* srcCoverage, |
| const char* dstColor, |
| const char* outColor, |
| const char* outColorSecondary, |
| const GrXferProcessor& proc) override { |
| fOpColorUni = uniformHandler->addUniform(kFragment_GrShaderFlag, |
| kVec3f_GrSLType, kHigh_GrSLPrecision, |
| "opColor"); |
| const char* kOpColorUni = uniformHandler->getUniformCStr(fOpColorUni); |
| |
| add_pixelxor_code(fragBuilder, srcColor, dstColor, outColor, kOpColorUni); |
| |
| // Apply coverage. |
| INHERITED::DefaultCoverageModulation(fragBuilder, srcCoverage, dstColor, outColor, |
| outColorSecondary, proc); |
| } |
| |
| void onSetData(const GrGLSLProgramDataManager& pdman, |
| const GrXferProcessor& processor) override { |
| const PixelXorXP& pixelXor = processor.cast<PixelXorXP>(); |
| pdman.set3f(fOpColorUni, |
| SkGetPackedR32(pixelXor.opColor())/255.0f, |
| SkGetPackedG32(pixelXor.opColor())/255.0f, |
| SkGetPackedB32(pixelXor.opColor())/255.0f); |
| }; |
| |
| GrGLSLProgramDataManager::UniformHandle fOpColorUni; |
| |
| typedef GrGLSLXferProcessor INHERITED; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| void PixelXorXP::onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const { |
| GLPixelXorXP::GenKey(*this, caps, b); |
| } |
| |
| GrGLSLXferProcessor* PixelXorXP::createGLSLInstance() const { return new GLPixelXorXP(*this); } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| class GrPixelXorXPFactory : public GrXPFactory { |
| public: |
| static GrXPFactory* Create(SkPMColor opColor) { |
| return new GrPixelXorXPFactory(opColor); |
| } |
| |
| void getInvariantBlendedColor(const GrProcOptInfo& colorPOI, |
| GrXPFactory::InvariantBlendedColor* blendedColor) const override { |
| blendedColor->fWillBlendWithDst = true; |
| blendedColor->fKnownColorFlags = kNone_GrColorComponentFlags; |
| } |
| |
| private: |
| GrPixelXorXPFactory(SkPMColor opColor) |
| : fOpColor(opColor) { |
| this->initClassID<GrPixelXorXPFactory>(); |
| } |
| |
| GrXferProcessor* onCreateXferProcessor(const GrCaps& caps, |
| const GrPipelineOptimizations& optimizations, |
| bool hasMixedSamples, |
| const DstTexture* dstTexture) const override { |
| return new PixelXorXP(dstTexture, hasMixedSamples, fOpColor); |
| } |
| |
| bool onWillReadDstColor(const GrCaps& caps, |
| const GrPipelineOptimizations& optimizations, |
| bool hasMixedSamples) const override { |
| return true; |
| } |
| |
| bool onIsEqual(const GrXPFactory& xpfBase) const override { |
| const GrPixelXorXPFactory& xpf = xpfBase.cast<GrPixelXorXPFactory>(); |
| return fOpColor == xpf.fOpColor; |
| } |
| |
| GR_DECLARE_XP_FACTORY_TEST; |
| |
| SkPMColor fOpColor; |
| |
| typedef GrXPFactory INHERITED; |
| }; |
| |
| GR_DEFINE_XP_FACTORY_TEST(GrPixelXorXPFactory); |
| |
| const GrXPFactory* GrPixelXorXPFactory::TestCreate(GrProcessorTestData* d) { |
| SkColor color = d->fRandom->nextU(); |
| |
| return GrPixelXorXPFactory::Create(SkPreMultiplyColor(color)); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| const GrFragmentProcessor* SkPixelXorXfermode::getFragmentProcessorForImageFilter( |
| const GrFragmentProcessor* dst) const { |
| return PixelXorFP::Create(fOpColor, dst); |
| } |
| |
| GrXPFactory* SkPixelXorXfermode::asXPFactory() const { |
| return GrPixelXorXPFactory::Create(fOpColor); |
| } |
| |
| #endif |