SkBlendMode.h File Reference

#include "include/core/SkTypes.h"

Go to the source code of this file.

Enumerations
enum class	SkBlendMode {   kClear , kSrc , kDst , kSrcOver ,   kDstOver , kSrcIn , kDstIn , kSrcOut ,   kDstOut , kSrcATop , kDstATop , kXor ,   kPlus , kModulate , kScreen , kOverlay ,   kDarken , kLighten , kColorDodge , kColorBurn ,   kHardLight , kSoftLight , kDifference , kExclusion ,   kMultiply , kHue , kSaturation , kColor ,   kLuminosity , kLastCoeffMode = kScreen , kLastSeparableMode = kMultiply , kLastMode = kLuminosity }
enum class	SkBlendModeCoeff {   kZero , kOne , kSC , kISC ,   kDC , kIDC , kSA , kISA ,   kDA , kIDA , kCoeffCount }

Functions
SK_API bool	SkBlendMode_AsCoeff (SkBlendMode mode, SkBlendModeCoeff *src, SkBlendModeCoeff *dst)
SK_API const char *	SkBlendMode_Name (SkBlendMode blendMode)

Variables
static constexpr int	kSkBlendModeCount = static_cast<int>(SkBlendMode::kLastMode) + 1

Enumeration Type Documentation

SkBlendMode

enum class SkBlendMode

strong

Blends are operators that take in two colors (source, destination) and return a new color. Many of these operate the same on all 4 components: red, green, blue, alpha. For these, we just document what happens to one component, rather than naming each one separately.

Different SkColorTypes have different representations for color components: 8-bit: 0..255 6-bit: 0..63 5-bit: 0..31 4-bit: 0..15 floats: 0...1

The documentation is expressed as if the component values are always 0..1 (floats).

For brevity, the documentation uses the following abbreviations s : source d : destination sa : source alpha da : destination alpha

Results are abbreviated r : if all 4 components are computed in the same manner ra : result alpha component rc : result "color": red, green, blue components

Enumerator
kClear	r = 0
kSrc	r = s
kDst	r = d
kSrcOver	r = s + (1-sa)*d
kDstOver	r = d + (1-da)*s
kSrcIn	r = s * da
kDstIn	r = d * sa
kSrcOut	r = s * (1-da)
kDstOut	r = d * (1-sa)
kSrcATop	r = s*da + d*(1-sa)
kDstATop	r = d*sa + s*(1-da)
kXor	r = s*(1-da) + d*(1-sa)
kPlus	r = min(s + d, 1)
kModulate	r = s*d
kScreen	r = s + d - s*d
kOverlay	multiply or screen, depending on destination
kDarken	rc = s + d - max(s*da, d*sa), ra = kSrcOver
kLighten	rc = s + d - min(s*da, d*sa), ra = kSrcOver
kColorDodge	brighten destination to reflect source
kColorBurn	darken destination to reflect source
kHardLight	multiply or screen, depending on source
kSoftLight	lighten or darken, depending on source
kDifference	rc = s + d - 2*(min(s*da, d*sa)), ra = kSrcOver
kExclusion	rc = s + d - two(s*d), ra = kSrcOver
kMultiply	r = s*(1-da) + d*(1-sa) + s*d
kHue	hue of source with saturation and luminosity of destination
kSaturation	saturation of source with hue and luminosity of destination
kColor	hue and saturation of source with luminosity of destination
kLuminosity	luminosity of source with hue and saturation of destination
kLastCoeffMode	last porter duff blend mode
kLastSeparableMode	last blend mode operating separately on components
kLastMode	last valid value

Definition at line 38 of file SkBlendMode.h.

                       {
    kClear,         //!< r = 0
    kSrc,           //!< r = s
    kDst,           //!< r = d
    kSrcOver,       //!< r = s + (1-sa)*d
    kDstOver,       //!< r = d + (1-da)*s
    kSrcIn,         //!< r = s * da
    kDstIn,         //!< r = d * sa
    kSrcOut,        //!< r = s * (1-da)
    kDstOut,        //!< r = d * (1-sa)
    kSrcATop,       //!< r = s*da + d*(1-sa)
    kDstATop,       //!< r = d*sa + s*(1-da)
    kXor,           //!< r = s*(1-da) + d*(1-sa)
    kPlus,          //!< r = min(s + d, 1)
    kModulate,      //!< r = s*d
    kScreen,        //!< r = s + d - s*d
 
    kOverlay,       //!< multiply or screen, depending on destination
    kDarken,        //!< rc = s + d - max(s*da, d*sa), ra = kSrcOver
    kLighten,       //!< rc = s + d - min(s*da, d*sa), ra = kSrcOver
    kColorDodge,    //!< brighten destination to reflect source
    kColorBurn,     //!< darken destination to reflect source
    kHardLight,     //!< multiply or screen, depending on source
    kSoftLight,     //!< lighten or darken, depending on source
    kDifference,    //!< rc = s + d - 2*(min(s*da, d*sa)), ra = kSrcOver
    kExclusion,     //!< rc = s + d - two(s*d), ra = kSrcOver
    kMultiply,      //!< r = s*(1-da) + d*(1-sa) + s*d
 
    kHue,           //!< hue of source with saturation and luminosity of destination
    kSaturation,    //!< saturation of source with hue and luminosity of destination
    kColor,         //!< hue and saturation of source with luminosity of destination
    kLuminosity,    //!< luminosity of source with hue and saturation of destination
 
    kLastCoeffMode     = kScreen,     //!< last porter duff blend mode
    kLastSeparableMode = kMultiply,   //!< last blend mode operating separately on components
    kLastMode          = kLuminosity, //!< last valid value
};

SkBlendModeCoeff

enum class SkBlendModeCoeff

strong

For Porter-Duff SkBlendModes (those <= kLastCoeffMode), these coefficients describe the blend equation used. Coefficient-based blend modes specify an equation: ('dstCoeff' * dst + 'srcCoeff' * src), where the coefficient values are constants, functions of the src or dst alpha, or functions of the src or dst color.

Enumerator
kZero
kOne	0
kSC	1
kISC	src color
kDC	inverse src color (i.e. 1 - sc)
kIDC	dst color
kSA	inverse dst color (i.e. 1 - dc)
kISA	src alpha
kDA	inverse src alpha (i.e. 1 - sa)
kIDA	dst alpha
kCoeffCount	inverse dst alpha (i.e. 1 - da)

Definition at line 84 of file SkBlendMode.h.

                            {
    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
};

Function Documentation

SkBlendMode_AsCoeff()

SK_API bool SkBlendMode_AsCoeff	(	SkBlendMode	mode,
		SkBlendModeCoeff *	src,
		SkBlendModeCoeff *	dst
	)

Returns true if 'mode' is a coefficient-based blend mode (<= kLastCoeffMode). If true is returned, the mode's src and dst coefficient functions are set in 'src' and 'dst'.

Definition at line 57 of file SkBlendMode.cpp.

                                                                                         {
    struct CoeffRec {
        SkBlendModeCoeff    fSrc;
        SkBlendModeCoeff    fDst;
    };
 
    static constexpr CoeffRec kCoeffs[] = {
        // For Porter-Duff blend functions, color = src * src coeff + dst * dst coeff
        // src coeff                  dst coeff                     blend func
        // ----------------------     -----------------------       ----------
        { SkBlendModeCoeff::kZero,    SkBlendModeCoeff::kZero }, // clear
        { SkBlendModeCoeff::kOne,     SkBlendModeCoeff::kZero }, // src
        { SkBlendModeCoeff::kZero,    SkBlendModeCoeff::kOne  }, // dst
        { SkBlendModeCoeff::kOne,     SkBlendModeCoeff::kISA  }, // src-over
        { SkBlendModeCoeff::kIDA,     SkBlendModeCoeff::kOne  }, // dst-over
        { SkBlendModeCoeff::kDA,      SkBlendModeCoeff::kZero }, // src-in
        { SkBlendModeCoeff::kZero,    SkBlendModeCoeff::kSA   }, // dst-in
        { SkBlendModeCoeff::kIDA,     SkBlendModeCoeff::kZero }, // src-out
        { SkBlendModeCoeff::kZero,    SkBlendModeCoeff::kISA  }, // dst-out
        { SkBlendModeCoeff::kDA,      SkBlendModeCoeff::kISA  }, // src-atop
        { SkBlendModeCoeff::kIDA,     SkBlendModeCoeff::kSA   }, // dst-atop
        { SkBlendModeCoeff::kIDA,     SkBlendModeCoeff::kISA  }, // xor
 
        { SkBlendModeCoeff::kOne,     SkBlendModeCoeff::kOne  }, // plus
        { SkBlendModeCoeff::kZero,    SkBlendModeCoeff::kSC   }, // modulate
        { SkBlendModeCoeff::kOne,     SkBlendModeCoeff::kISC  }, // screen
    };
 
    if (mode > SkBlendMode::kScreen) {
        return false;
    }
    if (src) {
        *src = kCoeffs[static_cast<int>(mode)].fSrc;
    }
    if (dst) {
        *dst = kCoeffs[static_cast<int>(mode)].fDst;
    }
    return true;
}

SkBlendMode_Name()

SK_API const char * SkBlendMode_Name

(

SkBlendMode

blendMode

)

Returns name of blendMode as null-terminated C string.

Returns

C string

Definition at line 167 of file SkBlendMode.cpp.

                                             {
    switch (bm) {
        case SkBlendMode::kClear:      return "Clear";
        case SkBlendMode::kSrc:        return "Src";
        case SkBlendMode::kDst:        return "Dst";
        case SkBlendMode::kSrcOver:    return "SrcOver";
        case SkBlendMode::kDstOver:    return "DstOver";
        case SkBlendMode::kSrcIn:      return "SrcIn";
        case SkBlendMode::kDstIn:      return "DstIn";
        case SkBlendMode::kSrcOut:     return "SrcOut";
        case SkBlendMode::kDstOut:     return "DstOut";
        case SkBlendMode::kSrcATop:    return "SrcATop";
        case SkBlendMode::kDstATop:    return "DstATop";
        case SkBlendMode::kXor:        return "Xor";
        case SkBlendMode::kPlus:       return "Plus";
        case SkBlendMode::kModulate:   return "Modulate";
        case SkBlendMode::kScreen:     return "Screen";
 
        case SkBlendMode::kOverlay:    return "Overlay";
        case SkBlendMode::kDarken:     return "Darken";
        case SkBlendMode::kLighten:    return "Lighten";
        case SkBlendMode::kColorDodge: return "ColorDodge";
        case SkBlendMode::kColorBurn:  return "ColorBurn";
        case SkBlendMode::kHardLight:  return "HardLight";
        case SkBlendMode::kSoftLight:  return "SoftLight";
        case SkBlendMode::kDifference: return "Difference";
        case SkBlendMode::kExclusion:  return "Exclusion";
        case SkBlendMode::kMultiply:   return "Multiply";
 
        case SkBlendMode::kHue:        return "Hue";
        case SkBlendMode::kSaturation: return "Saturation";
        case SkBlendMode::kColor:      return "Color";
        case SkBlendMode::kLuminosity: return "Luminosity";
    }
    SkUNREACHABLE;
}

Variable Documentation

kSkBlendModeCount

constexpr int kSkBlendModeCount = static_cast<int>(SkBlendMode::kLastMode) + 1

staticconstexpr

Definition at line 76 of file SkBlendMode.h.