#include <SkGradientShader.h>

Classes
struct	Interpolation

Public Types
enum	Flags { kInterpolateColorsInPremul_Flag = 1 << 0 }

Static Public Member Functions
static sk_sp< SkShader >	MakeLinear (const SkPoint pts[2], const SkColor colors[], const SkScalar pos[], int count, SkTileMode mode, uint32_t flags=0, const SkMatrix *localMatrix=nullptr)

static sk_sp< SkShader >	MakeLinear (const SkPoint pts[2], const SkColor4f colors[], sk_sp< SkColorSpace > colorSpace, const SkScalar pos[], int count, SkTileMode mode, const Interpolation &interpolation, const SkMatrix *localMatrix)

static sk_sp< SkShader >	MakeLinear (const SkPoint pts[2], const SkColor4f colors[], sk_sp< SkColorSpace > colorSpace, const SkScalar pos[], int count, SkTileMode mode, uint32_t flags=0, const SkMatrix *localMatrix=nullptr)

static sk_sp< SkShader >	MakeRadial (const SkPoint &center, SkScalar radius, const SkColor colors[], const SkScalar pos[], int count, SkTileMode mode, uint32_t flags=0, const SkMatrix *localMatrix=nullptr)

static sk_sp< SkShader >	MakeRadial (const SkPoint &center, SkScalar radius, const SkColor4f colors[], sk_sp< SkColorSpace > colorSpace, const SkScalar pos[], int count, SkTileMode mode, const Interpolation &interpolation, const SkMatrix *localMatrix)

static sk_sp< SkShader >	MakeRadial (const SkPoint &center, SkScalar radius, const SkColor4f colors[], sk_sp< SkColorSpace > colorSpace, const SkScalar pos[], int count, SkTileMode mode, uint32_t flags=0, const SkMatrix *localMatrix=nullptr)

static sk_sp< SkShader >	MakeTwoPointConical (const SkPoint &start, SkScalar startRadius, const SkPoint &end, SkScalar endRadius, const SkColor colors[], const SkScalar pos[], int count, SkTileMode mode, uint32_t flags=0, const SkMatrix *localMatrix=nullptr)

static sk_sp< SkShader >	MakeTwoPointConical (const SkPoint &start, SkScalar startRadius, const SkPoint &end, SkScalar endRadius, const SkColor4f colors[], sk_sp< SkColorSpace > colorSpace, const SkScalar pos[], int count, SkTileMode mode, const Interpolation &interpolation, const SkMatrix *localMatrix)

static sk_sp< SkShader >	MakeTwoPointConical (const SkPoint &start, SkScalar startRadius, const SkPoint &end, SkScalar endRadius, const SkColor4f colors[], sk_sp< SkColorSpace > colorSpace, const SkScalar pos[], int count, SkTileMode mode, uint32_t flags=0, const SkMatrix *localMatrix=nullptr)

static sk_sp< SkShader >	MakeSweep (SkScalar cx, SkScalar cy, const SkColor colors[], const SkScalar pos[], int count, SkTileMode mode, SkScalar startAngle, SkScalar endAngle, uint32_t flags, const SkMatrix *localMatrix)

static sk_sp< SkShader >	MakeSweep (SkScalar cx, SkScalar cy, const SkColor colors[], const SkScalar pos[], int count, uint32_t flags=0, const SkMatrix *localMatrix=nullptr)

static sk_sp< SkShader >	MakeSweep (SkScalar cx, SkScalar cy, const SkColor4f colors[], sk_sp< SkColorSpace > colorSpace, const SkScalar pos[], int count, SkTileMode mode, SkScalar startAngle, SkScalar endAngle, const Interpolation &interpolation, const SkMatrix *localMatrix)

static sk_sp< SkShader >	MakeSweep (SkScalar cx, SkScalar cy, const SkColor4f colors[], sk_sp< SkColorSpace > colorSpace, const SkScalar pos[], int count, SkTileMode mode, SkScalar startAngle, SkScalar endAngle, uint32_t flags, const SkMatrix *localMatrix)

static sk_sp< SkShader >	MakeSweep (SkScalar cx, SkScalar cy, const SkColor4f colors[], sk_sp< SkColorSpace > colorSpace, const SkScalar pos[], int count, uint32_t flags=0, const SkMatrix *localMatrix=nullptr)

Detailed Description

SkGradientShader hosts factories for creating subclasses of SkShader that render linear and radial gradients. In general, degenerate cases should not produce surprising results, but there are several types of degeneracies:

A linear gradient made from the same two points. A radial gradient with a radius of zero. A sweep gradient where the start and end angle are the same. A two point conical gradient where the two centers and the two radii are the same.

For any degenerate gradient with a decal tile mode, it will draw empty since the interpolating region is zero area and the outer region is discarded by the decal mode.

For any degenerate gradient with a repeat or mirror tile mode, it will draw a solid color that is the average gradient color, since infinitely many repetitions of the gradients will fill the shape.

For a clamped gradient, every type is well-defined at the limit except for linear gradients. The radial gradient with zero radius becomes the last color. The sweep gradient draws the sector from 0 to the provided angle with the first color, with a hardstop switching to the last color. When the provided angle is 0, this is just the solid last color again. Similarly, the two point conical gradient becomes a circle filled with the first color, sized to the provided radius, with a hardstop switching to the last color. When the two radii are both zero, this is just the solid last color.

As a linear gradient approaches the degenerate case, its shader will approach the appearance of two half planes, each filled by the first and last colors of the gradient. The planes will be oriented perpendicular to the vector between the two defining points of the gradient. However, once they become the same point, Skia cannot reconstruct what that expected orientation is. To provide a stable and predictable color in this case, Skia just uses the last color as a solid fill to be similar to many of the other degenerate gradients' behaviors in clamp mode.

Definition at line 59 of file SkGradientShader.h.

Member Enumeration Documentation

◆ Flags

enum SkGradientShader::Flags

Enumerator
kInterpolateColorsInPremul_Flag	By default gradients will interpolate their colors in unpremul space and then premultiply each of the results. By setting this flag, the gradients will premultiply their colors first, and then interpolate between them. example: https://fiddle.skia.org/c/@GradientShader_MakeLinear

Definition at line 61 of file SkGradientShader.h.

               {
        /** By default gradients will interpolate their colors in unpremul space
         *  and then premultiply each of the results. By setting this flag, the
         *  gradients will premultiply their colors first, and then interpolate
         *  between them.
         *  example: https://fiddle.skia.org/c/@GradientShader_MakeLinear
         */
        kInterpolateColorsInPremul_Flag = 1 << 0,
    };

Member Function Documentation

◆ MakeLinear() [1/3]

sk_sp< SkShader > SkGradientShader::MakeLinear	(	const SkPoint	pts[2],
		const SkColor	colors[],
		const SkScalar	pos[],
		int	count,
		SkTileMode	mode,
		uint32_t	flags = `0`,
		const SkMatrix *	localMatrix = `nullptr`
	)

static

Returns a shader that generates a linear gradient between the two specified points.

Parameters

pts	The start and end points for the gradient.
colors	The array[count] of colors, to be distributed between the two points
pos	May be NULL. array[count] of SkScalars, or NULL, of the relative position of each corresponding color in the colors array. If this is NULL, the the colors are distributed evenly between the start and end point. If this is not null, the values must lie between 0.0 and 1.0, and be strictly increasing. If the first value is not 0.0, then an additional color stop is added at position 0.0, with the same color as colors[0]. If the the last value is not 1.0, then an additional color stop is added at position 1.0, with the same color as colors[count - 1].
count	Must be >=2. The number of colors (and pos if not NULL) entries.
mode	The tiling mode

example: https://fiddle.skia.org/c/@GradientShader_MakeLinear

Definition at line 131 of file SkLinearGradient.cpp.

                                                                          {
    SkColorConverter converter(colors, colorCount);
    return MakeLinear(pts, converter.fColors4f.begin(), nullptr, pos, colorCount, mode, flags,
                      localMatrix);
}

◆ MakeLinear() [2/3]

sk_sp< SkShader > SkGradientShader::MakeLinear	(	const SkPoint	pts[2],
		const SkColor4f	colors[],
		sk_sp< SkColorSpace >	colorSpace,
		const SkScalar	pos[],
		int	count,
		SkTileMode	mode,
		const Interpolation &	interpolation,
		const SkMatrix *	localMatrix
	)

static

Returns a shader that generates a linear gradient between the two specified points.

Parameters

pts	The start and end points for the gradient.
colors	The array[count] of colors, to be distributed between the two points
pos	May be NULL. array[count] of SkScalars, or NULL, of the relative position of each corresponding color in the colors array. If this is NULL, the the colors are distributed evenly between the start and end point. If this is not null, the values must lie between 0.0 and 1.0, and be strictly increasing. If the first value is not 0.0, then an additional color stop is added at position 0.0, with the same color as colors[0]. If the the last value is not 1.0, then an additional color stop is added at position 1.0, with the same color as colors[count - 1].
count	Must be >=2. The number of colors (and pos if not NULL) entries.
mode	The tiling mode

example: https://fiddle.skia.org/c/@GradientShader_MakeLinear

Definition at line 95 of file SkLinearGradient.cpp.

                                                                          {
    if (!pts || !SkIsFinite((pts[1] - pts[0]).length())) {
        return nullptr;
    }
    if (!SkGradientBaseShader::ValidGradient(colors, colorCount, mode, interpolation)) {
        return nullptr;
    }
    if (1 == colorCount) {
        return SkShaders::Color(colors[0], std::move(colorSpace));
    }
    if (localMatrix && !localMatrix->invert(nullptr)) {
        return nullptr;
    }
 
    if (SkScalarNearlyZero((pts[1] - pts[0]).length(),
                           SkGradientBaseShader::kDegenerateThreshold)) {
        // Degenerate gradient, the only tricky complication is when in clamp mode, the limit of
        // the gradient approaches two half planes of solid color (first and last). However, they
        // are divided by the line perpendicular to the start and end point, which becomes undefined
        // once start and end are exactly the same, so just use the end color for a stable solution.
        return SkGradientBaseShader::MakeDegenerateGradient(
                colors, pos, colorCount, std::move(colorSpace), mode);
    }
 
    SkGradientBaseShader::Descriptor desc(
            colors, std::move(colorSpace), pos, colorCount, mode, interpolation);
    return SkLocalMatrixShader::MakeWrapped<SkLinearGradient>(localMatrix, pts, desc);
}

◆ MakeLinear() [3/3]

static sk_sp< SkShader > SkGradientShader::MakeLinear	(	const SkPoint	pts[2],
		const SkColor4f	colors[],
		sk_sp< SkColorSpace >	colorSpace,
		const SkScalar	pos[],
		int	count,
		SkTileMode	mode,
		uint32_t	flags = `0`,
		const SkMatrix *	localMatrix = `nullptr`
	)

inlinestatic

Definition at line 167 of file SkGradientShader.h.

                                                                                                 {
        return MakeLinear(pts, colors, std::move(colorSpace), pos, count, mode,
                          Interpolation::FromFlags(flags), localMatrix);
    }

◆ MakeRadial() [1/3]

sk_sp< SkShader > SkGradientShader::MakeRadial	(	const SkPoint &	center,
		SkScalar	radius,
		const SkColor	colors[],
		const SkScalar	pos[],
		int	count,
		SkTileMode	mode,
		uint32_t	flags = `0`,
		const SkMatrix *	localMatrix = `nullptr`
	)

static

Returns a shader that generates a radial gradient given the center and radius.

Parameters

center	The center of the circle for this gradient
radius	Must be positive. The radius of the circle for this gradient
colors	The array[count] of colors, to be distributed between the center and edge of the circle
pos	May be NULL. The array[count] of SkScalars, or NULL, of the relative position of each corresponding color in the colors array. If this is NULL, the the colors are distributed evenly between the center and edge of the circle. If this is not null, the values must lie between 0.0 and 1.0, and be strictly increasing. If the first value is not 0.0, then an additional color stop is added at position 0.0, with the same color as colors[0]. If the the last value is not 1.0, then an additional color stop is added at position 1.0, with the same color as colors[count - 1].
count	Must be >= 2. The number of colors (and pos if not NULL) entries
mode	The tiling mode

Definition at line 122 of file SkRadialGradient.cpp.

                                                                          {
    SkColorConverter converter(colors, colorCount);
    return MakeRadial(center, radius, converter.fColors4f.begin(), nullptr, pos, colorCount, mode,
                      flags, localMatrix);
}

◆ MakeRadial() [2/3]

sk_sp< SkShader > SkGradientShader::MakeRadial	(	const SkPoint &	center,
		SkScalar	radius,
		const SkColor4f	colors[],
		sk_sp< SkColorSpace >	colorSpace,
		const SkScalar	pos[],
		int	count,
		SkTileMode	mode,
		const Interpolation &	interpolation,
		const SkMatrix *	localMatrix
	)

static

Returns a shader that generates a radial gradient given the center and radius.

Parameters

center	The center of the circle for this gradient
radius	Must be positive. The radius of the circle for this gradient
colors	The array[count] of colors, to be distributed between the center and edge of the circle
pos	May be NULL. The array[count] of SkScalars, or NULL, of the relative position of each corresponding color in the colors array. If this is NULL, the the colors are distributed evenly between the center and edge of the circle. If this is not null, the values must lie between 0.0 and 1.0, and be strictly increasing. If the first value is not 0.0, then an additional color stop is added at position 0.0, with the same color as colors[0]. If the the last value is not 1.0, then an additional color stop is added at position 1.0, with the same color as colors[count - 1].
count	Must be >= 2. The number of colors (and pos if not NULL) entries
mode	The tiling mode

Definition at line 90 of file SkRadialGradient.cpp.

                                                                          {
    if (radius < 0) {
        return nullptr;
    }
    if (!SkGradientBaseShader::ValidGradient(colors, colorCount, mode, interpolation)) {
        return nullptr;
    }
    if (1 == colorCount) {
        return SkShaders::Color(colors[0], std::move(colorSpace));
    }
    if (localMatrix && !localMatrix->invert(nullptr)) {
        return nullptr;
    }
 
    if (SkScalarNearlyZero(radius, SkGradientBaseShader::kDegenerateThreshold)) {
        // Degenerate gradient optimization, and no special logic needed for clamped radial gradient
        return SkGradientBaseShader::MakeDegenerateGradient(
                colors, pos, colorCount, std::move(colorSpace), mode);
    }
 
    SkGradientBaseShader::Descriptor desc(
            colors, std::move(colorSpace), pos, colorCount, mode, interpolation);
    return SkLocalMatrixShader::MakeWrapped<SkRadialGradient>(localMatrix, center, radius, desc);
}

◆ MakeRadial() [3/3]

static sk_sp< SkShader > SkGradientShader::MakeRadial	(	const SkPoint &	center,
		SkScalar	radius,
		const SkColor4f	colors[],
		sk_sp< SkColorSpace >	colorSpace,
		const SkScalar	pos[],
		int	count,
		SkTileMode	mode,
		uint32_t	flags = `0`,
		const SkMatrix *	localMatrix = `nullptr`
	)

inlinestatic

Definition at line 217 of file SkGradientShader.h.

                                                                                                 {
        return MakeRadial(center, radius, colors, std::move(colorSpace), pos, count, mode,
                          Interpolation::FromFlags(flags), localMatrix);
    }

◆ MakeSweep() [1/5]

sk_sp< SkShader > SkGradientShader::MakeSweep	(	SkScalar	cx,
		SkScalar	cy,
		const SkColor	colors[],
		const SkScalar	pos[],
		int	count,
		SkTileMode	mode,
		SkScalar	startAngle,
		SkScalar	endAngle,
		uint32_t	flags,
		const SkMatrix *	localMatrix
	)

static

Returns a shader that generates a sweep gradient given a center.

The shader accepts negative angles and angles larger than 360, draws between 0 and 360 degrees, similar to the CSS conic-gradient semantics. 0 degrees means horizontal positive x axis. The start angle must be less than the end angle, otherwise a null pointer is returned. If color stops do not contain 0 and 1 but are within this range, the respective outer color stop is repeated for 0 and 1. Color stops less than 0 are clamped to 0, and greater than 1 are clamped to 1.

Parameters

cx	The X coordinate of the center of the sweep
cx	The Y coordinate of the center of the sweep
colors	The array[count] of colors, to be distributed around the center, within the gradient angle range.
pos	May be NULL. The array[count] of SkScalars, or NULL, of the relative position of each corresponding color in the colors array. If this is NULL, then the colors are distributed evenly within the angular range. If this is not null, the values must lie between 0.0 and 1.0, and be strictly increasing. If the first value is not 0.0, then an additional color stop is added at position 0.0, with the same color as colors[0]. If the the last value is not 1.0, then an additional color stop is added at position 1.0, with the same color as colors[count - 1].
count	Must be >= 2. The number of colors (and pos if not NULL) entries
mode	Tiling mode: controls drawing outside of the gradient angular range.
startAngle	Start of the angular range, corresponding to pos == 0.
endAngle	End of the angular range, corresponding to pos == 1.

Definition at line 158 of file SkSweepGradient.cpp.

                                                                         {
    SkColorConverter converter(colors, colorCount);
    return MakeSweep(cx, cy, converter.fColors4f.begin(), nullptr, pos, colorCount,
                     mode, startAngle, endAngle, flags, localMatrix);
}

◆ MakeSweep() [2/5]

static sk_sp< SkShader > SkGradientShader::MakeSweep	(	SkScalar	cx,
		SkScalar	cy,
		const SkColor	colors[],
		const SkScalar	pos[],
		int	count,
		uint32_t	flags = `0`,
		const SkMatrix *	localMatrix = `nullptr`
	)

inlinestatic

Definition at line 295 of file SkGradientShader.h.

                                                                                                {
        return MakeSweep(cx, cy, colors, pos, count, SkTileMode::kClamp, 0, 360, flags,
                         localMatrix);
    }

◆ MakeSweep() [3/5]

sk_sp< SkShader > SkGradientShader::MakeSweep	(	SkScalar	cx,
		SkScalar	cy,
		const SkColor4f	colors[],
		sk_sp< SkColorSpace >	colorSpace,
		const SkScalar	pos[],
		int	count,
		SkTileMode	mode,
		SkScalar	startAngle,
		SkScalar	endAngle,
		const Interpolation &	interpolation,
		const SkMatrix *	localMatrix
	)

static

Returns a shader that generates a sweep gradient given a center.

The shader accepts negative angles and angles larger than 360, draws between 0 and 360 degrees, similar to the CSS conic-gradient semantics. 0 degrees means horizontal positive x axis. The start angle must be less than the end angle, otherwise a null pointer is returned. If color stops do not contain 0 and 1 but are within this range, the respective outer color stop is repeated for 0 and 1. Color stops less than 0 are clamped to 0, and greater than 1 are clamped to 1.

Parameters

cx	The X coordinate of the center of the sweep
cx	The Y coordinate of the center of the sweep
colors	The array[count] of colors, to be distributed around the center, within the gradient angle range.
pos	May be NULL. The array[count] of SkScalars, or NULL, of the relative position of each corresponding color in the colors array. If this is NULL, then the colors are distributed evenly within the angular range. If this is not null, the values must lie between 0.0 and 1.0, and be strictly increasing. If the first value is not 0.0, then an additional color stop is added at position 0.0, with the same color as colors[0]. If the the last value is not 1.0, then an additional color stop is added at position 1.0, with the same color as colors[count - 1].
count	Must be >= 2. The number of colors (and pos if not NULL) entries
mode	Tiling mode: controls drawing outside of the gradient angular range.
startAngle	Start of the angular range, corresponding to pos == 0.
endAngle	End of the angular range, corresponding to pos == 1.

Definition at line 101 of file SkSweepGradient.cpp.

                                                                         {
    if (!SkGradientBaseShader::ValidGradient(colors, colorCount, mode, interpolation)) {
        return nullptr;
    }
    if (1 == colorCount) {
        return SkShaders::Color(colors[0], std::move(colorSpace));
    }
    if (!SkIsFinite(startAngle, endAngle) || startAngle > endAngle) {
        return nullptr;
    }
    if (localMatrix && !localMatrix->invert(nullptr)) {
        return nullptr;
    }
 
    if (SkScalarNearlyEqual(startAngle, endAngle, SkGradientBaseShader::kDegenerateThreshold)) {
        // Degenerate gradient, which should follow default degenerate behavior unless it is
        // clamped and the angle is greater than 0.
        if (mode == SkTileMode::kClamp && endAngle > SkGradientBaseShader::kDegenerateThreshold) {
            // In this case, the first color is repeated from 0 to the angle, then a hardstop
            // switches to the last color (all other colors are compressed to the infinitely thin
            // interpolation region).
            static constexpr SkScalar clampPos[3] = {0, 1, 1};
            SkColor4f reColors[3] = {colors[0], colors[0], colors[colorCount - 1]};
            return MakeSweep(cx, cy, reColors, std::move(colorSpace), clampPos, 3, mode, 0,
                             endAngle, interpolation, localMatrix);
        } else {
            return SkGradientBaseShader::MakeDegenerateGradient(
                    colors, pos, colorCount, std::move(colorSpace), mode);
        }
    }
 
    if (startAngle <= 0 && endAngle >= 360) {
        // If the t-range includes [0,1], then we can always use clamping (presumably faster).
        mode = SkTileMode::kClamp;
    }
 
    SkGradientBaseShader::Descriptor desc(
            colors, std::move(colorSpace), pos, colorCount, mode, interpolation);
 
    const SkScalar t0 = startAngle / 360,
                   t1 =   endAngle / 360;
 
    return SkLocalMatrixShader::MakeWrapped<SkSweepGradient>(localMatrix,
                                                             SkPoint::Make(cx, cy),
                                                             t0, t1,
                                                             desc);
}

◆ MakeSweep() [4/5]

static sk_sp< SkShader > SkGradientShader::MakeSweep	(	SkScalar	cx,
		SkScalar	cy,
		const SkColor4f	colors[],
		sk_sp< SkColorSpace >	colorSpace,
		const SkScalar	pos[],
		int	count,
		SkTileMode	mode,
		SkScalar	startAngle,
		SkScalar	endAngle,
		uint32_t	flags,
		const SkMatrix *	localMatrix
	)

inlinestatic

Definition at line 336 of file SkGradientShader.h.

                                                                                  {
        return MakeSweep(cx, cy, colors, std::move(colorSpace), pos, count, mode, startAngle,
                         endAngle, Interpolation::FromFlags(flags), localMatrix);
    }

◆ MakeSweep() [5/5]

static sk_sp< SkShader > SkGradientShader::MakeSweep	(	SkScalar	cx,
		SkScalar	cy,
		const SkColor4f	colors[],
		sk_sp< SkColorSpace >	colorSpace,
		const SkScalar	pos[],
		int	count,
		uint32_t	flags = `0`,
		const SkMatrix *	localMatrix = `nullptr`
	)

inlinestatic

Definition at line 345 of file SkGradientShader.h.

                                                                                                {
        return MakeSweep(cx, cy, colors, std::move(colorSpace), pos, count, SkTileMode::kClamp,
                         0, 360, flags, localMatrix);
    }

◆ MakeTwoPointConical() [1/3]

sk_sp< SkShader > SkGradientShader::MakeTwoPointConical	(	const SkPoint &	start,
		SkScalar	startRadius,
		const SkPoint &	end,
		SkScalar	endRadius,
		const SkColor	colors[],
		const SkScalar	pos[],
		int	count,
		SkTileMode	mode,
		uint32_t	flags = `0`,
		const SkMatrix *	localMatrix = `nullptr`
	)

static

Returns a shader that generates a conical gradient given two circles, or returns NULL if the inputs are invalid. The gradient interprets the two circles according to the following HTML spec. http://dev.w3.org/html5/2dcontext/#dom-context-2d-createradialgradient

Definition at line 337 of file SkConicalGradient.cpp.

                                                                                   {
    SkColorConverter converter(colors, colorCount);
    return MakeTwoPointConical(start,
                               startRadius,
                               end,
                               endRadius,
                               converter.fColors4f.begin(),
                               nullptr,
                               pos,
                               colorCount,
                               mode,
                               flags,
                               localMatrix);
}

◆ MakeTwoPointConical() [2/3]

sk_sp< SkShader > SkGradientShader::MakeTwoPointConical	(	const SkPoint &	start,
		SkScalar	startRadius,
		const SkPoint &	end,
		SkScalar	endRadius,
		const SkColor4f	colors[],
		sk_sp< SkColorSpace >	colorSpace,
		const SkScalar	pos[],
		int	count,
		SkTileMode	mode,
		const Interpolation &	interpolation,
		const SkMatrix *	localMatrix
	)

static

Returns a shader that generates a conical gradient given two circles, or returns NULL if the inputs are invalid. The gradient interprets the two circles according to the following HTML spec. http://dev.w3.org/html5/2dcontext/#dom-context-2d-createradialgradient

Definition at line 261 of file SkConicalGradient.cpp.

                                                                                   {
    if (startRadius < 0 || endRadius < 0) {
        return nullptr;
    }
    if (!SkGradientBaseShader::ValidGradient(colors, colorCount, mode, interpolation)) {
        return nullptr;
    }
    if (SkScalarNearlyZero((start - end).length(), SkGradientBaseShader::kDegenerateThreshold)) {
        // If the center positions are the same, then the gradient is the radial variant of a 2 pt
        // conical gradient, an actual radial gradient (startRadius == 0), or it is fully degenerate
        // (startRadius == endRadius).
        if (SkScalarNearlyEqual(
                    startRadius, endRadius, SkGradientBaseShader::kDegenerateThreshold)) {
            // Degenerate case, where the interpolation region area approaches zero. The proper
            // behavior depends on the tile mode, which is consistent with the default degenerate
            // gradient behavior, except when mode = clamp and the radii > 0.
            if (mode == SkTileMode::kClamp &&
                endRadius > SkGradientBaseShader::kDegenerateThreshold) {
                // The interpolation region becomes an infinitely thin ring at the radius, so the
                // final gradient will be the first color repeated from p=0 to 1, and then a hard
                // stop switching to the last color at p=1.
                static constexpr SkScalar circlePos[3] = {0, 1, 1};
                SkColor4f reColors[3] = {colors[0], colors[0], colors[colorCount - 1]};
                return MakeRadial(start,
                                  endRadius,
                                  reColors,
                                  std::move(colorSpace),
                                  circlePos,
                                  3,
                                  mode,
                                  interpolation,
                                  localMatrix);
            } else {
                // Otherwise use the default degenerate case
                return SkGradientBaseShader::MakeDegenerateGradient(
                        colors, pos, colorCount, std::move(colorSpace), mode);
            }
        } else if (SkScalarNearlyZero(startRadius, SkGradientBaseShader::kDegenerateThreshold)) {
            // We can treat this gradient as radial, which is faster. If we got here, we know
            // that endRadius is not equal to 0, so this produces a meaningful gradient
            return MakeRadial(start,
                              endRadius,
                              colors,
                              std::move(colorSpace),
                              pos,
                              colorCount,
                              mode,
                              interpolation,
                              localMatrix);
        }
        // Else it's the 2pt conical radial variant with no degenerate radii, so fall through to the
        // regular 2pt constructor.
    }
 
    if (localMatrix && !localMatrix->invert(nullptr)) {
        return nullptr;
    }
    EXPAND_1_COLOR(colorCount);
 
    SkGradientBaseShader::Descriptor desc(
            colors, std::move(colorSpace), pos, colorCount, mode, interpolation);
    return SkConicalGradient::Create(start, startRadius, end, endRadius, desc, localMatrix);
}

◆ MakeTwoPointConical() [3/3]

static sk_sp< SkShader > SkGradientShader::MakeTwoPointConical	(	const SkPoint &	start,
		SkScalar	startRadius,
		const SkPoint &	end,
		SkScalar	endRadius,
		const SkColor4f	colors[],
		sk_sp< SkColorSpace >	colorSpace,
		const SkScalar	pos[],
		int	count,
		SkTileMode	mode,
		uint32_t	flags = `0`,
		const SkMatrix *	localMatrix = `nullptr`
	)

inlinestatic

Definition at line 251 of file SkGradientShader.h.

                                                                                      {
        return MakeTwoPointConical(start, startRadius, end, endRadius, colors,
                                   std::move(colorSpace), pos, count, mode,
                                   Interpolation::FromFlags(flags), localMatrix);
    }

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

third_party/skia/include/effects/SkGradientShader.h
third_party/skia/src/shaders/gradients/SkConicalGradient.cpp
third_party/skia/src/shaders/gradients/SkLinearGradient.cpp
third_party/skia/src/shaders/gradients/SkRadialGradient.cpp
third_party/skia/src/shaders/gradients/SkSweepGradient.cpp

Classes

Public Types

Static Public Member Functions

Detailed Description

Member Enumeration Documentation

◆ Flags

Member Function Documentation

◆ MakeLinear() [1/3]

◆ MakeLinear() [2/3]

◆ MakeLinear() [3/3]

◆ MakeRadial() [1/3]

◆ MakeRadial() [2/3]

◆ MakeRadial() [3/3]

◆ MakeSweep() [1/5]

◆ MakeSweep() [2/5]

◆ MakeSweep() [3/5]

◆ MakeSweep() [4/5]

◆ MakeSweep() [5/5]

◆ MakeTwoPointConical() [1/3]

◆ MakeTwoPointConical() [2/3]

◆ MakeTwoPointConical() [3/3]