#include <SkConicalGradient.h>

Inheritance diagram for SkConicalGradient:

Classes
struct	FocalData

Public Types
enum class	Type { kRadial , kStrip , kFocal }

Public Types inherited from SkGradientBaseShader
using	Interpolation = SkGradientShader::Interpolation

Public Types inherited from SkShaderBase
enum class	ShaderType { M }

enum class	GradientType { kNone , M }

enum	Flags { kOpaqueAlpha_Flag = 1 << 0 }

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

Public Member Functions
GradientType	asGradient (GradientInfo info, SkMatrix localMatrix) const override

bool	isOpaque () const override

SkScalar	getCenterX1 () const

SkScalar	getStartRadius () const

SkScalar	getDiffRadius () const

const SkPoint &	getStartCenter () const

const SkPoint &	getEndCenter () const

SkScalar	getEndRadius () const

Type	getType () const

const FocalData &	getFocalData () const

	SkConicalGradient (const SkPoint &c0, SkScalar r0, const SkPoint &c1, SkScalar r1, const Descriptor &, Type, const SkMatrix &, const FocalData &)

Public Member Functions inherited from SkGradientBaseShader
	SkGradientBaseShader (const Descriptor &desc, const SkMatrix &ptsToUnit)

	~SkGradientBaseShader () override

ShaderType	type () const final

bool	isOpaque () const override

bool	interpolateInPremul () const

const SkMatrix &	getGradientMatrix () const

int	getColorCount () const

const float *	getPositions () const

const Interpolation &	getInterpolation () const

SkScalar	getPos (int i) const

SkColor	getLegacyColor (int i) const

bool	colorsAreOpaque () const

SkTileMode	getTileMode () const

const SkBitmap &	cachedBitmap () const

void	setCachedBitmap (SkBitmap b) const

Public Member Functions inherited from SkShaderBase
	~SkShaderBase () override

sk_sp< SkShader >	makeInvertAlpha () const

sk_sp< SkShader >	makeWithCTM (const SkMatrix &) const

virtual bool	isConstant () const

Context *	makeContext (const ContextRec &, SkArenaAlloc *) const

bool	asLuminanceColor (SkColor4f *) const

bool	appendRootStages (const SkStageRec &rec, const SkMatrix &ctm) const

virtual SkImage *	onIsAImage (SkMatrix *, SkTileMode[2]) const

virtual SkRuntimeEffect *	asRuntimeEffect () const

Type	getFlattenableType () const override

virtual sk_sp< SkShader >	makeAsALocalMatrixShader (SkMatrix *localMatrix) const

Public Member Functions inherited from SkShader
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

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< SkShader >	Create (const SkPoint &start, SkScalar startRadius, const SkPoint &end, SkScalar endRadius, const Descriptor &, const SkMatrix *localMatrix)

Static Public Member Functions inherited from SkGradientBaseShader
static bool	ValidGradient (const SkColor4f colors[], int count, SkTileMode tileMode, const Interpolation &interpolation)

static sk_sp< SkShader >	MakeDegenerateGradient (const SkColor4f colors[], const SkScalar pos[], int colorCount, sk_sp< SkColorSpace > colorSpace, SkTileMode mode)

static void	AppendGradientFillStages (SkRasterPipeline p, SkArenaAlloc alloc, const SkPMColor4f colors, const SkScalar positions, int count)

static void	AppendInterpolatedToDstStages (SkRasterPipeline p, SkArenaAlloc alloc, bool colorsAreOpaque, const Interpolation &interpolation, const SkColorSpace intermediateColorSpace, const SkColorSpace dstColorSpace)

Static Public Member Functions inherited from SkShaderBase
static Type	GetFlattenableType ()

static sk_sp< SkShaderBase >	Deserialize (const void data, size_t size, const SkDeserialProcs procs=nullptr)

static void	RegisterFlattenables ()

static SkMatrix	ConcatLocalMatrices (const SkMatrix &parentLM, const SkMatrix &childLM)

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)

Protected Member Functions
void	flatten (SkWriteBuffer &buffer) const override

void	appendGradientStages (SkArenaAlloc alloc, SkRasterPipeline tPipeline, SkRasterPipeline *postPipeline) const override

Protected Member Functions inherited from SkGradientBaseShader
void	flatten (SkWriteBuffer &) const override

void	commonAsAGradient (GradientInfo *) const

bool	onAsLuminanceColor (SkColor4f *) const override

bool	appendStages (const SkStageRec &, const SkShaders::MatrixRec &) const override

Protected Member Functions inherited from SkShaderBase
	SkShaderBase ()

void	flatten (SkWriteBuffer &) const override

Additional Inherited Members
Public Attributes inherited from SkGradientBaseShader
SkColor4f *	fColors

SkScalar *	fPositions

int	fColorCount

sk_sp< SkColorSpace >	fColorSpace

Interpolation	fInterpolation

bool	fFirstStopIsImplicit

bool	fLastStopIsImplicit

Static Public Attributes inherited from SkGradientBaseShader
static constexpr SkScalar	kDegenerateThreshold = SK_Scalar1 / (1 << 15)

Protected Attributes inherited from SkGradientBaseShader
const SkMatrix	fPtsToUnit

SkTileMode	fTileMode

Detailed Description

Definition at line 24 of file SkConicalGradient.h.

Member Enumeration Documentation

◆ Type

enum class SkConicalGradient::Type

strong

Enumerator
kRadial
kStrip
kFocal

Definition at line 51 of file SkConicalGradient.h.

51{ kRadial, kStrip, kFocal };

SkConicalGradient::Type::kStrip

@ kStrip

SkConicalGradient::Type::kFocal

@ kFocal

SkConicalGradient::Type::kRadial

@ kRadial

Constructor & Destructor Documentation

◆ SkConicalGradient()

SkConicalGradient::SkConicalGradient	(	const SkPoint &	c0,
		SkScalar	r0,
		const SkPoint &	c1,
		SkScalar	r1,
		const Descriptor &	desc,
		Type	type,
		const SkMatrix &	gradientMatrix,
		const FocalData &	data
	)

Definition at line 110 of file SkConicalGradient.cpp.

        : SkGradientBaseShader(desc, gradientMatrix)
        , fCenter1(start)
        , fCenter2(end)
        , fRadius1(startRadius)
        , fRadius2(endRadius)
        , fType(type) {
    // this is degenerate, and should be caught by our caller
    SkASSERT(fCenter1 != fCenter2 || fRadius1 != fRadius2);
    if (type == Type::kFocal) {
        fFocalData = data;
    }
}

Member Function Documentation

◆ appendGradientStages()

void SkConicalGradient::appendGradientStages	(	SkArenaAlloc *	alloc,
		SkRasterPipeline *	tPipeline,
		SkRasterPipeline *	postPipeline
	)		const

overrideprotectedvirtual

Implements SkGradientBaseShader.

Definition at line 192 of file SkConicalGradient.cpp.

                                                                                   {
    const auto dRadius = fRadius2 - fRadius1;
 
    if (fType == Type::kRadial) {
        p->append(SkRasterPipelineOp::xy_to_radius);
 
        // Tiny twist: radial computes a t for [0, r2], but we want a t for [r1, r2].
        auto scale = std::max(fRadius1, fRadius2) / dRadius;
        auto bias = -fRadius1 / dRadius;
 
        p->appendMatrix(alloc, SkMatrix::Translate(bias, 0) * SkMatrix::Scale(scale, 1));
        return;
    }
 
    if (fType == Type::kStrip) {
        auto* ctx = alloc->make<SkRasterPipeline_2PtConicalCtx>();
        SkScalar scaledR0 = fRadius1 / this->getCenterX1();
        ctx->fP0 = scaledR0 * scaledR0;
        p->append(SkRasterPipelineOp::xy_to_2pt_conical_strip, ctx);
        p->append(SkRasterPipelineOp::mask_2pt_conical_nan, ctx);
        postPipeline->append(SkRasterPipelineOp::apply_vector_mask, &ctx->fMask);
        return;
    }
 
    auto* ctx = alloc->make<SkRasterPipeline_2PtConicalCtx>();
    ctx->fP0 = 1 / fFocalData.fR1;
    ctx->fP1 = fFocalData.fFocalX;
 
    if (fFocalData.isFocalOnCircle()) {
        p->append(SkRasterPipelineOp::xy_to_2pt_conical_focal_on_circle);
    } else if (fFocalData.isWellBehaved()) {
        p->append(SkRasterPipelineOp::xy_to_2pt_conical_well_behaved, ctx);
    } else if (fFocalData.isSwapped() || 1 - fFocalData.fFocalX < 0) {
        p->append(SkRasterPipelineOp::xy_to_2pt_conical_smaller, ctx);
    } else {
        p->append(SkRasterPipelineOp::xy_to_2pt_conical_greater, ctx);
    }
 
    if (!fFocalData.isWellBehaved()) {
        p->append(SkRasterPipelineOp::mask_2pt_conical_degenerates, ctx);
    }
    if (1 - fFocalData.fFocalX < 0) {
        p->append(SkRasterPipelineOp::negate_x);
    }
    if (!fFocalData.isNativelyFocal()) {
        p->append(SkRasterPipelineOp::alter_2pt_conical_compensate_focal, ctx);
    }
    if (fFocalData.isSwapped()) {
        p->append(SkRasterPipelineOp::alter_2pt_conical_unswap);
    }
    if (!fFocalData.isWellBehaved()) {
        postPipeline->append(SkRasterPipelineOp::apply_vector_mask, &ctx->fMask);
    }
}

◆ asGradient()

SkShaderBase::GradientType SkConicalGradient::asGradient	(	GradientInfo *	info,
		SkMatrix *	localMatrix
	)		const

overridevirtual

Reimplemented from SkShaderBase.

Definition at line 139 of file SkConicalGradient.cpp.

                                                                                      {
    if (info) {
        commonAsAGradient(info);
        info->fPoint[0] = fCenter1;
        info->fPoint[1] = fCenter2;
        info->fRadius[0] = fRadius1;
        info->fRadius[1] = fRadius2;
    }
    if (localMatrix) {
        *localMatrix = SkMatrix::I();
    }
    return GradientType::kConical;
}

◆ Create()

sk_sp< SkShader > SkConicalGradient::Create	(	const SkPoint &	start,
		SkScalar	startRadius,
		const SkPoint &	end,
		SkScalar	endRadius,
		const Descriptor &	desc,
		const SkMatrix *	localMatrix
	)

static

Definition at line 66 of file SkConicalGradient.cpp.

                                                                       {
    SkMatrix gradientMatrix;
    Type gradientType;
 
    if (SkScalarNearlyZero((c0 - c1).length())) {
        if (SkScalarNearlyZero(std::max(r0, r1)) || SkScalarNearlyEqual(r0, r1)) {
            // Degenerate case; avoid dividing by zero. Should have been caught by caller but
            // just in case, recheck here.
            return nullptr;
        }
        // Concentric case: we can pretend we're radial (with a tiny twist).
        const SkScalar scale = sk_ieee_float_divide(1, std::max(r0, r1));
        gradientMatrix = SkMatrix::Translate(-c1.x(), -c1.y());
        gradientMatrix.postScale(scale, scale);
 
        gradientType = Type::kRadial;
    } else {
        const SkPoint centers[2] = { c0    , c1     };
        const SkPoint unitvec[2] = { {0, 0}, {1, 0} };
 
        if (!gradientMatrix.setPolyToPoly(centers, unitvec, 2)) {
            // Degenerate case.
            return nullptr;
        }
 
        gradientType = SkScalarNearlyZero(r1 - r0) ? Type::kStrip : Type::kFocal;
    }
 
    FocalData focalData;
    if (gradientType == Type::kFocal) {
        const auto dCenter = (c0 - c1).length();
        if (!focalData.set(r0 / dCenter, r1 / dCenter, &gradientMatrix)) {
            return nullptr;
        }
    }
    return SkLocalMatrixShader::MakeWrapped<SkConicalGradient>(
            localMatrix, c0, r0, c1, r1, desc, gradientType, gradientMatrix, focalData);
}

◆ flatten()

void SkConicalGradient::flatten ( SkWriteBuffer & ) const

overrideprotectedvirtual

Override this if your subclass needs to record data that it will need to recreate itself from its CreateProc (returned by getFactory()).

DEPRECATED public : will move to protected ... use serialize() instead

Reimplemented from SkFlattenable.

Definition at line 184 of file SkConicalGradient.cpp.

                                                           {
    this->SkGradientBaseShader::flatten(buffer);
    buffer.writePoint(fCenter1);
    buffer.writePoint(fCenter2);
    buffer.writeScalar(fRadius1);
    buffer.writeScalar(fRadius2);
}

◆ getCenterX1()

SkScalar SkConicalGradient::getCenterX1 ( ) const

inline

Definition at line 63 of file SkConicalGradient.h.

63{ return SkPoint::Distance(fCenter1, fCenter2); }

SkPoint::Distance

static float Distance(const SkPoint &a, const SkPoint &b)

Definition SkPoint_impl.h:508

◆ getDiffRadius()

SkScalar SkConicalGradient::getDiffRadius ( ) const

inline

Definition at line 65 of file SkConicalGradient.h.

65{ return fRadius2 - fRadius1; }

◆ getEndCenter()

const SkPoint & SkConicalGradient::getEndCenter ( ) const

inline

Definition at line 67 of file SkConicalGradient.h.

67{ return fCenter2; }

◆ getEndRadius()

SkScalar SkConicalGradient::getEndRadius ( ) const

inline

Definition at line 68 of file SkConicalGradient.h.

68{ return fRadius2; }

◆ getFocalData()

const FocalData & SkConicalGradient::getFocalData ( ) const

inline

Definition at line 71 of file SkConicalGradient.h.

71{ return fFocalData; }

◆ getStartCenter()

const SkPoint & SkConicalGradient::getStartCenter ( ) const

inline

Definition at line 66 of file SkConicalGradient.h.

66{ return fCenter1; }

◆ getStartRadius()

SkScalar SkConicalGradient::getStartRadius ( ) const

inline

Definition at line 64 of file SkConicalGradient.h.

64{ return fRadius1; }

◆ getType()

Type SkConicalGradient::getType ( ) const

inline

Definition at line 70 of file SkConicalGradient.h.

70{ return fType; }

◆ isOpaque()

bool SkConicalGradient::isOpaque ( ) const

overridevirtual

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 from SkShader.

Definition at line 131 of file SkConicalGradient.cpp.

                                       {
    // Because areas outside the cone are left untouched, we cannot treat the
    // shader as opaque even if the gradient itself is opaque.
    // TODO(junov): Compute whether the cone fills the plane crbug.com/222380
    return false;
}

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

third_party/skia/src/shaders/gradients/SkConicalGradient.h
third_party/skia/src/shaders/gradients/SkConicalGradient.cpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ Type

Constructor & Destructor Documentation

◆ SkConicalGradient()

Member Function Documentation

◆ appendGradientStages()

◆ asGradient()

◆ Create()

◆ flatten()

◆ getCenterX1()

◆ getDiffRadius()

◆ getEndCenter()

◆ getEndRadius()

◆ getFocalData()

◆ getStartCenter()

◆ getStartRadius()

◆ getType()

◆ isOpaque()