skif::FilterResult::AutoSurface Class Reference

Public Member Functions
	AutoSurface (const Context &ctx, const LayerSpace< SkIRect > &dstBounds, PixelBoundary boundary, bool renderInParameterSpace, const SkSurfaceProps *props=nullptr)
	operator bool () const
SkCanvas *	canvas ()
SkDevice *	device ()
SkCanvas *	operator-> ()
FilterResult	snap ()

Detailed Description

Definition at line 525 of file SkImageFilterTypes.cpp.

Constructor & Destructor Documentation

AutoSurface()

skif::FilterResult::AutoSurface::AutoSurface ( const Context &  ctx, const LayerSpace< SkIRect > &  dstBounds, PixelBoundary  boundary, bool  renderInParameterSpace, const SkSurfaceProps *  props = nullptr  )

inline

Definition at line 527 of file SkImageFilterTypes.cpp.

            : fDstBounds(dstBounds)
            , fBoundary(boundary) {
        // We don't intersect by ctx.desiredOutput() and only use the Context to make the surface.
        // It is assumed the caller has already accounted for the desired output, or it's a
        // situation where the desired output shouldn't apply (e.g. this surface will be transformed
        // to align with the actual desired output via FilterResult metadata).
        sk_sp<SkDevice> device = nullptr;
        if (!dstBounds.isEmpty()) {
            fDstBounds.outset(LayerSpace<SkISize>({this->padding(), this->padding()}));
            device = ctx.backend()->makeDevice(SkISize(fDstBounds.size()),
                                               ctx.refColorSpace(),
                                               props);
        }
 
        if (!device) {
            return;
        }
 
        // Wrap the device in a canvas and use that to configure its origin and clip. This ensures
        // the device and the canvas are in sync regardless of how the AutoSurface user intends
        // to render.
        ctx.markNewSurface();
        fCanvas.emplace(std::move(device));
        fCanvas->translate(-fDstBounds.left(), -fDstBounds.top());
        fCanvas->clear(SkColors::kTransparent);
        if (fBoundary == PixelBoundary::kTransparent) {
            // Clip to the original un-padded dst bounds, ensuring that the border pixels remain
            // fully transparent.
            fCanvas->clipIRect(SkIRect(dstBounds));
        } else {
            // Otherwise clip to the possibly padded fDstBounds, if the backend made an approx-fit
            // surface. If the bounds were padded for PixelBoundary::kInitialized, this will allow
            // the border pixels to be rendered naturally.
            fCanvas->clipIRect(SkIRect(fDstBounds));
        }
 
        if (renderInParameterSpace) {
            fCanvas->concat(SkMatrix(ctx.mapping().layerMatrix()));
        }
    }

Member Function Documentation

canvas()

SkCanvas * skif::FilterResult::AutoSurface::canvas ( )

inline

Definition at line 575 of file SkImageFilterTypes.cpp.

{ SkASSERT(fCanvas.has_value()); return &*fCanvas; }

device()

SkDevice * skif::FilterResult::AutoSurface::device ( )

inline

Definition at line 576 of file SkImageFilterTypes.cpp.

{ return SkCanvasPriv::TopDevice(this->canvas()); }

operator bool()

skif::FilterResult::AutoSurface::operator bool ( ) const

inlineexplicit

Definition at line 573 of file SkImageFilterTypes.cpp.

{ return fCanvas.has_value(); }

operator->()

SkCanvas * skif::FilterResult::AutoSurface::operator-> ( )

inline

Definition at line 577 of file SkImageFilterTypes.cpp.

{ return this->canvas(); }

snap()

FilterResult skif::FilterResult::AutoSurface::snap ( )

inline

Definition at line 579 of file SkImageFilterTypes.cpp.

                        {
        if (fCanvas.has_value()) {
            // Finish everything and mark the device as immutable so that snapSpecial() can avoid
            // copying data.
            fCanvas->restoreToCount(0);
            this->device()->setImmutable();
 
            // Snap a subset of the device with the padded dst bounds
            SkIRect subset = SkIRect::MakeWH(fDstBounds.width(), fDstBounds.height());
            sk_sp<SkSpecialImage> image = this->device()->snapSpecial(subset);
            fCanvas.reset(); // Only use the AutoSurface once
 
            if (image && fBoundary != PixelBoundary::kUnknown) {
                // Inset subset relative to 'image' reported size
                const int padding = this->padding();
                subset = SkIRect::MakeSize(image->dimensions()).makeInset(padding, padding);
                LayerSpace<SkIPoint> origin{{fDstBounds.left() + padding,
                                             fDstBounds.top() + padding}};
                return {image->makeSubset(subset), origin, fBoundary};
            } else {
                // No adjustment to make
                return {image, fDstBounds.topLeft(), PixelBoundary::kUnknown};
            }
        } else {
            return {};
        }
    }

---

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

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