diff options
author | Brian Salomon <bsalomon@google.com> | 2017-01-07 09:37:13 -0500 |
---|---|---|
committer | Skia Commit-Bot <skia-commit-bot@chromium.org> | 2017-01-09 15:44:53 +0000 |
commit | a8f80de2bc17672b4b6f26d3cf6b38123ac850c9 (patch) | |
tree | ae254be1a14e5ccaf0e0d8deffc43eff2983b923 /src/gpu/effects | |
parent | c083e4f586831459ef7b8e197a5bee3b189b8511 (diff) |
Removing ref counting from GrXPFactory.
All GrXPFactory instances are static constexpr.
Change-Id: If1086b08534166201e53b3fd9379104e361eb5e6
Reviewed-on: https://skia-review.googlesource.com/6701
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Brian Salomon <bsalomon@google.com>
Diffstat (limited to 'src/gpu/effects')
-rw-r--r-- | src/gpu/effects/GrCoverageSetOpXP.cpp | 82 | ||||
-rw-r--r-- | src/gpu/effects/GrCustomXfermode.cpp | 97 | ||||
-rw-r--r-- | src/gpu/effects/GrDisableColorXP.cpp | 9 | ||||
-rw-r--r-- | src/gpu/effects/GrDisableColorXP.h | 24 | ||||
-rw-r--r-- | src/gpu/effects/GrPorterDuffXferProcessor.cpp | 113 |
5 files changed, 176 insertions, 149 deletions
diff --git a/src/gpu/effects/GrCoverageSetOpXP.cpp b/src/gpu/effects/GrCoverageSetOpXP.cpp index 73adc49d96..5fbd046453 100644 --- a/src/gpu/effects/GrCoverageSetOpXP.cpp +++ b/src/gpu/effects/GrCoverageSetOpXP.cpp @@ -236,77 +236,79 @@ GrGLSLXferProcessor* ShaderCSOXferProcessor::createGLSLInstance() const { /////////////////////////////////////////////////////////////////////////////// // -GrCoverageSetOpXPFactory::GrCoverageSetOpXPFactory(SkRegion::Op regionOp, bool invertCoverage) - : fRegionOp(regionOp) - , fInvertCoverage(invertCoverage) { - this->initClassID<GrCoverageSetOpXPFactory>(); -} +constexpr GrCoverageSetOpXPFactory::GrCoverageSetOpXPFactory(SkRegion::Op regionOp, + bool invertCoverage) + : fRegionOp(regionOp), fInvertCoverage(invertCoverage) {} -sk_sp<GrXPFactory> GrCoverageSetOpXPFactory::Make(SkRegion::Op regionOp, bool invertCoverage) { +const GrXPFactory* GrCoverageSetOpXPFactory::Get(SkRegion::Op regionOp, bool invertCoverage) { switch (regionOp) { case SkRegion::kReplace_Op: { if (invertCoverage) { - static GrCoverageSetOpXPFactory gReplaceCDXPFI(regionOp, invertCoverage); - return sk_sp<GrXPFactory>(SkRef(&gReplaceCDXPFI)); + static constexpr const GrCoverageSetOpXPFactory gReplaceCDXPFI( + SkRegion::kReplace_Op, true); + return &gReplaceCDXPFI; } else { - static GrCoverageSetOpXPFactory gReplaceCDXPF(regionOp, invertCoverage); - return sk_sp<GrXPFactory>(SkRef(&gReplaceCDXPF)); + static constexpr const GrCoverageSetOpXPFactory gReplaceCDXPF(SkRegion::kReplace_Op, + false); + return &gReplaceCDXPF; } - break; } case SkRegion::kIntersect_Op: { if (invertCoverage) { - static GrCoverageSetOpXPFactory gIntersectCDXPFI(regionOp, invertCoverage); - return sk_sp<GrXPFactory>(SkRef(&gIntersectCDXPFI)); + static constexpr const GrCoverageSetOpXPFactory gIntersectCDXPFI( + SkRegion::kIntersect_Op, true); + return &gIntersectCDXPFI; } else { - static GrCoverageSetOpXPFactory gIntersectCDXPF(regionOp, invertCoverage); - return sk_sp<GrXPFactory>(SkRef(&gIntersectCDXPF)); + static constexpr const GrCoverageSetOpXPFactory gIntersectCDXPF( + SkRegion::kIntersect_Op, false); + return &gIntersectCDXPF; } - break; } case SkRegion::kUnion_Op: { if (invertCoverage) { - static GrCoverageSetOpXPFactory gUnionCDXPFI(regionOp, invertCoverage); - return sk_sp<GrXPFactory>(SkRef(&gUnionCDXPFI)); + static constexpr const GrCoverageSetOpXPFactory gUnionCDXPFI(SkRegion::kUnion_Op, + true); + return &gUnionCDXPFI; } else { - static GrCoverageSetOpXPFactory gUnionCDXPF(regionOp, invertCoverage); - return sk_sp<GrXPFactory>(SkRef(&gUnionCDXPF)); + static constexpr const GrCoverageSetOpXPFactory gUnionCDXPF(SkRegion::kUnion_Op, + false); + return &gUnionCDXPF; } - break; } case SkRegion::kXOR_Op: { if (invertCoverage) { - static GrCoverageSetOpXPFactory gXORCDXPFI(regionOp, invertCoverage); - return sk_sp<GrXPFactory>(SkRef(&gXORCDXPFI)); + static constexpr const GrCoverageSetOpXPFactory gXORCDXPFI(SkRegion::kXOR_Op, true); + return &gXORCDXPFI; } else { - static GrCoverageSetOpXPFactory gXORCDXPF(regionOp, invertCoverage); - return sk_sp<GrXPFactory>(SkRef(&gXORCDXPF)); + static constexpr const GrCoverageSetOpXPFactory gXORCDXPF(SkRegion::kXOR_Op, false); + return &gXORCDXPF; } - break; } case SkRegion::kDifference_Op: { if (invertCoverage) { - static GrCoverageSetOpXPFactory gDifferenceCDXPFI(regionOp, invertCoverage); - return sk_sp<GrXPFactory>(SkRef(&gDifferenceCDXPFI)); + static constexpr const GrCoverageSetOpXPFactory gDifferenceCDXPFI( + SkRegion::kDifference_Op, true); + return &gDifferenceCDXPFI; } else { - static GrCoverageSetOpXPFactory gDifferenceCDXPF(regionOp, invertCoverage); - return sk_sp<GrXPFactory>(SkRef(&gDifferenceCDXPF)); + static constexpr const GrCoverageSetOpXPFactory gDifferenceCDXPF( + SkRegion::kDifference_Op, false); + return &gDifferenceCDXPF; } - break; } case SkRegion::kReverseDifference_Op: { if (invertCoverage) { - static GrCoverageSetOpXPFactory gRevDiffCDXPFI(regionOp, invertCoverage); - return sk_sp<GrXPFactory>(SkRef(&gRevDiffCDXPFI)); + static constexpr const GrCoverageSetOpXPFactory gRevDiffCDXPFI( + SkRegion::kReverseDifference_Op, true); + return &gRevDiffCDXPFI; } else { - static GrCoverageSetOpXPFactory gRevDiffCDXPF(regionOp, invertCoverage); - return sk_sp<GrXPFactory>(SkRef(&gRevDiffCDXPF)); + static constexpr const GrCoverageSetOpXPFactory gRevDiffCDXPF( + SkRegion::kReverseDifference_Op, false); + return &gRevDiffCDXPF; } - break; } - default: - return nullptr; } + SkFAIL("Unknown region op."); + return nullptr; } GrXferProcessor* GrCoverageSetOpXPFactory::onCreateXferProcessor(const GrCaps& caps, @@ -335,8 +337,8 @@ void GrCoverageSetOpXPFactory::getInvariantBlendedColor(const GrProcOptInfo& col GR_DEFINE_XP_FACTORY_TEST(GrCoverageSetOpXPFactory); -sk_sp<GrXPFactory> GrCoverageSetOpXPFactory::TestCreate(GrProcessorTestData* d) { +const GrXPFactory* GrCoverageSetOpXPFactory::TestGet(GrProcessorTestData* d) { SkRegion::Op regionOp = SkRegion::Op(d->fRandom->nextULessThan(SkRegion::kLastOp + 1)); bool invertCoverage = !d->fRenderTargetContext->hasMixedSamples() && d->fRandom->nextBool(); - return GrCoverageSetOpXPFactory::Make(regionOp, invertCoverage); + return GrCoverageSetOpXPFactory::Get(regionOp, invertCoverage); } diff --git a/src/gpu/effects/GrCustomXfermode.cpp b/src/gpu/effects/GrCustomXfermode.cpp index 239c3043cd..8d1c5e8d5f 100644 --- a/src/gpu/effects/GrCustomXfermode.cpp +++ b/src/gpu/effects/GrCustomXfermode.cpp @@ -31,25 +31,26 @@ bool GrCustomXfermode::IsSupportedMode(SkBlendMode mode) { // Static helpers /////////////////////////////////////////////////////////////////////////////// -static GrBlendEquation hw_blend_equation(SkBlendMode mode) { - enum { kOffset = kOverlay_GrBlendEquation - (int)SkBlendMode::kOverlay }; - return static_cast<GrBlendEquation>((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 constexpr GrBlendEquation hw_blend_equation(SkBlendMode mode) { +// In C++14 this could be a constexpr int variable. +#define EQ_OFFSET (kOverlay_GrBlendEquation - (int)SkBlendMode::kOverlay) + GR_STATIC_ASSERT(kOverlay_GrBlendEquation == (int)SkBlendMode::kOverlay + EQ_OFFSET); + GR_STATIC_ASSERT(kDarken_GrBlendEquation == (int)SkBlendMode::kDarken + EQ_OFFSET); + GR_STATIC_ASSERT(kLighten_GrBlendEquation == (int)SkBlendMode::kLighten + EQ_OFFSET); + GR_STATIC_ASSERT(kColorDodge_GrBlendEquation == (int)SkBlendMode::kColorDodge + EQ_OFFSET); + GR_STATIC_ASSERT(kColorBurn_GrBlendEquation == (int)SkBlendMode::kColorBurn + EQ_OFFSET); + GR_STATIC_ASSERT(kHardLight_GrBlendEquation == (int)SkBlendMode::kHardLight + EQ_OFFSET); + GR_STATIC_ASSERT(kSoftLight_GrBlendEquation == (int)SkBlendMode::kSoftLight + EQ_OFFSET); + GR_STATIC_ASSERT(kDifference_GrBlendEquation == (int)SkBlendMode::kDifference + EQ_OFFSET); + GR_STATIC_ASSERT(kExclusion_GrBlendEquation == (int)SkBlendMode::kExclusion + EQ_OFFSET); + GR_STATIC_ASSERT(kMultiply_GrBlendEquation == (int)SkBlendMode::kMultiply + EQ_OFFSET); + GR_STATIC_ASSERT(kHSLHue_GrBlendEquation == (int)SkBlendMode::kHue + EQ_OFFSET); + GR_STATIC_ASSERT(kHSLSaturation_GrBlendEquation == (int)SkBlendMode::kSaturation + EQ_OFFSET); + GR_STATIC_ASSERT(kHSLColor_GrBlendEquation == (int)SkBlendMode::kColor + EQ_OFFSET); + GR_STATIC_ASSERT(kHSLLuminosity_GrBlendEquation == (int)SkBlendMode::kLuminosity + EQ_OFFSET); + GR_STATIC_ASSERT(kGrBlendEquationCnt == (int)SkBlendMode::kLastMode + 1 + EQ_OFFSET); + return static_cast<GrBlendEquation>((int)mode + EQ_OFFSET); +#undef EQ_OFFSET } static bool can_use_hw_blend_equation(GrBlendEquation equation, @@ -319,9 +320,16 @@ void CustomXP::onGetBlendInfo(BlendInfo* blendInfo) const { } /////////////////////////////////////////////////////////////////////////////// + +// See the comment above GrXPFactory's definition about this warning suppression. +#if defined(__GNUC__) || defined(__clang) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wnon-virtual-dtor" +#endif class CustomXPFactory : public GrXPFactory { public: - CustomXPFactory(SkBlendMode mode); + constexpr CustomXPFactory(SkBlendMode mode) + : fMode(mode), fHWBlendEquation(hw_blend_equation(mode)) {} void getInvariantBlendedColor(const GrProcOptInfo& colorPOI, GrXPFactory::InvariantBlendedColor*) const override; @@ -334,10 +342,6 @@ private: bool onWillReadDstColor(const GrCaps&, const GrPipelineAnalysis&) const override; - bool onIsEqual(const GrXPFactory& xpfBase) const override { - const CustomXPFactory& xpf = xpfBase.cast<CustomXPFactory>(); - return fMode == xpf.fMode; - } GR_DECLARE_XP_FACTORY_TEST; @@ -346,18 +350,15 @@ private: typedef GrXPFactory INHERITED; }; - -CustomXPFactory::CustomXPFactory(SkBlendMode mode) - : fMode(mode), - fHWBlendEquation(hw_blend_equation(mode)) { - SkASSERT(GrCustomXfermode::IsSupportedMode(fMode)); - this->initClassID<CustomXPFactory>(); -} +#if defined(__GNUC__) || defined(__clang) +#pragma GCC diagnostic pop +#endif GrXferProcessor* CustomXPFactory::onCreateXferProcessor(const GrCaps& caps, const GrPipelineAnalysis& analysis, bool hasMixedSamples, const DstTexture* dstTexture) const { + SkASSERT(GrCustomXfermode::IsSupportedMode(fMode)); if (can_use_hw_blend_equation(fHWBlendEquation, analysis, caps)) { SkASSERT(!dstTexture || !dstTexture->texture()); return new CustomXP(fMode, fHWBlendEquation); @@ -377,16 +378,16 @@ void CustomXPFactory::getInvariantBlendedColor(const GrProcOptInfo& colorPOI, } GR_DEFINE_XP_FACTORY_TEST(CustomXPFactory); -sk_sp<GrXPFactory> CustomXPFactory::TestCreate(GrProcessorTestData* d) { +const GrXPFactory* CustomXPFactory::TestGet(GrProcessorTestData* d) { int mode = d->fRandom->nextRangeU((int)SkBlendMode::kLastCoeffMode + 1, (int)SkBlendMode::kLastSeparableMode); - return sk_sp<GrXPFactory>(new CustomXPFactory(static_cast<SkBlendMode>(mode))); + return GrCustomXfermode::Get((SkBlendMode)mode); } /////////////////////////////////////////////////////////////////////////////// -sk_sp<GrXPFactory> GrCustomXfermode::MakeXPFactory(SkBlendMode mode) { +const GrXPFactory* GrCustomXfermode::Get(SkBlendMode mode) { static CustomXPFactory gOverlay(SkBlendMode::kOverlay); static CustomXPFactory gDarken(SkBlendMode::kDarken); static CustomXPFactory gLighten(SkBlendMode::kLighten); @@ -403,33 +404,33 @@ sk_sp<GrXPFactory> GrCustomXfermode::MakeXPFactory(SkBlendMode mode) { static CustomXPFactory gLuminosity(SkBlendMode::kLuminosity); switch (mode) { case SkBlendMode::kOverlay: - return sk_sp<GrXPFactory>(SkRef(&gOverlay)); + return &gOverlay; case SkBlendMode::kDarken: - return sk_sp<GrXPFactory>(SkRef(&gDarken)); + return &gDarken; case SkBlendMode::kLighten: - return sk_sp<GrXPFactory>(SkRef(&gLighten)); + return &gLighten; case SkBlendMode::kColorDodge: - return sk_sp<GrXPFactory>(SkRef(&gColorDodge)); + return &gColorDodge; case SkBlendMode::kColorBurn: - return sk_sp<GrXPFactory>(SkRef(&gColorBurn)); + return &gColorBurn; case SkBlendMode::kHardLight: - return sk_sp<GrXPFactory>(SkRef(&gHardLight)); + return &gHardLight; case SkBlendMode::kSoftLight: - return sk_sp<GrXPFactory>(SkRef(&gSoftLight)); + return &gSoftLight; case SkBlendMode::kDifference: - return sk_sp<GrXPFactory>(SkRef(&gDifference)); + return &gDifference; case SkBlendMode::kExclusion: - return sk_sp<GrXPFactory>(SkRef(&gExclusion)); + return &gExclusion; case SkBlendMode::kMultiply: - return sk_sp<GrXPFactory>(SkRef(&gMultiply)); + return &gMultiply; case SkBlendMode::kHue: - return sk_sp<GrXPFactory>(SkRef(&gHue)); + return &gHue; case SkBlendMode::kSaturation: - return sk_sp<GrXPFactory>(SkRef(&gSaturation)); + return &gSaturation; case SkBlendMode::kColor: - return sk_sp<GrXPFactory>(SkRef(&gColor)); + return &gColor; case SkBlendMode::kLuminosity: - return sk_sp<GrXPFactory>(SkRef(&gLuminosity)); + return &gLuminosity; default: SkASSERT(!GrCustomXfermode::IsSupportedMode(mode)); return nullptr; diff --git a/src/gpu/effects/GrDisableColorXP.cpp b/src/gpu/effects/GrDisableColorXP.cpp index 0182acc8a6..69c34ecc66 100644 --- a/src/gpu/effects/GrDisableColorXP.cpp +++ b/src/gpu/effects/GrDisableColorXP.cpp @@ -88,11 +88,6 @@ void DisableColorXP::onGetBlendInfo(GrXferProcessor::BlendInfo* blendInfo) const } /////////////////////////////////////////////////////////////////////////////// - -GrDisableColorXPFactory::GrDisableColorXPFactory() { - this->initClassID<GrDisableColorXPFactory>(); -} - GrXferProcessor* GrDisableColorXPFactory::onCreateXferProcessor(const GrCaps& caps, const GrPipelineAnalysis& analysis, bool hasMixedSamples, @@ -103,6 +98,6 @@ GrXferProcessor* GrDisableColorXPFactory::onCreateXferProcessor(const GrCaps& ca GR_DEFINE_XP_FACTORY_TEST(GrDisableColorXPFactory); -sk_sp<GrXPFactory> GrDisableColorXPFactory::TestCreate(GrProcessorTestData*) { - return GrDisableColorXPFactory::Make(); +const GrXPFactory* GrDisableColorXPFactory::TestGet(GrProcessorTestData*) { + return GrDisableColorXPFactory::Get(); } diff --git a/src/gpu/effects/GrDisableColorXP.h b/src/gpu/effects/GrDisableColorXP.h index 49e245949a..38624e05f2 100644 --- a/src/gpu/effects/GrDisableColorXP.h +++ b/src/gpu/effects/GrDisableColorXP.h @@ -14,12 +14,14 @@ class GrProcOptInfo; +// See the comment above GrXPFactory's definition about this warning suppression. +#if defined(__GNUC__) || defined(__clang) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wnon-virtual-dtor" +#endif class GrDisableColorXPFactory : public GrXPFactory { public: - static sk_sp<GrXPFactory> Make() { - static GrDisableColorXPFactory gDisableColorXPFactory; - return sk_sp<GrXPFactory>(SkRef(&gDisableColorXPFactory)); - } + static const GrXPFactory* Get(); void getInvariantBlendedColor(const GrProcOptInfo& colorPOI, GrXPFactory::InvariantBlendedColor* blendedColor) const override { @@ -28,7 +30,7 @@ public: } private: - GrDisableColorXPFactory(); + constexpr GrDisableColorXPFactory() {} GrXferProcessor* onCreateXferProcessor(const GrCaps& caps, const GrPipelineAnalysis&, @@ -39,13 +41,17 @@ private: return false; } - bool onIsEqual(const GrXPFactory& xpfBase) const override { - return true; - } - GR_DECLARE_XP_FACTORY_TEST; typedef GrXPFactory INHERITED; }; +#if defined(__GNUC__) || defined(__clang) +#pragma GCC diagnostic pop +#endif + +inline const GrXPFactory* GrDisableColorXPFactory::Get() { + static constexpr const GrDisableColorXPFactory gDisableColorXPFactory; + return &gDisableColorXPFactory; +} #endif diff --git a/src/gpu/effects/GrPorterDuffXferProcessor.cpp b/src/gpu/effects/GrPorterDuffXferProcessor.cpp index df8b96d374..c8f7160f84 100644 --- a/src/gpu/effects/GrPorterDuffXferProcessor.cpp +++ b/src/gpu/effects/GrPorterDuffXferProcessor.cpp @@ -675,40 +675,63 @@ GrXferProcessor::OptFlags PDLCDXferProcessor::onGetOptimizations(const GrPipelin /////////////////////////////////////////////////////////////////////////////// -GrPorterDuffXPFactory::GrPorterDuffXPFactory(SkBlendMode xfermode) - : fXfermode(xfermode) { - SkASSERT((unsigned)fXfermode <= (unsigned)SkBlendMode::kLastCoeffMode); - this->initClassID<GrPorterDuffXPFactory>(); -} - -sk_sp<GrXPFactory> 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) == (int)SkBlendMode::kLastCoeffMode + 1); - - if ((int)xfermode < 0 || (int)xfermode > (int)SkBlendMode::kLastCoeffMode) { - return nullptr; +constexpr GrPorterDuffXPFactory::GrPorterDuffXPFactory(SkBlendMode xfermode) + : fBlendMode(xfermode) {} + +const GrXPFactory* GrPorterDuffXPFactory::Get(SkBlendMode blendMode) { + SkASSERT((unsigned)blendMode <= (unsigned)SkBlendMode::kLastCoeffMode); + + static constexpr const GrPorterDuffXPFactory gClearPDXPF(SkBlendMode::kClear); + static constexpr const GrPorterDuffXPFactory gSrcPDXPF(SkBlendMode::kSrc); + static constexpr const GrPorterDuffXPFactory gDstPDXPF(SkBlendMode::kDst); + static constexpr const GrPorterDuffXPFactory gSrcOverPDXPF(SkBlendMode::kSrcOver); + static constexpr const GrPorterDuffXPFactory gDstOverPDXPF(SkBlendMode::kDstOver); + static constexpr const GrPorterDuffXPFactory gSrcInPDXPF(SkBlendMode::kSrcIn); + static constexpr const GrPorterDuffXPFactory gDstInPDXPF(SkBlendMode::kDstIn); + static constexpr const GrPorterDuffXPFactory gSrcOutPDXPF(SkBlendMode::kSrcOut); + static constexpr const GrPorterDuffXPFactory gDstOutPDXPF(SkBlendMode::kDstOut); + static constexpr const GrPorterDuffXPFactory gSrcATopPDXPF(SkBlendMode::kSrcATop); + static constexpr const GrPorterDuffXPFactory gDstATopPDXPF(SkBlendMode::kDstATop); + static constexpr const GrPorterDuffXPFactory gXorPDXPF(SkBlendMode::kXor); + static constexpr const GrPorterDuffXPFactory gPlusPDXPF(SkBlendMode::kPlus); + static constexpr const GrPorterDuffXPFactory gModulatePDXPF(SkBlendMode::kModulate); + static constexpr const GrPorterDuffXPFactory gScreenPDXPF(SkBlendMode::kScreen); + + switch (blendMode) { + case SkBlendMode::kClear: + return &gClearPDXPF; + case SkBlendMode::kSrc: + return &gSrcPDXPF; + case SkBlendMode::kDst: + return &gDstPDXPF; + case SkBlendMode::kSrcOver: + return &gSrcOverPDXPF; + case SkBlendMode::kDstOver: + return &gDstOverPDXPF; + case SkBlendMode::kSrcIn: + return &gSrcInPDXPF; + case SkBlendMode::kDstIn: + return &gDstInPDXPF; + case SkBlendMode::kSrcOut: + return &gSrcOutPDXPF; + case SkBlendMode::kDstOut: + return &gDstOutPDXPF; + case SkBlendMode::kSrcATop: + return &gSrcATopPDXPF; + case SkBlendMode::kDstATop: + return &gDstATopPDXPF; + case SkBlendMode::kXor: + return &gXorPDXPF; + case SkBlendMode::kPlus: + return &gPlusPDXPF; + case SkBlendMode::kModulate: + return &gModulatePDXPF; + case SkBlendMode::kScreen: + return &gScreenPDXPF; + default: + SkFAIL("Unexpected blend mode."); + return nullptr; } - return sk_sp<GrXPFactory>(SkRef(gFactories[(int)xfermode])); } GrXferProcessor* GrPorterDuffXPFactory::onCreateXferProcessor(const GrCaps& caps, @@ -716,27 +739,27 @@ GrXferProcessor* GrPorterDuffXPFactory::onCreateXferProcessor(const GrCaps& caps bool hasMixedSamples, const DstTexture* dstTexture) const { if (analysis.fUsesPLSDstRead) { - return new ShaderPDXferProcessor(dstTexture, hasMixedSamples, fXfermode); + return new ShaderPDXferProcessor(dstTexture, hasMixedSamples, fBlendMode); } BlendFormula blendFormula; if (analysis.fCoveragePOI.isFourChannelOutput()) { - if (SkBlendMode::kSrcOver == fXfermode && + if (SkBlendMode::kSrcOver == fBlendMode && kRGBA_GrColorComponentFlags == analysis.fColorPOI.validFlags() && !caps.shaderCaps()->dualSourceBlendingSupport() && !caps.shaderCaps()->dstReadInShaderSupport()) { // If we don't have dual source blending or in shader dst reads, we fall back to this // trick for rendering SrcOver LCD text instead of doing a dst copy. SkASSERT(!dstTexture || !dstTexture->texture()); - return PDLCDXferProcessor::Create(fXfermode, analysis.fColorPOI); + return PDLCDXferProcessor::Create(fBlendMode, analysis.fColorPOI); } - blendFormula = get_lcd_blend_formula(analysis.fCoveragePOI, fXfermode); + blendFormula = get_lcd_blend_formula(analysis.fCoveragePOI, fBlendMode); } else { blendFormula = get_blend_formula(analysis.fColorPOI, analysis.fCoveragePOI, hasMixedSamples, - fXfermode); + fBlendMode); } if (blendFormula.hasSecondaryOutput() && !caps.shaderCaps()->dualSourceBlendingSupport()) { - return new ShaderPDXferProcessor(dstTexture, hasMixedSamples, fXfermode); + return new ShaderPDXferProcessor(dstTexture, hasMixedSamples, fBlendMode); } SkASSERT(!dstTexture || !dstTexture->texture()); @@ -746,7 +769,7 @@ GrXferProcessor* 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][(int)fXfermode]; + BlendFormula colorFormula = gBlendTable[colorPOI.isOpaque()][0][(int)fBlendMode]; if (colorFormula.usesDstColor()) { blendedColor->fWillBlendWithDst = true; blendedColor->fKnownColorFlags = kNone_GrColorComponentFlags; @@ -784,12 +807,12 @@ 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 (analysis.fCoveragePOI.isFourChannelOutput()) { - if (SkBlendMode::kSrcOver == fXfermode && + if (SkBlendMode::kSrcOver == fBlendMode && kRGBA_GrColorComponentFlags == analysis.fColorPOI.validFlags() && !caps.shaderCaps()->dstReadInShaderSupport()) { return false; } - return get_lcd_blend_formula(analysis.fCoveragePOI, fXfermode).hasSecondaryOutput(); + return get_lcd_blend_formula(analysis.fCoveragePOI, fBlendMode).hasSecondaryOutput(); } // We fallback on the shader XP when the blend formula would use dual source blending but we @@ -797,15 +820,15 @@ bool GrPorterDuffXPFactory::onWillReadDstColor(const GrCaps& caps, static const bool kHasMixedSamples = false; SkASSERT(!caps.usesMixedSamples()); // We never use mixed samples without dual source blending. auto formula = get_blend_formula(analysis.fColorPOI, analysis.fCoveragePOI, kHasMixedSamples, - fXfermode); + fBlendMode); return formula.hasSecondaryOutput(); } GR_DEFINE_XP_FACTORY_TEST(GrPorterDuffXPFactory); -sk_sp<GrXPFactory> GrPorterDuffXPFactory::TestCreate(GrProcessorTestData* d) { +const GrXPFactory* GrPorterDuffXPFactory::TestGet(GrProcessorTestData* d) { SkBlendMode mode = SkBlendMode(d->fRandom->nextULessThan((int)SkBlendMode::kLastCoeffMode)); - return GrPorterDuffXPFactory::Make(mode); + return GrPorterDuffXPFactory::Get(mode); } void GrPorterDuffXPFactory::TestGetXPOutputTypes(const GrXferProcessor* xp, |