diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/core/SkBlendMode.cpp | 104 | ||||
| -rw-r--r-- | src/core/SkBlendModePriv.h | 16 | ||||
| -rw-r--r-- | src/core/SkValidationUtils.h | 6 | ||||
| -rw-r--r-- | src/core/SkXfermode.cpp | 225 | ||||
| -rw-r--r-- | src/core/SkXfermodePriv.h | 31 | ||||
| -rw-r--r-- | src/core/SkXfermode_proccoeff.h | 6 | ||||
| -rw-r--r-- | src/effects/SkXfermodeImageFilter.cpp | 1 | ||||
| -rw-r--r-- | src/gpu/SkGr.h | 24 | ||||
| -rw-r--r-- | src/gpu/effects/GrXfermodeFragmentProcessor.cpp | 1 | ||||
| -rw-r--r-- | src/gpu/glsl/GrGLSLBlend.cpp | 58 |
10 files changed, 211 insertions, 261 deletions
diff --git a/src/core/SkBlendMode.cpp b/src/core/SkBlendMode.cpp new file mode 100644 index 0000000000..d7ebfb8f8e --- /dev/null +++ b/src/core/SkBlendMode.cpp @@ -0,0 +1,104 @@ +/* + * Copyright 2017 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#include "SkBlendModePriv.h" +#include "SkRasterPipeline.h" + +bool SkBlendMode_CanOverflow(SkBlendMode mode) { + return mode == SkBlendMode::kPlus; +} + +bool SkBlendMode_SupportsCoverageAsAlpha(SkBlendMode mode) { + switch (mode) { + case SkBlendMode::kDst: + case SkBlendMode::kSrcOver: + case SkBlendMode::kDstOver: + case SkBlendMode::kDstOut: + case SkBlendMode::kSrcATop: + case SkBlendMode::kXor: + case SkBlendMode::kPlus: + return true; + default: + break; + } + return false; +} + +struct CoeffRec { + SkBlendModeCoeff fSrc; + SkBlendModeCoeff fDst; +}; + +const CoeffRec gCoeffs[] = { + { SkBlendModeCoeff::kZero, SkBlendModeCoeff::kZero }, + { SkBlendModeCoeff::kOne, SkBlendModeCoeff::kZero }, + { SkBlendModeCoeff::kZero, SkBlendModeCoeff::kOne }, + { SkBlendModeCoeff::kOne, SkBlendModeCoeff::kISA }, + { SkBlendModeCoeff::kIDA, SkBlendModeCoeff::kOne }, + { SkBlendModeCoeff::kDA, SkBlendModeCoeff::kZero }, + { SkBlendModeCoeff::kZero, SkBlendModeCoeff::kSA }, + { SkBlendModeCoeff::kIDA, SkBlendModeCoeff::kZero }, + { SkBlendModeCoeff::kZero, SkBlendModeCoeff::kISA }, + { SkBlendModeCoeff::kDA, SkBlendModeCoeff::kISA }, + { SkBlendModeCoeff::kIDA, SkBlendModeCoeff::kSA }, + { SkBlendModeCoeff::kIDA, SkBlendModeCoeff::kISA }, + + { SkBlendModeCoeff::kOne, SkBlendModeCoeff::kOne }, + { SkBlendModeCoeff::kZero, SkBlendModeCoeff::kSC }, + { SkBlendModeCoeff::kOne, SkBlendModeCoeff::kISC }, // screen +}; + +bool SkBlendMode_AsCoeff(SkBlendMode mode, SkBlendModeCoeff* src, SkBlendModeCoeff* dst) { + if (mode > SkBlendMode::kScreen) { + return false; + } + if (src) { + *src = gCoeffs[static_cast<int>(mode)].fSrc; + } + if (dst) { + *dst = gCoeffs[static_cast<int>(mode)].fDst; + } + return true; +} + +void SkBlendMode_AppendStages(SkBlendMode mode, SkRasterPipeline* p) { + auto stage = SkRasterPipeline::srcover; + switch (mode) { + case SkBlendMode::kClear: stage = SkRasterPipeline::clear; break; + case SkBlendMode::kSrc: return; // This stage is a no-op. + case SkBlendMode::kDst: stage = SkRasterPipeline::move_dst_src; break; + case SkBlendMode::kSrcOver: stage = SkRasterPipeline::srcover; break; + case SkBlendMode::kDstOver: stage = SkRasterPipeline::dstover; break; + case SkBlendMode::kSrcIn: stage = SkRasterPipeline::srcin; break; + case SkBlendMode::kDstIn: stage = SkRasterPipeline::dstin; break; + case SkBlendMode::kSrcOut: stage = SkRasterPipeline::srcout; break; + case SkBlendMode::kDstOut: stage = SkRasterPipeline::dstout; break; + case SkBlendMode::kSrcATop: stage = SkRasterPipeline::srcatop; break; + case SkBlendMode::kDstATop: stage = SkRasterPipeline::dstatop; break; + case SkBlendMode::kXor: stage = SkRasterPipeline::xor_; break; + case SkBlendMode::kPlus: stage = SkRasterPipeline::plus_; break; + case SkBlendMode::kModulate: stage = SkRasterPipeline::modulate; break; + + case SkBlendMode::kScreen: stage = SkRasterPipeline::screen; break; + case SkBlendMode::kOverlay: stage = SkRasterPipeline::overlay; break; + case SkBlendMode::kDarken: stage = SkRasterPipeline::darken; break; + case SkBlendMode::kLighten: stage = SkRasterPipeline::lighten; break; + case SkBlendMode::kColorDodge: stage = SkRasterPipeline::colordodge; break; + case SkBlendMode::kColorBurn: stage = SkRasterPipeline::colorburn; break; + case SkBlendMode::kHardLight: stage = SkRasterPipeline::hardlight; break; + case SkBlendMode::kSoftLight: stage = SkRasterPipeline::softlight; break; + case SkBlendMode::kDifference: stage = SkRasterPipeline::difference; break; + case SkBlendMode::kExclusion: stage = SkRasterPipeline::exclusion; break; + case SkBlendMode::kMultiply: stage = SkRasterPipeline::multiply; break; + + case SkBlendMode::kHue: stage = SkRasterPipeline::hue; break; + case SkBlendMode::kSaturation: stage = SkRasterPipeline::saturation; break; + case SkBlendMode::kColor: stage = SkRasterPipeline::color; break; + case SkBlendMode::kLuminosity: stage = SkRasterPipeline::luminosity; break; + } + p->append(stage); +} diff --git a/src/core/SkBlendModePriv.h b/src/core/SkBlendModePriv.h index 887c0dc482..c965fe2cb9 100644 --- a/src/core/SkBlendModePriv.h +++ b/src/core/SkBlendModePriv.h @@ -20,5 +20,21 @@ void SkBlendMode_AppendStages(SkBlendMode, SkRasterPipeline*); const GrXPFactory* SkBlendMode_AsXPFactory(SkBlendMode); #endif +enum class SkBlendModeCoeff { + kZero, /** 0 */ + kOne, /** 1 */ + kSC, /** src color */ + kISC, /** inverse src color (i.e. 1 - sc) */ + kDC, /** dst color */ + kIDC, /** inverse dst color (i.e. 1 - dc) */ + kSA, /** src alpha */ + kISA, /** inverse src alpha (i.e. 1 - sa) */ + kDA, /** dst alpha */ + kIDA, /** inverse dst alpha (i.e. 1 - da) */ + + kCoeffCount +}; + +bool SkBlendMode_AsCoeff(SkBlendMode mode, SkBlendModeCoeff* src, SkBlendModeCoeff* dst); #endif diff --git a/src/core/SkValidationUtils.h b/src/core/SkValidationUtils.h index 5e2b91d4d3..84b906a650 100644 --- a/src/core/SkValidationUtils.h +++ b/src/core/SkValidationUtils.h @@ -12,12 +12,6 @@ #include "SkBlendMode.h" #include "SkXfermodePriv.h" -/** Returns true if coeff's value is in the SkXfermode::Coeff enum. - */ -static inline bool SkIsValidCoeff(SkXfermode::Coeff coeff) { - return coeff >= 0 && coeff < SkXfermode::kCoeffCount; -} - /** Returns true if mode's value is in the SkBlendMode enum. */ static inline bool SkIsValidMode(SkBlendMode mode) { diff --git a/src/core/SkXfermode.cpp b/src/core/SkXfermode.cpp index b2fb40b20f..31f822feaf 100644 --- a/src/core/SkXfermode.cpp +++ b/src/core/SkXfermode.cpp @@ -5,6 +5,7 @@ * found in the LICENSE file. */ +#include "SkBlendModePriv.h" #include "SkXfermode_proccoeff.h" #include "SkColorPriv.h" #include "SkMathPriv.h" @@ -954,36 +955,36 @@ template <Sk4f (blend)(const Sk4f&, const Sk4f&)> SkPM4f proc_4f(const SkPM4f& s } const ProcCoeff gProcCoeffs[] = { - { clear_modeproc, proc_4f<clear_4f>, SkXfermode::kZero_Coeff, SkXfermode::kZero_Coeff }, - { src_modeproc, proc_4f<src_4f>, SkXfermode::kOne_Coeff, SkXfermode::kZero_Coeff }, - { dst_modeproc, proc_4f<dst_4f>, SkXfermode::kZero_Coeff, SkXfermode::kOne_Coeff }, - { srcover_modeproc, proc_4f<srcover_4f>, SkXfermode::kOne_Coeff, SkXfermode::kISA_Coeff }, - { dstover_modeproc, proc_4f<dstover_4f>, SkXfermode::kIDA_Coeff, SkXfermode::kOne_Coeff }, - { srcin_modeproc, proc_4f<srcin_4f>, SkXfermode::kDA_Coeff, SkXfermode::kZero_Coeff }, - { dstin_modeproc, proc_4f<dstin_4f>, SkXfermode::kZero_Coeff, SkXfermode::kSA_Coeff }, - { srcout_modeproc, proc_4f<srcout_4f>, SkXfermode::kIDA_Coeff, SkXfermode::kZero_Coeff }, - { dstout_modeproc, proc_4f<dstout_4f>, SkXfermode::kZero_Coeff, SkXfermode::kISA_Coeff }, - { srcatop_modeproc, proc_4f<srcatop_4f>, SkXfermode::kDA_Coeff, SkXfermode::kISA_Coeff }, - { dstatop_modeproc, proc_4f<dstatop_4f>, SkXfermode::kIDA_Coeff, SkXfermode::kSA_Coeff }, - { xor_modeproc, proc_4f<xor_4f>, SkXfermode::kIDA_Coeff, SkXfermode::kISA_Coeff }, - - { plus_modeproc, proc_4f<plus_4f>, SkXfermode::kOne_Coeff, SkXfermode::kOne_Coeff }, - { modulate_modeproc, proc_4f<modulate_4f>, SkXfermode::kZero_Coeff, SkXfermode::kSC_Coeff }, - { screen_modeproc, proc_4f<screen_4f>, SkXfermode::kOne_Coeff, SkXfermode::kISC_Coeff }, - { overlay_modeproc, proc_4f<overlay_4f>, CANNOT_USE_COEFF, CANNOT_USE_COEFF }, - { darken_modeproc, proc_4f<darken_4f>, CANNOT_USE_COEFF, CANNOT_USE_COEFF }, - { lighten_modeproc, proc_4f<lighten_4f>, CANNOT_USE_COEFF, CANNOT_USE_COEFF }, - { colordodge_modeproc, proc_4f<colordodge_4f>, CANNOT_USE_COEFF, CANNOT_USE_COEFF }, - { colorburn_modeproc, proc_4f<colorburn_4f>, CANNOT_USE_COEFF, CANNOT_USE_COEFF }, - { hardlight_modeproc, proc_4f<hardlight_4f>, CANNOT_USE_COEFF, CANNOT_USE_COEFF }, - { softlight_modeproc, proc_4f<softlight_4f>, CANNOT_USE_COEFF, CANNOT_USE_COEFF }, - { difference_modeproc, proc_4f<difference_4f>, CANNOT_USE_COEFF, CANNOT_USE_COEFF }, - { exclusion_modeproc, proc_4f<exclusion_4f>, CANNOT_USE_COEFF, CANNOT_USE_COEFF }, - { multiply_modeproc, proc_4f<multiply_4f>, CANNOT_USE_COEFF, CANNOT_USE_COEFF }, - { hue_modeproc, proc_4f<hue_4f>, CANNOT_USE_COEFF, CANNOT_USE_COEFF }, - { saturation_modeproc, proc_4f<saturation_4f>, CANNOT_USE_COEFF, CANNOT_USE_COEFF }, - { color_modeproc, proc_4f<color_4f>, CANNOT_USE_COEFF, CANNOT_USE_COEFF }, - { luminosity_modeproc, proc_4f<luminosity_4f>, CANNOT_USE_COEFF, CANNOT_USE_COEFF }, + { clear_modeproc, proc_4f<clear_4f> }, + { src_modeproc, proc_4f<src_4f> }, + { dst_modeproc, proc_4f<dst_4f> }, + { srcover_modeproc, proc_4f<srcover_4f> }, + { dstover_modeproc, proc_4f<dstover_4f> }, + { srcin_modeproc, proc_4f<srcin_4f> }, + { dstin_modeproc, proc_4f<dstin_4f> }, + { srcout_modeproc, proc_4f<srcout_4f> }, + { dstout_modeproc, proc_4f<dstout_4f> }, + { srcatop_modeproc, proc_4f<srcatop_4f> }, + { dstatop_modeproc, proc_4f<dstatop_4f> }, + { xor_modeproc, proc_4f<xor_4f> }, + + { plus_modeproc, proc_4f<plus_4f> }, + { modulate_modeproc, proc_4f<modulate_4f> }, + { screen_modeproc, proc_4f<screen_4f> }, + { overlay_modeproc, proc_4f<overlay_4f> }, + { darken_modeproc, proc_4f<darken_4f> }, + { lighten_modeproc, proc_4f<lighten_4f> }, + { colordodge_modeproc, proc_4f<colordodge_4f> }, + { colorburn_modeproc, proc_4f<colorburn_4f> }, + { hardlight_modeproc, proc_4f<hardlight_4f> }, + { softlight_modeproc, proc_4f<softlight_4f> }, + { difference_modeproc, proc_4f<difference_4f> }, + { exclusion_modeproc, proc_4f<exclusion_4f> }, + { multiply_modeproc, proc_4f<multiply_4f> }, + { hue_modeproc, proc_4f<hue_4f> }, + { saturation_modeproc, proc_4f<saturation_4f> }, + { color_modeproc, proc_4f<color_4f> }, + { luminosity_modeproc, proc_4f<luminosity_4f> }, }; /////////////////////////////////////////////////////////////////////////////// @@ -1069,44 +1070,11 @@ bool SkProcCoeffXfermode::asMode(Mode* mode) const { } bool SkProcCoeffXfermode::supportsCoverageAsAlpha() const { - if (CANNOT_USE_COEFF == fSrcCoeff) { - return false; - } - - switch (fDstCoeff) { - case SkXfermode::kOne_Coeff: - case SkXfermode::kISA_Coeff: - case SkXfermode::kISC_Coeff: - return true; - default: - return false; - } + return SkBlendMode_SupportsCoverageAsAlpha(fMode); } bool SkProcCoeffXfermode::isOpaque(SkXfermode::SrcColorOpacity opacityType) const { - if (CANNOT_USE_COEFF == fSrcCoeff) { - return false; - } - - if (SkXfermode::kDA_Coeff == fSrcCoeff || SkXfermode::kDC_Coeff == fSrcCoeff || - SkXfermode::kIDA_Coeff == fSrcCoeff || SkXfermode::kIDC_Coeff == fSrcCoeff) { - return false; - } - - switch (fDstCoeff) { - case SkXfermode::kZero_Coeff: - return true; - case SkXfermode::kISA_Coeff: - return SkXfermode::kOpaque_SrcColorOpacity == opacityType; - case SkXfermode::kSA_Coeff: - return SkXfermode::kTransparentBlack_SrcColorOpacity == opacityType || - SkXfermode::kTransparentAlpha_SrcColorOpacity == opacityType; - case SkXfermode::kSC_Coeff: - return SkXfermode::kTransparentBlack_SrcColorOpacity == opacityType; - default: - return false; - } - + return SkXfermode::IsOpaque(fMode, opacityType); } void SkProcCoeffXfermode::xfer32(SkPMColor* SK_RESTRICT dst, @@ -1145,7 +1113,7 @@ sk_sp<GrFragmentProcessor> SkProcCoeffXfermode::makeFragmentProcessorForImageFil } const GrXPFactory* SkProcCoeffXfermode::asXPFactory() const { - if (CANNOT_USE_COEFF != fSrcCoeff) { + if (SkBlendMode_AsCoeff(fMode, nullptr, nullptr)) { const GrXPFactory* result(GrPorterDuffXPFactory::Get(fMode)); SkASSERT(result); return result; @@ -1179,24 +1147,6 @@ void SkProcCoeffXfermode::toString(SkString* str) const { str->append("mode: "); str->append(ModeName(fMode)); - - static const char* gCoeffStrings[kCoeffCount] = { - "Zero", "One", "SC", "ISC", "DC", "IDC", "SA", "ISA", "DA", "IDA" - }; - - str->append(" src: "); - if (CANNOT_USE_COEFF == fSrcCoeff) { - str->append("can't use"); - } else { - str->append(gCoeffStrings[fSrcCoeff]); - } - - str->append(" dst: "); - if (CANNOT_USE_COEFF == fDstCoeff) { - str->append("can't use"); - } else { - str->append(gCoeffStrings[fDstCoeff]); - } } #endif @@ -1246,30 +1196,6 @@ SkXfermodeProc4f SkXfermode::GetProc4f(SkBlendMode mode) { return proc; } -bool SkXfermode::ModeAsCoeff(Mode mode, Coeff* src, Coeff* dst) { - SkASSERT(SK_ARRAY_COUNT(gProcCoeffs) == kModeCount); - - if ((unsigned)mode >= (unsigned)kModeCount) { - // illegal mode parameter - return false; - } - - const ProcCoeff& rec = gProcCoeffs[mode]; - - if (CANNOT_USE_COEFF == rec.fSC) { - return false; - } - - SkASSERT(CANNOT_USE_COEFF != rec.fDC); - if (src) { - *src = rec.fSC; - } - if (dst) { - *dst = rec.fDC; - } - return true; -} - bool SkXfermode::AsMode(const SkXfermode* xfer, Mode* mode) { if (nullptr == xfer) { if (mode) { @@ -1313,44 +1239,31 @@ SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END /////////////////////////////////////////////////////////////////////////////////////////////////// -bool SkBlendMode_SupportsCoverageAsAlpha(SkBlendMode mode) { - switch (mode) { - case SkBlendMode::kDst: - case SkBlendMode::kSrcOver: - case SkBlendMode::kDstOver: - case SkBlendMode::kDstOut: - case SkBlendMode::kSrcATop: - case SkBlendMode::kXor: - case SkBlendMode::kPlus: - return true; - default: - break; - } - return false; -} - bool SkXfermode::IsOpaque(SkBlendMode mode, SrcColorOpacity opacityType) { - const ProcCoeff rec = gProcCoeffs[(int)mode]; + SkBlendModeCoeff src, dst; + if (!SkBlendMode_AsCoeff(mode, &src, &dst)) { + return false; + } - switch (rec.fSC) { - case kDA_Coeff: - case kDC_Coeff: - case kIDA_Coeff: - case kIDC_Coeff: + switch (src) { + case SkBlendModeCoeff::kDA: + case SkBlendModeCoeff::kDC: + case SkBlendModeCoeff::kIDA: + case SkBlendModeCoeff::kIDC: return false; default: break; } - switch (rec.fDC) { - case kZero_Coeff: + switch (dst) { + case SkBlendModeCoeff::kZero: return true; - case kISA_Coeff: + case SkBlendModeCoeff::kISA: return kOpaque_SrcColorOpacity == opacityType; - case kSA_Coeff: + case SkBlendModeCoeff::kSA: return kTransparentBlack_SrcColorOpacity == opacityType || kTransparentAlpha_SrcColorOpacity == opacityType; - case kSC_Coeff: + case SkBlendModeCoeff::kSC: return kTransparentBlack_SrcColorOpacity == opacityType; default: return false; @@ -1360,8 +1273,7 @@ bool SkXfermode::IsOpaque(SkBlendMode mode, SrcColorOpacity opacityType) { #if SK_SUPPORT_GPU const GrXPFactory* SkBlendMode_AsXPFactory(SkBlendMode mode) { - const ProcCoeff rec = gProcCoeffs[(int)mode]; - if (CANNOT_USE_COEFF != rec.fSC) { + if (SkBlendMode_AsCoeff(mode, nullptr, nullptr)) { const GrXPFactory* result = GrPorterDuffXPFactory::Get(mode); SkASSERT(result); return result; @@ -1372,42 +1284,3 @@ const GrXPFactory* SkBlendMode_AsXPFactory(SkBlendMode mode) { } #endif -bool SkBlendMode_CanOverflow(SkBlendMode mode) { return mode == SkBlendMode::kPlus; } - -void SkBlendMode_AppendStages(SkBlendMode mode, SkRasterPipeline* p) { - auto stage = SkRasterPipeline::srcover; - switch (mode) { - case SkBlendMode::kClear: stage = SkRasterPipeline::clear; break; - case SkBlendMode::kSrc: return; // This stage is a no-op. - case SkBlendMode::kDst: stage = SkRasterPipeline::move_dst_src; break; - case SkBlendMode::kSrcOver: stage = SkRasterPipeline::srcover; break; - case SkBlendMode::kDstOver: stage = SkRasterPipeline::dstover; break; - case SkBlendMode::kSrcIn: stage = SkRasterPipeline::srcin; break; - case SkBlendMode::kDstIn: stage = SkRasterPipeline::dstin; break; - case SkBlendMode::kSrcOut: stage = SkRasterPipeline::srcout; break; - case SkBlendMode::kDstOut: stage = SkRasterPipeline::dstout; break; - case SkBlendMode::kSrcATop: stage = SkRasterPipeline::srcatop; break; - case SkBlendMode::kDstATop: stage = SkRasterPipeline::dstatop; break; - case SkBlendMode::kXor: stage = SkRasterPipeline::xor_; break; - case SkBlendMode::kPlus: stage = SkRasterPipeline::plus_; break; - case SkBlendMode::kModulate: stage = SkRasterPipeline::modulate; break; - - case SkBlendMode::kScreen: stage = SkRasterPipeline::screen; break; - case SkBlendMode::kOverlay: stage = SkRasterPipeline::overlay; break; - case SkBlendMode::kDarken: stage = SkRasterPipeline::darken; break; - case SkBlendMode::kLighten: stage = SkRasterPipeline::lighten; break; - case SkBlendMode::kColorDodge: stage = SkRasterPipeline::colordodge; break; - case SkBlendMode::kColorBurn: stage = SkRasterPipeline::colorburn; break; - case SkBlendMode::kHardLight: stage = SkRasterPipeline::hardlight; break; - case SkBlendMode::kSoftLight: stage = SkRasterPipeline::softlight; break; - case SkBlendMode::kDifference: stage = SkRasterPipeline::difference; break; - case SkBlendMode::kExclusion: stage = SkRasterPipeline::exclusion; break; - case SkBlendMode::kMultiply: stage = SkRasterPipeline::multiply; break; - - case SkBlendMode::kHue: stage = SkRasterPipeline::hue; break; - case SkBlendMode::kSaturation: stage = SkRasterPipeline::saturation; break; - case SkBlendMode::kColor: stage = SkRasterPipeline::color; break; - case SkBlendMode::kLuminosity: stage = SkRasterPipeline::luminosity; break; - } - p->append(stage); -} diff --git a/src/core/SkXfermodePriv.h b/src/core/SkXfermodePriv.h index f0fedbf74b..f5cee5a435 100644 --- a/src/core/SkXfermodePriv.h +++ b/src/core/SkXfermodePriv.h @@ -39,23 +39,6 @@ public: virtual void xfer32(SkPMColor dst[], const SkPMColor src[], int count, const SkAlpha aa[]) const; - /** Enum of possible coefficients to describe some xfermodes - */ - enum Coeff { - kZero_Coeff, /** 0 */ - kOne_Coeff, /** 1 */ - kSC_Coeff, /** src color */ - kISC_Coeff, /** inverse src color (i.e. 1 - sc) */ - kDC_Coeff, /** dst color */ - kIDC_Coeff, /** inverse dst color (i.e. 1 - dc) */ - kSA_Coeff, /** src alpha */ - kISA_Coeff, /** inverse src alpha (i.e. 1 - sa) */ - kDA_Coeff, /** dst alpha */ - kIDA_Coeff, /** inverse dst alpha (i.e. 1 - da) */ - - kCoeffCount - }; - /** List of predefined xfermodes. The algebra for the modes uses the following symbols: Sa, Sc - source alpha and color @@ -63,9 +46,6 @@ public: [a, c] - Resulting (alpha, color) values For these equations, the colors are in premultiplied state. If no xfermode is specified, kSrcOver is assumed. - The modes are ordered by those that can be expressed as a pair of Coeffs, followed by those - that aren't Coeffs but have separable r,g,b computations, and finally - those that are not separable. */ enum Mode { kClear_Mode, //!< [0, 0] @@ -176,17 +156,6 @@ public: static SkXfermodeProc4f GetProc4f(SkBlendMode); /** - * If the specified mode can be represented by a pair of Coeff, then return - * true and set (if not NULL) the corresponding coeffs. If the mode is - * not representable as a pair of Coeffs, return false and ignore the - * src and dst parameters. - */ - static bool ModeAsCoeff(Mode mode, Coeff* src, Coeff* dst); - static bool ModeAsCoeff(SkBlendMode mode, Coeff* src, Coeff* dst) { - return ModeAsCoeff((Mode)mode, src, dst); - } - - /** * Returns whether or not the xfer mode can support treating coverage as alpha */ virtual bool supportsCoverageAsAlpha() const; diff --git a/src/core/SkXfermode_proccoeff.h b/src/core/SkXfermode_proccoeff.h index b6d322025c..6704a822ec 100644 --- a/src/core/SkXfermode_proccoeff.h +++ b/src/core/SkXfermode_proccoeff.h @@ -14,8 +14,6 @@ struct ProcCoeff { SkXfermodeProc fProc; SkXfermodeProc4f fProc4f; - SkXfermode::Coeff fSC; - SkXfermode::Coeff fDC; }; #define CANNOT_USE_COEFF SkXfermode::Coeff(-1) @@ -25,9 +23,6 @@ public: SkProcCoeffXfermode(const ProcCoeff& rec, SkBlendMode mode) { fMode = mode; fProc = rec.fProc; - // these may be valid, or may be CANNOT_USE_COEFF - fSrcCoeff = rec.fSC; - fDstCoeff = rec.fDC; } void xfer32(SkPMColor dst[], const SkPMColor src[], int count, @@ -58,7 +53,6 @@ protected: private: SkXfermodeProc fProc; SkBlendMode fMode; - Coeff fSrcCoeff, fDstCoeff; friend class SkXfermode; diff --git a/src/effects/SkXfermodeImageFilter.cpp b/src/effects/SkXfermodeImageFilter.cpp index 14cf0c3a42..2af6d22a34 100644 --- a/src/effects/SkXfermodeImageFilter.cpp +++ b/src/effects/SkXfermodeImageFilter.cpp @@ -341,7 +341,6 @@ SkXfermodeImageFilter_Base::makeFGFrag(sk_sp<GrFragmentProcessor> bgFP) const { // have to get one the hard way. struct ProcCoeff rec; rec.fProc = SkXfermode::GetProc(SkBlendMode::kSrcOver); - SkXfermode::ModeAsCoeff(SkBlendMode::kSrcOver, &rec.fSC, &rec.fDC); srcover.reset(new SkProcCoeffXfermode(rec, SkBlendMode::kSrcOver)); xfer = srcover.get(); diff --git a/src/gpu/SkGr.h b/src/gpu/SkGr.h index 0145513139..7232c801d9 100644 --- a/src/gpu/SkGr.h +++ b/src/gpu/SkGr.h @@ -20,7 +20,7 @@ #include "SkMatrix.h" #include "SkPM4f.h" #include "SkVertices.h" -#include "SkXfermodePriv.h" +#include "SkBlendModePriv.h" class GrCaps; class GrColorSpaceXform; @@ -177,17 +177,17 @@ static inline GrPrimitiveType SkVertexModeToGrPrimitiveType(SkVertices::VertexMo ////////////////////////////////////////////////////////////////////////////// -GR_STATIC_ASSERT((int)kZero_GrBlendCoeff == (int)SkXfermode::kZero_Coeff); -GR_STATIC_ASSERT((int)kOne_GrBlendCoeff == (int)SkXfermode::kOne_Coeff); -GR_STATIC_ASSERT((int)kSC_GrBlendCoeff == (int)SkXfermode::kSC_Coeff); -GR_STATIC_ASSERT((int)kISC_GrBlendCoeff == (int)SkXfermode::kISC_Coeff); -GR_STATIC_ASSERT((int)kDC_GrBlendCoeff == (int)SkXfermode::kDC_Coeff); -GR_STATIC_ASSERT((int)kIDC_GrBlendCoeff == (int)SkXfermode::kIDC_Coeff); -GR_STATIC_ASSERT((int)kSA_GrBlendCoeff == (int)SkXfermode::kSA_Coeff); -GR_STATIC_ASSERT((int)kISA_GrBlendCoeff == (int)SkXfermode::kISA_Coeff); -GR_STATIC_ASSERT((int)kDA_GrBlendCoeff == (int)SkXfermode::kDA_Coeff); -GR_STATIC_ASSERT((int)kIDA_GrBlendCoeff == (int)SkXfermode::kIDA_Coeff); -GR_STATIC_ASSERT(SkXfermode::kCoeffCount == 10); +GR_STATIC_ASSERT((int)kZero_GrBlendCoeff == (int)SkBlendModeCoeff::kZero); +GR_STATIC_ASSERT((int)kOne_GrBlendCoeff == (int)SkBlendModeCoeff::kOne); +GR_STATIC_ASSERT((int)kSC_GrBlendCoeff == (int)SkBlendModeCoeff::kSC); +GR_STATIC_ASSERT((int)kISC_GrBlendCoeff == (int)SkBlendModeCoeff::kISC); +GR_STATIC_ASSERT((int)kDC_GrBlendCoeff == (int)SkBlendModeCoeff::kDC); +GR_STATIC_ASSERT((int)kIDC_GrBlendCoeff == (int)SkBlendModeCoeff::kIDC); +GR_STATIC_ASSERT((int)kSA_GrBlendCoeff == (int)SkBlendModeCoeff::kSA); +GR_STATIC_ASSERT((int)kISA_GrBlendCoeff == (int)SkBlendModeCoeff::kISA); +GR_STATIC_ASSERT((int)kDA_GrBlendCoeff == (int)SkBlendModeCoeff::kDA); +GR_STATIC_ASSERT((int)kIDA_GrBlendCoeff == (int)SkBlendModeCoeff::kIDA); +//GR_STATIC_ASSERT(SkXfermode::kCoeffCount == 10); #define SkXfermodeCoeffToGrBlendCoeff(X) ((GrBlendCoeff)(X)) diff --git a/src/gpu/effects/GrXfermodeFragmentProcessor.cpp b/src/gpu/effects/GrXfermodeFragmentProcessor.cpp index aa799370a3..aa1c1c7c9d 100644 --- a/src/gpu/effects/GrXfermodeFragmentProcessor.cpp +++ b/src/gpu/effects/GrXfermodeFragmentProcessor.cpp @@ -13,6 +13,7 @@ #include "glsl/GrGLSLBlend.h" #include "glsl/GrGLSLFragmentShaderBuilder.h" #include "SkGr.h" +#include "SkXfermodePriv.h" // Some of the cpu implementations of blend modes differ too much from the GPU enough that // we can't use the cpu implementation to implement constantOutputForConstantInput. diff --git a/src/gpu/glsl/GrGLSLBlend.cpp b/src/gpu/glsl/GrGLSLBlend.cpp index 2f41c4e588..bee5a83c5c 100644 --- a/src/gpu/glsl/GrGLSLBlend.cpp +++ b/src/gpu/glsl/GrGLSLBlend.cpp @@ -7,7 +7,7 @@ #include "GrGLSLBlend.h" #include "glsl/GrGLSLFragmentShaderBuilder.h" -#include "SkXfermodePriv.h" +#include "SkBlendModePriv.h" ////////////////////////////////////////////////////////////////////////////// // Advanced (non-coeff) blend helpers @@ -370,10 +370,10 @@ static void emit_advanced_xfermode_code(GrGLSLFragmentBuilder* fsBuilder, const // Porter-Duff blend helper ////////////////////////////////////////////////////////////////////////////// -static bool append_porterduff_term(GrGLSLFragmentBuilder* fsBuilder, SkXfermode::Coeff coeff, +static bool append_porterduff_term(GrGLSLFragmentBuilder* fsBuilder, SkBlendModeCoeff coeff, const char* colorName, const char* srcColorName, const char* dstColorName, bool hasPrevious) { - if (SkXfermode::kZero_Coeff == coeff) { + if (SkBlendModeCoeff::kZero == coeff) { return hasPrevious; } else { if (hasPrevious) { @@ -381,30 +381,30 @@ static bool append_porterduff_term(GrGLSLFragmentBuilder* fsBuilder, SkXfermode: } fsBuilder->codeAppendf("%s", colorName); switch (coeff) { - case SkXfermode::kOne_Coeff: + case SkBlendModeCoeff::kOne: break; - case SkXfermode::kSC_Coeff: + case SkBlendModeCoeff::kSC: fsBuilder->codeAppendf(" * %s", srcColorName); break; - case SkXfermode::kISC_Coeff: + case SkBlendModeCoeff::kISC: fsBuilder->codeAppendf(" * (vec4(1.0) - %s)", srcColorName); break; - case SkXfermode::kDC_Coeff: + case SkBlendModeCoeff::kDC: fsBuilder->codeAppendf(" * %s", dstColorName); break; - case SkXfermode::kIDC_Coeff: + case SkBlendModeCoeff::kIDC: fsBuilder->codeAppendf(" * (vec4(1.0) - %s)", dstColorName); break; - case SkXfermode::kSA_Coeff: + case SkBlendModeCoeff::kSA: fsBuilder->codeAppendf(" * %s.a", srcColorName); break; - case SkXfermode::kISA_Coeff: + case SkBlendModeCoeff::kISA: fsBuilder->codeAppendf(" * (1.0 - %s.a)", srcColorName); break; - case SkXfermode::kDA_Coeff: + case SkBlendModeCoeff::kDA: fsBuilder->codeAppendf(" * %s.a", dstColorName); break; - case SkXfermode::kIDA_Coeff: + case SkBlendModeCoeff::kIDA: fsBuilder->codeAppendf(" * (1.0 - %s.a)", dstColorName); break; default: @@ -420,8 +420,8 @@ void GrGLSLBlend::AppendMode(GrGLSLFragmentBuilder* fsBuilder, const char* srcCo const char* dstColor, const char* outColor, SkBlendMode mode) { - SkXfermode::Coeff srcCoeff, dstCoeff; - if (SkXfermode::ModeAsCoeff(mode, &srcCoeff, &dstCoeff)) { + SkBlendModeCoeff srcCoeff, dstCoeff; + if (SkBlendMode_AsCoeff(mode, &srcCoeff, &dstCoeff)) { // The only coeff mode that can go out of range is plus. bool clamp = mode == SkBlendMode::kPlus; @@ -448,37 +448,37 @@ void GrGLSLBlend::AppendMode(GrGLSLFragmentBuilder* fsBuilder, const char* srcCo void GrGLSLBlend::AppendRegionOp(GrGLSLFragmentBuilder* fsBuilder, const char* srcColor, const char* dstColor, const char* outColor, SkRegion::Op regionOp) { - SkXfermode::Coeff srcCoeff, dstCoeff; + SkBlendModeCoeff srcCoeff, dstCoeff; switch (regionOp) { case SkRegion::kReplace_Op: - srcCoeff = SkXfermode::kOne_Coeff; - dstCoeff = SkXfermode::kZero_Coeff; + srcCoeff = SkBlendModeCoeff::kOne; + dstCoeff = SkBlendModeCoeff::kZero; break; case SkRegion::kIntersect_Op: - srcCoeff = SkXfermode::kDC_Coeff; - dstCoeff = SkXfermode::kZero_Coeff; + srcCoeff = SkBlendModeCoeff::kDC; + dstCoeff = SkBlendModeCoeff::kZero; break; case SkRegion::kUnion_Op: - srcCoeff = SkXfermode::kOne_Coeff; - dstCoeff = SkXfermode::kISC_Coeff; + srcCoeff = SkBlendModeCoeff::kOne; + dstCoeff = SkBlendModeCoeff::kISC; break; case SkRegion::kXOR_Op: - srcCoeff = SkXfermode::kIDC_Coeff; - dstCoeff = SkXfermode::kISC_Coeff; + srcCoeff = SkBlendModeCoeff::kIDC; + dstCoeff = SkBlendModeCoeff::kISC; break; case SkRegion::kDifference_Op: - srcCoeff = SkXfermode::kZero_Coeff; - dstCoeff = SkXfermode::kISC_Coeff; + srcCoeff = SkBlendModeCoeff::kZero; + dstCoeff = SkBlendModeCoeff::kISC; break; case SkRegion::kReverseDifference_Op: - srcCoeff = SkXfermode::kIDC_Coeff; - dstCoeff = SkXfermode::kZero_Coeff; + srcCoeff = SkBlendModeCoeff::kIDC; + dstCoeff = SkBlendModeCoeff::kZero; break; default: SkFAIL("Unsupported Op"); // We should never get here but to make compiler happy - srcCoeff = SkXfermode::kZero_Coeff; - dstCoeff = SkXfermode::kZero_Coeff; + srcCoeff = SkBlendModeCoeff::kZero; + dstCoeff = SkBlendModeCoeff::kZero; } fsBuilder->codeAppendf("%s = ", outColor); // append src blend |