#include <SkShader.h>

Inheritance diagram for SkShader:

Public Member Functions
virtual bool	isOpaque () const

SkImage *	isAImage (SkMatrix *localMatrix, SkTileMode xy[2]) const

bool	isAImage () const

sk_sp< SkShader >	makeWithLocalMatrix (const SkMatrix &) const

sk_sp< SkShader >	makeWithColorFilter (sk_sp< SkColorFilter >) const

sk_sp< SkShader >	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

Friends
class	SkShaderBase

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 &)

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)

Detailed Description

Shaders specify the source color(s) for what is being drawn. If a paint has no shader, then the paint's color is used. If the paint has a shader, then the shader's color(s) are use instead, but they are modulated by the paint's alpha. This makes it easy to create a shader once (e.g. bitmap tiling or gradient) and then change its transparency w/o having to modify the original shader... only the paint's alpha needs to be modified.

Definition at line 36 of file SkShader.h.

Member Function Documentation

◆ isAImage() [1/2]

bool SkShader::isAImage ( ) const

inline

Definition at line 52 of file SkShader.h.

                          {
        return this->isAImage(nullptr, (SkTileMode*)nullptr) != nullptr;
    }

◆ isAImage() [2/2]

SkImage * SkShader::isAImage	(	SkMatrix *	localMatrix,
		SkTileMode	xy[2]
	)		const

Iff this shader is backed by a single SkImage, return its ptr (the caller must ref this if they want to keep it longer than the lifetime of the shader). If not, return nullptr.

Definition at line 22 of file SkShader.cpp.

                                                                         {
    return as_SB(this)->onIsAImage(localMatrix, xy);
}

◆ isOpaque()

virtual bool SkShader::isOpaque ( ) const

inlinevirtual

Returns true if the shader is guaranteed to produce only opaque colors, subject to the SkPaint using the shader to apply an opaque alpha value. Subclasses should override this to allow some optimizations.

Reimplemented in SkConicalGradient, SkGradientBaseShader, SkColorShader, SkColor4Shader, SkImageShader, SkLocalMatrixShader, SkCTMShader, SkRuntimeShader, and SkTransformShader.

Definition at line 44 of file SkShader.h.

44{ return false; }

◆ makeWithColorFilter()

sk_sp< SkShader > SkShader::makeWithColorFilter ( sk_sp< SkColorFilter > filter ) const

Create a new shader that produces the same colors as invoking this shader and then applying the colorfilter.

Definition at line 43 of file SkShader.cpp.

                                                                               {
    SkShader* base = const_cast<SkShader*>(this);
    if (!filter) {
        return sk_ref_sp(base);
    }
    return sk_make_sp<SkColorFilterShader>(sk_ref_sp(base), 1.0f, std::move(filter));
}

◆ makeWithLocalMatrix()

sk_sp< SkShader > SkShader::makeWithLocalMatrix ( const SkMatrix & localMatrix ) const

Return a shader that will apply the specified localMatrix to this shader. The specified matrix will be applied before any matrix associated with this shader.

Definition at line 26 of file SkShader.cpp.

                                                                               {
    const SkMatrix* lm = &localMatrix;
 
    sk_sp<SkShader> baseShader;
    SkMatrix otherLocalMatrix;
    sk_sp<SkShader> proxy = as_SB(this)->makeAsALocalMatrixShader(&otherLocalMatrix);
    if (proxy) {
        otherLocalMatrix = SkShaderBase::ConcatLocalMatrices(localMatrix, otherLocalMatrix);
        lm = &otherLocalMatrix;
        baseShader = proxy;
    } else {
        baseShader = sk_ref_sp(const_cast<SkShader*>(this));
    }
 
    return sk_make_sp<SkLocalMatrixShader>(std::move(baseShader), *lm);
}

◆ makeWithWorkingColorSpace()

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

Return a shader that will compute this shader in a specific color space. By default, all shaders operate in the destination (surface) color space. The results of a shader are still always converted to the destination - this API has no impact on simple shaders or images. Primarily, it impacts shaders that perform mathematical operations, like Blend shaders, or runtime shaders.

Definition at line 51 of file SkShader.cpp.

                                                                                          {
    SkShader* base = const_cast<SkShader*>(this);
    if (!workingSpace) {
        return sk_ref_sp(base);
    }
    return sk_make_sp<SkWorkingColorSpaceShader>(sk_ref_sp(base), std::move(workingSpace));
}

Friends And Related Function Documentation

◆ SkShaderBase

friend class SkShaderBase

friend

Definition at line 82 of file SkShader.h.

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

third_party/skia/include/core/SkShader.h
third_party/skia/src/shaders/SkShader.cpp

Public Member Functions

Friends

Additional Inherited Members