From 7d954ad797176afedb9262fdea4507d0fc60eb9d Mon Sep 17 00:00:00 2001 From: Mike Reed Date: Fri, 28 Oct 2016 15:42:34 -0400 Subject: remove xfermode from public api BUG=skia: GOLD_TRYBOT_URL= https://gold.skia.org/search?issue=4020 CQ_INCLUDE_TRYBOTS=master.client.skia:Test-Ubuntu-GCC-GCE-CPU-AVX2-x86_64-Release-SKNX_NO_SIMD-Trybot Change-Id: I19cd056f2af778f10e8c6c2b7b2735593b43dbac Reviewed-on: https://skia-review.googlesource.com/4020 Reviewed-by: Florin Malita Reviewed-by: Mike Klein Commit-Queue: Mike Reed --- src/gpu/effects/GrCustomXfermode.cpp | 65 +++++++++--------- src/gpu/effects/GrPorterDuffXferProcessor.cpp | 88 ++++++++++++------------- src/gpu/effects/GrXfermodeFragmentProcessor.cpp | 52 +++++++-------- 3 files changed, 103 insertions(+), 102 deletions(-) (limited to 'src/gpu/effects') diff --git a/src/gpu/effects/GrCustomXfermode.cpp b/src/gpu/effects/GrCustomXfermode.cpp index 1b94a6bee1..3895f57f5d 100644 --- a/src/gpu/effects/GrCustomXfermode.cpp +++ b/src/gpu/effects/GrCustomXfermode.cpp @@ -24,33 +24,34 @@ #include "glsl/GrGLSLUniformHandler.h" #include "glsl/GrGLSLXferProcessor.h" -bool GrCustomXfermode::IsSupportedMode(SkXfermode::Mode mode) { - return mode > SkXfermode::kLastCoeffMode && mode <= SkXfermode::kLastMode; +bool GrCustomXfermode::IsSupportedMode(SkBlendMode mode) { + return (int)mode > (int)SkBlendMode::kLastCoeffMode && + (int)mode <= (int)SkBlendMode::kLastMode; } /////////////////////////////////////////////////////////////////////////////// // Static helpers /////////////////////////////////////////////////////////////////////////////// -static GrBlendEquation hw_blend_equation(SkXfermode::Mode mode) { - enum { kOffset = kOverlay_GrBlendEquation - SkXfermode::kOverlay_Mode }; - return static_cast(mode + 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(kGrBlendEquationCnt == SkXfermode::kLastMode + 1 + kOffset); +static GrBlendEquation hw_blend_equation(SkBlendMode mode) { + enum { kOffset = kOverlay_GrBlendEquation - (int)SkBlendMode::kOverlay }; + return static_cast((int)mode + kOffset); + + GR_STATIC_ASSERT(kOverlay_GrBlendEquation == (int)SkBlendMode::kOverlay + kOffset); + GR_STATIC_ASSERT(kDarken_GrBlendEquation == (int)SkBlendMode::kDarken + kOffset); + GR_STATIC_ASSERT(kLighten_GrBlendEquation == (int)SkBlendMode::kLighten + kOffset); + GR_STATIC_ASSERT(kColorDodge_GrBlendEquation == (int)SkBlendMode::kColorDodge + kOffset); + GR_STATIC_ASSERT(kColorBurn_GrBlendEquation == (int)SkBlendMode::kColorBurn + kOffset); + GR_STATIC_ASSERT(kHardLight_GrBlendEquation == (int)SkBlendMode::kHardLight + kOffset); + GR_STATIC_ASSERT(kSoftLight_GrBlendEquation == (int)SkBlendMode::kSoftLight + kOffset); + GR_STATIC_ASSERT(kDifference_GrBlendEquation == (int)SkBlendMode::kDifference + kOffset); + GR_STATIC_ASSERT(kExclusion_GrBlendEquation == (int)SkBlendMode::kExclusion + kOffset); + GR_STATIC_ASSERT(kMultiply_GrBlendEquation == (int)SkBlendMode::kMultiply + kOffset); + GR_STATIC_ASSERT(kHSLHue_GrBlendEquation == (int)SkBlendMode::kHue + kOffset); + GR_STATIC_ASSERT(kHSLSaturation_GrBlendEquation == (int)SkBlendMode::kSaturation + kOffset); + GR_STATIC_ASSERT(kHSLColor_GrBlendEquation == (int)SkBlendMode::kColor + kOffset); + GR_STATIC_ASSERT(kHSLLuminosity_GrBlendEquation == (int)SkBlendMode::kLuminosity + kOffset); + GR_STATIC_ASSERT(kGrBlendEquationCnt == (int)SkBlendMode::kLastMode + 1 + kOffset); } static bool can_use_hw_blend_equation(GrBlendEquation equation, @@ -77,13 +78,13 @@ static bool can_use_hw_blend_equation(GrBlendEquation equation, class CustomXP : public GrXferProcessor { public: - CustomXP(SkXfermode::Mode mode, GrBlendEquation hwBlendEquation) + CustomXP(SkBlendMode mode, GrBlendEquation hwBlendEquation) : fMode(mode), fHWBlendEquation(hwBlendEquation) { this->initClassID(); } - CustomXP(const DstTexture* dstTexture, bool hasMixedSamples, SkXfermode::Mode mode) + CustomXP(const DstTexture* dstTexture, bool hasMixedSamples, SkBlendMode mode) : INHERITED(dstTexture, true, hasMixedSamples), fMode(mode), fHWBlendEquation(static_cast(-1)) { @@ -94,7 +95,7 @@ public: GrGLSLXferProcessor* createGLSLInstance() const override; - SkXfermode::Mode mode() const { return fMode; } + SkBlendMode mode() const { return fMode; } bool hasHWBlendEquation() const { return -1 != static_cast(fHWBlendEquation); } GrBlendEquation hwBlendEquation() const { @@ -116,7 +117,7 @@ private: bool onIsEqual(const GrXferProcessor& xpBase) const override; - const SkXfermode::Mode fMode; + const SkBlendMode fMode; const GrBlendEquation fHWBlendEquation; typedef GrXferProcessor INHERITED; @@ -138,7 +139,7 @@ public: GR_STATIC_ASSERT(GrGLSLCaps::kLast_AdvBlendEqInteraction < 4); } if (!xp.hasHWBlendEquation() || caps.mustEnableSpecificAdvBlendEqs()) { - key |= xp.mode() << 3; + key |= (int)xp.mode() << 3; } b->add32(key); } @@ -326,7 +327,7 @@ void CustomXP::onGetBlendInfo(BlendInfo* blendInfo) const { /////////////////////////////////////////////////////////////////////////////// class CustomXPFactory : public GrXPFactory { public: - CustomXPFactory(SkXfermode::Mode mode); + CustomXPFactory(SkBlendMode mode); void getInvariantBlendedColor(const GrProcOptInfo& colorPOI, GrXPFactory::InvariantBlendedColor*) const override; @@ -346,13 +347,13 @@ private: GR_DECLARE_XP_FACTORY_TEST; - SkXfermode::Mode fMode; - GrBlendEquation fHWBlendEquation; + SkBlendMode fMode; + GrBlendEquation fHWBlendEquation; typedef GrXPFactory INHERITED; }; -CustomXPFactory::CustomXPFactory(SkXfermode::Mode mode) +CustomXPFactory::CustomXPFactory(SkBlendMode mode) : fMode(mode), fHWBlendEquation(hw_blend_equation(mode)) { SkASSERT(GrCustomXfermode::IsSupportedMode(fMode)); @@ -386,12 +387,12 @@ sk_sp CustomXPFactory::TestCreate(GrProcessorTestData* d) { int mode = d->fRandom->nextRangeU(SkXfermode::kLastCoeffMode + 1, SkXfermode::kLastSeparableMode); - return sk_sp(new CustomXPFactory(static_cast(mode))); + return sk_sp(new CustomXPFactory(static_cast(mode))); } /////////////////////////////////////////////////////////////////////////////// -sk_sp GrCustomXfermode::MakeXPFactory(SkXfermode::Mode mode) { +sk_sp GrCustomXfermode::MakeXPFactory(SkBlendMode mode) { if (!GrCustomXfermode::IsSupportedMode(mode)) { return nullptr; } else { diff --git a/src/gpu/effects/GrPorterDuffXferProcessor.cpp b/src/gpu/effects/GrPorterDuffXferProcessor.cpp index f51e94ba82..d511fae45d 100644 --- a/src/gpu/effects/GrPorterDuffXferProcessor.cpp +++ b/src/gpu/effects/GrPorterDuffXferProcessor.cpp @@ -323,20 +323,20 @@ static const BlendFormula gLCDBlendTable[SkXfermode::kLastCoeffMode + 1] = { static BlendFormula get_blend_formula(const GrProcOptInfo& colorPOI, const GrProcOptInfo& coveragePOI, bool hasMixedSamples, - SkXfermode::Mode xfermode) { - SkASSERT(xfermode >= 0 && xfermode <= SkXfermode::kLastCoeffMode); + SkBlendMode xfermode) { + SkASSERT((unsigned)xfermode <= (unsigned)SkBlendMode::kLastCoeffMode); SkASSERT(!coveragePOI.isFourChannelOutput()); bool conflatesCoverage = !coveragePOI.isSolidWhite() || hasMixedSamples; - return gBlendTable[colorPOI.isOpaque()][conflatesCoverage][xfermode]; + return gBlendTable[colorPOI.isOpaque()][conflatesCoverage][(int)xfermode]; } static BlendFormula get_lcd_blend_formula(const GrProcOptInfo& coveragePOI, - SkXfermode::Mode xfermode) { - SkASSERT(xfermode >= 0 && xfermode <= SkXfermode::kLastCoeffMode); + SkBlendMode xfermode) { + SkASSERT((unsigned)xfermode <= (unsigned)SkBlendMode::kLastCoeffMode); SkASSERT(coveragePOI.isFourChannelOutput()); - return gLCDBlendTable[xfermode]; + return gLCDBlendTable[(int)xfermode]; } /////////////////////////////////////////////////////////////////////////////// @@ -506,7 +506,7 @@ class ShaderPDXferProcessor : public GrXferProcessor { public: ShaderPDXferProcessor(const DstTexture* dstTexture, bool hasMixedSamples, - SkXfermode::Mode xfermode) + SkBlendMode xfermode) : INHERITED(dstTexture, true, hasMixedSamples) , fXfermode(xfermode) { this->initClassID(); @@ -516,7 +516,7 @@ public: GrGLSLXferProcessor* createGLSLInstance() const override; - SkXfermode::Mode getXfermode() const { return fXfermode; } + SkBlendMode getXfermode() const { return fXfermode; } private: GrXferProcessor::OptFlags onGetOptimizations(const GrPipelineOptimizations&, bool, GrColor*, @@ -531,7 +531,7 @@ private: return fXfermode == xp.fXfermode; } - const SkXfermode::Mode fXfermode; + const SkBlendMode fXfermode; typedef GrXferProcessor INHERITED; }; @@ -542,7 +542,7 @@ class GLShaderPDXferProcessor : public GrGLSLXferProcessor { public: static void GenKey(const GrProcessor& processor, GrProcessorKeyBuilder* b) { const ShaderPDXferProcessor& xp = processor.cast(); - b->add32(xp.getXfermode()); + b->add32((int)xp.getXfermode()); } private: @@ -583,7 +583,7 @@ GrGLSLXferProcessor* ShaderPDXferProcessor::createGLSLInstance() const { class PDLCDXferProcessor : public GrXferProcessor { public: - static GrXferProcessor* Create(SkXfermode::Mode xfermode, const GrProcOptInfo& colorPOI); + static GrXferProcessor* Create(SkBlendMode xfermode, const GrProcOptInfo& colorPOI); ~PDLCDXferProcessor() override; @@ -654,9 +654,9 @@ PDLCDXferProcessor::PDLCDXferProcessor(GrColor blendConstant, uint8_t alpha) this->initClassID(); } -GrXferProcessor* PDLCDXferProcessor::Create(SkXfermode::Mode xfermode, +GrXferProcessor* PDLCDXferProcessor::Create(SkBlendMode xfermode, const GrProcOptInfo& colorPOI) { - if (SkXfermode::kSrcOver_Mode != xfermode) { + if (SkBlendMode::kSrcOver != xfermode) { return nullptr; } @@ -698,40 +698,40 @@ PDLCDXferProcessor::onGetOptimizations(const GrPipelineOptimizations& optimizati /////////////////////////////////////////////////////////////////////////////// -GrPorterDuffXPFactory::GrPorterDuffXPFactory(SkXfermode::Mode xfermode) +GrPorterDuffXPFactory::GrPorterDuffXPFactory(SkBlendMode xfermode) : fXfermode(xfermode) { - SkASSERT(fXfermode <= SkXfermode::kLastCoeffMode); + SkASSERT((unsigned)fXfermode <= (unsigned)SkBlendMode::kLastCoeffMode); this->initClassID(); } -sk_sp GrPorterDuffXPFactory::Make(SkXfermode::Mode xfermode) { - static GrPorterDuffXPFactory gClearPDXPF(SkXfermode::kClear_Mode); - static GrPorterDuffXPFactory gSrcPDXPF(SkXfermode::kSrc_Mode); - static GrPorterDuffXPFactory gDstPDXPF(SkXfermode::kDst_Mode); - static GrPorterDuffXPFactory gSrcOverPDXPF(SkXfermode::kSrcOver_Mode); - static GrPorterDuffXPFactory gDstOverPDXPF(SkXfermode::kDstOver_Mode); - static GrPorterDuffXPFactory gSrcInPDXPF(SkXfermode::kSrcIn_Mode); - static GrPorterDuffXPFactory gDstInPDXPF(SkXfermode::kDstIn_Mode); - static GrPorterDuffXPFactory gSrcOutPDXPF(SkXfermode::kSrcOut_Mode); - static GrPorterDuffXPFactory gDstOutPDXPF(SkXfermode::kDstOut_Mode); - static GrPorterDuffXPFactory gSrcATopPDXPF(SkXfermode::kSrcATop_Mode); - static GrPorterDuffXPFactory gDstATopPDXPF(SkXfermode::kDstATop_Mode); - static GrPorterDuffXPFactory gXorPDXPF(SkXfermode::kXor_Mode); - static GrPorterDuffXPFactory gPlusPDXPF(SkXfermode::kPlus_Mode); - static GrPorterDuffXPFactory gModulatePDXPF(SkXfermode::kModulate_Mode); - static GrPorterDuffXPFactory gScreenPDXPF(SkXfermode::kScreen_Mode); +sk_sp GrPorterDuffXPFactory::Make(SkBlendMode xfermode) { + static GrPorterDuffXPFactory gClearPDXPF(SkBlendMode::kClear); + static GrPorterDuffXPFactory gSrcPDXPF(SkBlendMode::kSrc); + static GrPorterDuffXPFactory gDstPDXPF(SkBlendMode::kDst); + static GrPorterDuffXPFactory gSrcOverPDXPF(SkBlendMode::kSrcOver); + static GrPorterDuffXPFactory gDstOverPDXPF(SkBlendMode::kDstOver); + static GrPorterDuffXPFactory gSrcInPDXPF(SkBlendMode::kSrcIn); + static GrPorterDuffXPFactory gDstInPDXPF(SkBlendMode::kDstIn); + static GrPorterDuffXPFactory gSrcOutPDXPF(SkBlendMode::kSrcOut); + static GrPorterDuffXPFactory gDstOutPDXPF(SkBlendMode::kDstOut); + static GrPorterDuffXPFactory gSrcATopPDXPF(SkBlendMode::kSrcATop); + static GrPorterDuffXPFactory gDstATopPDXPF(SkBlendMode::kDstATop); + static GrPorterDuffXPFactory gXorPDXPF(SkBlendMode::kXor); + static GrPorterDuffXPFactory gPlusPDXPF(SkBlendMode::kPlus); + static GrPorterDuffXPFactory gModulatePDXPF(SkBlendMode::kModulate); + static GrPorterDuffXPFactory gScreenPDXPF(SkBlendMode::kScreen); static GrPorterDuffXPFactory* gFactories[] = { &gClearPDXPF, &gSrcPDXPF, &gDstPDXPF, &gSrcOverPDXPF, &gDstOverPDXPF, &gSrcInPDXPF, &gDstInPDXPF, &gSrcOutPDXPF, &gDstOutPDXPF, &gSrcATopPDXPF, &gDstATopPDXPF, &gXorPDXPF, &gPlusPDXPF, &gModulatePDXPF, &gScreenPDXPF }; - GR_STATIC_ASSERT(SK_ARRAY_COUNT(gFactories) == SkXfermode::kLastCoeffMode + 1); + GR_STATIC_ASSERT(SK_ARRAY_COUNT(gFactories) == (int)SkBlendMode::kLastCoeffMode + 1); - if (xfermode < 0 || xfermode > SkXfermode::kLastCoeffMode) { + if ((int)xfermode < 0 || (int)xfermode > (int)SkBlendMode::kLastCoeffMode) { return nullptr; } - return sk_sp(SkRef(gFactories[xfermode])); + return sk_sp(SkRef(gFactories[(int)xfermode])); } GrXferProcessor* @@ -744,7 +744,7 @@ GrPorterDuffXPFactory::onCreateXferProcessor(const GrCaps& caps, } BlendFormula blendFormula; if (optimizations.fCoveragePOI.isFourChannelOutput()) { - if (SkXfermode::kSrcOver_Mode == fXfermode && + if (SkBlendMode::kSrcOver == fXfermode && kRGBA_GrColorComponentFlags == optimizations.fColorPOI.validFlags() && !caps.shaderCaps()->dualSourceBlendingSupport() && !caps.shaderCaps()->dstReadInShaderSupport()) { @@ -770,7 +770,7 @@ GrPorterDuffXPFactory::onCreateXferProcessor(const GrCaps& caps, void GrPorterDuffXPFactory::getInvariantBlendedColor(const GrProcOptInfo& colorPOI, InvariantBlendedColor* blendedColor) const { // Find the blended color info based on the formula that does not have coverage. - BlendFormula colorFormula = gBlendTable[colorPOI.isOpaque()][0][fXfermode]; + BlendFormula colorFormula = gBlendTable[colorPOI.isOpaque()][0][(int)fXfermode]; if (colorFormula.usesDstColor()) { blendedColor->fWillBlendWithDst = true; blendedColor->fKnownColorFlags = kNone_GrColorComponentFlags; @@ -808,7 +808,7 @@ bool GrPorterDuffXPFactory::onWillReadDstColor(const GrCaps& caps, // blend. The one exception is when we are using srcover mode and we know the input color into // the XP. if (optimizations.fCoveragePOI.isFourChannelOutput()) { - if (SkXfermode::kSrcOver_Mode == fXfermode && + if (SkBlendMode::kSrcOver == fXfermode && kRGBA_GrColorComponentFlags == optimizations.fColorPOI.validFlags() && !caps.shaderCaps()->dstReadInShaderSupport()) { return false; @@ -827,7 +827,7 @@ bool GrPorterDuffXPFactory::onWillReadDstColor(const GrCaps& caps, GR_DEFINE_XP_FACTORY_TEST(GrPorterDuffXPFactory); sk_sp GrPorterDuffXPFactory::TestCreate(GrProcessorTestData* d) { - SkXfermode::Mode mode = SkXfermode::Mode(d->fRandom->nextULessThan(SkXfermode::kLastCoeffMode)); + SkBlendMode mode = SkBlendMode(d->fRandom->nextULessThan((int)SkBlendMode::kLastCoeffMode)); return GrPorterDuffXPFactory::Make(mode); } @@ -860,7 +860,7 @@ GrXferProcessor* GrPorterDuffXPFactory::CreateSrcOverXferProcessor( bool hasMixedSamples, const GrXferProcessor::DstTexture* dstTexture) { if (optimizations.fOverrides.fUsePLSDstRead) { - return new ShaderPDXferProcessor(dstTexture, hasMixedSamples, SkXfermode::kSrcOver_Mode); + return new ShaderPDXferProcessor(dstTexture, hasMixedSamples, SkBlendMode::kSrcOver); } // We want to not make an xfer processor if possible. Thus for the simple case where we are not @@ -882,13 +882,13 @@ GrXferProcessor* GrPorterDuffXPFactory::CreateSrcOverXferProcessor( // back to this trick for rendering SrcOver LCD text instead of doing a // dst copy. SkASSERT(!dstTexture || !dstTexture->texture()); - return PDLCDXferProcessor::Create(SkXfermode::kSrcOver_Mode, optimizations.fColorPOI); + return PDLCDXferProcessor::Create(SkBlendMode::kSrcOver, optimizations.fColorPOI); } BlendFormula blendFormula; - blendFormula = get_lcd_blend_formula(optimizations.fCoveragePOI, SkXfermode::kSrcOver_Mode); + blendFormula = get_lcd_blend_formula(optimizations.fCoveragePOI, SkBlendMode::kSrcOver); if (blendFormula.hasSecondaryOutput() && !caps.shaderCaps()->dualSourceBlendingSupport()) { - return new ShaderPDXferProcessor(dstTexture, hasMixedSamples, SkXfermode::kSrcOver_Mode); + return new ShaderPDXferProcessor(dstTexture, hasMixedSamples, SkBlendMode::kSrcOver); } SkASSERT(!dstTexture || !dstTexture->texture()); @@ -911,7 +911,7 @@ bool GrPorterDuffXPFactory::SrcOverWillNeedDstTexture(const GrCaps& caps, return false; } return get_lcd_blend_formula(optimizations.fCoveragePOI, - SkXfermode::kSrcOver_Mode).hasSecondaryOutput(); + SkBlendMode::kSrcOver).hasSecondaryOutput(); } // We fallback on the shader XP when the blend formula would use dual source blending but we @@ -919,5 +919,5 @@ bool GrPorterDuffXPFactory::SrcOverWillNeedDstTexture(const GrCaps& caps, static const bool kHasMixedSamples = false; SkASSERT(!caps.usesMixedSamples()); // We never use mixed samples without dual source blending. return get_blend_formula(optimizations.fColorPOI, optimizations.fCoveragePOI, - kHasMixedSamples, SkXfermode::kSrcOver_Mode).hasSecondaryOutput(); + kHasMixedSamples, SkBlendMode::kSrcOver).hasSecondaryOutput(); } diff --git a/src/gpu/effects/GrXfermodeFragmentProcessor.cpp b/src/gpu/effects/GrXfermodeFragmentProcessor.cpp index 935747bccd..0e8e16c0e9 100644 --- a/src/gpu/effects/GrXfermodeFragmentProcessor.cpp +++ b/src/gpu/effects/GrXfermodeFragmentProcessor.cpp @@ -18,7 +18,7 @@ class ComposeTwoFragmentProcessor : public GrFragmentProcessor { public: ComposeTwoFragmentProcessor(sk_sp src, sk_sp dst, - SkXfermode::Mode mode) + SkBlendMode mode) : fMode(mode) { this->initClassID(); SkDEBUGCODE(int shaderAChildIndex = )this->registerChildProcessor(std::move(src)); @@ -30,10 +30,10 @@ public: const char* name() const override { return "ComposeTwo"; } void onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override { - b->add32(fMode); + b->add32((int)fMode); } - SkXfermode::Mode getMode() const { return fMode; } + SkBlendMode getMode() const { return fMode; } protected: bool onIsEqual(const GrFragmentProcessor& other) const override { @@ -48,7 +48,7 @@ protected: private: GrGLSLFragmentProcessor* onCreateGLSLInstance() const override; - SkXfermode::Mode fMode; + SkBlendMode fMode; GR_DECLARE_FRAGMENT_PROCESSOR_TEST; @@ -74,8 +74,8 @@ sk_sp ComposeTwoFragmentProcessor::TestCreate(GrProcessorTe sk_sp fpA(GrProcessorUnitTest::MakeChildFP(d)); sk_sp fpB(GrProcessorUnitTest::MakeChildFP(d)); - SkXfermode::Mode mode = static_cast( - d->fRandom->nextRangeU(0, SkXfermode::kLastMode)); + SkBlendMode mode = static_cast( + d->fRandom->nextRangeU(0, (int)SkBlendMode::kLastMode)); return sk_sp( new ComposeTwoFragmentProcessor(std::move(fpA), std::move(fpB), mode)); } @@ -105,7 +105,7 @@ void GLComposeTwoFragmentProcessor::emitCode(EmitArgs& args) { this->emitChild(1, inputColor, &dstColor, args); // emit blend code - SkXfermode::Mode mode = cs.getMode(); + SkBlendMode mode = cs.getMode(); fragBuilder->codeAppendf("// Compose Xfer Mode: %s\n", SkXfermode::ModeName(mode)); GrGLSLBlend::AppendMode(fragBuilder, srcColor.c_str(), @@ -120,14 +120,14 @@ void GLComposeTwoFragmentProcessor::emitCode(EmitArgs& args) { } sk_sp GrXfermodeFragmentProcessor::MakeFromTwoProcessors( - sk_sp src, sk_sp dst, SkXfermode::Mode mode) { + sk_sp src, sk_sp dst, SkBlendMode mode) { switch (mode) { - case SkXfermode::kClear_Mode: + case SkBlendMode::kClear: return GrConstColorProcessor::Make(GrColor4f::TransparentBlack(), GrConstColorProcessor::kIgnore_InputMode); - case SkXfermode::kSrc_Mode: + case SkBlendMode::kSrc: return src; - case SkXfermode::kDst_Mode: + case SkBlendMode::kDst: return dst; default: return sk_sp( @@ -144,7 +144,7 @@ public: kSrc_Child, }; - ComposeOneFragmentProcessor(sk_sp dst, SkXfermode::Mode mode, Child child) + ComposeOneFragmentProcessor(sk_sp dst, SkBlendMode mode, Child child) : fMode(mode) , fChild(child) { this->initClassID(); @@ -164,11 +164,11 @@ public: } void onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override { - GR_STATIC_ASSERT((SkXfermode::kLastMode & SK_MaxU16) == SkXfermode::kLastMode); - b->add32(fMode | (fChild << 16)); + GR_STATIC_ASSERT(((int)SkBlendMode::kLastMode & SK_MaxU16) == (int)SkBlendMode::kLastMode); + b->add32((int)fMode | (fChild << 16)); } - SkXfermode::Mode mode() const { return fMode; } + SkBlendMode mode() const { return fMode; } Child child() const { return fChild; } @@ -217,8 +217,8 @@ protected: private: GrGLSLFragmentProcessor* onCreateGLSLInstance() const override; - SkXfermode::Mode fMode; - Child fChild; + SkBlendMode fMode; + Child fChild; GR_DECLARE_FRAGMENT_PROCESSOR_TEST; @@ -231,7 +231,7 @@ class GLComposeOneFragmentProcessor : public GrGLSLFragmentProcessor { public: void emitCode(EmitArgs& args) override { GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder; - SkXfermode::Mode mode = args.fFp.cast().mode(); + SkBlendMode mode = args.fFp.cast().mode(); ComposeOneFragmentProcessor::Child child = args.fFp.cast().child(); SkString childColor("child"); @@ -267,8 +267,8 @@ sk_sp ComposeOneFragmentProcessor::TestCreate(GrProcessorTe // For now, we'll prevent either children from being a shader with children to prevent the // possibility of an arbitrarily large tree of procs. sk_sp dst(GrProcessorUnitTest::MakeChildFP(d)); - SkXfermode::Mode mode = static_cast( - d->fRandom->nextRangeU(0, SkXfermode::kLastMode)); + SkBlendMode mode = static_cast( + d->fRandom->nextRangeU(0, (int)SkBlendMode::kLastMode)); ComposeOneFragmentProcessor::Child child = d->fRandom->nextBool() ? ComposeOneFragmentProcessor::kDst_Child : ComposeOneFragmentProcessor::kSrc_Child; @@ -282,12 +282,12 @@ GrGLSLFragmentProcessor* ComposeOneFragmentProcessor::onCreateGLSLInstance() con ////////////////////////////////////////////////////////////////////////////// sk_sp GrXfermodeFragmentProcessor::MakeFromDstProcessor( - sk_sp dst, SkXfermode::Mode mode) { + sk_sp dst, SkBlendMode mode) { switch (mode) { - case SkXfermode::kClear_Mode: + case SkBlendMode::kClear: return GrConstColorProcessor::Make(GrColor4f::TransparentBlack(), GrConstColorProcessor::kIgnore_InputMode); - case SkXfermode::kSrc_Mode: + case SkBlendMode::kSrc: return nullptr; default: return sk_sp( @@ -297,12 +297,12 @@ sk_sp GrXfermodeFragmentProcessor::MakeFromDstProcessor( } sk_sp GrXfermodeFragmentProcessor::MakeFromSrcProcessor( - sk_sp src, SkXfermode::Mode mode) { + sk_sp src, SkBlendMode mode) { switch (mode) { - case SkXfermode::kClear_Mode: + case SkBlendMode::kClear: return GrConstColorProcessor::Make(GrColor4f::TransparentBlack(), GrConstColorProcessor::kIgnore_InputMode); - case SkXfermode::kDst_Mode: + case SkBlendMode::kDst: return nullptr; default: return sk_sp( -- cgit v1.2.3