SkShaders Namespace Reference

Classes
class	MatrixRec

Functions
SK_API sk_sp< SkShader >	Empty ()
SK_API sk_sp< SkShader >	Color (SkColor)
SK_API sk_sp< SkShader >	Color (const SkColor4f &, sk_sp< SkColorSpace >)
SK_API sk_sp< SkShader >	Blend (SkBlendMode mode, sk_sp< SkShader > dst, sk_sp< SkShader > src)
SK_API sk_sp< SkShader >	Blend (sk_sp< SkBlender >, sk_sp< SkShader > dst, sk_sp< SkShader > src)
SK_API sk_sp< SkShader >	CoordClamp (sk_sp< SkShader >, const SkRect &subset)
SK_API sk_sp< SkShader >	Image (sk_sp< SkImage > image, SkTileMode tmx, SkTileMode tmy, const SkSamplingOptions &options, const SkMatrix *localMatrix=nullptr)
SK_API sk_sp< SkShader >	RawImage (sk_sp< SkImage > image, SkTileMode tmx, SkTileMode tmy, const SkSamplingOptions &options, const SkMatrix *localMatrix=nullptr)
SK_API sk_sp< SkShader >	MakeFractalNoise (SkScalar baseFrequencyX, SkScalar baseFrequencyY, int numOctaves, SkScalar seed, const SkISize *tileSize=nullptr)
SK_API sk_sp< SkShader >	MakeTurbulence (SkScalar baseFrequencyX, SkScalar baseFrequencyY, int numOctaves, SkScalar seed, const SkISize *tileSize=nullptr)

Function Documentation

Blend() [1/2]

sk_sp< SkShader > SkShaders::Blend	(	sk_sp< SkBlender >	blender,
		sk_sp< SkShader >	dst,
		sk_sp< SkShader >	src
	)

Definition at line 117 of file SkBlendShader.cpp.

                                                      {
    using namespace SkKnownRuntimeEffects;
 
    if (!src || !dst) {
        return nullptr;
    }
    if (!blender) {
        return SkShaders::Blend(SkBlendMode::kSrcOver, std::move(dst), std::move(src));
    }
    if (std::optional<SkBlendMode> mode = as_BB(blender)->asBlendMode()) {
        return sk_make_sp<SkBlendShader>(mode.value(), std::move(dst), std::move(src));
    }
 
    // This isn't a built-in blend mode; we might as well use a runtime effect to evaluate it.
    const SkRuntimeEffect* blendEffect = GetKnownRuntimeEffect(StableKey::kBlend);
 
    SkRuntimeEffect::ChildPtr children[] = {std::move(src), std::move(dst), std::move(blender)};
    return blendEffect->makeShader(/*uniforms=*/{}, children);
}

Blend() [2/2]

sk_sp< SkShader > SkShaders::Blend	(	SkBlendMode	mode,
		sk_sp< SkShader >	dst,
		sk_sp< SkShader >	src
	)

Definition at line 100 of file SkBlendShader.cpp.

                                                                                           {
    if (!src || !dst) {
        return nullptr;
    }
    switch (mode) {
        case SkBlendMode::kClear:
            return Color(0);
        case SkBlendMode::kDst:
            return dst;
        case SkBlendMode::kSrc:
            return src;
        default:
            break;
    }
    return sk_sp<SkShader>(new SkBlendShader(mode, std::move(dst), std::move(src)));
}

Color() [1/2]

sk_sp< SkShader > SkShaders::Color	(	const SkColor4f &	color,
		sk_sp< SkColorSpace >	space
	)

Definition at line 105 of file SkColorShader.cpp.

                                                                         {
    if (!SkIsFinite(color.vec(), 4)) {
        return nullptr;
    }
    return sk_make_sp<SkColor4Shader>(color, std::move(space));
}

Color() [2/2]

sk_sp< SkShader > SkShaders::Color

(

SkColor

color

)

Definition at line 103 of file SkColorShader.cpp.

{ return sk_make_sp<SkColorShader>(color); }

CoordClamp()

sk_sp< SkShader > SkShaders::CoordClamp	(	sk_sp< SkShader >	shader,
		const SkRect &	subset
	)

Definition at line 59 of file SkCoordClampShader.cpp.

                                                                                  {
    if (!shader) {
        return nullptr;
    }
    if (!subset.isSorted()) {
        return nullptr;
    }
    return sk_make_sp<SkCoordClampShader>(std::move(shader), subset);
}

Empty()

sk_sp< SkShader > SkShaders::Empty

(

)

Definition at line 20 of file SkEmptyShader.cpp.

{ return sk_make_sp<SkEmptyShader>(); }

Image()

sk_sp< SkShader > SkShaders::Image	(	sk_sp< SkImage >	image,
		SkTileMode	tmx,
		SkTileMode	tmy,
		const SkSamplingOptions &	options,
		const SkMatrix *	localMatrix = nullptr
	)

Definition at line 800 of file SkImageShader.cpp.

                                                   {
    return SkImageShader::Make(std::move(image), tmx, tmy, options, localMatrix);
}

MakeFractalNoise()

sk_sp< SkShader > SkShaders::MakeFractalNoise	(	SkScalar	baseFrequencyX,
		SkScalar	baseFrequencyY,
		int	numOctaves,
		SkScalar	seed,
		const SkISize *	tileSize = nullptr
	)

This will construct Perlin noise of the given type (Fractal Noise or Turbulence).

Both base frequencies (X and Y) have a usual range of (0..1) and must be non-negative.

The number of octaves provided should be fairly small, with a limit of 255 enforced. Each octave doubles the frequency, so 10 octaves would produce noise from baseFrequency * 1, * 2, * 4, ..., * 512, which quickly yields insignificantly small periods and resembles regular unstructured noise rather than Perlin noise.

If tileSize isn't NULL or an empty size, the tileSize parameter will be used to modify the frequencies so that the noise will be tileable for the given tile size. If tileSize is NULL or an empty size, the frequencies will be used as is without modification.

Definition at line 135 of file SkPerlinNoiseShaderImpl.cpp.

                                                          {
    if (!valid_input(baseFrequencyX, baseFrequencyY, numOctaves, tileSize, seed)) {
        return nullptr;
    }
 
    if (0 == numOctaves) {
        // For kFractalNoise, w/o any octaves, the entire shader collapses to:
        //    [0,0,0,0] * 0.5 + 0.5
        constexpr SkColor4f kTransparentGray = {0.5f, 0.5f, 0.5f, 0.5f};
 
        return SkShaders::Color(kTransparentGray, /* colorSpace= */ nullptr);
    }
 
    return sk_sp<SkShader>(new SkPerlinNoiseShader(SkPerlinNoiseShaderType::kFractalNoise,
                                                   baseFrequencyX,
                                                   baseFrequencyY,
                                                   numOctaves,
                                                   seed,
                                                   tileSize));
}

MakeTurbulence()

sk_sp< SkShader > SkShaders::MakeTurbulence	(	SkScalar	baseFrequencyX,
		SkScalar	baseFrequencyY,
		int	numOctaves,
		SkScalar	seed,
		const SkISize *	tileSize = nullptr
	)

Definition at line 160 of file SkPerlinNoiseShaderImpl.cpp.

                                                        {
    if (!valid_input(baseFrequencyX, baseFrequencyY, numOctaves, tileSize, seed)) {
        return nullptr;
    }
 
    if (0 == numOctaves) {
        // For kTurbulence, w/o any octaves, the entire shader collapses to: [0,0,0,0]
        return SkShaders::Color(SkColors::kTransparent, /* colorSpace= */ nullptr);
    }
 
    return sk_sp<SkShader>(new SkPerlinNoiseShader(SkPerlinNoiseShaderType::kTurbulence,
                                                   baseFrequencyX,
                                                   baseFrequencyY,
                                                   numOctaves,
                                                   seed,
                                                   tileSize));
}

RawImage()

sk_sp< SkShader > SkShaders::RawImage	(	sk_sp< SkImage >	image,
		SkTileMode	tmx,
		SkTileMode	tmy,
		const SkSamplingOptions &	options,
		const SkMatrix *	localMatrix = nullptr
	)

Definition at line 807 of file SkImageShader.cpp.

                                                      {
    return SkImageShader::MakeRaw(std::move(image), tmx, tmy, options, localMatrix);
}