#include <Device.h>

Inheritance diagram for skgpu::ganesh::Device:

Public Types
enum class	InitContents { kClear , kUninit }

using	RescaleGamma = SkImage::RescaleGamma

using	RescaleMode = SkImage::RescaleMode

using	ReadPixelsCallback = SkImage::ReadPixelsCallback

using	ReadPixelsContext = SkImage::ReadPixelsContext

Public Member Functions
GrSurfaceProxyView	readSurfaceView ()

GrRenderTargetProxy *	targetProxy ()

GrRecordingContext *	recordingContext () const override

bool	wait (int numSemaphores, const GrBackendSemaphore *waitSemaphores, bool deleteSemaphoresAfterWait)

void	discard ()

void	resolveMSAA ()

bool	replaceBackingProxy (SkSurface::ContentChangeMode, sk_sp< GrRenderTargetProxy >, GrColorType, sk_sp< SkColorSpace >, GrSurfaceOrigin, const SkSurfaceProps &)

bool	replaceBackingProxy (SkSurface::ContentChangeMode)

void	asyncRescaleAndReadPixels (const SkImageInfo &info, const SkIRect &srcRect, RescaleGamma rescaleGamma, RescaleMode rescaleMode, ReadPixelsCallback callback, ReadPixelsContext context)

void	asyncRescaleAndReadPixelsYUV420 (SkYUVColorSpace yuvColorSpace, bool readAlpha, sk_sp< SkColorSpace > dstColorSpace, const SkIRect &srcRect, SkISize dstSize, RescaleGamma rescaleGamma, RescaleMode, ReadPixelsCallback callback, ReadPixelsContext context)

	~Device () override

SurfaceDrawContext *	surfaceDrawContext ()

const SurfaceDrawContext *	surfaceDrawContext () const

SurfaceFillContext *	surfaceFillContext ()

SkStrikeDeviceInfo	strikeDeviceInfo () const override

void	clearAll ()

void	drawPaint (const SkPaint &paint) override

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

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

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

void	drawDRRect (const SkRRect &outer, const SkRRect &inner, const SkPaint &paint) override

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

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

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

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

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

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

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

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

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

bool	shouldDrawAsTiledImageRect () const 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	drawDrawable (SkCanvas , SkDrawable , const SkMatrix *) override

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

void	drawSpecial (SkSpecialImage *, const SkMatrix &localToDevice, const SkSamplingOptions &, const SkPaint &, SkCanvas::SrcRectConstraint) 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	drawEdgeAAImage (const SkImage *, const SkRect &src, const SkRect &dst, const SkPoint dstClip[4], SkCanvas::QuadAAFlags, const SkMatrix &localToDevice, const SkSamplingOptions &, const SkPaint &, SkCanvas::SrcRectConstraint, const SkMatrix &srcToDst, SkTileMode)

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

sk_sp< SkSpecialImage >	makeSpecial (const SkBitmap &) override

sk_sp< SkSpecialImage >	makeSpecial (const SkImage *) override

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

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

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

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

Device *	asGaneshDevice () override

SkIRect	devClipBounds () const override

void	pushClipStack () override

void	popClipStack () override

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

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

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

void	replaceClip (const SkIRect &rect) override

void	clipRegion (const SkRegion &globalRgn, SkClipOp op) override

bool	isClipAntiAliased () const override

bool	isClipEmpty () const override

bool	isClipRect () const override

bool	isClipWideOpen () const override

void	android_utils_clipAsRgn (SkRegion *) const override

bool	android_utils_clipWithStencil () 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	useDrawCoverageMaskForMaskFilters () const

virtual bool	isNoPixelsDevice () const

virtual void *	getRasterHandle () const

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

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

virtual void	setImmutable ()

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

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 *)

sk_sp< SkSpecialImage >	snapSpecial ()

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 (GrRecordingContext *, GrColorType, sk_sp< GrSurfaceProxy >, sk_sp< SkColorSpace >, GrSurfaceOrigin, const SkSurfaceProps &, InitContents)

static sk_sp< Device >	Make (GrRecordingContext *, skgpu::Budgeted, const SkImageInfo &, SkBackingFit, int sampleCount, skgpu::Mipmapped, GrProtected, GrSurfaceOrigin, const SkSurfaceProps &, InitContents)

Private Member Functions
void	onDrawGlyphRunList (SkCanvas *, const sktext::GlyphRunList &, const SkPaint &paint) override

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

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

bool	onAccessPixels (SkPixmap *) override

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

void	onClipShader (sk_sp< SkShader > shader) override

Friends
class	::SkSurface_Ganesh

class	skgpu::TiledTextureUtils

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

Subclass of SkDevice, which directs all drawing to the GrGpu owned by the canvas.

Definition at line 91 of file Device.h.

Member Typedef Documentation

◆ ReadPixelsCallback

using skgpu::ganesh::Device::ReadPixelsCallback = SkImage::ReadPixelsCallback

Definition at line 120 of file Device.h.

◆ ReadPixelsContext

using skgpu::ganesh::Device::ReadPixelsContext = SkImage::ReadPixelsContext

Definition at line 121 of file Device.h.

◆ RescaleGamma

using skgpu::ganesh::Device::RescaleGamma = SkImage::RescaleGamma

Definition at line 118 of file Device.h.

◆ RescaleMode

using skgpu::ganesh::Device::RescaleMode = SkImage::RescaleMode

Definition at line 119 of file Device.h.

Member Enumeration Documentation

◆ InitContents

enum class skgpu::ganesh::Device::InitContents

strong

Enumerator
kClear
kUninit

Definition at line 93 of file Device.h.

                            {
        kClear,
        kUninit
    };

Constructor & Destructor Documentation

◆ ~Device()

skgpu::ganesh::Device::~Device ( )

overridedefault

Member Function Documentation

◆ android_utils_clipAsRgn()

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

overridevirtual

Implements SkDevice.

Definition at line 411 of file Device.cpp.

                                                           {
    SkIRect bounds = fClip.getConservativeBounds();
    // 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.isIdentity()) {
            tmp.setRect(e.fShape.rect().roundOut());
        } else {
            SkPath tmpPath;
            e.fShape.asPath(&tmpPath);
            tmpPath.transform(e.fLocalToDevice);
            tmp.setPath(tmpPath, deviceBounds);
        }
 
        region->op(tmp, (SkRegion::Op) e.fOp);
    }
}

◆ android_utils_clipWithStencil()

bool skgpu::ganesh::Device::android_utils_clipWithStencil ( )

overridevirtual

Reimplemented from SkDevice.

Definition at line 1465 of file Device.cpp.

                                           {
    SkRegion clipRegion;
    this->android_utils_clipAsRgn(&clipRegion);
    if (clipRegion.isEmpty()) {
        return false;
    }
    auto sdc = fSurfaceDrawContext.get();
    SkASSERT(sdc);
    GrPaint grPaint;
    grPaint.setXPFactory(GrDisableColorXPFactory::Get());
    static constexpr GrUserStencilSettings kDrawToStencil(
        GrUserStencilSettings::StaticInit<
            0x1,
            GrUserStencilTest::kAlways,
            0x1,
            GrUserStencilOp::kReplace,
            GrUserStencilOp::kReplace,
            0x1>()
    );
    // Regions don't actually need AA, but in DMSAA mode everything is antialiased.
    GrAA aa = GrAA(fSurfaceDrawContext->alwaysAntialias());
    sdc->drawRegion(nullptr, std::move(grPaint), aa, SkMatrix::I(), clipRegion,
                    GrStyle::SimpleFill(), &kDrawToStencil);
    return true;
}

◆ asGaneshDevice()

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

inlineoverridevirtual

Reimplemented from SkDevice.

Definition at line 259 of file Device.h.

259{ return this; }

◆ asyncRescaleAndReadPixels()

void skgpu::ganesh::Device::asyncRescaleAndReadPixels	(	const SkImageInfo &	info,
		const SkIRect &	srcRect,
		RescaleGamma	rescaleGamma,
		RescaleMode	rescaleMode,
		ReadPixelsCallback	callback,
		ReadPixelsContext	context
	)

Definition at line 1373 of file Device.cpp.

                                                                  {
    auto* sdc = fSurfaceDrawContext.get();
    // Context TODO: Elevate direct context requirement to public API.
    auto dContext = sdc->recordingContext()->asDirectContext();
    if (!dContext) {
        return;
    }
    sdc->asyncRescaleAndReadPixels(dContext, info, srcRect, rescaleGamma, rescaleMode, callback,
                                   context);
}

◆ asyncRescaleAndReadPixelsYUV420()

void skgpu::ganesh::Device::asyncRescaleAndReadPixelsYUV420	(	SkYUVColorSpace	yuvColorSpace,
		bool	readAlpha,
		sk_sp< SkColorSpace >	dstColorSpace,
		const SkIRect &	srcRect,
		SkISize	dstSize,
		RescaleGamma	rescaleGamma,
		RescaleMode	rescaleMode,
		ReadPixelsCallback	callback,
		ReadPixelsContext	context
	)

Definition at line 1389 of file Device.cpp.

                                                                        {
    auto* sdc = fSurfaceDrawContext.get();
    // Context TODO: Elevate direct context requirement to public API.
    auto dContext = sdc->recordingContext()->asDirectContext();
    if (!dContext) {
        return;
    }
    sdc->asyncRescaleAndReadPixelsYUV420(dContext,
                                         yuvColorSpace,
                                         readAlpha,
                                         std::move(dstColorSpace),
                                         srcRect,
                                         dstSize,
                                         rescaleGamma,
                                         rescaleMode,
                                         callback,
                                         context);
}

◆ clearAll()

void skgpu::ganesh::Device::clearAll ( )

Definition at line 373 of file Device.cpp.

                      {
    ASSERT_SINGLE_OWNER
    GR_CREATE_TRACE_MARKER_CONTEXT("skgpu::ganesh::Device", "clearAll", fContext.get());
 
    SkIRect rect = SkIRect::MakeWH(this->width(), this->height());
    fSurfaceDrawContext->clearAtLeast(rect, SK_PMColor4fTRANSPARENT);
}

◆ clipPath()

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

overridevirtual

Implements SkDevice.

Definition at line 383 of file Device.cpp.

                                                              {
#if defined(GR_TEST_UTILS)
    if (fContext->priv().options().fAllPathsVolatile && !path.isVolatile()) {
        this->clipPath(SkPath(path).setIsVolatile(true), op, aa);
        return;
    }
#endif
    SkASSERT(op == SkClipOp::kIntersect || op == SkClipOp::kDifference);
    fClip.clipPath(this->localToDevice(), path, GrAA(aa), op);
}

◆ clipRect()

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

inlineoverridevirtual

Implements SkDevice.

Definition at line 266 of file Device.h.

                                                                     {
        SkASSERT(op == SkClipOp::kIntersect || op == SkClipOp::kDifference);
        fClip.clipRect(this->localToDevice(), rect, GrAA(aa), op);
    }

◆ clipRegion()

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

overridevirtual

Implements SkDevice.

Definition at line 394 of file Device.cpp.

                                                              {
    SkASSERT(op == SkClipOp::kIntersect || op == SkClipOp::kDifference);
 
    // Regions don't actually need AA, but in DMSAA mode every clip element is antialiased.
    GrAA aa = GrAA(fSurfaceDrawContext->alwaysAntialias());
 
    if (globalRgn.isEmpty()) {
        fClip.clipRect(SkMatrix::I(), SkRect::MakeEmpty(), aa, op);
    } else if (globalRgn.isRect()) {
        fClip.clipRect(this->globalToDevice().asM33(), SkRect::Make(globalRgn.getBounds()), aa, op);
    } else {
        SkPath path;
        globalRgn.getBoundaryPath(&path);
        fClip.clipPath(this->globalToDevice().asM33(), path, aa, op);
    }
}

◆ clipRRect()

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

inlineoverridevirtual

Implements SkDevice.

Definition at line 270 of file Device.h.

                                                                        {
        SkASSERT(op == SkClipOp::kIntersect || op == SkClipOp::kDifference);
        fClip.clipRRect(this->localToDevice(), rrect, GrAA(aa), op);
    }

◆ convertGlyphRunListToSlug()

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

overridevirtual

Reimplemented from SkDevice.

Definition at line 1495 of file Device.cpp.

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

◆ createDevice()

sk_sp< SkDevice > skgpu::ganesh::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 1418 of file Device.cpp.

                                                                            {
    ASSERT_SINGLE_OWNER
 
    SkSurfaceProps props =
        this->surfaceProps().cloneWithPixelGeometry(cinfo.fPixelGeometry);
 
    SkASSERT(cinfo.fInfo.colorType() != kRGBA_1010102_SkColorType);
 
    auto sdc = SurfaceDrawContext::MakeWithFallback(
            fContext.get(),
            SkColorTypeToGrColorType(cinfo.fInfo.colorType()),
            cinfo.fInfo.refColorSpace(),
            SkBackingFit::kApprox,
            cinfo.fInfo.dimensions(),
            props,
            fSurfaceDrawContext->numSamples(),
            skgpu::Mipmapped::kNo,
            fSurfaceDrawContext->asSurfaceProxy()->isProtected(),
            fSurfaceDrawContext->origin(),
            skgpu::Budgeted::kYes);
    if (!sdc) {
        return nullptr;
    }
 
    // Skia's convention is to only clear a device if it is non-opaque.
    InitContents init = cinfo.fInfo.isOpaque() ? InitContents::kUninit : InitContents::kClear;
 
    return Device::Make(std::move(sdc), cinfo.fInfo.alphaType(), init);
}

◆ createImageFilteringBackend()

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

overrideprivatevirtual

Reimplemented from SkDevice.

Definition at line 835 of file Device.cpp.

                                                                                      {
    return skif::MakeGaneshBackend(
            fContext, fSurfaceDrawContext->origin(), surfaceProps, colorType);
}

◆ devClipBounds()

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

inlineoverridevirtual

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 261 of file Device.h.

261{ return fClip.getConservativeBounds(); }

◆ discard()

void skgpu::ganesh::Device::discard ( )

Definition at line 1300 of file Device.cpp.

                     {
    fSurfaceDrawContext->discard();
}

◆ drawArc()

void skgpu::ganesh::Device::drawArc	(	const SkRect &	oval,
		SkScalar	startAngle,
		SkScalar	sweepAngle,
		bool	useCenter,
		const SkPaint &	paint
	)

overridevirtual

By the time this is called we know that abs(sweepAngle) is in the range [0, 360).

Reimplemented from SkDevice.

Definition at line 775 of file Device.cpp.

                                           {
    ASSERT_SINGLE_OWNER
    GR_CREATE_TRACE_MARKER_CONTEXT("skgpu::ganesh::Device", "drawArc", fContext.get());
    if (paint.getMaskFilter()) {
        this->SkDevice::drawArc(oval, startAngle, sweepAngle, useCenter, paint);
        return;
    }
    GrPaint grPaint;
    if (!SkPaintToGrPaint(this->recordingContext(),
                          fSurfaceDrawContext->colorInfo(),
                          paint,
                          this->localToDevice(),
                          fSurfaceDrawContext->surfaceProps(),
                          &grPaint)) {
        return;
    }
 
    fSurfaceDrawContext->drawArc(this->clip(), std::move(grPaint),
                                 fSurfaceDrawContext->chooseAA(paint), this->localToDevice(), oval,
                                 startAngle, sweepAngle, useCenter, GrStyle(paint));
}

◆ drawAsTiledImageRect()

bool skgpu::ganesh::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 1000 of file Device.cpp.

                                                                        {
    GrRecordingContext* rCtx = canvas->recordingContext();
    if (!rCtx) {
        return false;
    }
    ASSERT_SINGLE_OWNER
 
    GrAA aa = fSurfaceDrawContext->chooseAA(paint);
    SkCanvas::QuadAAFlags aaFlags = (aa == GrAA::kYes) ? SkCanvas::kAll_QuadAAFlags
                                                       : SkCanvas::kNone_QuadAAFlags;
 
    // NOTE: if the context is not a direct context, it doesn't have access to the resource
    // cache, and theoretically, the resource cache's limits could be being changed on
    // another thread, so even having access to just the limit wouldn't be a reliable
    // test during recording here.
    size_t cacheSize = 0;
    if (auto dCtx = GrAsDirectContext(rCtx)) {
        cacheSize = dCtx->getResourceCacheLimit();
    }
    size_t maxTextureSize = rCtx->maxTextureSize();
#if defined(GR_TEST_UTILS)
    if (gOverrideMaxTextureSizeGanesh) {
        maxTextureSize = gOverrideMaxTextureSizeGanesh;
    }
    gNumTilesDrawnGanesh.store(0, std::memory_order_relaxed);
#endif
 
    [[maybe_unused]] auto [wasTiled, numTiles] = TiledTextureUtils::DrawAsTiledImageRect(
            canvas,
            image,
            src ? *src : SkRect::MakeIWH(image->width(), image->height()),
            dst,
            aaFlags,
            sampling,
            &paint,
            constraint,
            cacheSize,
            maxTextureSize);
#if defined(GR_TEST_UTILS)
    gNumTilesDrawnGanesh.store(numTiles, std::memory_order_relaxed);
#endif
    return wasTiled;
}

◆ drawAtlas()

void skgpu::ganesh::Device::drawAtlas	(	const SkRSXform	xform[],
		const SkRect	texRect[],
		const SkColor	colors[],
		int	count,
		sk_sp< SkBlender >	blender,
		const SkPaint &	paint
	)

overridevirtual

Reimplemented from SkDevice.

Definition at line 1198 of file Device.cpp.

                                             {
    ASSERT_SINGLE_OWNER
    GR_CREATE_TRACE_MARKER_CONTEXT("skgpu::ganesh::Device", "drawAtlas", fContext.get());
 
    GrPaint grPaint;
    if (colors) {
        if (!SkPaintToGrPaintWithBlend(this->recordingContext(),
                                       fSurfaceDrawContext->colorInfo(),
                                       paint,
                                       this->localToDevice(),
                                       blender.get(),
                                       fSurfaceDrawContext->surfaceProps(),
                                       &grPaint)) {
            return;
        }
    } else {
        if (!SkPaintToGrPaint(this->recordingContext(),
                              fSurfaceDrawContext->colorInfo(),
                              paint,
                              this->localToDevice(),
                              fSurfaceDrawContext->surfaceProps(),
                              &grPaint)) {
            return;
        }
    }
 
    fSurfaceDrawContext->drawAtlas(this->clip(), std::move(grPaint), this->localToDevice(), count,
                                   xform, texRect, colors);
}

◆ drawDevice()

void skgpu::ganesh::Device::drawDevice	(	SkDevice *	device,
		const SkSamplingOptions &	sampling,
		const SkPaint &	paint
	)

overridevirtual

The SkDevice passed will be an SkDevice which was returned by a call to onCreateDevice on this device with kNeverTile_TileExpectation.

The default implementation calls snapSpecial() and drawSpecial() with the relative transform from the input device to this device. The provided SkPaint cannot have a mask filter or image filter, and any shader is ignored.

Reimplemented from SkDevice.

Definition at line 967 of file Device.cpp.

                                              {
    ASSERT_SINGLE_OWNER
    // clear of the source device must occur before CHECK_SHOULD_DRAW
    GR_CREATE_TRACE_MARKER_CONTEXT("skgpu::ganesh::Device", "drawDevice", fContext.get());
    this->SkDevice::drawDevice(device, sampling, paint);
}

◆ drawDrawable()

void skgpu::ganesh::Device::drawDrawable	(	SkCanvas *	canvas,
		SkDrawable *	drawable,
		const SkMatrix *	matrix
	)

overridevirtual

Reimplemented from SkDevice.

Definition at line 1261 of file Device.cpp.

                                                                                        {
    ASSERT_SINGLE_OWNER
 
    GrBackendApi api = this->recordingContext()->backend();
    if (GrBackendApi::kVulkan == api) {
        const SkMatrix& ctm = this->localToDevice();
        const SkMatrix& combinedMatrix = matrix ? SkMatrix::Concat(ctm, *matrix) : ctm;
        std::unique_ptr<SkDrawable::GpuDrawHandler> gpuDraw =
                drawable->snapGpuDrawHandler(api, combinedMatrix, this->devClipBounds(),
                                             this->imageInfo());
        if (gpuDraw) {
            fSurfaceDrawContext->drawDrawable(
                    std::move(gpuDraw), combinedMatrix.mapRect(drawable->getBounds()));
            return;
        }
    }
    this->SkDevice::drawDrawable(canvas, drawable, matrix);
}

◆ drawDRRect()

void skgpu::ganesh::Device::drawDRRect	(	const SkRRect &	outer,
		const SkRRect &	inner,
		const SkPaint &	paint
	)

overridevirtual

Reimplemented from SkDevice.

Definition at line 672 of file Device.cpp.

                                                                                        {
    ASSERT_SINGLE_OWNER
    GR_CREATE_TRACE_MARKER_CONTEXT("skgpu::ganesh::Device", "drawDRRect", fContext.get());
    if (outer.isEmpty()) {
       return;
    }
 
    if (inner.isEmpty()) {
        return this->drawRRect(outer, paint);
    }
 
    SkStrokeRec stroke(paint);
 
    if (stroke.isFillStyle() && !paint.getMaskFilter() && !paint.getPathEffect()) {
        // For axis-aligned filled DRRects, just draw a regular rrect with inner clipped out using a
        // coverage FP instead of using path rendering.
        if (auto fp = make_inverse_rrect_fp(this->localToDevice(), inner,
                                            fSurfaceDrawContext->chooseAA(paint),
                                            *fSurfaceDrawContext->caps()->shaderCaps())) {
            GrPaint grPaint;
            if (!SkPaintToGrPaint(this->recordingContext(),
                                  fSurfaceDrawContext->colorInfo(),
                                  paint,
                                  this->localToDevice(),
                                  fSurfaceDrawContext->surfaceProps(),
                                  &grPaint)) {
                return;
            }
            SkASSERT(!grPaint.hasCoverageFragmentProcessor());
            grPaint.setCoverageFragmentProcessor(std::move(fp));
            fSurfaceDrawContext->drawRRect(this->clip(), std::move(grPaint),
                                           fSurfaceDrawContext->chooseAA(paint),
                                           this->localToDevice(), outer, GrStyle());
            return;
        }
    }
 
    SkPath path;
    path.setIsVolatile(true);
    path.addRRect(outer);
    path.addRRect(inner);
    path.setFillType(SkPathFillType::kEvenOdd);
 
    // TODO: We are losing the possible mutability of the path here but this should probably be
    // fixed by upgrading GrStyledShape to handle DRRects.
    GrStyledShape shape(path, paint);
 
    GrBlurUtils::DrawShapeWithMaskFilter(fContext.get(), fSurfaceDrawContext.get(), this->clip(),
                                         paint, this->localToDevice(), shape);
}

◆ drawEdgeAAImage()

void skgpu::ganesh::Device::drawEdgeAAImage	(	const SkImage *	image,
		const SkRect &	src,
		const SkRect &	dst,
		const SkPoint	dstClip[4],
		SkCanvas::QuadAAFlags	canvasAAFlags,
		const SkMatrix &	localToDevice,
		const SkSamplingOptions &	sampling,
		const SkPaint &	paint,
		SkCanvas::SrcRectConstraint	constraint,
		const SkMatrix &	srcToDst,
		SkTileMode	tm
	)

Definition at line 215 of file Device_drawTexture.cpp.

                                            {
    GrRecordingContext* rContext = fContext.get();
    SurfaceDrawContext* sdc = fSurfaceDrawContext.get();
    const GrClip* clip = this->clip();
 
    GrQuadAAFlags aaFlags = SkToGrQuadAAFlags(canvasAAFlags);
    auto ib = as_IB(image);
    if (tm == SkTileMode::kClamp && !ib->isYUVA() && can_use_draw_texture(paint, sampling)) {
        // We've done enough checks above to allow us to pass ClampNearest() and not check for
        // scaling adjustments.
        auto [view, ct] = skgpu::ganesh::AsView(rContext, image, skgpu::Mipmapped::kNo);
        if (!view) {
            return;
        }
        GrColorInfo info(image->imageInfo().colorInfo());
        info = info.makeColorType(ct);
        draw_texture(sdc,
                     clip,
                     localToDevice,
                     paint,
                     sampling.filter,
                     src,
                     dst,
                     dstClip,
                     aaFlags,
                     constraint,
                     std::move(view),
                     info);
        return;
    }
 
    const SkMaskFilter* mf = paint.getMaskFilter();
 
    // The shader expects proper local coords, so we can't replace local coords with texture coords
    // if the shader will be used. If we have a mask filter we will change the underlying geometry
    // that is rendered.
    bool canUseTextureCoordsAsLocalCoords = !use_shader(image->isAlphaOnly(), paint) && !mf;
 
    // Specifying the texture coords as local coordinates is an attempt to enable more GrDrawOp
    // combining by not baking anything about the srcRect, dstRect, or ctm, into the texture
    // FP. In the future this should be an opaque optimization enabled by the combination of
    // GrDrawOp/GP and FP.
    if (GrFragmentProcessors::IsSupported(mf)) {
        mf = nullptr;
    }
 
    bool restrictToSubset = SkCanvas::kStrict_SrcRectConstraint == constraint;
 
    // If we have to outset for AA then we will generate texture coords outside the src rect. The
    // same happens for any mask filter that extends the bounds rendered in the dst.
    // This is conservative as a mask filter does not have to expand the bounds rendered.
    bool coordsAllInsideSrcRect = aaFlags == GrQuadAAFlags::kNone && !mf;
 
    // Check for optimization to drop the src rect constraint when using linear filtering.
    // TODO: Just rely on image to handle this.
    if (sampling.isAniso() && !sampling.useCubic && sampling.filter == SkFilterMode::kLinear &&
        restrictToSubset && sampling.mipmap == SkMipmapMode::kNone && coordsAllInsideSrcRect &&
        !ib->isYUVA()) {
        SkMatrix combinedMatrix;
        combinedMatrix.setConcat(localToDevice, srcToDst);
        if (can_ignore_linear_filtering_subset(src, combinedMatrix, sdc->numSamples())) {
            restrictToSubset = false;
        }
    }
 
    SkMatrix textureMatrix;
    if (canUseTextureCoordsAsLocalCoords) {
        textureMatrix = SkMatrix::I();
    } else {
        if (!srcToDst.invert(&textureMatrix)) {
            return;
        }
    }
    const SkRect* subset = restrictToSubset       ? &src : nullptr;
    const SkRect* domain = coordsAllInsideSrcRect ? &src : nullptr;
    SkTileMode tileModes[] = {tm, tm};
    std::unique_ptr<GrFragmentProcessor> fp = skgpu::ganesh::AsFragmentProcessor(
            rContext, image, sampling, tileModes, textureMatrix, subset, domain);
    fp = GrColorSpaceXformEffect::Make(
            std::move(fp), image->imageInfo().colorInfo(), sdc->colorInfo());
    if (image->isAlphaOnly()) {
        if (const auto* shader = as_SB(paint.getShader())) {
            auto shaderFP = GrFragmentProcessors::Make(shader,
                                                       GrFPArgs(rContext,
                                                                &sdc->colorInfo(),
                                                                sdc->surfaceProps(),
                                                                GrFPArgs::Scope::kDefault),
                                                       localToDevice);
            if (!shaderFP) {
                return;
            }
            fp = GrBlendFragmentProcessor::Make<SkBlendMode::kDstIn>(std::move(fp),
                                                                     std::move(shaderFP));
        } else {
            // Multiply the input (paint) color by the texture (alpha)
            fp = GrFragmentProcessor::MulInputByChildAlpha(std::move(fp));
        }
    }
 
    GrPaint grPaint;
    if (!SkPaintToGrPaintReplaceShader(rContext,
                                       sdc->colorInfo(),
                                       paint,
                                       localToDevice,
                                       std::move(fp),
                                       sdc->surfaceProps(),
                                       &grPaint)) {
        return;
    }
 
    if (!mf) {
        // Can draw the image directly (any mask filter on the paint was converted to an FP already)
        if (dstClip) {
            SkPoint srcClipPoints[4];
            SkPoint* srcClip = nullptr;
            if (canUseTextureCoordsAsLocalCoords) {
                // Calculate texture coordinates that match the dst clip
                GrMapRectPoints(dst, src, dstClip, srcClipPoints, 4);
                srcClip = srcClipPoints;
            }
            sdc->fillQuadWithEdgeAA(clip, std::move(grPaint), aaFlags, localToDevice,
                                    dstClip, srcClip);
        } else {
            // Provide explicit texture coords when possible, otherwise rely on texture matrix
            sdc->fillRectWithEdgeAA(clip, std::move(grPaint), aaFlags, localToDevice, dst,
                                    canUseTextureCoordsAsLocalCoords ? &src : nullptr);
        }
    } else {
        // Must draw the mask filter as a GrStyledShape. For now, this loses the per-edge AA
        // information since it always draws with AA, but that should not be noticeable since the
        // mask filter is probably a blur.
        GrStyledShape shape;
        if (dstClip) {
            // Represent it as an SkPath formed from the dstClip
            SkPath path;
            path.addPoly(dstClip, 4, true);
            shape = GrStyledShape(path);
        } else {
            shape = GrStyledShape(dst);
        }
 
        GrBlurUtils::DrawShapeWithMaskFilter(
                rContext, sdc, clip, shape, std::move(grPaint), localToDevice, mf);
    }
}

◆ drawEdgeAAImageSet()

void skgpu::ganesh::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 475 of file Device_drawTexture.cpp.

                                                                      {
    SkASSERT(count > 0);
    if (!can_use_draw_texture(paint, sampling)) {
        // Send every entry through drawImageQuad() to handle the more complicated paint
        int dstClipIndex = 0;
        for (int i = 0; i < count; ++i) {
            // Only no clip or quad clip are supported
            SkASSERT(!set[i].fHasClip || dstClips);
            SkASSERT(set[i].fMatrixIndex < 0 || preViewMatrices);
 
            SkTCopyOnFirstWrite<SkPaint> entryPaint(paint);
            if (set[i].fAlpha != 1.f) {
                auto paintAlpha = paint.getAlphaf();
                entryPaint.writable()->setAlphaf(paintAlpha * set[i].fAlpha);
            }
            this->drawImageQuadDirect(
                    set[i].fImage.get(), set[i].fSrcRect, set[i].fDstRect,
                    set[i].fHasClip ? dstClips + dstClipIndex : nullptr,
                    static_cast<SkCanvas::QuadAAFlags>(set[i].fAAFlags),
                    set[i].fMatrixIndex < 0 ? nullptr : preViewMatrices + set[i].fMatrixIndex,
                    sampling, *entryPaint, constraint);
            dstClipIndex += 4 * set[i].fHasClip;
        }
        return;
    }
 
    GrSamplerState::Filter filter = sampling.filter == SkFilterMode::kNearest
                                            ? GrSamplerState::Filter::kNearest
                                            : GrSamplerState::Filter::kLinear;
    SkBlendMode mode = paint.getBlendMode_or(SkBlendMode::kSrcOver);
 
    AutoTArray<GrTextureSetEntry> textures(count);
    // We accumulate compatible proxies until we find an an incompatible one or reach the end and
    // issue the accumulated 'n' draws starting at 'base'. 'p' represents the number of proxy
    // switches that occur within the 'n' entries.
    int base = 0, n = 0, p = 0;
    auto draw = [&](int nextBase) {
        if (n > 0) {
            auto textureXform = GrColorSpaceXform::Make(set[base].fImage->imageInfo().colorInfo(),
                                                        fSurfaceDrawContext->colorInfo());
            fSurfaceDrawContext->drawTextureSet(this->clip(),
                                                textures.get() + base,
                                                n,
                                                p,
                                                filter,
                                                GrSamplerState::MipmapMode::kNone,
                                                mode,
                                                constraint,
                                                this->localToDevice(),
                                                std::move(textureXform));
        }
        base = nextBase;
        n = 0;
        p = 0;
    };
    int dstClipIndex = 0;
    for (int i = 0; i < count; ++i) {
        SkASSERT(!set[i].fHasClip || dstClips);
        SkASSERT(set[i].fMatrixIndex < 0 || preViewMatrices);
 
        // Manage the dst clip pointer tracking before any continues are used so we don't lose
        // our place in the dstClips array.
        const SkPoint* clip = set[i].fHasClip ? dstClips + dstClipIndex : nullptr;
        dstClipIndex += 4 * set[i].fHasClip;
 
        // The default SkDevice implementation is based on drawImageRect which does not allow
        // non-sorted src rects. TODO: Decide this is OK or make sure we handle it.
        if (!set[i].fSrcRect.isSorted()) {
            draw(i + 1);
            continue;
        }
 
        GrSurfaceProxyView view;
        const SkImage_Base* image = as_IB(set[i].fImage.get());
        // Extract view from image, but skip YUV images so they get processed through
        // drawImageQuad and the proper effect to dynamically sample their planes.
        if (!image->isYUVA()) {
            std::tie(view, std::ignore) =
                    skgpu::ganesh::AsView(this->recordingContext(), image, skgpu::Mipmapped::kNo);
            if (image->isAlphaOnly()) {
                skgpu::Swizzle swizzle = skgpu::Swizzle::Concat(view.swizzle(),
                                                                skgpu::Swizzle("aaaa"));
                view = {view.detachProxy(), view.origin(), swizzle};
            }
        }
 
        if (!view) {
            // This image can't go through the texture op, send through general image pipeline
            // after flushing current batch.
            draw(i + 1);
            SkTCopyOnFirstWrite<SkPaint> entryPaint(paint);
            if (set[i].fAlpha != 1.f) {
                auto paintAlpha = paint.getAlphaf();
                entryPaint.writable()->setAlphaf(paintAlpha * set[i].fAlpha);
            }
            this->drawImageQuadDirect(
                    image, set[i].fSrcRect, set[i].fDstRect, clip,
                    static_cast<SkCanvas::QuadAAFlags>(set[i].fAAFlags),
                    set[i].fMatrixIndex < 0 ? nullptr : preViewMatrices + set[i].fMatrixIndex,
                    sampling, *entryPaint, constraint);
            continue;
        }
 
        textures[i].fProxyView = std::move(view);
        textures[i].fSrcAlphaType = image->alphaType();
        textures[i].fSrcRect = set[i].fSrcRect;
        textures[i].fDstRect = set[i].fDstRect;
        textures[i].fDstClipQuad = clip;
        textures[i].fPreViewMatrix =
                set[i].fMatrixIndex < 0 ? nullptr : preViewMatrices + set[i].fMatrixIndex;
        textures[i].fColor = texture_color(paint.getColor4f(), set[i].fAlpha,
                                           SkColorTypeToGrColorType(image->colorType()),
                                           fSurfaceDrawContext->colorInfo());
        textures[i].fAAFlags = SkToGrQuadAAFlags(set[i].fAAFlags);
 
        if (n > 0 &&
            (!GrTextureProxy::ProxiesAreCompatibleAsDynamicState(
                    textures[i].fProxyView.proxy(),
                    textures[base].fProxyView.proxy()) ||
             textures[i].fProxyView.swizzle() != textures[base].fProxyView.swizzle() ||
             set[i].fImage->alphaType() != set[base].fImage->alphaType() ||
             !SkColorSpace::Equals(set[i].fImage->colorSpace(), set[base].fImage->colorSpace()))) {
            draw(i);
        }
        // Whether or not we submitted a draw in the above if(), this ith entry is in the current
        // set being accumulated so increment n, and increment p if proxies are different.
        ++n;
        if (n == 1 || textures[i - 1].fProxyView.proxy() != textures[i].fProxyView.proxy()) {
            // First proxy or a different proxy (that is compatible, otherwise we'd have drawn up
            // to i - 1).
            ++p;
        }
    }
    draw(count);
}

◆ drawEdgeAAQuad()

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

overridevirtual

Reimplemented from SkDevice.

Definition at line 597 of file Device.cpp.

                                              {
    ASSERT_SINGLE_OWNER
    GR_CREATE_TRACE_MARKER_CONTEXT("skgpu::ganesh::Device", "drawEdgeAAQuad", fContext.get());
 
    SkPMColor4f dstColor = SkColor4fPrepForDst(color, fSurfaceDrawContext->colorInfo()).premul();
 
    GrPaint grPaint;
    grPaint.setColor4f(dstColor);
    if (mode != SkBlendMode::kSrcOver) {
        grPaint.setXPFactory(GrXPFactory::FromBlendMode(mode));
    }
 
    if (clip) {
        // Use fillQuadWithEdgeAA
        fSurfaceDrawContext->fillQuadWithEdgeAA(this->clip(),
                                                std::move(grPaint),
                                                SkToGrQuadAAFlags(aaFlags),
                                                this->localToDevice(),
                                                clip,
                                                nullptr);
    } else {
        // Use fillRectWithEdgeAA to preserve mathematical properties of dst being rectangular
        fSurfaceDrawContext->fillRectWithEdgeAA(this->clip(),
                                                std::move(grPaint),
                                                SkToGrQuadAAFlags(aaFlags),
                                                this->localToDevice(),
                                                rect);
    }
}

◆ drawImageLattice()

void skgpu::ganesh::Device::drawImageLattice	(	const SkImage *	image,
		const SkCanvas::Lattice &	lattice,
		const SkRect &	dst,
		SkFilterMode	filter,
		const SkPaint &	paint
	)

overridevirtual

Reimplemented from SkDevice.

Definition at line 1094 of file Device.cpp.

                                                    {
    ASSERT_SINGLE_OWNER
    auto iter = std::make_unique<SkLatticeIter>(lattice, dst);
 
    auto [view, ct] = skgpu::ganesh::AsView(this->recordingContext(), image, skgpu::Mipmapped::kNo);
    if (view) {
        GrColorInfo colorInfo(ct, image->alphaType(), image->refColorSpace());
        this->drawViewLattice(
                std::move(view), std::move(colorInfo), std::move(iter), dst, filter, paint);
    }
}

◆ drawImageRect()

void skgpu::ganesh::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 976 of file Device.cpp.

                                                                 {
    ASSERT_SINGLE_OWNER
 
    GrAA aa = fSurfaceDrawContext->chooseAA(paint);
    SkCanvas::QuadAAFlags aaFlags = (aa == GrAA::kYes) ? SkCanvas::kAll_QuadAAFlags
                                                       : SkCanvas::kNone_QuadAAFlags;
 
    this->drawImageQuadDirect(image,
                              src ? *src
                                  : SkRect::MakeIWH(image->width(), image->height()),
                              dst,
                              /* dstClip= */ nullptr,
                              aaFlags,
                              /* preViewMatrix= */ nullptr,
                              sampling,
                              paint,
                              constraint);
}

◆ drawMesh()

void skgpu::ganesh::Device::drawMesh	(	const SkMesh &	mesh,
		sk_sp< SkBlender >	blender,
		const SkPaint &	paint
	)

overridevirtual

Implements SkDevice.

Definition at line 1145 of file Device.cpp.

                                                                                        {
    ASSERT_SINGLE_OWNER
    GR_CREATE_TRACE_MARKER_CONTEXT("skgpu::ganesh::Device", "drawMesh", fContext.get());
    if (!mesh.isValid()) {
        return;
    }
 
    GrPaint grPaint;
    if (!init_vertices_paint(fContext.get(),
                             fSurfaceDrawContext->colorInfo(),
                             paint,
                             this->localToDevice(),
                             blender.get(),
                             SkMeshSpecificationPriv::HasColors(*mesh.spec()),
                             fSurfaceDrawContext->surfaceProps(),
                             &grPaint)) {
        return;
    }
 
    TArray<std::unique_ptr<GrFragmentProcessor>> meshChildFPs;
    if (!init_mesh_child_effects(fContext.get(),
                                 fSurfaceDrawContext->colorInfo(),
                                 fSurfaceDrawContext->surfaceProps(),
                                 mesh,
                                 &meshChildFPs)) {
        return;
    }
    fSurfaceDrawContext->drawMesh(this->clip(), std::move(grPaint), this->localToDevice(), mesh,
                                  std::move(meshChildFPs));
}

◆ drawOval()

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

overridevirtual

Implements SkDevice.

Definition at line 750 of file Device.cpp.

                                                              {
    ASSERT_SINGLE_OWNER
    GR_CREATE_TRACE_MARKER_CONTEXT("skgpu::ganesh::Device", "drawOval", fContext.get());
 
    if (paint.getMaskFilter()) {
        // The RRect path can handle special case blurring
        SkRRect rr = SkRRect::MakeOval(oval);
        return this->drawRRect(rr, paint);
    }
 
    GrPaint grPaint;
    if (!SkPaintToGrPaint(this->recordingContext(),
                          fSurfaceDrawContext->colorInfo(),
                          paint,
                          this->localToDevice(),
                          fSurfaceDrawContext->surfaceProps(),
                          &grPaint)) {
        return;
    }
 
    fSurfaceDrawContext->drawOval(this->clip(), std::move(grPaint),
                                  fSurfaceDrawContext->chooseAA(paint), this->localToDevice(), oval,
                                  GrStyle(paint));
}

◆ drawPaint()

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

overridevirtual

Implements SkDevice.

Definition at line 443 of file Device.cpp.

                                           {
    ASSERT_SINGLE_OWNER
    GR_CREATE_TRACE_MARKER_CONTEXT("skgpu::ganesh::Device", "drawPaint", fContext.get());
 
    GrPaint grPaint;
    if (!SkPaintToGrPaint(this->recordingContext(),
                          fSurfaceDrawContext->colorInfo(),
                          paint,
                          this->localToDevice(),
                          fSurfaceDrawContext->surfaceProps(),
                          &grPaint)) {
        return;
    }
 
    fSurfaceDrawContext->drawPaint(this->clip(), std::move(grPaint), this->localToDevice());
}

◆ drawPath()

void skgpu::ganesh::Device::drawPath	(	const SkPath &	path,
		const SkPaint &	paint,
		bool	pathIsMutable
	)

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 803 of file Device.cpp.

                                                                                         {
#if defined(GR_TEST_UTILS)
    if (fContext->priv().options().fAllPathsVolatile && !origSrcPath.isVolatile()) {
        this->drawPath(SkPath(origSrcPath).setIsVolatile(true), paint, true);
        return;
    }
#endif
    ASSERT_SINGLE_OWNER
    GR_CREATE_TRACE_MARKER_CONTEXT("skgpu::ganesh::Device", "drawPath", fContext.get());
    if (!paint.getMaskFilter()) {
        GrPaint grPaint;
        if (!SkPaintToGrPaint(this->recordingContext(),
                              fSurfaceDrawContext->colorInfo(),
                              paint,
                              this->localToDevice(),
                              fSurfaceDrawContext->surfaceProps(),
                              &grPaint)) {
            return;
        }
        fSurfaceDrawContext->drawPath(this->clip(), std::move(grPaint),
                                      fSurfaceDrawContext->chooseAA(paint), this->localToDevice(),
                                      origSrcPath, GrStyle(paint));
        return;
    }
 
    // TODO: losing possible mutability of 'origSrcPath' here
    GrStyledShape shape(origSrcPath, paint);
 
    GrBlurUtils::DrawShapeWithMaskFilter(fContext.get(), fSurfaceDrawContext.get(), this->clip(),
                                         paint, this->localToDevice(), shape);
}

◆ drawPoints()

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

overridevirtual

Implements SkDevice.

Definition at line 460 of file Device.cpp.

                                              {
    ASSERT_SINGLE_OWNER
    GR_CREATE_TRACE_MARKER_CONTEXT("skgpu::ganesh::Device", "drawPoints", fContext.get());
    SkScalar width = paint.getStrokeWidth();
    if (width < 0) {
        return;
    }
 
    GrAA aa = fSurfaceDrawContext->chooseAA(paint);
 
    if (count == 2 && mode == SkCanvas::kLines_PointMode) {
        if (paint.getPathEffect()) {
            // Probably a dashed line. Draw as a path.
            GrPaint grPaint;
            if (SkPaintToGrPaint(this->recordingContext(),
                                 fSurfaceDrawContext->colorInfo(),
                                 paint,
                                 this->localToDevice(),
                                 fSurfaceDrawContext->surfaceProps(),
                                 &grPaint)) {
                SkPath path;
                path.setIsVolatile(true);
                path.moveTo(pts[0]);
                path.lineTo(pts[1]);
                fSurfaceDrawContext->drawPath(this->clip(),
                                              std::move(grPaint),
                                              aa,
                                              this->localToDevice(),
                                              path,
                                              GrStyle(paint, SkPaint::kStroke_Style));
            }
            return;
        }
        if (!paint.getMaskFilter() &&
            paint.getStrokeWidth() > 0 &&  // drawStrokedLine doesn't support hairlines.
            paint.getStrokeCap() != SkPaint::kRound_Cap) { // drawStrokedLine doesn't do round caps.
            // Simple stroked line. Bypass path rendering.
            GrPaint grPaint;
            if (SkPaintToGrPaint(this->recordingContext(),
                                 fSurfaceDrawContext->colorInfo(),
                                 paint,
                                 this->localToDevice(),
                                 fSurfaceDrawContext->surfaceProps(),
                                 &grPaint)) {
                fSurfaceDrawContext->drawStrokedLine(this->clip(),
                                                     std::move(grPaint),
                                                     aa,
                                                     this->localToDevice(),
                                                     pts,
                                                     SkStrokeRec(paint, SkPaint::kStroke_Style));
            }
            return;
        }
    }
 
    const GrCaps* caps = fContext->priv().caps();
    SkScalar scales[2];
    bool isHairline =
            ((0 == width) ||
             (1 == width && this->localToDevice().getMinMaxScales(scales) &&
              SkScalarNearlyEqual(scales[0], 1.f) && SkScalarNearlyEqual(scales[1], 1.f))) &&
 
            // Don't do this as a hairline draw, which will emit line primitives, if
            // lines are not permitted by caps.
            !((mode == SkCanvas::kLines_PointMode || mode == SkCanvas::kPolygon_PointMode) &&
              caps->avoidLineDraws());
 
    // we only handle non-coverage-aa hairlines and paints without path effects or mask filters,
    // else we let the SkDraw call our drawPath()
    if (!isHairline ||
        paint.getPathEffect() ||
        paint.getMaskFilter() ||
        fSurfaceDrawContext->chooseAAType(aa) == GrAAType::kCoverage) {
        SkRasterClip rc(this->devClipBounds());
        SkDrawBase draw;
        // don't need to set fBlitterChoose, as it should never get used
        draw.fDst = SkPixmap(SkImageInfo::MakeUnknown(this->width(), this->height()), nullptr, 0);
        draw.fCTM = &this->localToDevice();
        draw.fRC = &rc;
        draw.drawDevicePoints(mode, count, pts, paint, this);
        return;
    }
 
    GrPaint grPaint;
    if (!SkPaintToGrPaint(this->recordingContext(),
                          fSurfaceDrawContext->colorInfo(),
                          paint,
                          this->localToDevice(),
                          fSurfaceDrawContext->surfaceProps(),
                          &grPaint)) {
        return;
    }
 
    static constexpr SkVertices::VertexMode kIgnoredMode = SkVertices::kTriangles_VertexMode;
    sk_sp<SkVertices> vertices = SkVertices::MakeCopy(kIgnoredMode, SkToS32(count), pts, nullptr,
                                                      nullptr);
 
    GrPrimitiveType primitiveType = point_mode_to_primitive_type(mode);
    fSurfaceDrawContext->drawVertices(this->clip(), std::move(grPaint), this->localToDevice(),
                                      std::move(vertices), &primitiveType);
}

◆ drawRect()

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

overridevirtual

Implements SkDevice.

Definition at line 567 of file Device.cpp.

                                                              {
    ASSERT_SINGLE_OWNER
    GR_CREATE_TRACE_MARKER_CONTEXT("skgpu::ganesh::Device", "drawRect", fContext.get());
 
    GrStyle style(paint);
 
    // A couple reasons we might need to call drawPath.
    if (paint.getMaskFilter() || paint.getPathEffect()) {
        GrStyledShape shape(rect, style);
 
        GrBlurUtils::DrawShapeWithMaskFilter(fContext.get(), fSurfaceDrawContext.get(),
                                             this->clip(), paint, this->localToDevice(), shape);
        return;
    }
 
    GrPaint grPaint;
    if (!SkPaintToGrPaint(this->recordingContext(),
                          fSurfaceDrawContext->colorInfo(),
                          paint,
                          this->localToDevice(),
                          fSurfaceDrawContext->surfaceProps(),
                          &grPaint)) {
        return;
    }
 
    fSurfaceDrawContext->drawRect(this->clip(), std::move(grPaint),
                                  fSurfaceDrawContext->chooseAA(paint), this->localToDevice(), rect,
                                  &style);
}

◆ drawRegion()

void skgpu::ganesh::Device::drawRegion	(	const SkRegion &	r,
		const SkPaint &	paint
	)

overridevirtual

Reimplemented from SkDevice.

Definition at line 725 of file Device.cpp.

                                                                    {
    ASSERT_SINGLE_OWNER
 
    if (paint.getMaskFilter()) {
        SkPath path;
        region.getBoundaryPath(&path);
        path.setIsVolatile(true);
        return this->drawPath(path, paint, true);
    }
 
    GrPaint grPaint;
    if (!SkPaintToGrPaint(this->recordingContext(),
                          fSurfaceDrawContext->colorInfo(),
                          paint,
                          this->localToDevice(),
                          fSurfaceDrawContext->surfaceProps(),
                          &grPaint)) {
        return;
    }
 
    fSurfaceDrawContext->drawRegion(this->clip(), std::move(grPaint),
                                    fSurfaceDrawContext->chooseAA(paint), this->localToDevice(),
                                    region, GrStyle(paint));
}

◆ drawRRect()

void skgpu::ganesh::Device::drawRRect	(	const SkRRect &	r,
		const SkPaint &	paint
	)

overridevirtual

Implements SkDevice.

Definition at line 633 of file Device.cpp.

                                                                 {
    ASSERT_SINGLE_OWNER
    GR_CREATE_TRACE_MARKER_CONTEXT("skgpu::ganesh::Device", "drawRRect", fContext.get());
 
    auto mf = paint.getMaskFilter();
    if (mf) {
        if (GrFragmentProcessors::IsSupported(mf)) {
            mf = nullptr; // already handled in SkPaintToGrPaint
        }
    }
 
    GrStyle style(paint);
 
    if (mf || style.pathEffect()) {
        // A path effect will presumably transform this rrect into something else.
        GrStyledShape shape(rrect, style);
 
        GrBlurUtils::DrawShapeWithMaskFilter(fContext.get(), fSurfaceDrawContext.get(),
                                             this->clip(), paint, this->localToDevice(), shape);
        return;
    }
 
    SkASSERT(!style.pathEffect());
 
    GrPaint grPaint;
    if (!SkPaintToGrPaint(this->recordingContext(),
                          fSurfaceDrawContext->colorInfo(),
                          paint,
                          this->localToDevice(),
                          fSurfaceDrawContext->surfaceProps(),
                          &grPaint)) {
        return;
    }
 
    fSurfaceDrawContext->drawRRect(this->clip(), std::move(grPaint),
                                   fSurfaceDrawContext->chooseAA(paint), this->localToDevice(),
                                   rrect, style);
}

◆ drawShadow()

void skgpu::ganesh::Device::drawShadow	(	const SkPath &	path,
		const SkDrawShadowRec &	rec
	)

overridevirtual

Reimplemented from SkDevice.

Definition at line 1179 of file Device.cpp.

                                                                      {
#if defined(GR_TEST_UTILS)
    if (fContext->priv().options().fAllPathsVolatile && !path.isVolatile()) {
        this->drawShadow(SkPath(path).setIsVolatile(true), rec);
        return;
    }
#endif
    ASSERT_SINGLE_OWNER
    GR_CREATE_TRACE_MARKER_CONTEXT("skgpu::ganesh::Device", "drawShadow", fContext.get());
 
    if (!fSurfaceDrawContext->drawFastShadow(this->clip(), this->localToDevice(), path, rec)) {
        // failed to find an accelerated case
        this->SkDevice::drawShadow(path, rec);
    }
}

◆ drawSlug()

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

overridevirtual

Reimplemented from SkDevice.

Definition at line 1504 of file Device.cpp.

                                                                                       {
    SkASSERT(canvas);
    SkASSERT(slug);
    const sktext::gpu::SlugImpl* slugImpl = static_cast<const sktext::gpu::SlugImpl*>(slug);
#if defined(SK_DEBUG)
    if (!fContext->priv().options().fSupportBilerpFromGlyphAtlas) {
        // We can draw a slug if the atlas has padding or if the creation matrix and the
        // drawing matrix are the same. If they are the same, then the Slug will use the direct
        // drawing code and not use bi-lerp.
        SkMatrix slugMatrix = slugImpl->initialPositionMatrix();
        SkMatrix positionMatrix = this->localToDevice();
        positionMatrix.preTranslate(slugImpl->origin().x(), slugImpl->origin().y());
        SkASSERT(slugMatrix == positionMatrix);
    }
#endif
    auto atlasDelegate = [&](const sktext::gpu::AtlasSubRun* subRun,
                             SkPoint drawOrigin,
                             const SkPaint& paint,
                             sk_sp<SkRefCnt> subRunStorage,
                             sktext::gpu::RendererData) {
        auto[drawingClip, op] = subRun->makeAtlasTextOp(
                this->clip(), this->localToDevice(), drawOrigin, paint,
                std::move(subRunStorage), fSurfaceDrawContext.get());
        if (op != nullptr) {
            fSurfaceDrawContext->addDrawOp(drawingClip, std::move(op));
        }
    };
 
    slugImpl->subRuns()->draw(canvas, slugImpl->origin(), paint, slugImpl, atlasDelegate);
}

◆ drawSpecial()

void skgpu::ganesh::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 371 of file Device_drawTexture.cpp.

                                                               {
    SkASSERT(!paint.getMaskFilter() && !paint.getImageFilter());
    SkASSERT(special->isGaneshBacked());
 
    SkRect src = SkRect::Make(special->subset());
    SkRect dst = SkRect::MakeWH(special->width(), special->height());
    SkMatrix srcToDst = SkMatrix::RectToRect(src, dst);
 
    SkSamplingOptions sampling = SkSamplingOptions(downgrade_to_filter(origSampling));
    GrAA aa = fSurfaceDrawContext->chooseAA(paint);
    SkCanvas::QuadAAFlags aaFlags = (aa == GrAA::kYes) ? SkCanvas::kAll_QuadAAFlags
                                                       : SkCanvas::kNone_QuadAAFlags;
 
    GrSurfaceProxyView view = SkSpecialImages::AsView(this->recordingContext(), special);
    if (!view) {
        // This shouldn't happen since we shouldn't be mixing SkSpecialImage subclasses but
        // returning early should avoid problems in release builds.
        SkASSERT(false);
        return;
    }
 
    if (constraint == SkCanvas::kFast_SrcRectConstraint) {
        // If 'fast' was requested, we assume the caller has done sufficient analysis to know the
        // logical dimensions are safe (which is true for FilterResult, the only current caller that
        // passes in 'fast'). Without exactify'ing the proxy, GrTextureEffect would re-introduce
        // subset clamping.
        view.proxy()->priv().exactify();
    }
 
    SkImage_Ganesh image(sk_ref_sp(special->getContext()),
                         special->uniqueID(),
                         std::move(view),
                         special->colorInfo());
    // In most cases this ought to hit draw_texture since there won't be a color filter,
    // alpha-only texture+shader, or a high filter quality.
    this->drawEdgeAAImage(&image,
                          src,
                          dst,
                          /* dstClip= */nullptr,
                          aaFlags,
                          localToDevice,
                          sampling,
                          paint,
                          constraint,
                          srcToDst,
                          SkTileMode::kClamp);
}

◆ drawVertices()

void skgpu::ganesh::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 1110 of file Device.cpp.

                                               {
    ASSERT_SINGLE_OWNER
    GR_CREATE_TRACE_MARKER_CONTEXT("skgpu::ganesh::Device", "drawVertices", fContext.get());
    SkASSERT(vertices);
 
#ifdef SK_LEGACY_IGNORE_DRAW_VERTICES_BLEND_WITH_NO_SHADER
    if (!paint.getShader()) {
        blender = SkBlender::Mode(SkBlendMode::kDst);
    }
#endif
 
    SkVerticesPriv info(vertices->priv());
 
    GrPaint grPaint;
    if (!init_vertices_paint(fContext.get(),
                             fSurfaceDrawContext->colorInfo(),
                             paint,
                             this->localToDevice(),
                             blender.get(),
                             info.hasColors(),
                             fSurfaceDrawContext->surfaceProps(),
                             &grPaint)) {
        return;
    }
    fSurfaceDrawContext->drawVertices(this->clip(),
                                      std::move(grPaint),
                                      this->localToDevice(),
                                      sk_ref_sp(const_cast<SkVertices*>(vertices)),
                                      nullptr,
                                      skipColorXform);
}

◆ isClipAntiAliased()

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

overridevirtual

Implements SkDevice.

Definition at line 431 of file Device.cpp.

                                     {
    for (const ClipStack::Element& e : fClip) {
        if (e.fAA == GrAA::kYes) {
            return true;
        }
        SkASSERT(!fSurfaceDrawContext->alwaysAntialias());
    }
    return false;
}

◆ isClipEmpty()

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

inlineoverridevirtual

Implements SkDevice.

Definition at line 285 of file Device.h.

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

◆ isClipRect()

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

inlineoverridevirtual

Implements SkDevice.

Definition at line 289 of file Device.h.

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

◆ isClipWideOpen()

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

inlineoverridevirtual

Implements SkDevice.

Definition at line 294 of file Device.h.

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

◆ Make() [1/2]

sk_sp< Device > skgpu::ganesh::Device::Make	(	GrRecordingContext *	rContext,
		GrColorType	colorType,
		sk_sp< GrSurfaceProxy >	proxy,
		sk_sp< SkColorSpace >	colorSpace,
		GrSurfaceOrigin	origin,
		const SkSurfaceProps &	surfaceProps,
		InitContents	init
	)

static

This factory uses the color space, origin, surface properties, and initialization method along with the provided proxy to create the gpu device.

Definition at line 212 of file Device.cpp.

                                              {
    auto sdc = SurfaceDrawContext::Make(rContext,
                                        colorType,
                                        std::move(proxy),
                                        std::move(colorSpace),
                                        origin,
                                        surfaceProps);
 
    return Device::Make(std::move(sdc), kPremul_SkAlphaType, init);
}

◆ Make() [2/2]

sk_sp< Device > skgpu::ganesh::Device::Make	(	GrRecordingContext *	rContext,
		skgpu::Budgeted	budgeted,
		const SkImageInfo &	ii,
		SkBackingFit	fit,
		int	sampleCount,
		skgpu::Mipmapped	mipmapped,
		GrProtected	isProtected,
		GrSurfaceOrigin	origin,
		const SkSurfaceProps &	props,
		InitContents	init
	)

static

This factory uses the budgeted, imageInfo, fit, sampleCount, mipmapped, and isProtected parameters to create a proxy to back the gpu device. The color space (from the image info), origin, surface properties, and initialization method are then used (with the created proxy) to create the device.

Definition at line 281 of file Device.cpp.

                                              {
    if (!rContext) {
        return nullptr;
    }
 
    auto sdc = SurfaceDrawContext::Make(rContext,
                                        SkColorTypeToGrColorType(ii.colorType()),
                                        ii.refColorSpace(),
                                        fit,
                                        ii.dimensions(),
                                        props,
                                        /*label=*/"MakeDevice",
                                        sampleCount,
                                        mipmapped,
                                        isProtected,
                                        origin,
                                        budgeted);
 
    return Device::Make(std::move(sdc), ii.alphaType(), init);
}

◆ makeSpecial() [1/2]

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

overridevirtual

Reimplemented from SkDevice.

Definition at line 841 of file Device.cpp.

                                                                {
    ASSERT_SINGLE_OWNER
 
    // TODO: this makes a tight copy of 'bitmap' but it doesn't have to be (given SkSpecialImage's
    // semantics). Since this is cached we would have to bake the fit into the cache key though.
    auto view = std::get<0>(
            GrMakeCachedBitmapProxyView(fContext.get(), bitmap, /*label=*/"Device_MakeSpecial"));
    if (!view) {
        return nullptr;
    }
 
    const SkIRect rect = SkIRect::MakeSize(view.proxy()->dimensions());
 
    // GrMakeCachedBitmapProxyView creates a tight copy of 'bitmap' so we don't have to subset
    // the special image
    return SkSpecialImages::MakeDeferredFromGpu(fContext.get(),
                                                rect,
                                                bitmap.getGenerationID(),
                                                std::move(view),
                                                {SkColorTypeToGrColorType(bitmap.colorType()),
                                                 kPremul_SkAlphaType,
                                                 bitmap.refColorSpace()},
                                                this->surfaceProps());
}

◆ makeSpecial() [2/2]

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

overridevirtual

Reimplemented from SkDevice.

Definition at line 866 of file Device.cpp.

                                                              {
    ASSERT_SINGLE_OWNER
 
    SkPixmap pm;
    if (image->isTextureBacked()) {
        auto [view, ct] =
                skgpu::ganesh::AsView(this->recordingContext(), image, skgpu::Mipmapped::kNo);
        SkASSERT(view);
 
        return SkSpecialImages::MakeDeferredFromGpu(
                fContext.get(),
                SkIRect::MakeWH(image->width(), image->height()),
                image->uniqueID(),
                std::move(view),
                {ct, kPremul_SkAlphaType, image->refColorSpace()},
                this->surfaceProps());
    } else if (image->peekPixels(&pm)) {
        SkBitmap bm;
 
        bm.installPixels(pm);
        return this->makeSpecial(bm);
    } else {
        return nullptr;
    }
}

◆ makeSurface()

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

overridevirtual

Reimplemented from SkDevice.

Definition at line 1448 of file Device.cpp.

                                                                                         {
    ASSERT_SINGLE_OWNER
    // TODO: Change the signature of newSurface to take a budgeted parameter.
    static const skgpu::Budgeted kBudgeted = skgpu::Budgeted::kNo;
    bool isProtected = this->targetProxy()->isProtected() == GrProtected::kYes;
    return SkSurfaces::RenderTarget(fContext.get(),
                                    kBudgeted,
                                    info,
                                    fSurfaceDrawContext->numSamples(),
                                    fSurfaceDrawContext->origin(),
                                    &props,
                                    /* shouldCreateWithMips= */ false,
                                    isProtected);
}

◆ onAccessPixels()

bool skgpu::ganesh::Device::onAccessPixels ( SkPixmap * pmap )

overrideprivatevirtual

Reimplemented from SkDevice.

Definition at line 353 of file Device.cpp.

                                          {
    ASSERT_SINGLE_OWNER
    return false;
}

◆ onClipShader()

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

inlineoverrideprivatevirtual

Implements SkDevice.

Definition at line 336 of file Device.h.

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

◆ onDrawGlyphRunList()

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

overrideprivatevirtual

Implements SkDevice.

Definition at line 1235 of file Device.cpp.

                                                      {
    ASSERT_SINGLE_OWNER
    GR_CREATE_TRACE_MARKER_CONTEXT("skgpu::ganesh::Device", "drawGlyphRunList", fContext.get());
    SkASSERT(!glyphRunList.hasRSXForm());
 
    if (glyphRunList.blob() == nullptr) {
        // If the glyphRunList does not have an associated text blob, then it was created by one of
        // the direct draw APIs (drawGlyphs, etc.). Use a Slug to draw the glyphs.
        auto slug = this->convertGlyphRunListToSlug(glyphRunList, paint);
        if (slug != nullptr) {
            this->drawSlug(canvas, slug.get(), paint);
        }
    } else {
        fSurfaceDrawContext->drawGlyphRunList(canvas,
                                              this->clip(),
                                              this->localToDevice(),
                                              glyphRunList,
                                              this->strikeDeviceInfo(),
                                              paint);
    }
}

◆ onReadPixels()

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

overrideprivatevirtual

Reimplemented from SkDevice.

Definition at line 329 of file Device.cpp.

                                                          {
    ASSERT_SINGLE_OWNER
 
    // Context TODO: Elevate direct context requirement to public API
    auto dContext = fContext->asDirectContext();
    if (!dContext || !SkImageInfoValidConversion(pm.info(), this->imageInfo())) {
        return false;
    }
 
    return fSurfaceDrawContext->readPixels(dContext, pm, {x, y});
}

◆ onWritePixels()

bool skgpu::ganesh::Device::onWritePixels	(	const SkPixmap &	pm,
		int	x,
		int	y
	)

overrideprivatevirtual

Reimplemented from SkDevice.

Definition at line 341 of file Device.cpp.

                                                           {
    ASSERT_SINGLE_OWNER
 
    // Context TODO: Elevate direct context requirement to public API
    auto dContext = fContext->asDirectContext();
    if (!dContext || !SkImageInfoValidConversion(this->imageInfo(), pm.info())) {
        return false;
    }
 
    return fSurfaceDrawContext->writePixels(dContext, pm, {x, y});
}

◆ popClipStack()

void skgpu::ganesh::Device::popClipStack ( )

inlineoverridevirtual

Implements SkDevice.

Definition at line 264 of file Device.h.

264{ fClip.restore(); }

skgpu::ganesh::ClipStack::restore

void restore()

Definition ClipStack.cpp:1175

◆ pushClipStack()

void skgpu::ganesh::Device::pushClipStack ( )

inlineoverridevirtual

Implements SkDevice.

Definition at line 263 of file Device.h.

263{ fClip.save(); }

skgpu::ganesh::ClipStack::save

void save()

Definition ClipStack.cpp:1170

◆ readSurfaceView()

GrSurfaceProxyView skgpu::ganesh::Device::readSurfaceView ( )

Definition at line 1283 of file Device.cpp.

                                           {
    return this->surfaceFillContext()->readSurfaceView();
}

◆ recordingContext()

GrRecordingContext * skgpu::ganesh::Device::recordingContext ( ) const

inlineoverridevirtual

Reimplemented from SkDevice.

Definition at line 101 of file Device.h.

101{ return fContext.get(); }

◆ replaceBackingProxy() [1/2]

bool skgpu::ganesh::Device::replaceBackingProxy ( SkSurface::ContentChangeMode mode )

Definition at line 1338 of file Device.cpp.

                                                                {
    ASSERT_SINGLE_OWNER
 
    const SkImageInfo& ii = this->imageInfo();
    GrRenderTargetProxy* oldRTP = this->targetProxy();
    GrSurfaceProxyView oldView = this->readSurfaceView();
 
    auto grColorType = SkColorTypeToGrColorType(ii.colorType());
    auto format = fContext->priv().caps()->getDefaultBackendFormat(grColorType, GrRenderable::kYes);
    if (!format.isValid()) {
        return false;
    }
 
    GrProxyProvider* proxyProvider = fContext->priv().proxyProvider();
    // This entry point is used by SkSurface_Ganesh::onCopyOnWrite so it must create a
    // kExact-backed render target proxy
    sk_sp<GrTextureProxy> proxy =
            proxyProvider->createProxy(format,
                                       ii.dimensions(),
                                       GrRenderable::kYes,
                                       oldRTP->numSamples(),
                                       oldView.mipmapped(),
                                       SkBackingFit::kExact,
                                       oldRTP->isBudgeted(),
                                       GrProtected::kNo,
                                       /*label=*/"BaseDevice_ReplaceBackingProxy");
    if (!proxy) {
        return false;
    }
 
    return this->replaceBackingProxy(mode, sk_ref_sp(proxy->asRenderTargetProxy()),
                                     grColorType, ii.refColorSpace(), oldView.origin(),
                                     this->surfaceProps());
}

◆ replaceBackingProxy() [2/2]

bool skgpu::ganesh::Device::replaceBackingProxy	(	SkSurface::ContentChangeMode	mode,
		sk_sp< GrRenderTargetProxy >	newRTP,
		GrColorType	grColorType,
		sk_sp< SkColorSpace >	colorSpace,
		GrSurfaceOrigin	origin,
		const SkSurfaceProps &	props
	)

Definition at line 1308 of file Device.cpp.

                                                              {
    auto sdc = SurfaceDrawContext::Make(fContext.get(), grColorType, std::move(newRTP),
                                        std::move(colorSpace), origin, props);
    if (!sdc) {
        return false;
    }
 
    SkASSERT(sdc->dimensions() == fSurfaceDrawContext->dimensions());
    SkASSERT(sdc->numSamples() == fSurfaceDrawContext->numSamples());
    SkASSERT(sdc->asSurfaceProxy()->priv().isExact());
    if (mode == SkSurface::kRetain_ContentChangeMode) {
        if (fContext->abandoned()) {
            return false;
        }
 
        SkASSERT(fSurfaceDrawContext->asTextureProxy());
        SkAssertResult(sdc->blitTexture(fSurfaceDrawContext->readSurfaceView(),
                                        SkIRect::MakeWH(this->width(), this->height()),
                                        SkIPoint::Make(0, 0)));
    }
 
    fSurfaceDrawContext = std::move(sdc);
    return true;
}

◆ replaceClip()

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

inlineoverridevirtual

Implements SkDevice.

Definition at line 276 of file Device.h.

                                                   {
        // Transform from "global/canvas" coordinates to relative to this device
        SkRect deviceRect = SkMatrixPriv::MapRect(this->globalToDevice(), SkRect::Make(rect));
        fClip.replaceClip(deviceRect.round());
    }

◆ resolveMSAA()

void skgpu::ganesh::Device::resolveMSAA ( )

Definition at line 1304 of file Device.cpp.

                         {
    fSurfaceDrawContext->resolveMSAA();
}

◆ shouldDrawAsTiledImageRect()

bool skgpu::ganesh::Device::shouldDrawAsTiledImageRect ( ) const

inlineoverridevirtual

Reimplemented from SkDevice.

Definition at line 203 of file Device.h.

203{ return true; }

◆ snapSpecial()

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

overridevirtual

Reimplemented from SkDevice.

Definition at line 892 of file Device.cpp.

                                                                               {
    ASSERT_SINGLE_OWNER
 
    auto sdc = fSurfaceDrawContext.get();
 
    // If we are wrapping a vulkan secondary command buffer, then we can't snap off a special image
    // since it would require us to make a copy of the underlying VkImage which we don't have access
    // to. Additionaly we can't stop and start the render pass that is used with the secondary
    // command buffer.
    if (sdc->wrapsVkSecondaryCB()) {
        return nullptr;
    }
 
    SkASSERT(sdc->asSurfaceProxy());
 
    SkIRect finalSubset = subset;
    GrSurfaceProxyView view = sdc->readSurfaceView();
    if (forceCopy || !view.asTextureProxy()) {
        // When the device doesn't have a texture, or a copy is requested, we create a temporary
        // texture that matches the device contents
        view = GrSurfaceProxyView::Copy(fContext.get(),
                                        std::move(view),
                                        skgpu::Mipmapped::kNo,  // Don't auto generate mips
                                        subset,
                                        SkBackingFit::kApprox,
                                        skgpu::Budgeted::kYes,
                                        /*label=*/"Device_SnapSpecial");  // Always budgeted
        if (!view) {
            return nullptr;
        }
        // Since this copied only the requested subset, the special image wrapping the proxy no
        // longer needs the original subset.
        finalSubset = SkIRect::MakeSize(view.dimensions());
    }
 
    return SkSpecialImages::MakeDeferredFromGpu(fContext.get(),
                                                finalSubset,
                                                kNeedNewImageUniqueID_SpecialImage,
                                                std::move(view),
                                                GrColorInfo(this->imageInfo().colorInfo()),
                                                this->surfaceProps());
}

◆ snapSpecialScaled()

sk_sp< SkSpecialImage > skgpu::ganesh::Device::snapSpecialScaled	(	const SkIRect &	subset,
		const SkISize &	dstDims
	)

overridevirtual

Reimplemented from SkDevice.

Definition at line 935 of file Device.cpp.

                                                                                             {
     ASSERT_SINGLE_OWNER
 
    auto sdc = fSurfaceDrawContext.get();
 
    // If we are wrapping a vulkan secondary command buffer, then we can't snap off a special image
    // since it would require us to make a copy of the underlying VkImage which we don't have access
    // to. Additionaly we can't stop and start the render pass that is used with the secondary
    // command buffer.
    if (sdc->wrapsVkSecondaryCB()) {
        return nullptr;
    }
 
    SkASSERT(sdc->asSurfaceProxy());
 
    auto scaledContext = sdc->rescale(sdc->imageInfo().makeDimensions(dstDims),
                                      sdc->origin(),
                                      subset,
                                      RescaleGamma::kSrc,
                                      RescaleMode::kLinear);
    if (!scaledContext) {
        return nullptr;
    }
 
    return SkSpecialImages::MakeDeferredFromGpu(fContext.get(),
                                                SkIRect::MakeSize(dstDims),
                                                kNeedNewImageUniqueID_SpecialImage,
                                                scaledContext->readSurfaceView(),
                                                GrColorInfo(this->imageInfo().colorInfo()),
                                                this->surfaceProps());
}

◆ strikeDeviceInfo()

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

overridevirtual

Reimplemented from SkDevice.

Definition at line 1491 of file Device.cpp.

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

◆ surfaceDrawContext() [1/2]

SurfaceDrawContext * skgpu::ganesh::Device::surfaceDrawContext ( )

Definition at line 358 of file Device.cpp.

                                               {
    ASSERT_SINGLE_OWNER
    return fSurfaceDrawContext.get();
}

◆ surfaceDrawContext() [2/2]

const SurfaceDrawContext * skgpu::ganesh::Device::surfaceDrawContext ( ) const

Definition at line 363 of file Device.cpp.

                                                           {
    ASSERT_SINGLE_OWNER
    return fSurfaceDrawContext.get();
}

◆ surfaceFillContext()

SurfaceFillContext * skgpu::ganesh::Device::surfaceFillContext ( )

Definition at line 368 of file Device.cpp.

                                               {
    ASSERT_SINGLE_OWNER
    return fSurfaceDrawContext.get();
}

◆ targetProxy()

GrRenderTargetProxy * skgpu::ganesh::Device::targetProxy ( )

Definition at line 1287 of file Device.cpp.

                                         {
    return this->readSurfaceView().asRenderTargetProxy();
}

◆ wait()

bool skgpu::ganesh::Device::wait	(	int	numSemaphores,
		const GrBackendSemaphore *	waitSemaphores,
		bool	deleteSemaphoresAfterWait
	)

Definition at line 1291 of file Device.cpp.

                                                  {
    ASSERT_SINGLE_OWNER
 
    return fSurfaceDrawContext->waitOnSemaphores(numSemaphores, waitSemaphores,
                                                 deleteSemaphoresAfterWait);
}

Friends And Related Symbol Documentation

◆ ::SkSurface_Ganesh

friend class ::SkSurface_Ganesh

friend

Definition at line 363 of file Device.h.

◆ skgpu::TiledTextureUtils

friend class skgpu::TiledTextureUtils

friend

Definition at line 364 of file Device.h.

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

third_party/skia/src/gpu/ganesh/Device.h
third_party/skia/src/gpu/ganesh/Device.cpp
third_party/skia/src/gpu/ganesh/Device_drawTexture.cpp

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ ReadPixelsCallback

◆ ReadPixelsContext

◆ RescaleGamma

◆ RescaleMode

Member Enumeration Documentation

◆ InitContents

Constructor & Destructor Documentation

◆ ~Device()

Member Function Documentation

◆ android_utils_clipAsRgn()

◆ android_utils_clipWithStencil()

◆ asGaneshDevice()

◆ asyncRescaleAndReadPixels()

◆ asyncRescaleAndReadPixelsYUV420()

◆ clearAll()

◆ clipPath()

◆ clipRect()

◆ clipRegion()

◆ clipRRect()

◆ convertGlyphRunListToSlug()

◆ createDevice()

◆ createImageFilteringBackend()

◆ devClipBounds()

◆ discard()

◆ drawArc()

◆ drawAsTiledImageRect()

◆ drawAtlas()

◆ drawDevice()

◆ drawDrawable()

◆ drawDRRect()

◆ drawEdgeAAImage()

◆ drawEdgeAAImageSet()

◆ drawEdgeAAQuad()

◆ drawImageLattice()

◆ drawImageRect()

◆ drawMesh()

◆ drawOval()

◆ drawPaint()

◆ drawPath()

◆ drawPoints()

◆ drawRect()

◆ drawRegion()

◆ drawRRect()

◆ drawShadow()

◆ drawSlug()

◆ drawSpecial()

◆ drawVertices()

◆ isClipAntiAliased()

◆ isClipEmpty()

◆ isClipRect()

◆ isClipWideOpen()

◆ Make() [1/2]

◆ Make() [2/2]

◆ makeSpecial() [1/2]

◆ makeSpecial() [2/2]

◆ makeSurface()

◆ onAccessPixels()

◆ onClipShader()

◆ onDrawGlyphRunList()

◆ onReadPixels()

◆ onWritePixels()

◆ popClipStack()

◆ pushClipStack()

◆ readSurfaceView()

◆ recordingContext()

◆ replaceBackingProxy() [1/2]

◆ replaceBackingProxy() [2/2]

◆ replaceClip()

◆ resolveMSAA()

◆ shouldDrawAsTiledImageRect()

◆ snapSpecial()

◆ snapSpecialScaled()