#include <SkGradientBaseShader.h>

Inheritance diagram for SkGradientBaseShader:

Classes
struct	Descriptor

class	DescriptorScope

Public Types
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
	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

virtual ShaderType	type () const =0

virtual GradientType	asGradient (GradientInfo info=nullptr, SkMatrix localMatrix=nullptr) const

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

bool	asLuminanceColor (SkColor4f *) const

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

virtual bool	appendStages (const SkStageRec &, const SkShaders::MatrixRec &) const =0

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

Static Public Member Functions
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)

Public Attributes
SkColor4f *	fColors

SkScalar *	fPositions

int	fColorCount

sk_sp< SkColorSpace >	fColorSpace

Interpolation	fInterpolation

bool	fFirstStopIsImplicit

bool	fLastStopIsImplicit

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

Protected Member Functions
void	flatten (SkWriteBuffer &) const override

void	commonAsAGradient (GradientInfo *) const

bool	onAsLuminanceColor (SkColor4f *) const override

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

virtual void	appendGradientStages (SkArenaAlloc alloc, SkRasterPipeline tPipeline, SkRasterPipeline *postPipeline) const =0

Protected Member Functions inherited from SkShaderBase
	SkShaderBase ()

void	flatten (SkWriteBuffer &) const override

virtual bool	onAsLuminanceColor (SkColor4f *) const

Protected Attributes
const SkMatrix	fPtsToUnit

SkTileMode	fTileMode

Detailed Description

Definition at line 35 of file SkGradientBaseShader.h.

Member Typedef Documentation

◆ Interpolation

using SkGradientBaseShader::Interpolation = SkGradientShader::Interpolation

Definition at line 37 of file SkGradientBaseShader.h.

Constructor & Destructor Documentation

◆ SkGradientBaseShader()

SkGradientBaseShader::SkGradientBaseShader	(	const Descriptor &	desc,
		const SkMatrix &	ptsToUnit
	)

Definition at line 178 of file SkGradientBaseShader.cpp.

        : fPtsToUnit(ptsToUnit)
        , fColorSpace(desc.fColorSpace ? desc.fColorSpace : SkColorSpace::MakeSRGB())
        , fFirstStopIsImplicit(false)
        , fLastStopIsImplicit(false)
        , fColorsAreOpaque(true) {
    fPtsToUnit.getType();  // Precache so reads are threadsafe.
    SkASSERT(desc.fColorCount > 1);
 
    fInterpolation = desc.fInterpolation;
 
    SkASSERT((unsigned)desc.fTileMode < kSkTileModeCount);
    fTileMode = desc.fTileMode;
 
    /*  Note: we let the caller skip the first and/or last position.
        i.e. pos[0] = 0.3, pos[1] = 0.7
        In these cases, we insert entries to ensure that the final data
        will be bracketed by [0, 1].
        i.e. our_pos[0] = 0, our_pos[1] = 0.3, our_pos[2] = 0.7, our_pos[3] = 1
 
        Thus colorCount (the caller's value, and fColorCount (our value) may
        differ by up to 2. In the above example:
            colorCount = 2
            fColorCount = 4
     */
    fColorCount = desc.fColorCount;
 
    // Check if we need to add in start and/or end position/colors
    if (desc.fPositions) {
        fFirstStopIsImplicit = desc.fPositions[0] > 0;
        fLastStopIsImplicit = desc.fPositions[desc.fColorCount - 1] != SK_Scalar1;
        fColorCount += fFirstStopIsImplicit + fLastStopIsImplicit;
    }
 
    size_t storageSize =
            fColorCount * (sizeof(SkColor4f) + (desc.fPositions ? sizeof(SkScalar) : 0));
    fColors = reinterpret_cast<SkColor4f*>(fStorage.reset(storageSize));
    fPositions = desc.fPositions ? reinterpret_cast<SkScalar*>(fColors + fColorCount) : nullptr;
 
    // Now copy over the colors, adding the duplicates at t=0 and t=1 as needed
    SkColor4f* colors = fColors;
    if (fFirstStopIsImplicit) {
        *colors++ = desc.fColors[0];
    }
    for (int i = 0; i < desc.fColorCount; ++i) {
        colors[i] = desc.fColors[i];
        fColorsAreOpaque = fColorsAreOpaque && (desc.fColors[i].fA == 1);
    }
    if (fLastStopIsImplicit) {
        colors += desc.fColorCount;
        *colors = desc.fColors[desc.fColorCount - 1];
    }
 
    if (desc.fPositions) {
        SkScalar prev = 0;
        SkScalar* positions = fPositions;
        *positions++ = prev;  // force the first pos to 0
 
        int startIndex = fFirstStopIsImplicit ? 0 : 1;
        int count = desc.fColorCount + fLastStopIsImplicit;
 
        bool uniformStops = true;
        const SkScalar uniformStep = desc.fPositions[startIndex] - prev;
        for (int i = startIndex; i < count; i++) {
            // Pin the last value to 1.0, and make sure pos is monotonic.
            float curr = 1.0f;
            if (i != desc.fColorCount) {
                curr = SkTPin(desc.fPositions[i], prev, 1.0f);
 
                // If a value is clamped to 1.0 before the last stop, the last stop
                // actually isn't implicit if we thought it was.
                if (curr == 1.0f && fLastStopIsImplicit) {
                    fLastStopIsImplicit = false;
                }
            }
 
            uniformStops &= SkScalarNearlyEqual(uniformStep, curr - prev);
 
            *positions++ = prev = curr;
        }
 
        if (uniformStops) {
            // If the stops are uniform, treat them as implicit.
            fPositions = nullptr;
        } else {
            // Remove duplicate stops with more than two of the same stop,
            // keeping the leftmost and rightmost stop colors.
            // i.e.       0, 0, 0,   0.2, 0.2, 0.3, 0.3, 0.3, 1, 1
            // w/  clamp  0,    0,   0.2, 0.2, 0.3,      0.3, 1, 1
            // w/o clamp        0,   0.2, 0.2, 0.3,      0.3, 1
            int i = 0;
            int dedupedColorCount = 0;
            for (int j = 1; j <= fColorCount; j++) {
                // We can compare the current positions at i and j since once these fPosition
                // values are overwritten, our i and j pointers will be past the overwritten values.
                if (j == fColorCount || fPositions[i] != fPositions[j]) {
                    bool dupStop = j - i > 1;
 
                    // Ignore the leftmost stop (i) if it is a non-clamp tilemode with
                    // a duplicate stop on t = 0.
                    bool ignoreLeftmost = dupStop && fTileMode != SkTileMode::kClamp
                                                    && fPositions[i] == 0;
                    if (!ignoreLeftmost) {
                        fPositions[dedupedColorCount] = fPositions[i];
                        fColors[dedupedColorCount] =  fColors[i];
                        dedupedColorCount++;
                    }
 
                    // Include the rightmost stop (j-1) only if the stop has a duplicate,
                    // ignoring the rightmost stop if it is a non-clamp tilemode with t = 1.
                    bool ignoreRightmost = fTileMode != SkTileMode::kClamp
                                                    && fPositions[j - 1] == 1;
                    if (dupStop && !ignoreRightmost) {
                        fPositions[dedupedColorCount] = fPositions[j - 1];
                        fColors[dedupedColorCount] = fColors[j - 1];
                        dedupedColorCount++;
                    }
                    i = j;
                }
            }
            fColorCount = dedupedColorCount;
        }
    }
}

◆ ~SkGradientBaseShader()

SkGradientBaseShader::~SkGradientBaseShader ( )

override

Definition at line 303 of file SkGradientBaseShader.cpp.

303{}

Member Function Documentation

◆ AppendGradientFillStages()

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

static

Definition at line 372 of file SkGradientBaseShader.cpp.

                                                               {
    // The two-stop case with stops at 0 and 1.
    if (count == 2 && positions == nullptr) {
        const SkPMColor4f c_l = pmColors[0], c_r = pmColors[1];
 
        // See F and B below.
        auto ctx = alloc->make<SkRasterPipeline_EvenlySpaced2StopGradientCtx>();
        (skvx::float4::Load(c_r.vec()) - skvx::float4::Load(c_l.vec())).store(ctx->f);
        (skvx::float4::Load(c_l.vec())).store(ctx->b);
 
        p->append(SkRasterPipelineOp::evenly_spaced_2_stop_gradient, ctx);
    } else {
        auto* ctx = alloc->make<SkRasterPipeline_GradientCtx>();
 
        // Note: In order to handle clamps in search, the search assumes a stop conceptully placed
        // at -inf. Therefore, the max number of stops is fColorCount+1.
        for (int i = 0; i < 4; i++) {
            // Allocate at least at for the AVX2 gather from a YMM register.
            ctx->fs[i] = alloc->makeArray<float>(std::max(count + 1, 8));
            ctx->bs[i] = alloc->makeArray<float>(std::max(count + 1, 8));
        }
 
        if (positions == nullptr) {
            // Handle evenly distributed stops.
 
            size_t stopCount = count;
            float gapCount = stopCount - 1;
 
            SkPMColor4f c_l = pmColors[0];
            for (size_t i = 0; i < stopCount - 1; i++) {
                SkPMColor4f c_r = pmColors[i + 1];
                init_stop_evenly(ctx, gapCount, i, c_l, c_r);
                c_l = c_r;
            }
            add_const_color(ctx, stopCount - 1, c_l);
 
            ctx->stopCount = stopCount;
            p->append(SkRasterPipelineOp::evenly_spaced_gradient, ctx);
        } else {
            // Handle arbitrary stops.
 
            ctx->ts = alloc->makeArray<float>(count + 1);
 
            // Remove the default stops inserted by SkGradientBaseShader::SkGradientBaseShader
            // because they are naturally handled by the search method.
            int firstStop;
            int lastStop;
            if (count > 2) {
                firstStop = pmColors[0] != pmColors[1] ? 0 : 1;
                lastStop = pmColors[count - 2] != pmColors[count - 1] ? count - 1 : count - 2;
            } else {
                firstStop = 0;
                lastStop = 1;
            }
 
            size_t stopCount = 0;
            float t_l = positions[firstStop];
            SkPMColor4f c_l = pmColors[firstStop];
            add_const_color(ctx, stopCount++, c_l);
            // N.B. lastStop is the index of the last stop, not one after.
            for (int i = firstStop; i < lastStop; i++) {
                float t_r = positions[i + 1];
                SkPMColor4f c_r = pmColors[i + 1];
                SkASSERT(t_l <= t_r);
                if (t_l < t_r) {
                    float c_scale = sk_ieee_float_divide(1, t_r - t_l);
                    if (SkIsFinite(c_scale)) {
                        init_stop_pos(ctx, stopCount, t_l, c_scale, c_l, c_r);
                        stopCount += 1;
                    }
                }
                t_l = t_r;
                c_l = c_r;
            }
 
            ctx->ts[stopCount] = t_l;
            add_const_color(ctx, stopCount++, c_l);
 
            ctx->stopCount = stopCount;
            p->append(SkRasterPipelineOp::gradient, ctx);
        }
    }
}

◆ appendGradientStages()

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

protectedpure virtual

Implemented in SkLinearGradient, SkConicalGradient, SkRadialGradient, and SkSweepGradient.

◆ AppendInterpolatedToDstStages()

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

static

Definition at line 460 of file SkGradientBaseShader.cpp.

                                                                                            {
    using ColorSpace = Interpolation::ColorSpace;
    bool colorIsPremul = static_cast<bool>(interpolation.fInPremul);
 
    // If we interpolated premul colors in any of the special color spaces, we need to unpremul
    if (colorIsPremul && !colorsAreOpaque) {
        switch (interpolation.fColorSpace) {
            case ColorSpace::kLab:
            case ColorSpace::kOKLab:
            case ColorSpace::kOKLabGamutMap:
                p->append(SkRasterPipelineOp::unpremul);
                colorIsPremul = false;
                break;
            case ColorSpace::kLCH:
            case ColorSpace::kOKLCH:
            case ColorSpace::kOKLCHGamutMap:
            case ColorSpace::kHSL:
            case ColorSpace::kHWB:
                p->append(SkRasterPipelineOp::unpremul_polar);
                colorIsPremul = false;
                break;
            default:
                break;
        }
    }
 
    // Convert colors in exotic spaces back to their intermediate SkColorSpace
    switch (interpolation.fColorSpace) {
        case ColorSpace::kLab:   p->append(SkRasterPipelineOp::css_lab_to_xyz);           break;
        case ColorSpace::kOKLab: p->append(SkRasterPipelineOp::css_oklab_to_linear_srgb); break;
        case ColorSpace::kOKLabGamutMap:
            p->append(SkRasterPipelineOp::css_oklab_gamut_map_to_linear_srgb);
            break;
        case ColorSpace::kLCH:   p->append(SkRasterPipelineOp::css_hcl_to_lab);
                                 p->append(SkRasterPipelineOp::css_lab_to_xyz);           break;
        case ColorSpace::kOKLCH: p->append(SkRasterPipelineOp::css_hcl_to_lab);
                                 p->append(SkRasterPipelineOp::css_oklab_to_linear_srgb); break;
        case ColorSpace::kOKLCHGamutMap:
            p->append(SkRasterPipelineOp::css_hcl_to_lab);
            p->append(SkRasterPipelineOp::css_oklab_gamut_map_to_linear_srgb);
            break;
        case ColorSpace::kHSL:   p->append(SkRasterPipelineOp::css_hsl_to_srgb);          break;
        case ColorSpace::kHWB:   p->append(SkRasterPipelineOp::css_hwb_to_srgb);          break;
        default: break;
    }
 
    // Now transform from intermediate to destination color space.
    // See comments in GrGradientShader.cpp about the decisions here.
    if (!dstColorSpace) {
        dstColorSpace = sk_srgb_singleton();
    }
    SkAlphaType intermediateAlphaType = colorIsPremul ? kPremul_SkAlphaType : kUnpremul_SkAlphaType;
    // TODO(skia:13108): Get dst alpha type correctly
    SkAlphaType dstAlphaType = kPremul_SkAlphaType;
 
    if (colorsAreOpaque) {
        intermediateAlphaType = dstAlphaType = kUnpremul_SkAlphaType;
    }
 
    alloc->make<SkColorSpaceXformSteps>(
                 intermediateColorSpace, intermediateAlphaType, dstColorSpace, dstAlphaType)
            ->apply(p);
}

◆ appendStages()

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

overrideprotectedvirtual

Adds stages to implement this shader. To ensure that the correct input coords are present in r,g MatrixRec::apply() must be called (unless the shader doesn't require it's input coords). The default impl creates shadercontext and calls that (not very efficient).

Implements SkShaderBase.

Definition at line 529 of file SkGradientBaseShader.cpp.

                                                                              {
    SkRasterPipeline* p = rec.fPipeline;
    SkArenaAlloc* alloc = rec.fAlloc;
    SkRasterPipeline_DecalTileCtx* decal_ctx = nullptr;
 
    std::optional<SkShaders::MatrixRec> newMRec = mRec.apply(rec, fPtsToUnit);
    if (!newMRec.has_value()) {
        return false;
    }
 
    SkRasterPipeline_<256> postPipeline;
 
    this->appendGradientStages(alloc, p, &postPipeline);
 
    switch (fTileMode) {
        case SkTileMode::kMirror:
            p->append(SkRasterPipelineOp::mirror_x_1);
            break;
        case SkTileMode::kRepeat:
            p->append(SkRasterPipelineOp::repeat_x_1);
            break;
        case SkTileMode::kDecal:
            decal_ctx = alloc->make<SkRasterPipeline_DecalTileCtx>();
            decal_ctx->limit_x = SkBits2Float(SkFloat2Bits(1.0f) + 1);
            // reuse mask + limit_x stage, or create a custom decal_1 that just stores the mask
            p->append(SkRasterPipelineOp::decal_x, decal_ctx);
            [[fallthrough]];
 
        case SkTileMode::kClamp:
            if (!fPositions) {
                // We clamp only when the stops are evenly spaced.
                // If not, there may be hard stops, and clamping ruins hard stops at 0 and/or 1.
                // In that case, we must make sure we're using the general "gradient" stage,
                // which is the only stage that will correctly handle unclamped t.
                p->append(SkRasterPipelineOp::clamp_x_1);
            }
            break;
    }
 
    // Transform all of the colors to destination color space, possibly premultiplied
    SkColor4fXformer xformedColors(this, rec.fDstCS);
    AppendGradientFillStages(p, alloc,
                             xformedColors.fColors.begin(),
                             xformedColors.fPositions,
                             xformedColors.fColors.size());
    AppendInterpolatedToDstStages(p, alloc, fColorsAreOpaque, fInterpolation,
                                  xformedColors.fIntermediateColorSpace.get(), rec.fDstCS);
 
    if (decal_ctx) {
        p->append(SkRasterPipelineOp::check_decal_mask, decal_ctx);
    }
 
    p->extend(postPipeline);
 
    return true;
}

◆ cachedBitmap()

const SkBitmap & SkGradientBaseShader::cachedBitmap ( ) const

inline

Definition at line 152 of file SkGradientBaseShader.h.

152{ return fColorsAndOffsetsBitmap; }

◆ colorsAreOpaque()

bool SkGradientBaseShader::colorsAreOpaque ( ) const

inline

Definition at line 148 of file SkGradientBaseShader.h.

148{ return fColorsAreOpaque; }

◆ commonAsAGradient()

void SkGradientBaseShader::commonAsAGradient ( GradientInfo * info ) const

protected

Definition at line 972 of file SkGradientBaseShader.cpp.

                                                                     {
    if (info) {
        if (info->fColorCount >= fColorCount) {
            if (info->fColors) {
                for (int i = 0; i < fColorCount; ++i) {
                    info->fColors[i] = this->getLegacyColor(i);
                }
            }
            if (info->fColorOffsets) {
                for (int i = 0; i < fColorCount; ++i) {
                    info->fColorOffsets[i] = this->getPos(i);
                }
            }
        }
        info->fColorCount = fColorCount;
        info->fTileMode = fTileMode;
 
        info->fGradientFlags =
                this->interpolateInPremul() ? SkGradientShader::kInterpolateColorsInPremul_Flag : 0;
    }
}

◆ flatten()

void SkGradientBaseShader::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.

Reimplemented in SkLinearGradient, SkRadialGradient, and SkSweepGradient.

Definition at line 75 of file SkGradientBaseShader.cpp.

                                                              {
    uint32_t flags = 0;
    if (fPositions) {
        flags |= kHasPosition_GSF;
    }
    sk_sp<SkData> colorSpaceData = fColorSpace ? fColorSpace->serialize() : nullptr;
    if (colorSpaceData) {
        flags |= kHasColorSpace_GSF;
    }
    if (fInterpolation.fInPremul == Interpolation::InPremul::kYes) {
        flags |= kInterpolationInPremul_GSF;
    }
    SkASSERT(static_cast<uint32_t>(fTileMode) <= kTileModeMask_GSF);
    flags |= ((uint32_t)fTileMode << kTileModeShift_GSF);
    SkASSERT(static_cast<uint32_t>(fInterpolation.fColorSpace) <= kInterpolationColorSpaceMask_GSF);
    flags |= ((uint32_t)fInterpolation.fColorSpace << kInterpolationColorSpaceShift_GSF);
    SkASSERT(static_cast<uint32_t>(fInterpolation.fHueMethod) <= kInterpolationHueMethodMask_GSF);
    flags |= ((uint32_t)fInterpolation.fHueMethod << kInterpolationHueMethodShift_GSF);
 
    buffer.writeUInt(flags);
 
    // If we injected implicit first/last stops at construction time, omit those when serializing:
    int colorCount = fColorCount;
    const SkColor4f* colors = fColors;
    const SkScalar* positions = fPositions;
    if (fFirstStopIsImplicit) {
        colorCount--;
        colors++;
        if (positions) {
            positions++;
        }
    }
    if (fLastStopIsImplicit) {
        colorCount--;
    }
 
    buffer.writeColor4fArray(colors, colorCount);
    if (colorSpaceData) {
        buffer.writeDataAsByteArray(colorSpaceData.get());
    }
    if (positions) {
        buffer.writeScalarArray(positions, colorCount);
    }
}

◆ getColorCount()

int SkGradientBaseShader::getColorCount ( ) const

inline

Definition at line 81 of file SkGradientBaseShader.h.

81{ return fColorCount; }

◆ getGradientMatrix()

const SkMatrix & SkGradientBaseShader::getGradientMatrix ( ) const

inline

Definition at line 80 of file SkGradientBaseShader.h.

80{ return fPtsToUnit; }

◆ getInterpolation()

const Interpolation & SkGradientBaseShader::getInterpolation ( ) const

inline

Definition at line 83 of file SkGradientBaseShader.h.

83{ return fInterpolation; }

◆ getLegacyColor()

SkColor SkGradientBaseShader::getLegacyColor ( int i ) const

inline

Definition at line 135 of file SkGradientBaseShader.h.

                                        {
        SkASSERT(i < fColorCount);
        return fColors[i].toSkColor();
    }

◆ getPos()

SkScalar SkGradientBaseShader::getPos ( int i ) const

inline

Definition at line 130 of file SkGradientBaseShader.h.

                                 {
        SkASSERT(i < fColorCount);
        return fPositions ? fPositions[i] : SkIntToScalar(i) / (fColorCount - 1);
    }

◆ getPositions()

const float * SkGradientBaseShader::getPositions ( ) const

inline

Definition at line 82 of file SkGradientBaseShader.h.

82{ return fPositions; }

◆ getTileMode()

SkTileMode SkGradientBaseShader::getTileMode ( ) const

inline

Definition at line 150 of file SkGradientBaseShader.h.

150{ return fTileMode; }

◆ interpolateInPremul()

bool SkGradientBaseShader::interpolateInPremul ( ) const

inline

Definition at line 76 of file SkGradientBaseShader.h.

                                     {
        return fInterpolation.fInPremul == SkGradientShader::Interpolation::InPremul::kYes;
    }

◆ isOpaque()

bool SkGradientBaseShader::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 587 of file SkGradientBaseShader.cpp.

                                          {
    return fColorsAreOpaque && (this->getTileMode() != SkTileMode::kDecal);
}

◆ MakeDegenerateGradient()

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

static

Definition at line 1075 of file SkGradientBaseShader.cpp.

                                                                              {
    switch (mode) {
        case SkTileMode::kDecal:
            // normally this would reject the area outside of the interpolation region, so since
            // inside region is empty when the radii are equal, the entire draw region is empty
            return SkShaders::Empty();
        case SkTileMode::kRepeat:
        case SkTileMode::kMirror:
            // repeat and mirror are treated the same: the border colors are never visible,
            // but approximate the final color as infinite repetitions of the colors, so
            // it can be represented as the average color of the gradient.
            return SkShaders::Color(average_gradient_color(colors, pos, colorCount),
                                    std::move(colorSpace));
        case SkTileMode::kClamp:
            // Depending on how the gradient shape degenerates, there may be a more specialized
            // fallback representation for the factories to use, but this is a reasonable default.
            return SkShaders::Color(colors[colorCount - 1], std::move(colorSpace));
    }
    SkDEBUGFAIL("Should not be reached");
    return nullptr;
}

◆ onAsLuminanceColor()

bool SkGradientBaseShader::onAsLuminanceColor ( SkColor4f * lum ) const

overrideprotectedvirtual

Reimplemented from SkShaderBase.

Definition at line 591 of file SkGradientBaseShader.cpp.

                                                                  {
    // We just compute an average color. There are several things we could do better:
    // 1) We already have a different average_gradient_color helper later in this file, that weights
    //    contribution by the relative size of each band.
    // 2) Colors should be converted to some standard color space! These could be in any space.
    // 3) Do we want to average in the source space, sRGB, or some linear space?
    SkColor4f color{0, 0, 0, 1};
    for (int i = 0; i < fColorCount; ++i) {
        color.fR += fColors[i].fR;
        color.fG += fColors[i].fG;
        color.fB += fColors[i].fB;
    }
    const float scale = 1.0f / fColorCount;
    color.fR *= scale;
    color.fG *= scale;
    color.fB *= scale;
    *lum = color;
    return true;
}

◆ setCachedBitmap()

void SkGradientBaseShader::setCachedBitmap ( SkBitmap b ) const

inline

Definition at line 153 of file SkGradientBaseShader.h.

153{ fColorsAndOffsetsBitmap = b; }

b

static bool b

Definition: ffi_native_test_module.c:74

◆ type()

ShaderType SkGradientBaseShader::type ( ) const

inlinefinalvirtual

Implements SkShaderBase.

Definition at line 72 of file SkGradientBaseShader.h.

72{ return ShaderType::kGradientBase; }

◆ ValidGradient()

bool SkGradientBaseShader::ValidGradient	(	const SkColor4f	colors[],
		int	count,
		SkTileMode	tileMode,
		const Interpolation &	interpolation
	)

static

Definition at line 996 of file SkGradientBaseShader.cpp.

                                                                             {
    return nullptr != colors && count >= 1 && (unsigned)tileMode < kSkTileModeCount &&
           (unsigned)interpolation.fColorSpace < Interpolation::kColorSpaceCount &&
           (unsigned)interpolation.fHueMethod < Interpolation::kHueMethodCount;
}

Member Data Documentation

◆ fColorCount

int SkGradientBaseShader::fColorCount

Definition at line 142 of file SkGradientBaseShader.h.

◆ fColors

SkColor4f* SkGradientBaseShader::fColors

Definition at line 140 of file SkGradientBaseShader.h.

◆ fColorSpace

sk_sp<SkColorSpace> SkGradientBaseShader::fColorSpace

Definition at line 143 of file SkGradientBaseShader.h.

◆ fFirstStopIsImplicit

bool SkGradientBaseShader::fFirstStopIsImplicit

Definition at line 145 of file SkGradientBaseShader.h.

◆ fInterpolation

Interpolation SkGradientBaseShader::fInterpolation

Definition at line 144 of file SkGradientBaseShader.h.

◆ fLastStopIsImplicit

bool SkGradientBaseShader::fLastStopIsImplicit

Definition at line 146 of file SkGradientBaseShader.h.

◆ fPositions

SkScalar* SkGradientBaseShader::fPositions

Definition at line 141 of file SkGradientBaseShader.h.

◆ fPtsToUnit

const SkMatrix SkGradientBaseShader::fPtsToUnit

protected

Definition at line 113 of file SkGradientBaseShader.h.

◆ fTileMode

SkTileMode SkGradientBaseShader::fTileMode

protected

Definition at line 114 of file SkGradientBaseShader.h.

◆ kDegenerateThreshold

constexpr SkScalar SkGradientBaseShader::kDegenerateThreshold = SK_Scalar1 / (1 << 15)

staticconstexpr

Definition at line 98 of file SkGradientBaseShader.h.

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

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

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ Interpolation

Constructor & Destructor Documentation

◆ SkGradientBaseShader()

◆ ~SkGradientBaseShader()

Member Function Documentation

◆ AppendGradientFillStages()

◆ appendGradientStages()

◆ AppendInterpolatedToDstStages()

◆ appendStages()

◆ cachedBitmap()

◆ colorsAreOpaque()

◆ commonAsAGradient()

◆ flatten()

◆ getColorCount()

◆ getGradientMatrix()

◆ getInterpolation()

◆ getLegacyColor()

◆ getPos()

◆ getPositions()

◆ getTileMode()

◆ interpolateInPremul()

◆ isOpaque()

◆ MakeDegenerateGradient()

◆ onAsLuminanceColor()

◆ setCachedBitmap()

◆ type()

◆ ValidGradient()

Member Data Documentation

◆ fColorCount

◆ fColors

◆ fColorSpace

◆ fFirstStopIsImplicit

◆ fInterpolation

◆ fLastStopIsImplicit

◆ fPositions

◆ fPtsToUnit

◆ fTileMode

◆ kDegenerateThreshold