skif Namespace Reference

Classes
class	Backend
class	Context
class	DeviceSpace
class	FilterResult
struct	IVector
class	LayerSpace
class	LayerSpace< IVector >
class	LayerSpace< SkIPoint >
class	LayerSpace< SkIRect >
class	LayerSpace< SkISize >
class	LayerSpace< SkMatrix >
class	LayerSpace< SkPoint >
class	LayerSpace< SkRect >
class	LayerSpace< SkSize >
class	LayerSpace< Vector >
class	LayerSpace< ZValue >
class	Mapping
class	ParameterSpace
struct	Stats
struct	Vector

Enumerations
enum class	MatrixCapability { kTranslate , kScaleTranslate , kComplex }

Functions
sk_sp< Backend >	MakeRasterBackend (const SkSurfaceProps &surfaceProps, SkColorType colorType)
SkIRect	RoundOut (SkRect r)
SkIRect	RoundIn (SkRect r)
static bool	compatible_sampling (const SkSamplingOptions &currentSampling, bool currentXformWontAffectNearest, SkSamplingOptions *nextSampling, bool nextXformWontAffectNearest)
sk_sp< Backend >	MakeGaneshBackend (sk_sp< GrRecordingContext > context, GrSurfaceOrigin origin, const SkSurfaceProps &surfaceProps, SkColorType colorType)
sk_sp< Backend >	MakeGraphiteBackend (skgpu::graphite::Recorder *recorder, const SkSurfaceProps &surfaceProps, SkColorType colorType)

Enumeration Type Documentation

MatrixCapability

enum class skif::MatrixCapability

strong

Most ImageFilters can natively handle scaling and translate components in the CTM. Only some of them can handle affine (or more complex) matrices. Some may only handle translation.

Enumerator
kTranslate
kScaleTranslate
kComplex

Definition at line 545 of file SkImageFilterTypes.h.

                            {
    kTranslate,
    kScaleTranslate,
    kComplex,
};

Function Documentation

compatible_sampling()

static bool skif::compatible_sampling ( const SkSamplingOptions &  currentSampling, bool  currentXformWontAffectNearest, SkSamplingOptions *  nextSampling, bool  nextXformWontAffectNearest  )

static

Definition at line 986 of file SkImageFilterTypes.cpp.

                                                                 {
    // Both transforms could perform non-trivial sampling, but if they are similar enough we
    // assume performing one non-trivial sampling operation with the concatenated transform will
    // not be visually distinguishable from sampling twice.
    // TODO(michaelludwig): For now ignore mipmap policy, SkSpecialImages are not supposed to be
    // drawn with mipmapping, and the majority of filter steps produce images that are at the
    // proper scale and do not define mip levels. The main exception is the ::Image() filter
    // leaf but that doesn't use this system yet.
    if (currentSampling.isAniso() && nextSampling->isAniso()) {
        // Assume we can get away with one sampling at the highest anisotropy level
        *nextSampling =  SkSamplingOptions::Aniso(std::max(currentSampling.maxAniso,
                                                           nextSampling->maxAniso));
        return true;
    } else if (currentSampling.isAniso() && nextSampling->filter == SkFilterMode::kLinear) {
        // Assume we can get away with the current anisotropic filter since the next is linear
        *nextSampling = currentSampling;
        return true;
    } else if (nextSampling->isAniso() && currentSampling.filter == SkFilterMode::kLinear) {
        // Mirror of the above, assume we can just get away with next's anisotropic filter
        return true;
    } else if (currentSampling.useCubic && (nextSampling->filter == SkFilterMode::kLinear ||
                                            (nextSampling->useCubic &&
                                             currentSampling.cubic.B == nextSampling->cubic.B &&
                                             currentSampling.cubic.C == nextSampling->cubic.C))) {
        // Assume we can get away with the current bicubic filter, since the next is the same
        // or a bilerp that can be upgraded.
        *nextSampling = currentSampling;
        return true;
    } else if (nextSampling->useCubic && currentSampling.filter == SkFilterMode::kLinear) {
        // Mirror of the above, assume we can just get away with next's cubic resampler
        return true;
    } else if (currentSampling.filter == SkFilterMode::kLinear &&
               nextSampling->filter == SkFilterMode::kLinear) {
        // Assume we can get away with a single bilerp vs. the two
        return true;
    } else if (nextSampling->filter == SkFilterMode::kNearest && currentXformWontAffectNearest) {
        // The next transform and nearest-neighbor filtering isn't impacted by the current transform
        SkASSERT(currentSampling.filter == SkFilterMode::kLinear);
        return true;
    } else if (currentSampling.filter == SkFilterMode::kNearest && nextXformWontAffectNearest) {
        // The next transform doesn't change the nearest-neighbor filtering of the current transform
        SkASSERT(nextSampling->filter == SkFilterMode::kLinear);
        *nextSampling = currentSampling;
        return true;
    } else {
        // The current or next sampling is nearest neighbor, and will produce visible texels
        // oriented with the current transform; assume this is a desired effect and preserve it.
        return false;
    }
}

MakeGaneshBackend()

sk_sp< Backend > skif::MakeGaneshBackend	(	sk_sp< GrRecordingContext >	context,
		GrSurfaceOrigin	origin,
		const SkSurfaceProps &	surfaceProps,
		SkColorType	colorType
	)

Definition at line 895 of file GrImageUtils.cpp.

                                                        {
    SkASSERT(context);
    return sk_make_sp<GaneshBackend>(std::move(context), origin, surfaceProps, colorType);
}

MakeGraphiteBackend()

sk_sp< Backend > skif::MakeGraphiteBackend	(	skgpu::graphite::Recorder *	recorder,
		const SkSurfaceProps &	surfaceProps,
		SkColorType	colorType
	)

Definition at line 980 of file TextureUtils.cpp.

                                                          {
    SkASSERT(recorder);
    return sk_make_sp<GraphiteBackend>(recorder, surfaceProps, colorType);
}

MakeRasterBackend()

sk_sp< Backend > skif::MakeRasterBackend	(	const SkSurfaceProps &	surfaceProps,
		SkColorType	colorType
	)

Definition at line 218 of file SkImageFilterTypes.cpp.

                                                                                            {
    // TODO (skbug:14286): Remove this forcing to 8888. Many legacy image filters only support
    // N32 on CPU, but once they are implemented in terms of draws and SkSL they will support
    // all color types, like the GPU backends.
    colorType = kN32_SkColorType;
 
    return sk_make_sp<RasterBackend>(surfaceProps, colorType);
}

RoundIn()

SkIRect skif::RoundIn

(

SkRect

r

)

Definition at line 255 of file SkImageFilterTypes.cpp.

{ return r.makeOutset(kRoundEpsilon, kRoundEpsilon).roundIn(); }

RoundOut()

SkIRect skif::RoundOut

(

SkRect

r

)

Definition at line 253 of file SkImageFilterTypes.cpp.

{ return r.makeInset(kRoundEpsilon, kRoundEpsilon).roundOut(); }