#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 (Recorder *recorder=nullptr)

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

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

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

virtual bool	android_utils_clipWithStencil ()

virtual bool	isNoPixelsDevice () const

virtual void *	getRasterHandle () const

virtual GrRecordingContext *	recordingContext () const

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

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

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

virtual void	drawArc (const SkRect &oval, SkScalar startAngle, SkScalar sweepAngle, bool useCenter, const SkPaint &paint)

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

virtual bool	shouldDrawAsTiledImageRect () const

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

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

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

sk_sp< SkSpecialImage >	snapSpecial ()

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

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, bool registerWithRecorder=true)

Private Member Functions
sk_sp< SkSpecialImage >	makeSpecial (const SkBitmap &) override

sk_sp< SkSpecialImage >	makeSpecial (const SkImage *) override

bool	onReadPixels (const SkPixmap &, int x, int y) override

bool	onWritePixels (const SkPixmap &, int x, int y) override

void	onDrawGlyphRunList (SkCanvas *, const sktext::GlyphRunList &, const SkPaint &) override

void	onClipShader (sk_sp< SkShader > shader) override

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

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

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

Friends
class	ClipStack

Additional Inherited Members
Protected Member Functions inherited from SkDevice
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 343 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 74 of file Device.h.

74{ fRecorder = nullptr; }

◆ android_utils_clipAsRgn()

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

overridevirtual

Implements SkDevice.

Definition at line 539 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 69 of file Device.h.

69{ return this; }

◆ clipPath()

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

overridevirtual

Implements SkDevice.

Definition at line 571 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 558 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 584 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 564 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);
}

◆ convertGlyphRunListToSlug()

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

overrideprivatevirtual

Reimplemented from SkDevice.

Definition at line 1658 of file Device.cpp.

                                                                                 {
    return sktext::gpu::SlugImpl::Make(this->localToDevice(),
                                       glyphRunList,
                                       paint,
                                       this->strikeDeviceInfo(),
                                       SkStrikeCache::GlobalStrikeCache());
}

◆ 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 385 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;
 
    return Make(fRecorder,
                info.fInfo,
                skgpu::Budgeted::kYes,
                Mipmapped::kNo,
#if defined(GRAPHITE_USE_APPROX_FIT_FOR_FILTERS)
                SkBackingFit::kApprox,
#else
                SkBackingFit::kExact,
#endif
                props,
                initialLoadOp);
}

◆ createImageFilteringBackend()

sk_sp< skif::Backend > skgpu::graphite::Device::createImageFilteringBackend	(	const SkSurfaceProps &	surfaceProps,
		SkColorType	colorType
	)		const

overrideprivatevirtual

Reimplemented from SkDevice.

Definition at line 1636 of file Device.cpp.

                                                                                      {
    return skif::MakeGraphiteBackend(fRecorder, surfaceProps, colorType);
}

◆ 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 534 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 672 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 183 of file Device.h.

184 {}

◆ 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 1672 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 1552 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;
    }
 
    // '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(SkFilterMode::kLinear, kClamp, maskProxyView.refProxy());
    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 186 of file Device.h.

186{}

◆ 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 786 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 768 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 181 of file Device.h.

182 {}

◆ 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 847 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 187 of file Device.h.

187{}

◆ drawOval()

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

overridevirtual

Implements SkDevice.

Definition at line 716 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 620 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 735 of file Device.cpp.

                                                                                  {
    // TODO: If we do try to inspect the path, it should happen here and possibly after computing
    // the path effect. Alternatively, all that should be handled in SkCanvas.
    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 655 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 730 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 188 of file Device.h.

188{}

◆ drawSlug()

void skgpu::graphite::Device::drawSlug	(	SkCanvas *	canvas,
		const sktext::gpu::Slug *	slug,
		const SkPaint &	paint
	)

overrideprivatevirtual

Reimplemented from SkDevice.

Definition at line 1667 of file Device.cpp.

                                                                                       {
    auto slugImpl = static_cast<const sktext::gpu::SlugImpl*>(slug);
    slugImpl->subRuns()->draw(canvas, slugImpl->origin(), paint, slugImpl, this->atlasDelegate());
}

◆ 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 1520 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 660 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 ( Recorder * recorder = nullptr )

Definition at line 1410 of file Device.cpp.

                                                          {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
 
    // Confirm sentinels match the original values set from fRecorder
    SkDEBUGCODE(intptr_t expected = reinterpret_cast<intptr_t>(recorder ? recorder : fRecorder);)
    SkASSERT(fPreRecorderSentinel == expected - 1);
    SkASSERT(fPostRecorderSentinel == expected + 1);
 
    SkASSERT(recorder == nullptr || recorder == fRecorder);
    if (recorder && recorder != fRecorder) {
        // TODO(b/333073673): This should not happen but if the Device were corrupted exit now
        // to avoid further access of Device's state.
        return;
    }
 
    // 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);
    // TODO(b/333073673):
    // The only time flushPendingWorkToRecorder() is called with a non-null Recorder is from
    // flushTrackedDevices(), so the scoped recording ID of the device should be 0 or it means a
    // non-tracked device got added to the recorder or something has stomped the heap.
    SkASSERT(!recorder || fScopedRecordingID == 0);
    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 520 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 128 of file Device.h.

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

◆ isClipRect()

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

inlineoverridevirtual

Implements SkDevice.

Definition at line 131 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 125 of file Device.h.

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

◆ isScratchDevice()

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

Definition at line 1645 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 1405 of file Device.cpp.

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

◆ localToDeviceTransform()

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

Definition at line 374 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,
		bool	registerWithRecorder = `true`
	)

static

Definition at line 237 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, 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 268 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 411 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};
    }
    return Image::Copy(fRecorder, srcView, colorInfo, subset, budgeted, mipmapped, backingFit);
}

◆ makeSpecial() [1/2]

sk_sp< SkSpecialImage > skgpu::graphite::Device::makeSpecial ( const SkBitmap & )

overrideprivatevirtual

Reimplemented from SkDevice.

Definition at line 1598 of file Device.cpp.

                                                         {
    return nullptr;
}

◆ makeSpecial() [2/2]

sk_sp< SkSpecialImage > skgpu::graphite::Device::makeSpecial ( const SkImage * )

overrideprivatevirtual

Reimplemented from SkDevice.

Definition at line 1602 of file Device.cpp.

                                                        {
    return nullptr;
}

◆ makeSurface()

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

overridevirtual

Reimplemented from SkDevice.

Definition at line 407 of file Device.cpp.

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

◆ onClipShader()

void skgpu::graphite::Device::onClipShader ( sk_sp< SkShader > shader )

overrideprivatevirtual

Implements SkDevice.

Definition at line 579 of file Device.cpp.

                                                {
    fClip.clipShader(std::move(shader));
}

◆ onDrawGlyphRunList()

void skgpu::graphite::Device::onDrawGlyphRunList	(	SkCanvas *	canvas,
		const sktext::GlyphRunList &	glyphRunList,
		const SkPaint &	paint
	)

overrideprivatevirtual

Implements SkDevice.

Definition at line 868 of file Device.cpp.

                                                      {
    ASSERT_SINGLE_OWNER
    fRecorder->priv().textBlobCache()->drawGlyphRunList(canvas,
                                                        this->localToDevice(),
                                                        glyphRunList,
                                                        paint,
                                                        this->strikeDeviceInfo(),
                                                        this->atlasDelegate());
}

◆ onReadPixels()

bool skgpu::graphite::Device::onReadPixels	(	const SkPixmap &	pm,
		int	x,
		int	y
	)

overrideprivatevirtual

Reimplemented from SkDevice.

Definition at line 430 of file Device.cpp.

                                                                {
#if defined(GRAPHITE_TEST_UTILS)
    // This testing-only function should only be called before the Device has detached from its
    // Recorder, since it's accessed via the test-held Surface.
    ASSERT_SINGLE_OWNER
    if (Context* context = fRecorder->priv().context()) {
        // Add all previous commands generated to the command buffer.
        // If the client snaps later they'll only get post-read commands in their Recording,
        // but since they're doing a readPixels in the middle that shouldn't be unexpected.
        std::unique_ptr<Recording> recording = fRecorder->snap();
        if (!recording) {
            return false;
        }
        InsertRecordingInfo info;
        info.fRecording = recording.get();
        if (!context->insertRecording(info)) {
            return false;
        }
        return context->priv().readPixels(pm, fDC->target(), this->imageInfo(), srcX, srcY);
    }
#endif
    // We have no access to a context to do a read pixels here.
    return false;
}

◆ onWritePixels()

bool skgpu::graphite::Device::onWritePixels	(	const SkPixmap &	src,
		int	x,
		int	y
	)

overrideprivatevirtual

Reimplemented from SkDevice.

Definition at line 455 of file Device.cpp.

                                                            {
    ASSERT_SINGLE_OWNER
    // TODO: we may need to share this in a more central place to handle uploads
    // to backend textures
 
    const TextureProxy* target = fDC->target();
 
    // TODO: add mipmap support for createBackendTexture
 
    if (src.colorType() == kUnknown_SkColorType) {
        return false;
    }
 
    // If one alpha type is unknown and the other isn't, it's too underspecified.
    if ((src.alphaType() == kUnknown_SkAlphaType) !=
        (this->imageInfo().alphaType() == kUnknown_SkAlphaType)) {
        return false;
    }
 
    // TODO: canvas2DFastPath?
 
    if (!fRecorder->priv().caps()->supportsWritePixels(target->textureInfo())) {
        auto image = SkImages::RasterFromPixmap(src, nullptr, nullptr);
        image = SkImages::TextureFromImage(fRecorder, image.get());
        if (!image) {
            return false;
        }
 
        SkPaint paint;
        paint.setBlendMode(SkBlendMode::kSrc);
        this->drawImageRect(image.get(),
                            /*src=*/nullptr,
                            SkRect::MakeXYWH(x, y, src.width(), src.height()),
                            SkFilterMode::kNearest,
                            paint,
                            SkCanvas::kFast_SrcRectConstraint);
        return true;
    }
 
    // TODO: check for flips and either handle here or pass info to UploadTask
 
    // Determine rect to copy
    SkIRect dstRect = SkIRect::MakePtSize({x, y}, src.dimensions());
    if (!target->isFullyLazy() && !dstRect.intersect(SkIRect::MakeSize(target->dimensions()))) {
        return false;
    }
 
    // Set up copy location
    const void* addr = src.addr(dstRect.fLeft - x, dstRect.fTop - y);
    std::vector<MipLevel> levels;
    levels.push_back({addr, src.rowBytes()});
 
    // The writePixels() still respects painter's order, so flush everything to tasks before this
    // recording the upload for the pixel data.
    this->internalFlush();
    // The new upload will be executed before any new draws are recorded and also ensures that
    // the next call to flushDeviceToRecorder() will produce a non-null DrawTask. If this Device's
    // target is mipmapped, mipmap generation tasks will be added automatically at that point.
    return fDC->recordUpload(fRecorder, fDC->refTarget(), src.info().colorInfo(),
                             this->imageInfo().colorInfo(), levels, dstRect, nullptr);
}

◆ popClipStack()

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

inlineoverridevirtual

Implements SkDevice.

Definition at line 123 of file Device.h.

123{ 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 122 of file Device.h.

122{ fClip.save(); }

skgpu::graphite::ClipStack::save

void save()

Definition ClipStack_graphite.cpp:976

◆ readSurfaceView()

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

Definition at line 1643 of file Device.cpp.

1643{ return fDC->readSurfaceView(); }

◆ recorder()

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

inlineoverridevirtual

Reimplemented from SkDevice.

Definition at line 71 of file Device.h.

71{ return fRecorder; }

◆ replaceClip()

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

overridevirtual

Implements SkDevice.

Definition at line 603 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 359 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 1606 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 381 of file Device.cpp.

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

◆ target()

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

Definition at line 1641 of file Device.cpp.

1641{ return fDC->target(); }

◆ useDrawCoverageMaskForMaskFilters()

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

inlineoverridevirtual

Reimplemented from SkDevice.

Definition at line 118 of file Device.h.

118{ return true; }

Friends And Related Symbol Documentation

◆ ClipStack

friend class ClipStack

friend

Definition at line 336 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

Private Member Functions

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ~Device()

Member Function Documentation

◆ abandonRecorder()

◆ android_utils_clipAsRgn()

◆ asGraphiteDevice()

◆ clipPath()

◆ clipRect()

◆ clipRegion()

◆ clipRRect()

◆ convertGlyphRunListToSlug()

◆ createDevice()

◆ createImageFilteringBackend()

◆ devClipBounds()

◆ drawAsTiledImageRect()

◆ drawAtlas()

◆ drawBlurredRRect()

◆ drawCoverageMask()

◆ drawDrawable()

◆ drawEdgeAAImageSet()

◆ drawEdgeAAQuad()

◆ drawImageLattice()

◆ drawImageRect()

◆ drawMesh()

◆ drawOval()

◆ drawPaint()

◆ drawPath()

◆ drawPoints()

◆ drawRect()

◆ drawRRect()

◆ drawShadow()

◆ drawSlug()

◆ drawSpecial()

◆ drawVertices()

◆ flushPendingWorkToRecorder()

◆ isClipAntiAliased()

◆ isClipEmpty()

◆ isClipRect()

◆ isClipWideOpen()

◆ isScratchDevice()

◆ lastDrawTask()

◆ localToDeviceTransform()

◆ Make() [1/2]

◆ Make() [2/2]

◆ makeImageCopy()

◆ makeSpecial() [1/2]

◆ makeSpecial() [2/2]

◆ makeSurface()

◆ onClipShader()

◆ onDrawGlyphRunList()

◆ onReadPixels()

◆ onWritePixels()

◆ popClipStack()

◆ pushClipStack()

◆ readSurfaceView()

◆ recorder()

◆ replaceClip()

◆ setImmutable()

◆ snapSpecial()

◆ strikeDeviceInfo()

◆ target()

◆ useDrawCoverageMaskForMaskFilters()

Friends And Related Symbol Documentation

◆ ClipStack