#include <Device.h>

Inheritance diagram for skgpu::graphite::Device:

Classes
class	IntersectionTreeSet

Public Member Functions
	~Device () override

Device *	asGraphiteDevice () override

Recorder *	recorder () const override

void	abandonRecorder ()

void	flushPendingWorkToRecorder ()

const Transform &	localToDeviceTransform ()

void	setImmutable () override

SkStrikeDeviceInfo	strikeDeviceInfo () const override

TextureProxy *	target ()

TextureProxyView	readSurfaceView () const

sk_sp< Image >	makeImageCopy (const SkIRect &subset, Budgeted, Mipmapped, SkBackingFit)

bool	isScratchDevice () const

sk_sp< Task >	lastDrawTask () const

bool	useDrawCoverageMaskForMaskFilters () const override

void	pushClipStack () override

void	popClipStack () override

bool	isClipWideOpen () const override

bool	isClipEmpty () const override

bool	isClipRect () const override

bool	isClipAntiAliased () const override

SkIRect	devClipBounds () const override

void	android_utils_clipAsRgn (SkRegion *) const override

void	clipRect (const SkRect &rect, SkClipOp, bool aa) override

void	clipRRect (const SkRRect &rrect, SkClipOp, bool aa) override

void	clipPath (const SkPath &path, SkClipOp, bool aa) override

void	clipRegion (const SkRegion &globalRgn, SkClipOp) override

void	replaceClip (const SkIRect &rect) override

void	drawPaint (const SkPaint &paint) override

void	drawRect (const SkRect &r, const SkPaint &paint) override

void	drawOval (const SkRect &oval, const SkPaint &paint) override

void	drawRRect (const SkRRect &rr, const SkPaint &paint) override

void	drawPoints (SkCanvas::PointMode mode, size_t count, const SkPoint[], const SkPaint &paint) override

void	drawPath (const SkPath &path, const SkPaint &paint, bool pathIsMutable=false) override

void	drawEdgeAAQuad (const SkRect &rect, const SkPoint clip[4], SkCanvas::QuadAAFlags aaFlags, const SkColor4f &color, SkBlendMode mode) override

void	drawEdgeAAImageSet (const SkCanvas::ImageSetEntry[], int count, const SkPoint dstClips[], const SkMatrix preViewMatrices[], const SkSamplingOptions &, const SkPaint &, SkCanvas::SrcRectConstraint) override

void	drawImageRect (const SkImage , const SkRect src, const SkRect &dst, const SkSamplingOptions &, const SkPaint &, SkCanvas::SrcRectConstraint) override

void	drawVertices (const SkVertices *, sk_sp< SkBlender >, const SkPaint &, bool) override

bool	drawAsTiledImageRect (SkCanvas , const SkImage , const SkRect *src, const SkRect &dst, const SkSamplingOptions &, const SkPaint &, SkCanvas::SrcRectConstraint) override

void	drawImageLattice (const SkImage *, const SkCanvas::Lattice &, const SkRect &dst, SkFilterMode, const SkPaint &) override

void	drawAtlas (const SkRSXform[], const SkRect[], const SkColor[], int count, sk_sp< SkBlender >, const SkPaint &) override

void	drawDrawable (SkCanvas , SkDrawable , const SkMatrix *) override

void	drawMesh (const SkMesh &, sk_sp< SkBlender >, const SkPaint &) override

void	drawShadow (const SkPath &, const SkDrawShadowRec &) override

sk_sp< SkSurface >	makeSurface (const SkImageInfo &, const SkSurfaceProps &) override

sk_sp< SkDevice >	createDevice (const CreateInfo &, const SkPaint *) override

sk_sp< SkSpecialImage >	snapSpecial (const SkIRect &subset, bool forceCopy=false) override

void	drawSpecial (SkSpecialImage *, const SkMatrix &localToDevice, const SkSamplingOptions &, const SkPaint &, SkCanvas::SrcRectConstraint) override

void	drawCoverageMask (const SkSpecialImage *, const SkMatrix &localToDevice, const SkSamplingOptions &, const SkPaint &) override

bool	drawBlurredRRect (const SkRRect &, const SkPaint &, float deviceSigma) override

Public Member Functions inherited from SkDevice
	SkDevice (const SkImageInfo &, const SkSurfaceProps &)

const SkImageInfo &	imageInfo () const

int	width () const

int	height () const

bool	isOpaque () const

SkIRect	bounds () const

SkISize	size () const

const SkSurfaceProps &	surfaceProps () const

SkScalerContextFlags	scalerContextFlags () const

virtual SkStrikeDeviceInfo	strikeDeviceInfo () const

bool	writePixels (const SkPixmap &src, int x, int y)

bool	readPixels (const SkPixmap &dst, int x, int y)

bool	accessPixels (SkPixmap *pmap)

bool	peekPixels (SkPixmap *)

const SkM44 &	localToDevice44 () const

const SkMatrix &	localToDevice () const

const SkM44 &	deviceToGlobal () const

const SkM44 &	globalToDevice () const

SkIPoint	getOrigin () const

bool	isPixelAlignedToGlobal () const

SkMatrix	getRelativeTransform (const SkDevice &) const

void	setLocalToDevice (const SkM44 &localToDevice)

void	setGlobalCTM (const SkM44 &ctm)

void	getGlobalBounds (SkIRect *bounds) const

SkIRect	getGlobalBounds () const

virtual SkIRect	devClipBounds () const =0

virtual void	pushClipStack ()=0

virtual void	popClipStack ()=0

virtual void	clipRect (const SkRect &rect, SkClipOp op, bool aa)=0

virtual void	clipRRect (const SkRRect &rrect, SkClipOp op, bool aa)=0

virtual void	clipPath (const SkPath &path, SkClipOp op, bool aa)=0

virtual void	clipRegion (const SkRegion &region, SkClipOp op)=0

void	clipShader (sk_sp< SkShader > sh, SkClipOp op)

virtual void	replaceClip (const SkIRect &rect)=0

virtual bool	isClipAntiAliased () const =0

virtual bool	isClipEmpty () const =0

virtual bool	isClipRect () const =0

virtual bool	isClipWideOpen () const =0

virtual void	android_utils_clipAsRgn (SkRegion *) const =0

virtual bool	android_utils_clipWithStencil ()

virtual bool	useDrawCoverageMaskForMaskFilters () const

virtual bool	isNoPixelsDevice () const

virtual void *	getRasterHandle () const

virtual GrRecordingContext *	recordingContext () const

virtual skgpu::graphite::Recorder *	recorder () const

virtual skgpu::ganesh::Device *	asGaneshDevice ()

virtual skgpu::graphite::Device *	asGraphiteDevice ()

virtual void	setImmutable ()

virtual sk_sp< SkSurface >	makeSurface (const SkImageInfo &, const SkSurfaceProps &)

virtual sk_sp< SkDevice >	createDevice (const CreateInfo &, const SkPaint *)

void	drawGlyphRunList (SkCanvas *, const sktext::GlyphRunList &glyphRunList, const SkPaint &paint)

virtual sk_sp< sktext::gpu::Slug >	convertGlyphRunListToSlug (const sktext::GlyphRunList &glyphRunList, const SkPaint &paint)

virtual void	drawSlug (SkCanvas , const sktext::gpu::Slug slug, const SkPaint &paint)

virtual void	drawPaint (const SkPaint &paint)=0

virtual void	drawPoints (SkCanvas::PointMode mode, size_t count, const SkPoint[], const SkPaint &paint)=0

virtual void	drawRect (const SkRect &r, const SkPaint &paint)=0

virtual void	drawRegion (const SkRegion &r, const SkPaint &paint)

virtual void	drawOval (const SkRect &oval, const SkPaint &paint)=0

virtual void	drawArc (const SkArc &arc, const SkPaint &paint)

virtual void	drawRRect (const SkRRect &rr, const SkPaint &paint)=0

virtual void	drawDRRect (const SkRRect &outer, const SkRRect &inner, const SkPaint &)

virtual void	drawPath (const SkPath &path, const SkPaint &paint, bool pathIsMutable=false)=0

virtual void	drawImageRect (const SkImage , const SkRect src, const SkRect &dst, const SkSamplingOptions &, const SkPaint &, SkCanvas::SrcRectConstraint)=0

virtual bool	shouldDrawAsTiledImageRect () const

virtual bool	drawAsTiledImageRect (SkCanvas , const SkImage , const SkRect *src, const SkRect &dst, const SkSamplingOptions &, const SkPaint &, SkCanvas::SrcRectConstraint)

virtual void	drawImageLattice (const SkImage *, const SkCanvas::Lattice &, const SkRect &dst, SkFilterMode, const SkPaint &)

virtual void	drawVertices (const SkVertices *, sk_sp< SkBlender >, const SkPaint &, bool skipColorXform=false)=0

virtual void	drawMesh (const SkMesh &mesh, sk_sp< SkBlender >, const SkPaint &)=0

virtual void	drawShadow (const SkPath &, const SkDrawShadowRec &)

virtual void	drawPatch (const SkPoint cubics[12], const SkColor colors[4], const SkPoint texCoords[4], sk_sp< SkBlender >, const SkPaint &paint)

virtual void	drawAtlas (const SkRSXform[], const SkRect[], const SkColor[], int count, sk_sp< SkBlender >, const SkPaint &)

virtual void	drawAnnotation (const SkRect &, const char[], SkData *)

virtual void	drawEdgeAAQuad (const SkRect &rect, const SkPoint clip[4], SkCanvas::QuadAAFlags aaFlags, const SkColor4f &color, SkBlendMode mode)

virtual void	drawEdgeAAImageSet (const SkCanvas::ImageSetEntry[], int count, const SkPoint dstClips[], const SkMatrix preViewMatrices[], const SkSamplingOptions &, const SkPaint &, SkCanvas::SrcRectConstraint)

virtual void	drawDrawable (SkCanvas , SkDrawable , const SkMatrix *)

virtual sk_sp< SkSpecialImage >	snapSpecial (const SkIRect &subset, bool forceCopy=false)

virtual sk_sp< SkSpecialImage >	snapSpecialScaled (const SkIRect &subset, const SkISize &dstDims)

sk_sp< SkSpecialImage >	snapSpecial ()

virtual void	drawDevice (SkDevice *, const SkSamplingOptions &, const SkPaint &)

virtual void	drawSpecial (SkSpecialImage *, const SkMatrix &localToDevice, const SkSamplingOptions &, const SkPaint &, SkCanvas::SrcRectConstraint constraint=SkCanvas::kStrict_SrcRectConstraint)

virtual void	drawCoverageMask (const SkSpecialImage *, const SkMatrix &maskToDevice, const SkSamplingOptions &, const SkPaint &)

virtual bool	drawBlurredRRect (const SkRRect &, const SkPaint &, float deviceSigma)

void	drawFilteredImage (const skif::Mapping &mapping, SkSpecialImage src, SkColorType ct, const SkImageFilter , const SkSamplingOptions &, const SkPaint &)

Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()

virtual	~SkRefCntBase ()

bool	unique () const

void	ref () const

void	unref () const

Static Public Member Functions
static sk_sp< Device >	Make (Recorder *recorder, sk_sp< TextureProxy >, SkISize deviceSize, const SkColorInfo &, const SkSurfaceProps &, LoadOp initialLoadOp, bool registerWithRecorder=true)

static sk_sp< Device >	Make (Recorder *, const SkImageInfo &, Budgeted, Mipmapped, SkBackingFit, const SkSurfaceProps &, LoadOp initialLoadOp, std::string_view label, bool registerWithRecorder=true)

Friends
class	ClipStack

Additional Inherited Members
Protected Member Functions inherited from SkDevice
virtual sk_sp< SkSpecialImage >	makeSpecial (const SkBitmap &)

virtual sk_sp< SkSpecialImage >	makeSpecial (const SkImage *)

void	setDeviceCoordinateSystem (const SkM44 &deviceToGlobal, const SkM44 &globalToDevice, const SkM44 &localToDevice, int bufferOriginX, int bufferOriginY)

void	setOrigin (const SkM44 &globalCTM, int x, int y)

bool	checkLocalToDeviceDirty ()

Detailed Description

Definition at line 45 of file Device.h.

Constructor & Destructor Documentation

◆ ~Device()

skgpu::graphite::Device::~Device ( )

override

Definition at line 350 of file Device.cpp.

                {
    // The Device should have been marked immutable before it's destroyed, or the Recorder was the
    // last holder of a reference to it and de-registered the device as part of its cleanup.
    // However, if the Device was not registered with the recorder (i.e. a scratch device) we don't
    // require that its recorder be adandoned. Scratch devices must either have been marked
    // immutable or be destroyed before the recorder has been snapped.
    SkASSERT(!fRecorder || fScopedRecordingID != 0);
#if defined(SK_DEBUG)
    if (fScopedRecordingID != 0 && fRecorder) {
        SkASSERT(fScopedRecordingID == fRecorder->priv().nextRecordingID());
    }
    // else it wasn't a scratch device, or it was a scratch device that was marked immutable so its
    // lifetime was validated when setImmutable() was called.
#endif
}

Member Function Documentation

◆ abandonRecorder()

void skgpu::graphite::Device::abandonRecorder ( )

inline

Definition at line 75 of file Device.h.

75{ fRecorder = nullptr; }

◆ android_utils_clipAsRgn()

void skgpu::graphite::Device::android_utils_clipAsRgn ( SkRegion * region ) const

overridevirtual

Implements SkDevice.

Definition at line 558 of file Device.cpp.

                                                           {
    SkIRect bounds = this->devClipBounds();
    // Assume wide open and then perform intersect/difference operations reducing the region
    region->setRect(bounds);
    const SkRegion deviceBounds(bounds);
    for (const ClipStack::Element& e : fClip) {
        SkRegion tmp;
        if (e.fShape.isRect() && e.fLocalToDevice.type() == Transform::Type::kIdentity) {
            tmp.setRect(rect_to_pixelbounds(e.fShape.rect()));
        } else {
            SkPath tmpPath = e.fShape.asPath();
            tmpPath.transform(e.fLocalToDevice);
            tmp.setPath(tmpPath, deviceBounds);
        }
 
        region->op(tmp, (SkRegion::Op) e.fOp);
    }
}

◆ asGraphiteDevice()

Device * skgpu::graphite::Device::asGraphiteDevice ( )

inlineoverridevirtual

Reimplemented from SkDevice.

Definition at line 70 of file Device.h.

70{ return this; }

◆ clipPath()

void skgpu::graphite::Device::clipPath	(	const SkPath &	path,
		SkClipOp	op,
		bool	aa
	)

overridevirtual

Implements SkDevice.

Definition at line 590 of file Device.cpp.

                                                              {
    SkASSERT(op == SkClipOp::kIntersect || op == SkClipOp::kDifference);
    // TODO: Ensure all path inspection is handled here or in SkCanvas, and that non-AA rects as
    // paths are routed appropriately.
    // TODO: Must also detect paths that are lines so the clip stack can be set to empty
    fClip.clipShape(this->localToDeviceTransform(), Shape{path}, op);
}

◆ clipRect()

void skgpu::graphite::Device::clipRect	(	const SkRect &	rect,
		SkClipOp	op,
		bool	aa
	)

overridevirtual

Implements SkDevice.

Definition at line 577 of file Device.cpp.

                                                              {
    SkASSERT(op == SkClipOp::kIntersect || op == SkClipOp::kDifference);
    // TODO: Snap rect edges to pixel bounds if non-AA and axis-aligned?
    fClip.clipShape(this->localToDeviceTransform(), Shape{rect}, op);
}

◆ clipRegion()

void skgpu::graphite::Device::clipRegion	(	const SkRegion &	globalRgn,
		SkClipOp	op
	)

overridevirtual

Implements SkDevice.

Definition at line 603 of file Device.cpp.

                                                              {
    SkASSERT(op == SkClipOp::kIntersect || op == SkClipOp::kDifference);
 
    Transform globalToDevice{this->globalToDevice()};
 
    if (globalRgn.isEmpty()) {
        fClip.clipShape(globalToDevice, Shape{}, op);
    } else if (globalRgn.isRect()) {
        // TODO: Region clips are non-AA so this should match non-AA onClipRect(), but we use a
        // different transform so can't just call that instead.
        fClip.clipShape(globalToDevice, Shape{SkRect::Make(globalRgn.getBounds())}, op);
    } else {
        // TODO: Can we just iterate the region and do non-AA rects for each chunk?
        SkPath path;
        globalRgn.getBoundaryPath(&path);
        fClip.clipShape(globalToDevice, Shape{path}, op);
    }
}

◆ clipRRect()

void skgpu::graphite::Device::clipRRect	(	const SkRRect &	rrect,
		SkClipOp	op,
		bool	aa
	)

overridevirtual

Implements SkDevice.

Definition at line 583 of file Device.cpp.

                                                                 {
    SkASSERT(op == SkClipOp::kIntersect || op == SkClipOp::kDifference);
    // TODO: Snap rrect edges to pixel bounds if non-AA and axis-aligned? Is that worth doing to
    // seam with non-AA rects even if the curves themselves are AA'ed?
    fClip.clipShape(this->localToDeviceTransform(), Shape{rrect}, op);
}

◆ createDevice()

sk_sp< SkDevice > skgpu::graphite::Device::createDevice	(	const CreateInfo &	,
		const SkPaint *
	)

overridevirtual

Create a new device based on CreateInfo. If the paint is not null, then it represents a preview of how the new device will be composed with its creator device (this).

The subclass may be handed this device in drawDevice(), so it must always return a device that it knows how to draw, and that it knows how to identify if it is not of the same subclass (since drawDevice is passed a SkDevice*). If the subclass cannot fulfill that contract (e.g. PDF cannot support some settings on the paint) it should return NULL, and the caller may then decide to explicitly create a bitmapdevice, knowing that later it could not call drawDevice with it (but it could call drawSprite or drawBitmap).

Reimplemented from SkDevice.

Definition at line 392 of file Device.cpp.

                                                                           {
    // TODO: Inspect the paint and create info to determine if there's anything that has to be
    // modified to support inline subpasses.
    SkSurfaceProps props =
        this->surfaceProps().cloneWithPixelGeometry(info.fPixelGeometry);
 
    // Skia's convention is to only clear a device if it is non-opaque.
    LoadOp initialLoadOp = info.fInfo.isOpaque() ? LoadOp::kDiscard : LoadOp::kClear;
 
    std::string label = this->target()->label();
    if (label.empty()) {
        label = "ChildDevice";
    } else {
        label += "_ChildDevice";
    }
 
    return Make(fRecorder,
                info.fInfo,
                skgpu::Budgeted::kYes,
                Mipmapped::kNo,
                SkBackingFit::kApprox,
                props,
                initialLoadOp,
                label);
}

◆ devClipBounds()

SkIRect skgpu::graphite::Device::devClipBounds ( ) const

overridevirtual

Returns the bounding box of the current clip, in this device's coordinate space. No pixels outside of these bounds will be touched by draws unless the clip is further modified (at which point this will return the updated bounds).

Implements SkDevice.

Definition at line 553 of file Device.cpp.

                                    {
    return rect_to_pixelbounds(fClip.conservativeBounds());
}

◆ drawAsTiledImageRect()

bool skgpu::graphite::Device::drawAsTiledImageRect	(	SkCanvas *	canvas,
		const SkImage *	image,
		const SkRect *	src,
		const SkRect &	dst,
		const SkSamplingOptions &	sampling,
		const SkPaint &	paint,
		SkCanvas::SrcRectConstraint	constraint
	)

overridevirtual

Reimplemented from SkDevice.

Definition at line 691 of file Device.cpp.

                                                                        {
    auto recorder = canvas->recorder();
    if (!recorder) {
        return false;
    }
    SkASSERT(src);
 
    // For Graphite this is a pretty loose heuristic. The Recorder-local cache size (relative
    // to the large image's size) is used as a proxy for how conservative we should be when
    // allocating tiles. Since the tiles will actually be owned by the client (via an
    // ImageProvider) they won't actually add any memory pressure directly to Graphite.
    size_t cacheSize = recorder->priv().getResourceCacheLimit();
    size_t maxTextureSize = recorder->priv().caps()->maxTextureSize();
 
#if defined(GRAPHITE_TEST_UTILS)
    if (gOverrideMaxTextureSizeGraphite) {
        maxTextureSize = gOverrideMaxTextureSizeGraphite;
    }
    gNumTilesDrawnGraphite.store(0, std::memory_order_relaxed);
#endif
 
    [[maybe_unused]] auto [wasTiled, numTiles] =
            skgpu::TiledTextureUtils::DrawAsTiledImageRect(canvas,
                                                           image,
                                                           *src,
                                                           dst,
                                                           SkCanvas::kAll_QuadAAFlags,
                                                           sampling,
                                                           &paint,
                                                           constraint,
                                                           cacheSize,
                                                           maxTextureSize);
#if defined(GRAPHITE_TEST_UTILS)
    gNumTilesDrawnGraphite.store(numTiles, std::memory_order_relaxed);
#endif
    return wasTiled;
}

◆ drawAtlas()

void skgpu::graphite::Device::drawAtlas	(	const	SkRSXform[],
		const	SkRect[],
		const	SkColor[],
		int	count,
		sk_sp< SkBlender >	,
		const SkPaint &
	)

inlineoverridevirtual

Reimplemented from SkDevice.

Definition at line 179 of file Device.h.

180 {}

◆ drawBlurredRRect()

bool skgpu::graphite::Device::drawBlurredRRect	(	const SkRRect &	,
		const SkPaint &	,
		float	deviceSigma
	)

overridevirtual

Draw rrect with an optimized path for analytic blurs, if provided by the device.

Reimplemented from SkDevice.

Definition at line 1717 of file Device.cpp.

                                                                                           {
    SkStrokeRec style(paint);
    if (skgpu::BlurIsEffectivelyIdentity(deviceSigma)) {
        this->drawGeometry(this->localToDeviceTransform(),
                           Geometry(rrect.isRect() ? Shape(rrect.rect()) : Shape(rrect)),
                           paint,
                           style);
        return true;
    }
 
    std::optional<AnalyticBlurMask> analyticBlur = AnalyticBlurMask::Make(
            this->recorder(), this->localToDeviceTransform(), deviceSigma, rrect);
    if (!analyticBlur) {
        return false;
    }
 
    this->drawGeometry(this->localToDeviceTransform(), Geometry(*analyticBlur), paint, style);
    return true;
}

◆ drawCoverageMask()

void skgpu::graphite::Device::drawCoverageMask	(	const SkSpecialImage *	,
		const SkMatrix &	maskToDevice,
		const SkSamplingOptions &	,
		const SkPaint &
	)

overridevirtual

Draw the special image's subset to this device, treating its alpha channel as coverage for the draw and ignoring any RGB channels that might be present. This will be drawn using the provided matrix transform instead of the device's current local to device matrix.

Coverage values beyond the image's subset are treated as 0 (i.e. kDecal tiling). Color values before coverage are determined as normal by the SkPaint, ignoring style, path effects, mask filters and image filters. The local coords of any SkShader on the paint should be relative to the SkDevice's current matrix (i.e. 'maskToDevice' determines how the coverage mask aligns with device-space, but otherwise shading proceeds like other draws).

Reimplemented from SkDevice.

Definition at line 1590 of file Device.cpp.

                                                    {
    CoverageMaskShape::MaskInfo maskInfo{/*fTextureOrigin=*/{SkTo<uint16_t>(mask->subset().fLeft),
                                                             SkTo<uint16_t>(mask->subset().fTop)},
                                         /*fMaskSize=*/{SkTo<uint16_t>(mask->width()),
                                                        SkTo<uint16_t>(mask->height())}};
 
    auto maskProxyView = AsView(mask->asImage());
    if (!maskProxyView) {
        SKGPU_LOG_W("Couldn't get Graphite-backed special image as texture proxy view");
        return;
    }
 
    // Every other "Image" draw reaches the underlying texture via AddToKey/NotifyInUse, which
    // handles notifying the image and either flushing the linked surface or attaching draw tasks
    // from a scratch device to the current draw context. In this case, 'mask' is very likely to
    // be linked to a scratch device, but we must perform the same notifyInUse manually here because
    // the texture is consumed by the RenderStep and not part of the PaintParams.
    static_cast<Image_Base*>(mask->asImage().get())->notifyInUse(fRecorder, fDC.get());
 
    // 'mask' logically has 0 coverage outside of its pixels, which is equivalent to kDecal tiling.
    // However, since we draw geometry tightly fitting 'mask', we can use the better-supported
    // kClamp tiling and behave effectively the same way.
    const SkTileMode kClamp[2] = {SkTileMode::kClamp, SkTileMode::kClamp};
 
    // Ensure this is kept alive; normally textures are kept alive by the PipelineDataGatherer for
    // image shaders, or by the PathAtlas. This is a unique circumstance.
    // TODO: Find a cleaner way to ensure 'maskProxyView' is transferred to the final Recording.
    TextureDataBlock tdb;
    // NOTE: CoverageMaskRenderStep controls the final sampling options; this texture data block
    // serves only to keep the mask alive so the sampling passed to add() doesn't matter.
    tdb.add(maskProxyView.refProxy(), {SkFilterMode::kLinear, kClamp});
    fRecorder->priv().textureDataCache()->insert(tdb);
 
    // CoverageMaskShape() wraps a Shape when it's used as a PathAtlas, but in this case the
    // original shape has been long lost, so just use a Rect that bounds the image.
    CoverageMaskShape maskShape{Shape{Rect::WH((float)mask->width(), (float)mask->height())},
                                maskProxyView.proxy(),
                                // Use the active local-to-device transform for this since it
                                // determines the local coords for evaluating the skpaint, whereas
                                // the provided 'localToDevice' just places the coverage mask.
                                this->localToDeviceTransform().inverse(),
                                maskInfo};
 
    this->drawGeometry(Transform(SkM44(localToDevice)),
                       Geometry(maskShape),
                       paint,
                       DefaultFillStyle(),
                       DrawFlags::kIgnorePathEffect);
}

◆ drawDrawable()

void skgpu::graphite::Device::drawDrawable	(	SkCanvas *	,
		SkDrawable *	,
		const SkMatrix *
	)

inlineoverridevirtual

Reimplemented from SkDevice.

Definition at line 182 of file Device.h.

182{}

◆ drawEdgeAAImageSet()

void skgpu::graphite::Device::drawEdgeAAImageSet	(	const SkCanvas::ImageSetEntry	set[],
		int	count,
		const SkPoint	dstClips[],
		const SkMatrix	preViewMatrices[],
		const SkSamplingOptions &	sampling,
		const SkPaint &	paint,
		SkCanvas::SrcRectConstraint	constraint
	)

overridevirtual

Reimplemented from SkDevice.

Definition at line 828 of file Device.cpp.

                                                                      {
    SkASSERT(count > 0);
 
    SkPaint paintWithShader(paint);
    int dstClipIndex = 0;
    for (int i = 0; i < count; ++i) {
        // If the entry is clipped by 'dstClips', that must be provided
        SkASSERT(!set[i].fHasClip || dstClips);
        // Similarly, if it has an extra transform, those must be provided
        SkASSERT(set[i].fMatrixIndex < 0 || preViewMatrices);
 
        auto [ imageToDraw, newSampling ] =
                skgpu::graphite::GetGraphiteBacked(this->recorder(), set[i].fImage.get(), sampling);
        if (!imageToDraw) {
            SKGPU_LOG_W("Device::drawImageRect: Creation of Graphite-backed image failed");
            return;
        }
 
        // TODO: Produce an image shading paint key and data directly without having to reconstruct
        // the equivalent SkPaint for each entry. Reuse the key and data between entries if possible
        paintWithShader.setShader(paint.refShader());
        paintWithShader.setAlphaf(paint.getAlphaf() * set[i].fAlpha);
        SkRect dst = SkModifyPaintAndDstForDrawImageRect(
                    imageToDraw.get(), newSampling, set[i].fSrcRect, set[i].fDstRect,
                    constraint == SkCanvas::kStrict_SrcRectConstraint,
                    &paintWithShader);
        if (dst.isEmpty()) {
            return;
        }
 
        auto flags =
                SkEnumBitMask<EdgeAAQuad::Flags>(static_cast<EdgeAAQuad::Flags>(set[i].fAAFlags));
        EdgeAAQuad quad = set[i].fHasClip ? EdgeAAQuad(dstClips + dstClipIndex, flags)
                                          : EdgeAAQuad(dst, flags);
 
        // TODO: Calling drawGeometry() for each entry re-evaluates the clip stack every time, which
        // is consistent with Ganesh's behavior. It also matches the behavior if edge-AA images were
        // submitted one at a time by SkiaRenderer (a nice client simplification). However, we
        // should explore the performance trade off with doing one bulk evaluation for the whole set
        if (set[i].fMatrixIndex < 0) {
            this->drawGeometry(this->localToDeviceTransform(),
                               Geometry(quad),
                               paintWithShader,
                               DefaultFillStyle(),
                               DrawFlags::kIgnorePathEffect);
        } else {
            SkM44 xtraTransform(preViewMatrices[set[i].fMatrixIndex]);
            this->drawGeometry(this->localToDeviceTransform().concat(xtraTransform),
                               Geometry(quad),
                               paintWithShader,
                               DefaultFillStyle(),
                               DrawFlags::kIgnorePathEffect);
        }
 
        dstClipIndex += 4 * set[i].fHasClip;
    }
}

◆ drawEdgeAAQuad()

void skgpu::graphite::Device::drawEdgeAAQuad	(	const SkRect &	rect,
		const SkPoint	clip[4],
		SkCanvas::QuadAAFlags	aaFlags,
		const SkColor4f &	color,
		SkBlendMode	mode
	)

overridevirtual

Reimplemented from SkDevice.

Definition at line 810 of file Device.cpp.

                                              {
    SkPaint solidColorPaint;
    solidColorPaint.setColor4f(color, /*colorSpace=*/nullptr);
    solidColorPaint.setBlendMode(mode);
 
    auto flags = SkEnumBitMask<EdgeAAQuad::Flags>(static_cast<EdgeAAQuad::Flags>(aaFlags));
    EdgeAAQuad quad = clip ? EdgeAAQuad(clip, flags) : EdgeAAQuad(rect, flags);
    this->drawGeometry(this->localToDeviceTransform(),
                       Geometry(quad),
                       solidColorPaint,
                       DefaultFillStyle(),
                       DrawFlags::kIgnorePathEffect);
}

◆ drawImageLattice()

void skgpu::graphite::Device::drawImageLattice	(	const SkImage *	,
		const SkCanvas::Lattice &	,
		const SkRect &	dst,
		SkFilterMode	,
		const SkPaint &
	)

inlineoverridevirtual

Reimplemented from SkDevice.

Definition at line 177 of file Device.h.

178 {}

◆ drawImageRect()

void skgpu::graphite::Device::drawImageRect	(	const SkImage *	image,
		const SkRect *	src,
		const SkRect &	dst,
		const SkSamplingOptions &	sampling,
		const SkPaint &	paint,
		SkCanvas::SrcRectConstraint	constraint
	)

overridevirtual

Implements SkDevice.

Definition at line 889 of file Device.cpp.

                                                                 {
    SkCanvas::ImageSetEntry single{sk_ref_sp(image),
                                   src ? *src : SkRect::Make(image->bounds()),
                                   dst,
                                   /*alpha=*/1.f,
                                   SkCanvas::kAll_QuadAAFlags};
    this->drawEdgeAAImageSet(&single, 1, nullptr, nullptr, sampling, paint, constraint);
}

◆ drawMesh()

void skgpu::graphite::Device::drawMesh	(	const SkMesh &	,
		sk_sp< SkBlender >	,
		const SkPaint &
	)

inlineoverridevirtual

Implements SkDevice.

Definition at line 183 of file Device.h.

183{}

◆ drawOval()

void skgpu::graphite::Device::drawOval	(	const SkRect &	oval,
		const SkPaint &	paint
	)

overridevirtual

Implements SkDevice.

Definition at line 735 of file Device.cpp.

                                                              {
    if (paint.getPathEffect()) {
        // Dashing requires that the oval path starts on the right side and travels clockwise. This
        // is the default for the SkPath::Oval constructor, as used by SkBitmapDevice.
        this->drawGeometry(this->localToDeviceTransform(), Geometry(Shape(SkPath::Oval(oval))),
                           paint, SkStrokeRec(paint));
    } else {
        // TODO: This has wasted effort from the SkCanvas level since it instead converts rrects
        // that happen to be ovals into this, only for us to go right back to rrect.
        this->drawGeometry(this->localToDeviceTransform(), Geometry(Shape(SkRRect::MakeOval(oval))),
                           paint, SkStrokeRec(paint));
    }
}

◆ drawPaint()

void skgpu::graphite::Device::drawPaint ( const SkPaint & paint )

overridevirtual

Implements SkDevice.

Definition at line 639 of file Device.cpp.

                                           {
    ASSERT_SINGLE_OWNER
    // We never want to do a fullscreen clear on a fully-lazy render target, because the device size
    // may be smaller than the final surface we draw to, in which case we don't want to fill the
    // entire final surface.
    if (this->isClipWideOpen() && !fDC->target()->isFullyLazy()) {
        if (!paint_depends_on_dst(paint)) {
            if (std::optional<SkColor4f> color = extract_paint_color(paint, fDC->colorInfo())) {
                // do fullscreen clear
                fDC->clear(*color);
                return;
            } else {
                // This paint does not depend on the destination and covers the entire surface, so
                // discard everything previously recorded and proceed with the draw.
                fDC->discard();
            }
        }
    }
 
    const Transform& localToDevice = this->localToDeviceTransform();
    if (!localToDevice.valid()) {
        // TBD: This matches legacy behavior for drawPaint() that requires local coords, although
        // v1 handles arbitrary transforms when the paint is solid color because it just fills the
        // device bounds directly. In the new world it might be nice to have non-invertible
        // transforms formalized (i.e. no drawing ever, handled at SkCanvas level possibly?)
        return;
    }
    Rect localCoveringBounds = localToDevice.inverseMapRect(fClip.conservativeBounds());
    this->drawGeometry(localToDevice,
                       Geometry(Shape(localCoveringBounds)),
                       paint,
                       DefaultFillStyle(),
                       DrawFlags::kIgnorePathEffect);
}

◆ drawPath()

void skgpu::graphite::Device::drawPath	(	const SkPath &	path,
		const SkPaint &	paint,
		bool	pathIsMutable = `false`
	)

overridevirtual

If pathIsMutable, then the implementation is allowed to cast path to a non-const pointer and modify it in place (as an optimization). Canvas may do this to implement helpers such as drawOval, by placing a temp path on the stack to hold the representation of the oval.

Implements SkDevice.

Definition at line 754 of file Device.cpp.

                                                                                  {
    // Alternatively, we could move this analysis to SkCanvas. Also, we could consider applying the
    // path effect, being careful about starting point and direction.
    if (!paint.getPathEffect() && !path.isInverseFillType()) {
        if (SkRect oval; path.isOval(&oval)) {
            this->drawGeometry(this->localToDeviceTransform(),
                               Geometry(Shape(SkRRect::MakeOval(oval))),
                               paint,
                               SkStrokeRec(paint));
            return;
        }
        if (SkRRect rrect; path.isRRect(&rrect)) {
            this->drawGeometry(this->localToDeviceTransform(),
                               Geometry(Shape(rrect)),
                               paint,
                               SkStrokeRec(paint));
            return;
        }
        if (SkRect rect; paint.getStyle() == SkPaint::kFill_Style && path.isRect(&rect)) {
            this->drawGeometry(this->localToDeviceTransform(),
                               Geometry(Shape(rect)),
                               paint,
                               SkStrokeRec(paint));
            return;
        }
    }
    this->drawGeometry(this->localToDeviceTransform(), Geometry(Shape(path)),
                       paint, SkStrokeRec(paint));
}

◆ drawPoints()

void skgpu::graphite::Device::drawPoints	(	SkCanvas::PointMode	mode,
		size_t	count,
		const	SkPoint[],
		const SkPaint &	paint
	)

overridevirtual

Implements SkDevice.

◆ drawRect()

void skgpu::graphite::Device::drawRect	(	const SkRect &	r,
		const SkPaint &	paint
	)

overridevirtual

Implements SkDevice.

Definition at line 674 of file Device.cpp.

                                                           {
    this->drawGeometry(this->localToDeviceTransform(), Geometry(Shape(r)),
                       paint, SkStrokeRec(paint));
}

◆ drawRRect()

void skgpu::graphite::Device::drawRRect	(	const SkRRect &	rr,
		const SkPaint &	paint
	)

overridevirtual

Implements SkDevice.

Definition at line 749 of file Device.cpp.

                                                              {
    this->drawGeometry(this->localToDeviceTransform(), Geometry(Shape(rr)),
                       paint, SkStrokeRec(paint));
}

◆ drawShadow()

void skgpu::graphite::Device::drawShadow	(	const SkPath &	,
		const SkDrawShadowRec &
	)

inlineoverridevirtual

Reimplemented from SkDevice.

Definition at line 184 of file Device.h.

184{}

◆ drawSpecial()

void skgpu::graphite::Device::drawSpecial	(	SkSpecialImage *	,
		const SkMatrix &	localToDevice,
		const SkSamplingOptions &	,
		const SkPaint &	,
		SkCanvas::SrcRectConstraint	constraint
	)

overridevirtual

Draw the special image's subset to this device, subject to the given matrix transform instead of the device's current local to device matrix.

If 'constraint' is kFast, the rendered geometry of the image still reflects the extent of the SkSpecialImage's subset, but it's assumed that the pixel data beyond the subset is valid (e.g. SkSpecialImage::makeSubset() was called to crop a larger image).

Reimplemented from SkDevice.

Definition at line 1558 of file Device.cpp.

                                                               {
    SkASSERT(!paint.getMaskFilter() && !paint.getImageFilter());
 
    sk_sp<SkImage> img = special->asImage();
    if (!img || !as_IB(img)->isGraphiteBacked()) {
        SKGPU_LOG_W("Couldn't get Graphite-backed special image as image");
        return;
    }
 
    SkPaint paintWithShader(paint);
    SkRect dst = SkModifyPaintAndDstForDrawImageRect(
            img.get(),
            sampling,
            /*src=*/SkRect::Make(special->subset()),
            /*dst=*/SkRect::MakeIWH(special->width(), special->height()),
            /*strictSrcSubset=*/constraint == SkCanvas::kStrict_SrcRectConstraint,
            &paintWithShader);
    if (dst.isEmpty()) {
        return;
    }
 
    this->drawGeometry(Transform(SkM44(localToDevice)),
                       Geometry(Shape(dst)),
                       paintWithShader,
                       DefaultFillStyle(),
                       DrawFlags::kIgnorePathEffect);
}

◆ drawVertices()

void skgpu::graphite::Device::drawVertices	(	const SkVertices *	,
		sk_sp< SkBlender >	,
		const SkPaint &	,
		bool	skipColorXform
	)

overridevirtual

If skipColorXform is true, then the implementation should assume that the provided vertex colors are already in the destination color space.

Implements SkDevice.

Definition at line 679 of file Device.cpp.

                                                                      {
  // TODO - Add GPU handling of skipColorXform once Graphite has its color system more fleshed out.
    this->drawGeometry(this->localToDeviceTransform(),
                       Geometry(sk_ref_sp(vertices)),
                       paint,
                       DefaultFillStyle(),
                       DrawFlags::kIgnorePathEffect,
                       std::move(blender),
                       skipColorXform);
}

◆ flushPendingWorkToRecorder()

void skgpu::graphite::Device::flushPendingWorkToRecorder ( )

Definition at line 1465 of file Device.cpp.

                                        {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
 
    // If this is a scratch device being flushed, it should only be flushing into the expected
    // next recording from when the Device was first created.
    SkASSERT(fRecorder);
    SkASSERT(fScopedRecordingID == 0 || fScopedRecordingID == fRecorder->priv().nextRecordingID());
 
    // TODO(b/330864257):  flushPendingWorkToRecorder() can be recursively called if this Device
    // recorded a picture shader draw and during a flush (triggered by snap or automatically from
    // reaching limits), the picture shader will be rendered to a new device. If that picture drawn
    // to the temporary device fills up an atlas it can trigger the global
    // recorder->flushTrackedDevices(), which will then encounter this device that is already in
    // the midst of flushing. To avoid crashing we only actually flush the first time this is called
    // and set a bit to early-out on any recursive calls.
    // This is not an ideal solution since the temporary Device's flush-the-world may have reset
    // atlas entries that the current Device's flushed draws will reference. But at this stage it's
    // not possible to split the already recorded draws into a before-list and an after-list that
    // can reference the old and new contents of the atlas. While avoiding the crash, this may cause
    // incorrect accesses to a shared atlas. Once paint data is extracted at draw time, picture
    // shaders will be resolved outside of flushes and then this will be fixed automatically.
    if (fIsFlushing) {
        return;
    } else {
        fIsFlushing = true;
    }
 
    this->internalFlush();
    sk_sp<Task> drawTask = fDC->snapDrawTask(fRecorder);
    if (this->isScratchDevice()) {
        // TODO(b/323887221): Once shared atlas resources are less brittle, scratch devices won't
        // flush to the recorder at all and will only store the snapped task here.
        fLastTask = drawTask;
    } else {
        // Non-scratch devices do not need to point back to the last snapped task since they are
        // always added to the root task list.
        // TODO: It is currently possible for scratch devices to be flushed and instantiated before
        // their work is finished, meaning they will produce additional tasks to be included in
        // a follow-up Recording: https://chat.google.com/room/AAAA2HlH94I/YU0XdFqX2Uw.
        // However, in this case they no longer appear scratch because the first Recording
        // instantiated the targets. When scratch devices are not actually registered with the
        // Recorder and are only included when they are drawn (e.g. restored), we should be able to
        // assert that `fLastTask` is null.
        fLastTask = nullptr;
    }
 
    if (drawTask) {
        fRecorder->priv().add(std::move(drawTask));
 
        // TODO(b/297344089): This always regenerates mipmaps on the draw target when it's drawn to.
        // This could be wasteful if we draw to a target multiple times before reading from it with
        // downscaling.
        if (fDC->target()->mipmapped() == Mipmapped::kYes) {
            if (!GenerateMipmaps(fRecorder, fDC->refTarget(), fDC->colorInfo())) {
                SKGPU_LOG_W("Device::flushPendingWorkToRecorder: Failed to generate mipmaps");
            }
        }
    }
 
    fIsFlushing = false;
}

◆ isClipAntiAliased()

bool skgpu::graphite::Device::isClipAntiAliased ( ) const

overridevirtual

Implements SkDevice.

Definition at line 539 of file Device.cpp.

                                     {
    // All clips are AA'ed unless it's wide-open, empty, or a device-rect with integer coordinates
    ClipStack::ClipState type = fClip.clipState();
    if (type == ClipStack::ClipState::kWideOpen || type == ClipStack::ClipState::kEmpty) {
        return false;
    } else if (type == ClipStack::ClipState::kDeviceRect) {
        const ClipStack::Element rect = *fClip.begin();
        SkASSERT(rect.fShape.isRect() && rect.fLocalToDevice.type() == Transform::Type::kIdentity);
        return rect.fShape.rect() != rect.fShape.rect().makeRoundOut();
    } else {
        return true;
    }
}

◆ isClipEmpty()

bool skgpu::graphite::Device::isClipEmpty ( ) const

inlineoverridevirtual

Implements SkDevice.

Definition at line 124 of file Device.h.

                                      {
        return fClip.clipState() == ClipStack::ClipState::kEmpty;
    }

◆ isClipRect()

bool skgpu::graphite::Device::isClipRect ( ) const

inlineoverridevirtual

Implements SkDevice.

Definition at line 127 of file Device.h.

                                     {
        return fClip.clipState() == ClipStack::ClipState::kDeviceRect ||
               fClip.clipState() == ClipStack::ClipState::kWideOpen;
    }

◆ isClipWideOpen()

bool skgpu::graphite::Device::isClipWideOpen ( ) const

inlineoverridevirtual

Implements SkDevice.

Definition at line 121 of file Device.h.

                                         {
        return fClip.clipState() == ClipStack::ClipState::kWideOpen;
    }

◆ isScratchDevice()

bool skgpu::graphite::Device::isScratchDevice ( ) const

Definition at line 1690 of file Device.cpp.

                                   {
    // Scratch device status is inferred from whether or not the Device's target is instantiated.
    // By default devices start out un-instantiated unless they are wrapping an existing backend
    // texture (definitely not a scratch scenario), or Surface explicitly instantiates the target
    // before returning to the client (not a scratch scenario).
    //
    // Scratch device targets are instantiated during the prepareResources() phase of
    // Recorder::snap(). Truly scratch devices that have gone out of scope as intended will have
    // already been destroyed at this point. Scratch devices that become longer-lived (linked to
    // a client-owned object) automatically transition to non-scratch usage.
    return !fDC->target()->isInstantiated() && !fDC->target()->isLazy();
}

◆ lastDrawTask()

sk_sp< Task > skgpu::graphite::Device::lastDrawTask ( ) const

Definition at line 1460 of file Device.cpp.

                                       {
    SkASSERT(this->isScratchDevice());
    return fLastTask;
}

◆ localToDeviceTransform()

const Transform & skgpu::graphite::Device::localToDeviceTransform ( )

Definition at line 381 of file Device.cpp.

                                                {
    if (this->checkLocalToDeviceDirty()) {
        fCachedLocalToDevice = Transform{this->localToDevice44()};
    }
    return fCachedLocalToDevice;
}

◆ Make() [1/2]

sk_sp< Device > skgpu::graphite::Device::Make	(	Recorder *	recorder,
		const SkImageInfo &	ii,
		skgpu::Budgeted	budgeted,
		Mipmapped	mipmapped,
		SkBackingFit	backingFit,
		const SkSurfaceProps &	props,
		LoadOp	initialLoadOp,
		std::string_view	label,
		bool	registerWithRecorder = `true`
	)

static

Definition at line 244 of file Device.cpp.

                                                      {
    SkASSERT(!(mipmapped == Mipmapped::kYes && backingFit == SkBackingFit::kApprox));
    if (!recorder) {
        return nullptr;
    }
 
    const Caps* caps = recorder->priv().caps();
    SkISize backingDimensions = backingFit == SkBackingFit::kApprox ? GetApproxSize(ii.dimensions())
                                                                    : ii.dimensions();
    auto textureInfo = caps->getDefaultSampledTextureInfo(ii.colorType(),
                                                          mipmapped,
                                                          recorder->priv().isProtected(),
                                                          Renderable::kYes);
 
    return Make(recorder,
                TextureProxy::Make(caps, recorder->priv().resourceProvider(),
                                   backingDimensions, textureInfo, std::move(label), budgeted),
                ii.dimensions(),
                ii.colorInfo(),
                props,
                initialLoadOp,
                registerWithRecorder);
}

◆ Make() [2/2]

sk_sp< Device > skgpu::graphite::Device::Make	(	Recorder *	recorder,
		sk_sp< TextureProxy >	target,
		SkISize	deviceSize,
		const SkColorInfo &	colorInfo,
		const SkSurfaceProps &	props,
		LoadOp	initialLoadOp,
		bool	registerWithRecorder = `true`
	)

static

Definition at line 276 of file Device.cpp.

                                                      {
    if (!recorder) {
        return nullptr;
    }
 
    sk_sp<DrawContext> dc = DrawContext::Make(recorder->priv().caps(),
                                              std::move(target),
                                              deviceSize,
                                              colorInfo,
                                              props);
    if (!dc) {
        return nullptr;
    } else if (initialLoadOp == LoadOp::kClear) {
        dc->clear(SkColors::kTransparent);
    } else if (initialLoadOp == LoadOp::kDiscard) {
        dc->discard();
    } // else kLoad is the default initial op for a DrawContext
 
    sk_sp<Device> device{new Device(recorder, std::move(dc))};
    if (registerWithRecorder) {
        // We don't register the device with the recorder until after the constructor has returned.
        recorder->registerDevice(device);
    } else {
        // Since it's not registered, it should go out of scope before nextRecordingID() changes
        // from what is saved to fScopedRecordingID.
        SkDEBUGCODE(device->fScopedRecordingID = recorder->priv().nextRecordingID();)
    }
    return device;
}

◆ makeImageCopy()

sk_sp< Image > skgpu::graphite::Device::makeImageCopy	(	const SkIRect &	subset,
		Budgeted	budgeted,
		Mipmapped	mipmapped,
		SkBackingFit	backingFit
	)

Definition at line 422 of file Device.cpp.

                                                            {
    ASSERT_SINGLE_OWNER
    this->flushPendingWorkToRecorder();
 
    const SkColorInfo& colorInfo = this->imageInfo().colorInfo();
    TextureProxyView srcView = this->readSurfaceView();
    if (!srcView) {
        // readSurfaceView() returns an empty view when the target is not texturable. Create an
        // equivalent view for the blitting operation.
        Swizzle readSwizzle = fRecorder->priv().caps()->getReadSwizzle(
                colorInfo.colorType(), this->target()->textureInfo());
        srcView = {sk_ref_sp(this->target()), readSwizzle};
    }
    std::string label = this->target()->label();
    if (label.empty()) {
        label = "CopyDeviceTexture";
    } else {
        label += "_DeviceCopy";
    }
 
    return Image::Copy(fRecorder, srcView, colorInfo, subset, budgeted, mipmapped, backingFit,
                       label);
}

◆ makeSurface()

sk_sp< SkSurface > skgpu::graphite::Device::makeSurface	(	const SkImageInfo &	ii,
		const SkSurfaceProps &	props
	)

overridevirtual

Reimplemented from SkDevice.

Definition at line 418 of file Device.cpp.

                                                                                       {
    return SkSurfaces::RenderTarget(fRecorder, ii, Mipmapped::kNo, &props);
}

◆ popClipStack()

void skgpu::graphite::Device::popClipStack ( )

inlineoverridevirtual

Implements SkDevice.

Definition at line 119 of file Device.h.

119{ fClip.restore(); }

skgpu::graphite::ClipStack::restore

void restore()

Definition: ClipStack_graphite.cpp:981

◆ pushClipStack()

void skgpu::graphite::Device::pushClipStack ( )

inlineoverridevirtual

Implements SkDevice.

Definition at line 118 of file Device.h.

118{ fClip.save(); }

skgpu::graphite::ClipStack::save

void save()

Definition: ClipStack_graphite.cpp:976

◆ readSurfaceView()

TextureProxyView skgpu::graphite::Device::readSurfaceView ( ) const

Definition at line 1688 of file Device.cpp.

1688{ return fDC->readSurfaceView(); }

◆ recorder()

Recorder * skgpu::graphite::Device::recorder ( ) const

inlineoverridevirtual

Reimplemented from SkDevice.

Definition at line 72 of file Device.h.

72{ return fRecorder; }

◆ replaceClip()

void skgpu::graphite::Device::replaceClip ( const SkIRect & rect )

overridevirtual

Implements SkDevice.

Definition at line 622 of file Device.cpp.

                                            {
    // ReplaceClip() is currently not intended to be supported in Graphite since it's only used
    // for emulating legacy clip ops in Android Framework, and apps/devices that require that
    // should not use Graphite. However, if it needs to be supported, we could probably implement
    // it by:
    //  1. Flush all pending clip element depth draws.
    //  2. Draw a fullscreen rect to the depth attachment using a Z value greater than what's
    //     been used so far.
    //  3. Make sure all future "unclipped" draws use this Z value instead of 0 so they aren't
    //     sorted before the depth reset.
    //  4. Make sure all prior elements are inactive so they can't affect subsequent draws.
    //
    // For now, just ignore it.
}

◆ setImmutable()

void skgpu::graphite::Device::setImmutable ( )

overridevirtual

Reimplemented from SkDevice.

Definition at line 366 of file Device.cpp.

                          {
    if (fRecorder) {
        // Push any pending work to the Recorder now. setImmutable() is only called by the
        // destructor of a client-owned Surface, or explicitly in layer/filtering workflows. In
        // both cases this is restricted to the Recorder's thread. This is in contrast to ~Device(),
        // which might be called from another thread if it was linked to an Image used in multiple
        // recorders.
        this->flushPendingWorkToRecorder();
        fRecorder->deregisterDevice(this);
        // Abandoning the recorder ensures that there are no further operations that can be recorded
        // and is relied on by Image::notifyInUse() to detect when it can unlink from a Device.
        this->abandonRecorder();
    }
}

◆ snapSpecial()

sk_sp< SkSpecialImage > skgpu::graphite::Device::snapSpecial	(	const SkIRect &	subset,
		bool	forceCopy = `false`
	)

overridevirtual

Reimplemented from SkDevice.

Definition at line 1651 of file Device.cpp.

                                                                               {
    // NOTE: snapSpecial() can be called even after the device has been marked immutable (null
    // recorder), but in those cases it should not be a copy and just returns the image view.
    sk_sp<Image> deviceImage;
    SkIRect finalSubset;
    if (forceCopy || !this->readSurfaceView() || this->readSurfaceView().proxy()->isFullyLazy()) {
        deviceImage = this->makeImageCopy(
                subset, Budgeted::kYes, Mipmapped::kNo, SkBackingFit::kApprox);
        finalSubset = SkIRect::MakeSize(subset.size());
    } else {
        // TODO(b/323886870): For now snapSpecial() force adds the pending work to the recorder's
        // root task list. Once shared atlas management is solved and DrawTasks can be nested in a
        // graph then this can go away in favor of auto-flushing through the image's linked device.
        if (fRecorder) {
            this->flushPendingWorkToRecorder();
        }
        deviceImage = Image::WrapDevice(sk_ref_sp(this));
        finalSubset = subset;
    }
 
    if (!deviceImage) {
        return nullptr;
    }
 
    // For non-copying "snapSpecial", the semantics are returning an image view of the surface data,
    // and relying on higher-level draw and restore logic for the contents to make sense.
    return SkSpecialImages::MakeGraphite(
            fRecorder, finalSubset, std::move(deviceImage), this->surfaceProps());
}

◆ strikeDeviceInfo()

SkStrikeDeviceInfo skgpu::graphite::Device::strikeDeviceInfo ( ) const

overridevirtual

Reimplemented from SkDevice.

Definition at line 388 of file Device.cpp.

                                                  {
    return {this->surfaceProps(), this->scalerContextFlags(), &fSDFTControl};
}

◆ target()

TextureProxy * skgpu::graphite::Device::target ( )

Definition at line 1686 of file Device.cpp.

1686{ return fDC->target(); }

◆ useDrawCoverageMaskForMaskFilters()

bool skgpu::graphite::Device::useDrawCoverageMaskForMaskFilters ( ) const

inlineoverridevirtual

Reimplemented from SkDevice.

Definition at line 115 of file Device.h.

115{ return true; }

Friends And Related Function Documentation

◆ ClipStack

friend class ClipStack

friend

Definition at line 328 of file Device.h.

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

third_party/skia/src/gpu/graphite/Device.h
third_party/skia/src/gpu/graphite/Device.cpp

Classes

Public Member Functions

Static Public Member Functions

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ~Device()

Member Function Documentation

◆ abandonRecorder()

◆ android_utils_clipAsRgn()

◆ asGraphiteDevice()

◆ clipPath()

◆ clipRect()

◆ clipRegion()

◆ clipRRect()

◆ createDevice()

◆ devClipBounds()

◆ drawAsTiledImageRect()

◆ drawAtlas()

◆ drawBlurredRRect()

◆ drawCoverageMask()

◆ drawDrawable()

◆ drawEdgeAAImageSet()

◆ drawEdgeAAQuad()

◆ drawImageLattice()

◆ drawImageRect()

◆ drawMesh()

◆ drawOval()

◆ drawPaint()

◆ drawPath()

◆ drawPoints()

◆ drawRect()

◆ drawRRect()

◆ drawShadow()

◆ drawSpecial()

◆ drawVertices()

◆ flushPendingWorkToRecorder()

◆ isClipAntiAliased()

◆ isClipEmpty()

◆ isClipRect()

◆ isClipWideOpen()

◆ isScratchDevice()

◆ lastDrawTask()

◆ localToDeviceTransform()

◆ Make() [1/2]

◆ Make() [2/2]

◆ makeImageCopy()

◆ makeSurface()

◆ popClipStack()

◆ pushClipStack()

◆ readSurfaceView()

◆ recorder()

◆ replaceClip()

◆ setImmutable()

◆ snapSpecial()

◆ strikeDeviceInfo()

◆ target()

◆ useDrawCoverageMaskForMaskFilters()

Friends And Related Function Documentation

◆ ClipStack