Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(35)

Unified Diff: src/android/effects/SkPixelXorXfermode.cpp

Issue 1644903004: Revert of Move SkPixelXorXfermode.h to include/client/android (Closed) Base URL: https://skia.googlesource.com/skia.git@master
Patch Set: Created 4 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « include/effects/SkPixelXorXfermode.h ('k') | src/effects/SkPixelXorXfermode.cpp » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: src/android/effects/SkPixelXorXfermode.cpp
diff --git a/src/android/effects/SkPixelXorXfermode.cpp b/src/android/effects/SkPixelXorXfermode.cpp
deleted file mode 100644
index e0ae146dda5886a4e74d14b0a29b4c08245c0c6b..0000000000000000000000000000000000000000
--- a/src/android/effects/SkPixelXorXfermode.cpp
+++ /dev/null
@@ -1,390 +0,0 @@
-/*
- * 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:
- GLPixelXorFP(const PixelXorFP&) {}
-
- ~GLPixelXorFP() override {}
-
- void emitCode(EmitArgs& args) override {
- GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
- SkString dstColor("dstColor");
- this->emitChild(0, nullptr, &dstColor, args);
-
- fOpColorUni = args.fUniformHandler->addUniform(GrGLSLUniformHandler::kFragment_Visibility,
- 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(*this);
-}
-
-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(GrGLSLUniformHandler::kFragment_Visibility,
- 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 willReadDstColor(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));
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-bool SkPixelXorXfermode::asFragmentProcessor(const GrFragmentProcessor** output,
- const GrFragmentProcessor* dst) const {
- if (output) {
- *output = PixelXorFP::Create(fOpColor, dst);
- }
- return true;
-}
-
-bool SkPixelXorXfermode::asXPFactory(GrXPFactory** xpf) const {
- if (xpf) {
- *xpf = GrPixelXorXPFactory::Create(fOpColor);
- }
- return true;
-}
-
-#endif
« no previous file with comments | « include/effects/SkPixelXorXfermode.h ('k') | src/effects/SkPixelXorXfermode.cpp » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698