skif::FilterResult::Builder Class Reference

#include <SkImageFilterTypes.h>

Public Member Functions
	Builder (const Context &context)
	~Builder ()
Builder &	add (const FilterResult &input, std::optional< LayerSpace< SkIRect > > sampleBounds={}, SkEnumBitMask< ShaderFlags > inputFlags=ShaderFlags::kNone, const SkSamplingOptions &inputSampling=kDefaultSampling)
FilterResult	merge ()
FilterResult	blur (const LayerSpace< SkSize > &sigma)
template<typename ShaderFn >
FilterResult	eval (ShaderFn shaderFn, std::optional< LayerSpace< SkIRect > > explicitOutput={}, bool evaluateInParameterSpace=false)

Detailed Description

Definition at line 995 of file SkImageFilterTypes.h.

Constructor & Destructor Documentation

Builder()

skif::FilterResult::Builder::Builder

(

const Context &

context

)

Definition at line 1763 of file SkImageFilterTypes.cpp.

: fContext(context) {}

~Builder()

skif::FilterResult::Builder::~Builder ( )

default

Member Function Documentation

add()

Builder & skif::FilterResult::Builder::add ( const FilterResult &  input, std::optional< LayerSpace< SkIRect > >  sampleBounds = {}, SkEnumBitMask< ShaderFlags >  inputFlags = ShaderFlags::kNone, const SkSamplingOptions &  inputSampling = kDefaultSampling  )

inline

Definition at line 1012 of file SkImageFilterTypes.h.

                                                                 {},
                 SkEnumBitMask<ShaderFlags> inputFlags = ShaderFlags::kNone,
                 const SkSamplingOptions& inputSampling = kDefaultSampling) {
        fInputs.push_back({input, sampleBounds, inputFlags, inputSampling});
        return *this;
    }

blur()

FilterResult skif::FilterResult::Builder::blur

(

const LayerSpace< SkSize > &

sigma

)

Definition at line 1861 of file SkImageFilterTypes.cpp.

                                                                      {
    SkASSERT(fInputs.size() == 1);
 
    // TODO: The blur functor is only supported for GPU contexts; SkBlurImageFilter should have
    // detected this.
    const SkBlurEngine* blurEngine = fContext.backend()->getBlurEngine();
    SkASSERT(blurEngine);
 
    // TODO: All tilemodes are applied right now in resolve() so query with just kDecal
    const SkBlurEngine::Algorithm* algorithm = blurEngine->findAlgorithm(
            SkSize(sigma), fContext.backend()->colorType());
    if (!algorithm) {
        return {};
    }
 
    // TODO: Move resizing logic out of GrBlurUtils into this function
    SkASSERT(sigma.width() <= algorithm->maxSigma() && sigma.height() <= algorithm->maxSigma());
 
    // TODO: De-duplicate this logic between SkBlurImageFilter, here, and skgpu::BlurUtils.
    skif::LayerSpace<SkISize> radii =
            LayerSpace<SkSize>({3.f*sigma.width(), 3.f*sigma.height()}).ceil();
    auto maxOutput = fInputs[0].fImage.layerBounds();
    maxOutput.outset(radii);
 
    // TODO: If the input image is periodic, the output that's calculated can be the original image
    // size and then have the layer bounds and tilemode of the output image apply the tile again.
    // Similarly, a clamped blur can be restricted to a radius-outset buffer of the image bounds
    // (vs. layer bounds) and rendered with clamp tiling.
    const auto outputBounds = this->outputBounds(maxOutput);
    if (outputBounds.isEmpty()) {
        return {};
    }
 
    // These are the source pixels that will be read from the input image, which can be calculated
    // internally because the blur's access pattern is well defined (vs. needing it to be provided
    // in Builder::add()).
    auto sampleBounds = outputBounds;
    sampleBounds.outset(radii);
 
    // TODO: If the blur implementation requires downsampling, we should incorporate any deferred
    // transform and colorfilter to the first rescale step instead of generating a full resolution
    // simple image first.
    // TODO: The presence of a non-decal tilemode should not force resolving to a simple image; it
    // should be incorporated into the image that's sampled by the blur effect (modulo biasing edge
    // pixels somehow for very large clamp blurs).
    // TODO: resolve() doesn't actually guarantee that the returned image has the same color space
    // as the Context, but probably should since the blur algorithm operates in the color space of
    // the input image.
    FilterResult resolved = fInputs[0].fImage.resolve(fContext, sampleBounds);
    if (!resolved) {
        return {};
    }
 
    // TODO: Can blur() take advantage of AutoSurface? Right now the GPU functions are responsible
    // for creating their own target surfaces.
    auto srcRelativeOutput = outputBounds;
    srcRelativeOutput.offset(-resolved.layerBounds().topLeft());
    resolved = {algorithm->blur(SkSize(sigma),
                                resolved.fImage,
                                SkIRect::MakeSize(resolved.fImage->dimensions()),
                                SkTileMode::kDecal,
                                SkIRect(srcRelativeOutput)),
                outputBounds.topLeft()};
    // TODO: Allow the blur functor to provide an upscaling transform that is applied to the
    // FilterResult so that a render pass can possibly be elided if this is the final operation.
    return resolved;
}

eval()

template<typename ShaderFn >

FilterResult skif::FilterResult::Builder::eval ( ShaderFn  shaderFn, std::optional< LayerSpace< SkIRect > >  explicitOutput = {}, bool  evaluateInParameterSpace = false  )

inline

Definition at line 1049 of file SkImageFilterTypes.h.

                                                                        {},
                      bool evaluateInParameterSpace=false) {
        auto outputBounds = this->outputBounds(explicitOutput);
        if (outputBounds.isEmpty()) {
            return {};
        }
 
        auto inputShaders = this->createInputShaders(outputBounds, evaluateInParameterSpace);
        return this->drawShader(shaderFn(inputShaders), outputBounds, evaluateInParameterSpace);
    }

merge()

FilterResult skif::FilterResult::Builder::merge

(

)

Definition at line 1832 of file SkImageFilterTypes.cpp.

                                        {
    // merge() could return an empty image on 0 added inputs, but this should have been caught
    // earlier and routed to SkImageFilters::Empty() instead.
    SkASSERT(!fInputs.empty());
    if (fInputs.size() == 1) {
        SkASSERT(!fInputs[0].fSampleBounds.has_value() &&
                 fInputs[0].fSampling == kDefaultSampling &&
                 fInputs[0].fFlags == ShaderFlags::kNone);
        return fInputs[0].fImage;
    }
 
    const auto mergedBounds = LayerSpace<SkIRect>::Union(
            (int) fInputs.size(),
            [this](int i) { return fInputs[i].fImage.layerBounds(); });
    const auto outputBounds = this->outputBounds(mergedBounds);
 
    AutoSurface surface{fContext, outputBounds, PixelBoundary::kTransparent,
                        /*renderInParameterSpace=*/false};
    if (surface) {
        for (const SampledFilterResult& input : fInputs) {
            SkASSERT(!input.fSampleBounds.has_value() &&
                     input.fSampling == kDefaultSampling &&
                     input.fFlags == ShaderFlags::kNone);
            input.fImage.draw(fContext, surface.device(), /*preserveDeviceState=*/true);
        }
    }
    return surface.snap();
}

---

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

• third_party/skia/src/core/SkImageFilterTypes.h
• third_party/skia/src/core/SkImageFilterTypes.cpp