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 1955 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 2053 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);
 
    const SkBlurEngine::Algorithm* algorithm = blurEngine->findAlgorithm(
            SkSize(sigma), fContext.backend()->colorType());
    if (!algorithm) {
        return {};
    }
 
    // TODO: De-duplicate this logic between SkBlurImageFilter, here, and skgpu::BlurUtils.
    LayerSpace<SkISize> radii =
            LayerSpace<SkSize>({3.f*sigma.width(), 3.f*sigma.height()}).ceil();
    auto maxOutput = fInputs[0].fImage.layerBounds();
    maxOutput.outset(radii);
 
    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);
 
    if (fContext.backend()->useLegacyFilterResultBlur()) {
        SkASSERT(sigma.width() <= algorithm->maxSigma() && sigma.height() <= algorithm->maxSigma());
 
        FilterResult resolved = fInputs[0].fImage.resolve(fContext, sampleBounds);
        if (!resolved) {
            return {};
        }
        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()};
        return resolved;
    }
 
    float sx = sigma.width()  > algorithm->maxSigma() ? algorithm->maxSigma()/sigma.width()  : 1.f;
    float sy = sigma.height() > algorithm->maxSigma() ? algorithm->maxSigma()/sigma.height() : 1.f;
 
    // For identity scale factors, this rescale() is a no-op when possible, but otherwise it will
    // also handle resolving any color filters or transform similar to a resolve() except that it
    // can defer the tile mode.
    FilterResult lowResImage = fInputs[0].fImage.rescale(
            fContext.withNewDesiredOutput(sampleBounds),
            LayerSpace<SkSize>({sx, sy}),
            algorithm->supportsOnlyDecalTiling());
    if (!lowResImage) {
        return {};
    }
    SkASSERT(lowResImage.tileMode() == SkTileMode::kDecal ||
             !algorithm->supportsOnlyDecalTiling());
 
    // Map 'sigma' into the low-res image's pixel space to determine the low-res blur params to pass
    // into the blur engine.
    PixelSpace<SkMatrix> layerToLowRes;
    SkAssertResult(lowResImage.fTransform.invert(&layerToLowRes));
    PixelSpace<SkSize> lowResSigma = layerToLowRes.mapSize(sigma);
    // The layerToLowRes mapped size should be <= maxSigma, but clamp it just in case floating point
    // error made it slightly higher.
    lowResSigma = PixelSpace<SkSize>{{std::min(algorithm->maxSigma(), lowResSigma.width()),
                                      std::min(algorithm->maxSigma(), lowResSigma.height())}};
    PixelSpace<SkIRect> lowResMaxOutput{SkISize{lowResImage.fImage->width(),
                                                lowResImage.fImage->height()}};
 
    PixelSpace<SkIRect> srcRelativeOutput;
    if (lowResImage.tileMode() == SkTileMode::kRepeat ||
        lowResImage.tileMode() == SkTileMode::kMirror) {
        // The periodic tiling was deferred when down-sampling; we can further defer it to after the
        // blur. The low-res output is 1-to-1 with the low res image.
        srcRelativeOutput = lowResMaxOutput;
    } else {
        // For decal and clamp tiling, the blurred image stops being interesting outside the radii
        // outset, so redo the max output analysis with the 'outputBounds' mapped into pixel space.
        srcRelativeOutput = layerToLowRes.mapRect(outputBounds);
 
        // NOTE: Since 'lowResMaxOutput' is based on the actual image and deferred tiling, this can
        // be smaller than the pessimistic filling for a clamp-tiled blur.
        lowResMaxOutput.outset(PixelSpace<SkSize>({3.f * lowResSigma.width(),
                                                   3.f * lowResSigma.height()}).ceil());
        srcRelativeOutput = lowResMaxOutput.relevantSubset(srcRelativeOutput,
                                                           lowResImage.tileMode());
        // Clamp won't return empty from relevantSubset() and a non-intersecting decal should have
        // been caught earlier.
        SkASSERT(!srcRelativeOutput.isEmpty());
 
        // Include 1px of blur output so that it can be sampled during the upscale, which is needed
        // to correctly seam large blurs across crop/raster tiles (crbug.com/1500021).
        srcRelativeOutput.outset(PixelSpace<SkISize>({1, 1}));
    }
 
    sk_sp<SkSpecialImage> lowResBlur = lowResImage.refImage();
    SkIRect blurOutputBounds = SkIRect(srcRelativeOutput);
    SkTileMode tileMode = lowResImage.tileMode();
    if (lowResImage.canClampToTransparentBoundary(BoundsAnalysis::kSimple)) {
        // Have to manage this manually since the BlurEngine isn't aware of the known pixel padding.
        lowResBlur = lowResBlur->makePixelOutset();
        blurOutputBounds.offset(1, 1);
        tileMode = SkTileMode::kClamp;
    }
 
    lowResBlur = algorithm->blur(SkSize(lowResSigma),
                                 lowResBlur,
                                 SkIRect::MakeSize(lowResBlur->dimensions()),
                                 tileMode,
                                 blurOutputBounds);
 
    FilterResult result{std::move(lowResBlur), srcRelativeOutput.topLeft()};
    if (lowResImage.tileMode() == SkTileMode::kClamp ||
        lowResImage.tileMode() == SkTileMode::kDecal) {
        // Undo the outset padding that was added to srcRelativeOutput before invoking the blur
        result = result.insetByPixel();
    }
 
    result.fTransform.postConcat(lowResImage.fTransform);
    if (lowResImage.tileMode() == SkTileMode::kDecal) {
        // Recalculate the output bounds based on the blur output; with rounding the final image may
        // be slightly larger than the original, which would unnecessarily add cropping to the layer
        // bounds. But so long as the `outputBounds` had been constrained by the input's own layer,
        // that crop is unnecessary. The result is still restricted to the desired output bounds,
        // which will induce clipping as needed for a rounded-out image.
        outputBounds = this->outputBounds(
                result.fTransform.mapRect(LayerSpace<SkIRect>(result.fImage->dimensions())));
    }
    result.fLayerBounds = outputBounds;
    result.fTileMode = lowResImage.tileMode();
    return result;
}

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