#include <SkColorFilter.h>

Inheritance diagram for SkColorFilter:

Public Member Functions
bool	asAColorMode (SkColor color, SkBlendMode mode) const

bool	asAColorMatrix (float matrix[20]) const

bool	isAlphaUnchanged () const

SkColor	filterColor (SkColor) const

SkColor4f	filterColor4f (const SkColor4f &srcColor, SkColorSpace srcCS, SkColorSpace dstCS) const

sk_sp< SkColorFilter >	makeComposed (sk_sp< SkColorFilter > inner) const

sk_sp< SkColorFilter >	makeWithWorkingColorSpace (sk_sp< SkColorSpace >) const

Public Member Functions inherited from SkFlattenable
	SkFlattenable ()

virtual Factory	getFactory () const =0

virtual const char *	getTypeName () const =0

virtual void	flatten (SkWriteBuffer &) const

virtual Type	getFlattenableType () const =0

sk_sp< SkData >	serialize (const SkSerialProcs *=nullptr) const

size_t	serialize (void memory, size_t memory_size, const SkSerialProcs =nullptr) const

Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()

virtual	~SkRefCntBase ()

bool	unique () const

void	ref () const

void	unref () const

Static Public Member Functions
static sk_sp< SkColorFilter >	Deserialize (const void data, size_t size, const SkDeserialProcs procs=nullptr)

Static Public Member Functions inherited from SkFlattenable
static Factory	NameToFactory (const char name[])

static const char *	FactoryToName (Factory)

static void	Register (const char name[], Factory)

static sk_sp< SkFlattenable >	Deserialize (Type, const void data, size_t length, const SkDeserialProcs procs=nullptr)

Friends
class	SkColorFilterBase

Additional Inherited Members
Public Types inherited from SkFlattenable
enum	Type { kSkColorFilter_Type , kSkBlender_Type , kSkDrawable_Type , kSkDrawLooper_Type , kSkImageFilter_Type , kSkMaskFilter_Type , kSkPathEffect_Type , kSkShader_Type }

typedef sk_sp< SkFlattenable >(*	Factory) (SkReadBuffer &)

Detailed Description

ColorFilters are optional objects in the drawing pipeline. When present in a paint, they are called with the "src" colors, and return new colors, which are then passed onto the next stage (either ImageFilter or Xfermode).

All subclasses are required to be reentrant-safe : it must be legal to share the same instance between several threads.

Definition at line 35 of file SkColorFilter.h.

Member Function Documentation

◆ asAColorMatrix()

bool SkColorFilter::asAColorMatrix ( float matrix[20] ) const

If the filter can be represented by a 5x4 matrix, this returns true, and sets the matrix appropriately. If not, this returns false and ignores the parameter.

Definition at line 30 of file SkColorFilter.cpp.

                                                         {
    return as_CFB(this)->onAsAColorMatrix(matrix);
}

◆ asAColorMode()

bool SkColorFilter::asAColorMode	(	SkColor *	color,
		SkBlendMode *	mode
	)		const

If the filter can be represented by a source color plus Mode, this returns true, and sets (if not NULL) the color and mode appropriately. If not, this returns false and ignores the parameters.

Definition at line 26 of file SkColorFilter.cpp.

                                                                        {
    return as_CFB(this)->onAsAColorMode(color, mode);
}

◆ Deserialize()

sk_sp< SkColorFilter > SkColorFilter::Deserialize	(	const void *	data,
		size_t	size,
		const SkDeserialProcs *	procs = `nullptr`
	)

static

Definition at line 38 of file SkColorFilter.cpp.

                                                                              {
    return sk_sp<SkColorFilter>(static_cast<SkColorFilter*>(
                                SkFlattenable::Deserialize(
                                kSkColorFilter_Type, data, size, procs).release()));
}

◆ filterColor()

SkColor SkColorFilter::filterColor ( SkColor c ) const

Applies this filter to the input color. This function does no color management.

DEPRECATED: Please use filterColor4f instead. That function supports higher precision, wide-gamut color, and is explicit about the color space of the input and output.

Definition at line 45 of file SkColorFilter.cpp.

                                                  {
    // This is mostly meaningless. We should phase-out this call entirely.
    SkColorSpace* cs = nullptr;
    return this->filterColor4f(SkColor4f::FromColor(c), cs, cs).toSkColor();
}

◆ filterColor4f()

SkColor4f SkColorFilter::filterColor4f	(	const SkColor4f &	srcColor,
		SkColorSpace *	srcCS,
		SkColorSpace *	dstCS
	)		const

Converts the src color (in src colorspace), into the dst colorspace, then applies this filter to it, returning the filtered color in the dst colorspace.

Definition at line 51 of file SkColorFilter.cpp.

                                                                  {
    SkPMColor4f color = { origSrcColor.fR, origSrcColor.fG, origSrcColor.fB, origSrcColor.fA };
    SkColorSpaceXformSteps(srcCS, kUnpremul_SkAlphaType,
                           dstCS, kPremul_SkAlphaType).apply(color.vec());
 
    SkPMColor4f filteredColor = as_CFB(this)->onFilterColor4f(color, dstCS);
    // SkColor4f will assert if we allow alpha outside [0,1]. (SkSL color filters might do this).
    filteredColor.fA = SkTPin(filteredColor.fA, 0.0f, 1.0f);
    return filteredColor.unpremul();
}

◆ isAlphaUnchanged()

bool SkColorFilter::isAlphaUnchanged ( ) const

Definition at line 34 of file SkColorFilter.cpp.

                                           {
    return as_CFB(this)->onIsAlphaUnchanged();
}

◆ makeComposed()

sk_sp< SkColorFilter > SkColorFilter::makeComposed ( sk_sp< SkColorFilter > inner ) const

Construct a colorfilter whose effect is to first apply the inner filter and then apply this filter, applied to the output of the inner filter.

result = this(inner(...))

Definition at line 48 of file SkComposeColorFilter.cpp.

                                                                                 {
    if (!inner) {
        return sk_ref_sp(this);
    }
 
    return sk_sp<SkColorFilter>(new SkComposeColorFilter(sk_ref_sp(this), std::move(inner)));
}

◆ makeWithWorkingColorSpace()

sk_sp< SkColorFilter > SkColorFilter::makeWithWorkingColorSpace ( sk_sp< SkColorSpace > workingSpace ) const

Return a colorfilter that will compute this filter in a specific color space. By default all filters operate in the destination (surface) color space. This allows filters like Blend and Matrix, or runtime color filters to perform their math in a known space.

Definition at line 63 of file SkColorFilter.cpp.

                                                {
    SkColorFilter* base = const_cast<SkColorFilter*>(this);
    if (!workingSpace) {
        return sk_ref_sp(base);
    }
 
    skcms_TransferFunction tf;
    skcms_Matrix3x3 toXYZ;
    workingSpace->transferFn(&tf);
    workingSpace->toXYZD50(&toXYZ);
    const SkAlphaType* kOriginalAlphaType = nullptr;
    return SkColorFilterPriv::WithWorkingFormat(sk_ref_sp(base), &tf, &toXYZ, kOriginalAlphaType);
}

Friends And Related Function Documentation

◆ SkColorFilterBase

friend class SkColorFilterBase

friend

Definition at line 85 of file SkColorFilter.h.

The documentation for this class was generated from the following files:

third_party/skia/include/core/SkColorFilter.h
third_party/skia/src/core/SkColorFilter.cpp
third_party/skia/src/effects/colorfilters/SkComposeColorFilter.cpp

Public Member Functions

Static Public Member Functions

Friends

Additional Inherited Members