#include <SkDevice.h>

Inheritance diagram for SkDevice:

Classes
struct	CreateInfo

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

const SkImageInfo &	imageInfo () const

int	width () const

int	height () const

bool	isOpaque () const

SkIRect	bounds () const

SkISize	size () const

const SkSurfaceProps &	surfaceProps () const

SkScalerContextFlags	scalerContextFlags () const

virtual SkStrikeDeviceInfo	strikeDeviceInfo () const

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

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

bool	accessPixels (SkPixmap *pmap)

bool	peekPixels (SkPixmap *)

const SkM44 &	localToDevice44 () const

const SkMatrix &	localToDevice () const

const SkM44 &	deviceToGlobal () const

const SkM44 &	globalToDevice () const

SkIPoint	getOrigin () const

bool	isPixelAlignedToGlobal () const

SkMatrix	getRelativeTransform (const SkDevice &) const

void	setLocalToDevice (const SkM44 &localToDevice)

void	setGlobalCTM (const SkM44 &ctm)

void	getGlobalBounds (SkIRect *bounds) const

SkIRect	getGlobalBounds () const

virtual SkIRect	devClipBounds () const =0

virtual void	pushClipStack ()=0

virtual void	popClipStack ()=0

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

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

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

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

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

virtual void	replaceClip (const SkIRect &rect)=0

virtual bool	isClipAntiAliased () const =0

virtual bool	isClipEmpty () const =0

virtual bool	isClipRect () const =0

virtual bool	isClipWideOpen () const =0

virtual void	android_utils_clipAsRgn (SkRegion *) const =0

virtual bool	android_utils_clipWithStencil ()

virtual bool	useDrawCoverageMaskForMaskFilters () const

virtual bool	isNoPixelsDevice () const

virtual void *	getRasterHandle () const

virtual GrRecordingContext *	recordingContext () const

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

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

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

virtual void	setImmutable ()

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

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

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

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

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

virtual void	drawPaint (const SkPaint &paint)=0

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

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

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

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

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

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

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

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

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

virtual bool	shouldDrawAsTiledImageRect () const

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

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

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

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

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

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

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

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

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

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

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

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

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

sk_sp< SkSpecialImage >	snapSpecial ()

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

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

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

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

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

Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()

virtual	~SkRefCntBase ()

bool	unique () const

void	ref () const

void	unref () const

Protected Member Functions
virtual sk_sp< SkSpecialImage >	makeSpecial (const SkBitmap &)

virtual sk_sp< SkSpecialImage >	makeSpecial (const SkImage *)

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

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

bool	checkLocalToDeviceDirty ()

Private Member Functions
virtual sk_sp< skif::Backend >	createImageFilteringBackend (const SkSurfaceProps &surfaceProps, SkColorType colorType) const

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

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

virtual bool	onAccessPixels (SkPixmap *)

virtual bool	onPeekPixels (SkPixmap *)

virtual void	onClipShader (sk_sp< SkShader >)=0

virtual void	onDrawGlyphRunList (SkCanvas *, const sktext::GlyphRunList &, const SkPaint &paint)=0

Friends
class	SkCanvas

class	DeviceTestingAccess

Detailed Description

SkDevice is the internal API and implementation that SkCanvas will use to perform rendering and implement the saveLayer abstraction. A device wraps some pixel allocation (for non-document based devices) or wraps some other container that stores rendering operations. The drawing operations perform equivalently to their corresponding functions in SkCanvas except that the canvas is responsible for all SkImageFilters. An image filter is applied by automatically creating a layer, drawing the filter-less paint into the layer, and then evaluating the filter on the layer's image.

Each layer in an SkCanvas stack is represented by an SkDevice instance that was created by the parent SkDevice (up to the canvas's base device). In most cases these devices will be pixel aligned with one another but may differ in size based on the known extent of the active clip. In complex image filtering scenarios, they may not be axis aligned, although the effective pixel size should remain approximately equal across all devices in a canvas.

While SkCanvas manages a single stack of layers and canvas transforms, SkDevice does not have a stack of transforms. Instead, it has a single active transform that is modified as needed by SkCanvas. However, SkDevices are the means by which SkCanvas manages the clip stack because each layer's clip stack starts anew (although the layer's results are then clipped by its parent's stack when it is restored).

Definition at line 107 of file SkDevice.h.

Constructor & Destructor Documentation

◆ SkDevice()

SkDevice::SkDevice	(	const SkImageInfo &	info,
		const SkSurfaceProps &	surfaceProps
	)

Definition at line 45 of file SkDevice.cpp.

        : fInfo(info)
        , fSurfaceProps(surfaceProps) {
    fDeviceToGlobal.setIdentity();
    fGlobalToDevice.setIdentity();
}

Member Function Documentation

◆ accessPixels()

bool SkDevice::accessPixels ( SkPixmap * pmap )

Try to get write-access to the pixels behind the device. If successful, this returns true and fills-out the pixmap parameter. On success it also bumps the genID of the underlying bitmap.

On failure, returns false and ignores the pixmap parameter.

Definition at line 383 of file SkDevice.cpp.

                                          {
    SkPixmap tempStorage;
    if (nullptr == pmap) {
        pmap = &tempStorage;
    }
    return this->onAccessPixels(pmap);
}

◆ android_utils_clipAsRgn()

virtual void SkDevice::android_utils_clipAsRgn ( SkRegion * ) const

pure virtual

Implemented in SkBitmapDevice, SkClipStackDevice, skgpu::ganesh::Device, skgpu::graphite::Device, and SkNoPixelsDevice.

◆ android_utils_clipWithStencil()

virtual bool SkDevice::android_utils_clipWithStencil ( )

inlinevirtual

Reimplemented in skgpu::ganesh::Device.

Definition at line 267 of file SkDevice.h.

267{ return false; }

◆ asGaneshDevice()

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

inlinevirtual

Reimplemented in skgpu::ganesh::Device.

Definition at line 287 of file SkDevice.h.

287{ return nullptr; }

◆ asGraphiteDevice()

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

inlinevirtual

Reimplemented in skgpu::graphite::Device.

Definition at line 288 of file SkDevice.h.

288{ return nullptr; }

◆ bounds()

SkIRect SkDevice::bounds ( ) const

inline

Definition at line 125 of file SkDevice.h.

125{ return SkIRect::MakeWH(this->width(), this->height()); }

SkDevice::height

int height() const

Definition: SkDevice.h:120

SkDevice::width

int width() const

Definition: SkDevice.h:119

SkIRect::MakeWH

static constexpr SkIRect MakeWH(int32_t w, int32_t h)

Definition: SkRect.h:56

◆ checkLocalToDeviceDirty()

bool SkDevice::checkLocalToDeviceDirty ( )

inlineprotected

Definition at line 513 of file SkDevice.h.

                                   {
        bool wasDirty = fLocalToDeviceDirty;
        fLocalToDeviceDirty = false;
        return wasDirty;
    }

◆ clipPath()

virtual void SkDevice::clipPath	(	const SkPath &	path,
		SkClipOp	op,
		bool	aa
	)

pure virtual

Implemented in SkNoPixelsDevice, skgpu::ganesh::Device, SkBitmapDevice, SkClipStackDevice, and skgpu::graphite::Device.

◆ clipRect()

virtual void SkDevice::clipRect	(	const SkRect &	rect,
		SkClipOp	op,
		bool	aa
	)

pure virtual

Implemented in SkNoPixelsDevice, skgpu::ganesh::Device, SkBitmapDevice, SkClipStackDevice, and skgpu::graphite::Device.

◆ clipRegion()

virtual void SkDevice::clipRegion	(	const SkRegion &	region,
		SkClipOp	op
	)

pure virtual

Implemented in SkBitmapDevice, SkClipStackDevice, SkNoPixelsDevice, skgpu::ganesh::Device, and skgpu::graphite::Device.

◆ clipRRect()

virtual void SkDevice::clipRRect	(	const SkRRect &	rrect,
		SkClipOp	op,
		bool	aa
	)

pure virtual

Implemented in SkNoPixelsDevice, skgpu::ganesh::Device, SkBitmapDevice, SkClipStackDevice, and skgpu::graphite::Device.

◆ clipShader()

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

inline

Definition at line 251 of file SkDevice.h.

                                                     {
        sh = as_SB(sh)->makeWithCTM(this->localToDevice());
        if (op == SkClipOp::kDifference) {
            sh = as_SB(sh)->makeInvertAlpha();
        }
        this->onClipShader(std::move(sh));
    }

◆ convertGlyphRunListToSlug()

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

virtual

Reimplemented in skgpu::ganesh::Device, and GlyphTrackingDevice.

Definition at line 483 of file SkDevice.cpp.

                                                                      {
    return nullptr;
}

◆ createDevice()

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

inlinevirtual

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 in SkBitmapDevice, skgpu::ganesh::Device, skgpu::graphite::Device, SkPDFDevice, and GlyphTrackingDevice.

Definition at line 322 of file SkDevice.h.

322{ return nullptr; }

◆ createImageFilteringBackend()

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

privatevirtual

Definition at line 324 of file SkDevice.cpp.

                                                                                        {
    return skif::MakeRasterBackend(surfaceProps, colorType);
}

◆ devClipBounds()

virtual SkIRect SkDevice::devClipBounds ( ) const

pure virtual

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

Implemented in SkBitmapDevice, SkClipStackDevice, SkNoPixelsDevice, skgpu::ganesh::Device, and skgpu::graphite::Device.

◆ deviceToGlobal()

const SkM44 & SkDevice::deviceToGlobal ( ) const

inline

Return the device's coordinate space transform: this maps from the device's coordinate space into the global canvas' space (or root device space). This includes the translation necessary to account for the device's origin.

Definition at line 186 of file SkDevice.h.

186{ return fDeviceToGlobal; }

◆ drawAnnotation()

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

inlinevirtual

Reimplemented in SkPDFDevice, and SkSVGDevice.

Definition at line 399 of file SkDevice.h.

399{}

◆ drawArc()

void SkDevice::drawArc	(	const SkArc &	arc,
		const SkPaint &	paint
	)

virtual

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

Reimplemented in skgpu::ganesh::Device.

Definition at line 134 of file SkDevice.cpp.

                                                             {
    SkPath path;
    bool isFillNoPathEffect = SkPaint::kFill_Style == paint.getStyle() && !paint.getPathEffect();
    SkPathPriv::CreateDrawArcPath(&path, arc, isFillNoPathEffect);
    this->drawPath(path, paint);
}

◆ drawAsTiledImageRect()

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

inlinevirtual

Reimplemented in skgpu::ganesh::Device, and skgpu::graphite::Device.

Definition at line 369 of file SkDevice.h.

375 { return false; }

◆ drawAtlas()

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

virtual

Reimplemented in SkBitmapDevice, skgpu::ganesh::Device, and skgpu::graphite::Device.

Definition at line 203 of file SkDevice.cpp.

                                               {
    const int triCount = quadCount << 1;
    const int vertexCount = triCount * 3;
    uint32_t flags = SkVertices::kHasTexCoords_BuilderFlag;
    if (colors) {
        flags |= SkVertices::kHasColors_BuilderFlag;
    }
    SkVertices::Builder builder(SkVertices::kTriangles_VertexMode, vertexCount, 0, flags);
 
    SkPoint* vPos = builder.positions();
    SkPoint* vTex = builder.texCoords();
    SkColor* vCol = builder.colors();
    for (int i = 0; i < quadCount; ++i) {
        SkPoint tmp[4];
        xform[i].toQuad(tex[i].width(), tex[i].height(), tmp);
        vPos = quad_to_tris(vPos, tmp);
 
        tex[i].toQuad(tmp);
        vTex = quad_to_tris(vTex, tmp);
 
        if (colors) {
            SkOpts::memset32(vCol, colors[i], 6);
            vCol += 6;
        }
    }
    this->drawVertices(builder.detach().get(), std::move(blender), paint);
}

◆ drawBlurredRRect()

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

inlinevirtual

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

Reimplemented in skgpu::graphite::Device.

Definition at line 469 of file SkDevice.h.

                                                                                     {
        return false;
    }

◆ drawCoverageMask()

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

virtual

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 in skgpu::graphite::Device.

Definition at line 306 of file SkDevice.cpp.

                                                                          {
    // This shouldn't be reached; SkCanvas will only call this if
    // useDrawCoverageMaskForMaskFilters() is overridden to return true.
    SK_ABORT("Must override if useDrawCoverageMaskForMaskFilters() is true");
}

◆ drawDevice()

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

virtual

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 in SkNoPixelsDevice, skgpu::ganesh::Device, and SkPDFDevice.

Definition at line 329 of file SkDevice.cpp.

                                                {
    sk_sp<SkSpecialImage> deviceImage = device->snapSpecial();
    if (deviceImage) {
        // SkCanvas only calls drawDevice() when there are no filters (so the transform is pixel
        // aligned). As such it can be drawn without clamping.
        SkMatrix relativeTransform = device->getRelativeTransform(*this);
        const bool strict = sampling != SkFilterMode::kNearest ||
                            !relativeTransform.isTranslate() ||
                            !SkScalarIsInt(relativeTransform.getTranslateX()) ||
                            !SkScalarIsInt(relativeTransform.getTranslateY());
        this->drawSpecial(deviceImage.get(), relativeTransform, sampling, paint,
                          strict ? SkCanvas::kStrict_SrcRectConstraint
                                 : SkCanvas::kFast_SrcRectConstraint);
    }
}

◆ drawDrawable()

void SkDevice::drawDrawable	(	SkCanvas *	canvas,
		SkDrawable *	drawable,
		const SkMatrix *	matrix
	)

virtual

Reimplemented in skgpu::ganesh::Device, and skgpu::graphite::Device.

Definition at line 298 of file SkDevice.cpp.

                                                                                          {
    drawable->draw(canvas, matrix);
}

◆ drawDRRect()

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

virtual

Reimplemented in skgpu::ganesh::Device.

Definition at line 141 of file SkDevice.cpp.

                                                                      {
    SkPath path;
    path.addRRect(outer);
    path.addRRect(inner);
    path.setFillType(SkPathFillType::kEvenOdd);
    path.setIsVolatile(true);
 
    this->drawPath(path, paint, true);
}

◆ drawEdgeAAImageSet()

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

virtual

Reimplemented in skgpu::ganesh::Device, and skgpu::graphite::Device.

Definition at line 253 of file SkDevice.cpp.

                                                                        {
    SkASSERT(paint.getStyle() == SkPaint::kFill_Style);
    SkASSERT(!paint.getPathEffect());
 
    SkPaint entryPaint = paint;
    const SkM44 baseLocalToDevice = this->localToDevice44();
    int clipIndex = 0;
    for (int i = 0; i < count; ++i) {
        // TODO: Handle per-edge AA. Right now this mirrors the SkiaRenderer component of Chrome
        // which turns off antialiasing unless all four edges should be antialiased. This avoids
        // seaming in tiled composited layers.
        entryPaint.setAntiAlias(images[i].fAAFlags == SkCanvas::kAll_QuadAAFlags);
        entryPaint.setAlphaf(paint.getAlphaf() * images[i].fAlpha);
 
        SkASSERT(images[i].fMatrixIndex < 0 || preViewMatrices);
        if (images[i].fMatrixIndex >= 0) {
            this->setLocalToDevice(baseLocalToDevice *
                                   SkM44(preViewMatrices[images[i].fMatrixIndex]));
        }
 
        SkASSERT(!images[i].fHasClip || dstClips);
        if (images[i].fHasClip) {
            // Since drawImageRect requires a srcRect, the dst clip is implemented as a true clip
            this->pushClipStack();
            SkPath clipPath;
            clipPath.addPoly(dstClips + clipIndex, 4, true);
            this->clipPath(clipPath, SkClipOp::kIntersect, entryPaint.isAntiAlias());
            clipIndex += 4;
        }
        this->drawImageRect(images[i].fImage.get(), &images[i].fSrcRect, images[i].fDstRect,
                            sampling, entryPaint, constraint);
        if (images[i].fHasClip) {
            this->popClipStack();
        }
        if (images[i].fMatrixIndex >= 0) {
            this->setLocalToDevice(baseLocalToDevice);
        }
    }
}

◆ drawEdgeAAQuad()

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

virtual

Reimplemented in skgpu::ganesh::Device, and skgpu::graphite::Device.

Definition at line 236 of file SkDevice.cpp.

                                                                        {
    SkPaint paint;
    paint.setColor4f(color);
    paint.setBlendMode(mode);
    paint.setAntiAlias(aa == SkCanvas::kAll_QuadAAFlags);
 
    if (clip) {
        // Draw the clip directly as a quad since it's a filled color with no local coords
        SkPath clipPath;
        clipPath.addPoly(clip, 4, true);
        this->drawPath(clipPath, paint);
    } else {
        this->drawRect(r, paint);
    }
}

◆ drawFilteredImage()

void SkDevice::drawFilteredImage	(	const skif::Mapping &	mapping,
		SkSpecialImage *	src,
		SkColorType	ct,
		const SkImageFilter *	filter,
		const SkSamplingOptions &	sampling,
		const SkPaint &	paint
	)

Evaluate 'filter' and draw the final output into this device using 'paint'. The 'mapping' defines the parameter-to-layer space transform used to evaluate the image filter on 'src', and the layer-to-device space transform that is used to draw the result into this device. Since 'mapping' fully specifies the transform, this draw function ignores the current local-to-device matrix (i.e. just like drawSpecial and drawDevice).

The final paint must not have an image filter or mask filter set on it; a shader is ignored. The provided color type will be used for any intermediate surfaces that need to be created as part of filter evaluation. It does not have to be src's color type or this Device's type.

Definition at line 347 of file SkDevice.cpp.

                                                       {
    SkASSERT(!paint.getImageFilter() && !paint.getMaskFilter());
 
    skif::LayerSpace<SkIRect> targetOutput = mapping.deviceToLayer(
            skif::DeviceSpace<SkIRect>(this->devClipBounds()));
 
    if (colorType == kUnknown_SkColorType) {
        colorType = kRGBA_8888_SkColorType;
    }
 
    skif::Stats stats;
    skif::Context ctx{this->createImageFilteringBackend(src ? src->props() : this->surfaceProps(),
                                                        colorType),
                      mapping,
                      targetOutput,
                      skif::FilterResult(sk_ref_sp(src)),
                      this->imageInfo().colorSpace(),
                      &stats};
 
    SkIPoint offset;
    sk_sp<SkSpecialImage> result = as_IFB(filter)->filterImage(ctx).imageAndOffset(ctx, &offset);
    stats.reportStats();
    if (result) {
        SkMatrix deviceMatrixWithOffset = mapping.layerToDevice();
        deviceMatrixWithOffset.preTranslate(offset.fX, offset.fY);
        this->drawSpecial(result.get(), deviceMatrixWithOffset, sampling, paint);
    }
}

◆ drawGlyphRunList()

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

Definition at line 426 of file SkDevice.cpp.

                                                      {
    if (!this->localToDevice().isFinite()) {
        return;
    }
 
    if (!glyphRunList.hasRSXForm()) {
        this->onDrawGlyphRunList(canvas, glyphRunList, paint);
    } else {
        this->simplifyGlyphRunRSXFormAndRedraw(canvas, glyphRunList, paint);
    }
}

◆ drawImageLattice()

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

virtual

Reimplemented in skgpu::ganesh::Device, and skgpu::graphite::Device.

Definition at line 163 of file SkDevice.cpp.

                                                                                              {
    SkLatticeIter iter(lattice, dst);
 
    SkRect srcR, dstR;
    SkColor c;
    bool isFixedColor = false;
    const SkImageInfo info = SkImageInfo::Make(1, 1, kBGRA_8888_SkColorType, kUnpremul_SkAlphaType);
 
    while (iter.next(&srcR, &dstR, &isFixedColor, &c)) {
        // TODO: support this fast-path for GPU images
        if (isFixedColor || (srcR.width() <= 1.0f && srcR.height() <= 1.0f &&
                             image->readPixels(nullptr, info, &c, 4, srcR.fLeft, srcR.fTop))) {
              // Fast draw with drawRect, if this is a patch containing a single color
              // or if this is a patch containing a single pixel.
              if (0 != c || !paint.isSrcOver()) {
                   SkPaint paintCopy(paint);
                   int alpha = SkAlphaMul(SkColorGetA(c), SkAlpha255To256(paint.getAlpha()));
                   paintCopy.setColor(SkColorSetA(c, alpha));
                   this->drawRect(dstR, paintCopy);
              }
        } else {
            this->drawImageRect(image, &srcR, dstR, SkSamplingOptions(filter), paint,
                                SkCanvas::kStrict_SrcRectConstraint);
        }
    }
}

◆ drawImageRect()

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

pure virtual

Implemented in SkNoPixelsDevice, SkBitmapDevice, skgpu::ganesh::Device, skgpu::graphite::Device, SkPDFDevice, and SkSVGDevice.

◆ drawMesh()

virtual void SkDevice::drawMesh	(	const SkMesh &	mesh,
		sk_sp< SkBlender >	,
		const SkPaint &
	)

pure virtual

Implemented in SkBitmapDevice, SkNoPixelsDevice, skgpu::ganesh::Device, skgpu::graphite::Device, SkPDFDevice, and SkSVGDevice.

◆ drawOval()

virtual void SkDevice::drawOval	(	const SkRect &	oval,
		const SkPaint &	paint
	)

pure virtual

Implemented in SkNoPixelsDevice, SkBitmapDevice, skgpu::ganesh::Device, skgpu::graphite::Device, SkPDFDevice, and SkSVGDevice.

◆ drawPaint()

virtual void SkDevice::drawPaint ( const SkPaint & paint )

pure virtual

Implemented in SkBitmapDevice, SkNoPixelsDevice, skgpu::ganesh::Device, skgpu::graphite::Device, SkPDFDevice, and SkSVGDevice.

◆ drawPatch()

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

virtual

Definition at line 152 of file SkDevice.cpp.

                                               {
    SkISize lod = SkPatchUtils::GetLevelOfDetail(cubics, &this->localToDevice());
    auto vertices = SkPatchUtils::MakeVertices(cubics, colors, texCoords, lod.width(), lod.height(),
                                               this->imageInfo().colorSpace());
    if (vertices) {
        this->drawVertices(vertices.get(), std::move(blender), paint);
    }
}

◆ drawPath()

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

pure virtual

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.

Implemented in SkBitmapDevice, SkNoPixelsDevice, SkPDFDevice, skgpu::ganesh::Device, skgpu::graphite::Device, and SkSVGDevice.

◆ drawPoints()

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

pure virtual

Implemented in SkBitmapDevice, skgpu::ganesh::Device, skgpu::graphite::Device, SkPDFDevice, SkSVGDevice, and SkNoPixelsDevice.

◆ drawRect()

virtual void SkDevice::drawRect	(	const SkRect &	r,
		const SkPaint &	paint
	)

pure virtual

Implemented in SkNoPixelsDevice, SkBitmapDevice, skgpu::ganesh::Device, skgpu::graphite::Device, SkPDFDevice, and SkSVGDevice.

◆ drawRegion()

void SkDevice::drawRegion	(	const SkRegion &	r,
		const SkPaint &	paint
	)

virtual

Reimplemented in skgpu::ganesh::Device.

Definition at line 113 of file SkDevice.cpp.

                                                                      {
    const SkMatrix& localToDevice = this->localToDevice();
    bool isNonTranslate = localToDevice.getType() & ~(SkMatrix::kTranslate_Mask);
    bool complexPaint = paint.getStyle() != SkPaint::kFill_Style || paint.getMaskFilter() ||
                        paint.getPathEffect();
    bool antiAlias = paint.isAntiAlias() && (!is_int(localToDevice.getTranslateX()) ||
                                             !is_int(localToDevice.getTranslateY()));
    if (isNonTranslate || complexPaint || antiAlias) {
        SkPath path;
        region.getBoundaryPath(&path);
        path.setIsVolatile(true);
        return this->drawPath(path, paint, true);
    }
 
    SkRegion::Iterator it(region);
    while (!it.done()) {
        this->drawRect(SkRect::Make(it.rect()), paint);
        it.next();
    }
}

◆ drawRRect()

virtual void SkDevice::drawRRect	(	const SkRRect &	rr,
		const SkPaint &	paint
	)

pure virtual

Implemented in SkNoPixelsDevice, skgpu::ganesh::Device, SkBitmapDevice, skgpu::graphite::Device, SkPDFDevice, and SkSVGDevice.

◆ drawShadow()

void SkDevice::drawShadow	(	const SkPath &	path,
		const SkDrawShadowRec &	rec
	)

virtual

Reimplemented in skgpu::ganesh::Device, and skgpu::graphite::Device.

Definition at line 593 of file SkShadowUtils.cpp.

                                                                        {
    if (!validate_rec(rec)) {
        return;
    }
 
    SkMatrix viewMatrix = this->localToDevice();
    SkAutoDeviceTransformRestore adr(this, SkMatrix::I());
 
#if !defined(SK_ENABLE_OPTIMIZE_SIZE)
    auto drawVertsProc = [this](const SkVertices* vertices, SkBlendMode mode, const SkPaint& paint,
                                SkScalar tx, SkScalar ty, bool hasPerspective) {
        if (vertices->priv().vertexCount()) {
            // For perspective shadows we've already computed the shadow in world space,
            // and we can't translate it without changing it. Otherwise we concat the
            // change in translation from the cached version.
            SkAutoDeviceTransformRestore adr(
                    this,
                    hasPerspective ? SkMatrix::I()
                                   : this->localToDevice() * SkMatrix::Translate(tx, ty));
            // The vertex colors for a tesselated shadow polygon are always either opaque black
            // or transparent and their real contribution to the final blended color is via
            // their alpha. We can skip expensive per-vertex color conversion for this.
            this->drawVertices(vertices, SkBlender::Mode(mode), paint, /*skipColorXform=*/true);
        }
    };
 
    ShadowedPath shadowedPath(&path, &viewMatrix);
 
    bool tiltZPlane = tilted(rec.fZPlaneParams);
    bool transparent = SkToBool(rec.fFlags & SkShadowFlags::kTransparentOccluder_ShadowFlag);
    bool useBlur = SkToBool(rec.fFlags & SkShadowFlags::kConcaveBlurOnly_ShadowFlag) &&
                   !path.isConvex();
    bool uncached = tiltZPlane || path.isVolatile();
#endif
    bool directional = SkToBool(rec.fFlags & SkShadowFlags::kDirectionalLight_ShadowFlag);
 
    SkPoint3 zPlaneParams = rec.fZPlaneParams;
    SkPoint3 devLightPos = rec.fLightPos;
    if (!directional) {
        viewMatrix.mapPoints((SkPoint*)&devLightPos.fX, 1);
    }
    float lightRadius = rec.fLightRadius;
 
    if (SkColorGetA(rec.fAmbientColor) > 0) {
        bool success = false;
#if !defined(SK_ENABLE_OPTIMIZE_SIZE)
        if (uncached && !useBlur) {
            sk_sp<SkVertices> vertices = SkShadowTessellator::MakeAmbient(path, viewMatrix,
                                                                          zPlaneParams,
                                                                          transparent);
            if (vertices) {
                SkPaint paint;
                // Run the vertex color through a GaussianColorFilter and then modulate the
                // grayscale result of that against our 'color' param.
                paint.setColorFilter(
                    SkColorFilters::Blend(rec.fAmbientColor,
                                                  SkBlendMode::kModulate)->makeComposed(
                                                               SkColorFilterPriv::MakeGaussian()));
                // The vertex colors for a tesselated shadow polygon are always either opaque black
                // or transparent and their real contribution to the final blended color is via
                // their alpha. We can skip expensive per-vertex color conversion for this.
                this->drawVertices(vertices.get(),
                                   SkBlender::Mode(SkBlendMode::kModulate),
                                   paint,
                                   /*skipColorXform=*/true);
                success = true;
            }
        }
 
        if (!success && !useBlur) {
            AmbientVerticesFactory factory;
            factory.fOccluderHeight = zPlaneParams.fZ;
            factory.fTransparent = transparent;
            if (viewMatrix.hasPerspective()) {
                factory.fOffset.set(0, 0);
            } else {
                factory.fOffset.fX = viewMatrix.getTranslateX();
                factory.fOffset.fY = viewMatrix.getTranslateY();
            }
 
            success = draw_shadow(factory, drawVertsProc, shadowedPath, rec.fAmbientColor);
        }
#endif // !defined(SK_ENABLE_OPTIMIZE_SIZE)
 
        // All else has failed, draw with blur
        if (!success) {
            // Pretransform the path to avoid transforming the stroke, below.
            SkPath devSpacePath;
            path.transform(viewMatrix, &devSpacePath);
            devSpacePath.setIsVolatile(true);
 
            // The tesselator outsets by AmbientBlurRadius (or 'r') to get the outer ring of
            // the tesselation, and sets the alpha on the path to 1/AmbientRecipAlpha (or 'a').
            //
            // We want to emulate this with a blur. The full blur width (2*blurRadius or 'f')
            // can be calculated by interpolating:
            //
            //            original edge        outer edge
            //         |       |<---------- r ------>|
            //         |<------|--- f -------------->|
            //         |       |                     |
            //    alpha = 1  alpha = a          alpha = 0
            //
            // Taking ratios, f/1 = r/a, so f = r/a and blurRadius = f/2.
            //
            // We now need to outset the path to place the new edge in the center of the
            // blur region:
            //
            //             original   new
            //         |       |<------|--- r ------>|
            //         |<------|--- f -|------------>|
            //         |       |<- o ->|<--- f/2 --->|
            //
            //     r = o + f/2, so o = r - f/2
            //
            // We outset by using the stroker, so the strokeWidth is o/2.
            //
            SkScalar devSpaceOutset = SkDrawShadowMetrics::AmbientBlurRadius(zPlaneParams.fZ);
            SkScalar oneOverA = SkDrawShadowMetrics::AmbientRecipAlpha(zPlaneParams.fZ);
            SkScalar blurRadius = 0.5f*devSpaceOutset*oneOverA;
            SkScalar strokeWidth = 0.5f*(devSpaceOutset - blurRadius);
 
            // Now draw with blur
            SkPaint paint;
            paint.setColor(rec.fAmbientColor);
            paint.setStrokeWidth(strokeWidth);
            paint.setStyle(SkPaint::kStrokeAndFill_Style);
            SkScalar sigma = SkBlurMask::ConvertRadiusToSigma(blurRadius);
            bool respectCTM = false;
            paint.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, sigma, respectCTM));
            this->drawPath(devSpacePath, paint);
        }
    }
 
    if (SkColorGetA(rec.fSpotColor) > 0) {
        bool success = false;
#if !defined(SK_ENABLE_OPTIMIZE_SIZE)
        if (uncached && !useBlur) {
            sk_sp<SkVertices> vertices = SkShadowTessellator::MakeSpot(path, viewMatrix,
                                                                       zPlaneParams,
                                                                       devLightPos, lightRadius,
                                                                       transparent,
                                                                       directional);
            if (vertices) {
                SkPaint paint;
                // Run the vertex color through a GaussianColorFilter and then modulate the
                // grayscale result of that against our 'color' param.
                paint.setColorFilter(
                    SkColorFilters::Blend(rec.fSpotColor,
                                                  SkBlendMode::kModulate)->makeComposed(
                                                      SkColorFilterPriv::MakeGaussian()));
                // The vertex colors for a tesselated shadow polygon are always either opaque black
                // or transparent and their real contribution to the final blended color is via
                // their alpha. We can skip expensive per-vertex color conversion for this.
                this->drawVertices(vertices.get(),
                                   SkBlender::Mode(SkBlendMode::kModulate),
                                   paint,
                                   /*skipColorXform=*/true);
                success = true;
            }
        }
 
        if (!success && !useBlur) {
            SpotVerticesFactory factory;
            factory.fOccluderHeight = zPlaneParams.fZ;
            factory.fDevLightPos = devLightPos;
            factory.fLightRadius = lightRadius;
 
            SkPoint center = SkPoint::Make(path.getBounds().centerX(), path.getBounds().centerY());
            factory.fLocalCenter = center;
            viewMatrix.mapPoints(&center, 1);
            SkScalar radius, scale;
            if (SkToBool(rec.fFlags & kDirectionalLight_ShadowFlag)) {
                SkDrawShadowMetrics::GetDirectionalParams(zPlaneParams.fZ, devLightPos.fX,
                                                          devLightPos.fY, devLightPos.fZ,
                                                          lightRadius, &radius, &scale,
                                                          &factory.fOffset);
            } else {
                SkDrawShadowMetrics::GetSpotParams(zPlaneParams.fZ, devLightPos.fX - center.fX,
                                                   devLightPos.fY - center.fY, devLightPos.fZ,
                                                   lightRadius, &radius, &scale, &factory.fOffset);
            }
 
            SkRect devBounds;
            viewMatrix.mapRect(&devBounds, path.getBounds());
            if (transparent ||
                SkTAbs(factory.fOffset.fX) > 0.5f*devBounds.width() ||
                SkTAbs(factory.fOffset.fY) > 0.5f*devBounds.height()) {
                // if the translation of the shadow is big enough we're going to end up
                // filling the entire umbra, we can treat these as all the same
                if (directional) {
                    factory.fOccluderType =
                            SpotVerticesFactory::OccluderType::kDirectionalTransparent;
                } else {
                    factory.fOccluderType = SpotVerticesFactory::OccluderType::kPointTransparent;
                }
            } else if (directional) {
                factory.fOccluderType = SpotVerticesFactory::OccluderType::kDirectional;
            } else if (factory.fOffset.length()*scale + scale < radius) {
                // if we don't translate more than the blur distance, can assume umbra is covered
                factory.fOccluderType = SpotVerticesFactory::OccluderType::kPointOpaqueNoUmbra;
            } else if (path.isConvex()) {
                factory.fOccluderType = SpotVerticesFactory::OccluderType::kPointOpaquePartialUmbra;
            } else {
                factory.fOccluderType = SpotVerticesFactory::OccluderType::kPointTransparent;
            }
            // need to add this after we classify the shadow
            factory.fOffset.fX += viewMatrix.getTranslateX();
            factory.fOffset.fY += viewMatrix.getTranslateY();
 
            SkColor color = rec.fSpotColor;
#ifdef DEBUG_SHADOW_CHECKS
            switch (factory.fOccluderType) {
                case SpotVerticesFactory::OccluderType::kPointTransparent:
                    color = 0xFFD2B48C;  // tan for transparent
                    break;
                case SpotVerticesFactory::OccluderType::kPointOpaquePartialUmbra:
                    color = 0xFFFFA500;   // orange for opaque
                    break;
                case SpotVerticesFactory::OccluderType::kPointOpaqueNoUmbra:
                    color = 0xFFE5E500;  // corn yellow for covered
                    break;
                case SpotVerticesFactory::OccluderType::kDirectional:
                case SpotVerticesFactory::OccluderType::kDirectionalTransparent:
                    color = 0xFF550000;  // dark red for directional
                    break;
            }
#endif
            success = draw_shadow(factory, drawVertsProc, shadowedPath, color);
        }
#endif // !defined(SK_ENABLE_OPTIMIZE_SIZE)
 
        // All else has failed, draw with blur
        if (!success) {
            SkMatrix shadowMatrix;
            SkScalar radius;
            if (!SkDrawShadowMetrics::GetSpotShadowTransform(devLightPos, lightRadius,
                                                             viewMatrix, zPlaneParams,
                                                             path.getBounds(), directional,
                                                             &shadowMatrix, &radius)) {
                return;
            }
            SkAutoDeviceTransformRestore adr2(this, shadowMatrix);
 
            SkPaint paint;
            paint.setColor(rec.fSpotColor);
            SkScalar sigma = SkBlurMask::ConvertRadiusToSigma(radius);
            bool respectCTM = false;
            paint.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, sigma, respectCTM));
            this->drawPath(path, paint);
        }
    }
}

◆ drawSlug()

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

virtual

Reimplemented in SkNoPixelsDevice, and skgpu::ganesh::Device.

Definition at line 488 of file SkDevice.cpp.

                                                                       {
    SK_ABORT("Slug drawing not supported.");
}

◆ drawSpecial()

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

virtual

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 in SkBitmapDevice, SkPDFDevice, skgpu::ganesh::Device, and skgpu::graphite::Device.

Definition at line 304 of file SkDevice.cpp.

305 {}

◆ drawVertices()

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

pure virtual

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

Implemented in SkBitmapDevice, SkNoPixelsDevice, skgpu::ganesh::Device, skgpu::graphite::Device, SkPDFDevice, and SkSVGDevice.

◆ getGlobalBounds() [1/2]

SkIRect SkDevice::getGlobalBounds ( ) const

inline

Definition at line 230 of file SkDevice.h.

                                    {
        SkIRect bounds;
        this->getGlobalBounds(&bounds);
        return bounds;
    }

◆ getGlobalBounds() [2/2]

void SkDevice::getGlobalBounds ( SkIRect * bounds ) const

inline

Return the bounds of the device in the coordinate space of the root canvas. The root device will have its top-left at 0,0, but other devices such as those associated with saveLayer may have a non-zero origin.

Definition at line 225 of file SkDevice.h.

                                                {
        SkASSERT(bounds);
        *bounds = SkMatrixPriv::MapRect(fDeviceToGlobal, SkRect::Make(this->bounds())).roundOut();
    }

◆ getOrigin()

SkIPoint SkDevice::getOrigin ( ) const

DEPRECATED: This asserts that 'getDeviceToGlobal' is a translation matrix with integer components. In the future some SkDevices will have more complex device-to-global transforms, so getDeviceToGlobal() or getRelativeTransform() should be used instead.

Definition at line 91 of file SkDevice.cpp.

                                   {
    // getOrigin() is deprecated, the old origin has been moved into the fDeviceToGlobal matrix.
    // This extracts the origin from the matrix, but asserts that a more complicated coordinate
    // space hasn't been set of the device. This function can be removed once existing use cases
    // have been updated to use the device-to-global matrix instead or have themselves been removed
    // (e.g. Android's device-space clip regions are going away, and are not compatible with the
    // generalized device coordinate system).
    SkASSERT(this->isPixelAlignedToGlobal());
    return SkIPoint::Make(SkScalarFloorToInt(fDeviceToGlobal.rc(0, 3)),
                          SkScalarFloorToInt(fDeviceToGlobal.rc(1, 3)));
}

◆ getRasterHandle()

virtual void * SkDevice::getRasterHandle ( ) const

inlinevirtual

Reimplemented in SkBitmapDevice.

Definition at line 282 of file SkDevice.h.

282{ return nullptr; }

◆ getRelativeTransform()

SkMatrix SkDevice::getRelativeTransform ( const SkDevice & dstDevice ) const

Get the transformation from this device's coordinate system to the provided device space. This transform can be used to draw this device into the provided device, such that once that device is drawn to the root device, the net effect will be that this device's contents have been transformed by the global CTM.

Definition at line 103 of file SkDevice.cpp.

                                                                       {
    // To get the transform from this space to the other device's, transform from our space to
    // global and then from global to the other device.
    return (dstDevice.fGlobalToDevice * fDeviceToGlobal).asM33();
}

◆ globalToDevice()

const SkM44 & SkDevice::globalToDevice ( ) const

inline

Return the inverse of getDeviceToGlobal(), mapping from the global canvas' space (or root device space) into this device's coordinate space.

Definition at line 191 of file SkDevice.h.

191{ return fGlobalToDevice; }

◆ height()

int SkDevice::height ( ) const

inline

Definition at line 120 of file SkDevice.h.

120{ return this->imageInfo().height(); }

SkImageInfo::height

int height() const

Definition: SkImageInfo.h:371

◆ imageInfo()

const SkImageInfo & SkDevice::imageInfo ( ) const

inline

Return ImageInfo for this device. If the canvas is not backed by pixels (cpu or gpu), then the info's ColorType will be kUnknown_SkColorType.

Definition at line 117 of file SkDevice.h.

117{ return fInfo; }

◆ isClipAntiAliased()

virtual bool SkDevice::isClipAntiAliased ( ) const

pure virtual

Implemented in SkBitmapDevice, SkClipStackDevice, SkNoPixelsDevice, skgpu::ganesh::Device, and skgpu::graphite::Device.

◆ isClipEmpty()

virtual bool SkDevice::isClipEmpty ( ) const

pure virtual

Implemented in SkBitmapDevice, SkClipStackDevice, SkNoPixelsDevice, skgpu::ganesh::Device, and skgpu::graphite::Device.

◆ isClipRect()

virtual bool SkDevice::isClipRect ( ) const

pure virtual

Implemented in SkBitmapDevice, SkClipStackDevice, SkNoPixelsDevice, skgpu::ganesh::Device, and skgpu::graphite::Device.

◆ isClipWideOpen()

virtual bool SkDevice::isClipWideOpen ( ) const

pure virtual

Implemented in SkBitmapDevice, SkClipStackDevice, SkNoPixelsDevice, skgpu::ganesh::Device, and skgpu::graphite::Device.

◆ isNoPixelsDevice()

virtual bool SkDevice::isNoPixelsDevice ( ) const

inlinevirtual

Reimplemented in SkNoPixelsDevice.

Definition at line 280 of file SkDevice.h.

280{ return false; }

◆ isOpaque()

bool SkDevice::isOpaque ( ) const

inline

Definition at line 122 of file SkDevice.h.

122{ return this->imageInfo().isOpaque(); }

SkImageInfo::isOpaque

bool isOpaque() const

Definition: SkImageInfo.h:415

◆ isPixelAlignedToGlobal()

bool SkDevice::isPixelAlignedToGlobal ( ) const

Returns true when this device's pixel grid is axis aligned with the global coordinate space, and any relative translation between the two spaces is in integer pixel units.

Definition at line 82 of file SkDevice.cpp.

                                            {
    // pixelAligned is set to the identity + integer translation of the device-to-global matrix.
    // If they are equal then the device is by definition pixel aligned.
    SkM44 pixelAligned = SkM44();
    pixelAligned.setRC(0, 3, SkScalarFloorToScalar(fDeviceToGlobal.rc(0, 3)));
    pixelAligned.setRC(1, 3, SkScalarFloorToScalar(fDeviceToGlobal.rc(1, 3)));
    return pixelAligned == fDeviceToGlobal;
}

◆ localToDevice()

const SkMatrix & SkDevice::localToDevice ( ) const

inline

Definition at line 179 of file SkDevice.h.

179{ return fLocalToDevice33; }

◆ localToDevice44()

const SkM44 & SkDevice::localToDevice44 ( ) const

inline

Returns the transformation that maps from the local space to the device's coordinate space.

Definition at line 178 of file SkDevice.h.

178{ return fLocalToDevice; }

◆ makeSpecial() [1/2]

sk_sp< SkSpecialImage > SkDevice::makeSpecial ( const SkBitmap & )

protectedvirtual

Reimplemented in SkBitmapDevice, skgpu::ganesh::Device, and SkPDFDevice.

Definition at line 313 of file SkDevice.cpp.

313{ return nullptr; }

◆ makeSpecial() [2/2]

sk_sp< SkSpecialImage > SkDevice::makeSpecial ( const SkImage * )

protectedvirtual

Reimplemented in SkBitmapDevice, skgpu::ganesh::Device, and SkPDFDevice.

Definition at line 314 of file SkDevice.cpp.

314{ return nullptr; }

◆ makeSurface()

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

virtual

Reimplemented in SkBitmapDevice, skgpu::ganesh::Device, skgpu::graphite::Device, and SkPDFDevice.

Definition at line 494 of file SkDevice.cpp.

                                                                                {
    return nullptr;
}

◆ onAccessPixels()

virtual bool SkDevice::onAccessPixels ( SkPixmap * )

inlineprivatevirtual

Definition at line 533 of file SkDevice.h.

533{ return false; }

◆ onClipShader()

virtual void SkDevice::onClipShader ( sk_sp< SkShader > )

privatepure virtual

◆ onDrawGlyphRunList()

virtual void SkDevice::onDrawGlyphRunList	(	SkCanvas *	,
		const sktext::GlyphRunList &	,
		const SkPaint &	paint
	)

privatepure virtual

Implemented in SkNoPixelsDevice, and GlyphTrackingDevice.

◆ onPeekPixels()

virtual bool SkDevice::onPeekPixels ( SkPixmap * )

inlineprivatevirtual

Definition at line 535 of file SkDevice.h.

535{ return false; }

◆ onReadPixels()

virtual bool SkDevice::onReadPixels	(	const SkPixmap &	,
		int	x,
		int	y
	)

inlineprivatevirtual

Definition at line 528 of file SkDevice.h.

528{ return false; }

◆ onWritePixels()

virtual bool SkDevice::onWritePixels	(	const SkPixmap &	,
		int	x,
		int	y
	)

inlineprivatevirtual

Definition at line 531 of file SkDevice.h.

531{ return false; }

◆ peekPixels()

bool SkDevice::peekPixels ( SkPixmap * pmap )

Try to get read-only-access to the pixels behind the device. If successful, this returns true and fills-out the pixmap parameter.

On failure, returns false and ignores the pixmap parameter.

Definition at line 391 of file SkDevice.cpp.

                                        {
    SkPixmap tempStorage;
    if (nullptr == pmap) {
        pmap = &tempStorage;
    }
    return this->onPeekPixels(pmap);
}

◆ popClipStack()

virtual void SkDevice::popClipStack ( )

pure virtual

Implemented in SkBitmapDevice, SkClipStackDevice, SkNoPixelsDevice, skgpu::ganesh::Device, and skgpu::graphite::Device.

◆ pushClipStack()

virtual void SkDevice::pushClipStack ( )

pure virtual

Implemented in SkBitmapDevice, SkClipStackDevice, SkNoPixelsDevice, skgpu::ganesh::Device, and skgpu::graphite::Device.

◆ readPixels()

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

inline

Read pixels from this Device at the specified x,y offset into dst. The caller is responsible for "pre-clipping" the dst

Definition at line 153 of file SkDevice.h.

153{ return this->onReadPixels(dst, x, y); }

SkDevice::onReadPixels

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

Definition: SkDevice.h:528

y

double y

Definition: mouse-input-test.cc:83

x

double x

Definition: mouse-input-test.cc:82

◆ recorder()

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

inlinevirtual

Reimplemented in skgpu::graphite::Device.

Definition at line 285 of file SkDevice.h.

285{ return nullptr; }

◆ recordingContext()

virtual GrRecordingContext * SkDevice::recordingContext ( ) const

inlinevirtual

Reimplemented in skgpu::ganesh::Device.

Definition at line 284 of file SkDevice.h.

284{ return nullptr; }

◆ replaceClip()

virtual void SkDevice::replaceClip ( const SkIRect & rect )

pure virtual

Implemented in SkBitmapDevice, SkClipStackDevice, SkNoPixelsDevice, skgpu::ganesh::Device, and skgpu::graphite::Device.

◆ scalerContextFlags()

SkScalerContextFlags SkDevice::scalerContextFlags ( ) const

Definition at line 498 of file SkDevice.cpp.

                                                        {
    // If we're doing linear blending, then we can disable the gamma hacks.
    // Otherwise, leave them on. In either case, we still want the contrast boost:
    // TODO: Can we be even smarter about mask gamma based on the dest transfer function?
    const SkColorSpace* const cs = fInfo.colorSpace();
    if (cs && cs->gammaIsLinear()) {
        return SkScalerContextFlags::kBoostContrast;
    } else {
        return SkScalerContextFlags::kFakeGammaAndBoostContrast;
    }
}

◆ setDeviceCoordinateSystem()

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

protected

Definition at line 52 of file SkDevice.cpp.

                                                            {
    fDeviceToGlobal = deviceToGlobal;
    fDeviceToGlobal.normalizePerspective();
    fGlobalToDevice = globalToDevice;
    fGlobalToDevice.normalizePerspective();
 
    fLocalToDevice = localToDevice;
    fLocalToDevice.normalizePerspective();
    if (bufferOriginX | bufferOriginY) {
        fDeviceToGlobal.preTranslate(bufferOriginX, bufferOriginY);
        fGlobalToDevice.postTranslate(-bufferOriginX, -bufferOriginY);
        fLocalToDevice.postTranslate(-bufferOriginX, -bufferOriginY);
    }
    fLocalToDevice33 = fLocalToDevice.asM33();
    fLocalToDeviceDirty = true;
}

◆ setGlobalCTM()

void SkDevice::setGlobalCTM ( const SkM44 & ctm )

Definition at line 73 of file SkDevice.cpp.

                                            {
    fLocalToDevice = ctm;
    fLocalToDevice.normalizePerspective();
    // Map from the global CTM state to this device's coordinate system.
    fLocalToDevice.postConcat(fGlobalToDevice);
    fLocalToDevice33 = fLocalToDevice.asM33();
    fLocalToDeviceDirty = true;
}

◆ setImmutable()

virtual void SkDevice::setImmutable ( )

inlinevirtual

Reimplemented in SkBitmapDevice, and skgpu::graphite::Device.

Definition at line 293 of file SkDevice.h.

293{}

◆ setLocalToDevice()

void SkDevice::setLocalToDevice ( const SkM44 & localToDevice )

inline

Definition at line 211 of file SkDevice.h.

                                                      {
        fLocalToDevice = localToDevice;
        fLocalToDevice33 = fLocalToDevice.asM33();
        fLocalToDeviceDirty = true;
    }

◆ setOrigin()

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

inlineprotected

Definition at line 508 of file SkDevice.h.

                                                         {
        this->setDeviceCoordinateSystem(SkM44(), SkM44(), globalCTM, x, y);
    }

◆ shouldDrawAsTiledImageRect()

virtual bool SkDevice::shouldDrawAsTiledImageRect ( ) const

inlinevirtual

Reimplemented in skgpu::ganesh::Device.

Definition at line 368 of file SkDevice.h.

368{ return false; }

◆ size()

SkISize SkDevice::size ( ) const

inline

Definition at line 126 of file SkDevice.h.

126{ return this->imageInfo().dimensions(); }

SkImageInfo::dimensions

SkISize dimensions() const

Definition: SkImageInfo.h:421

◆ snapSpecial() [1/2]

sk_sp< SkSpecialImage > SkDevice::snapSpecial ( )

Definition at line 320 of file SkDevice.cpp.

                                            {
    return this->snapSpecial(SkIRect::MakeWH(this->width(), this->height()));
}

◆ snapSpecial() [2/2]

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

virtual

Reimplemented in SkBitmapDevice, skgpu::ganesh::Device, and skgpu::graphite::Device.

Definition at line 315 of file SkDevice.cpp.

315{ return nullptr; }

◆ snapSpecialScaled()

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

virtual

Reimplemented in skgpu::ganesh::Device.

Definition at line 316 of file SkDevice.cpp.

                                                                          {
    return nullptr;
}

◆ strikeDeviceInfo()

virtual SkStrikeDeviceInfo SkDevice::strikeDeviceInfo ( ) const

inlinevirtual

Reimplemented in skgpu::ganesh::Device, skgpu::graphite::Device, and GlyphTrackingDevice.

Definition at line 137 of file SkDevice.h.

                                                        {
        return {fSurfaceProps, this->scalerContextFlags(), nullptr};
    }

◆ surfaceProps()

const SkSurfaceProps & SkDevice::surfaceProps ( ) const

inline

Return SurfaceProps for this device.

Definition at line 131 of file SkDevice.h.

                                               {
        return fSurfaceProps;
    }

◆ useDrawCoverageMaskForMaskFilters()

virtual bool SkDevice::useDrawCoverageMaskForMaskFilters ( ) const

inlinevirtual

Reimplemented in skgpu::graphite::Device.

Definition at line 276 of file SkDevice.h.

276{ return false; }

◆ width()

int SkDevice::width ( ) const

inline

Definition at line 119 of file SkDevice.h.

119{ return this->imageInfo().width(); }

SkImageInfo::width

int width() const

Definition: SkImageInfo.h:365

◆ writePixels()

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

inline

Write the pixels in 'src' into this Device at the specified x,y offset. The caller is responsible for "pre-clipping" the src.

Definition at line 147 of file SkDevice.h.

147{ return this->onWritePixels(src, x, y); }

SkDevice::onWritePixels

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

Definition: SkDevice.h:531

Friends And Related Function Documentation

◆ DeviceTestingAccess

friend class DeviceTestingAccess

friend

Definition at line 521 of file SkDevice.h.

◆ SkCanvas

friend class SkCanvas

friend

Definition at line 520 of file SkDevice.h.

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

third_party/skia/src/core/SkDevice.h
third_party/skia/src/core/SkDevice.cpp
third_party/skia/src/utils/SkShadowUtils.cpp

Classes

Public Member Functions

Protected Member Functions

Private Member Functions

Friends

Detailed Description

Constructor & Destructor Documentation

◆ SkDevice()

Member Function Documentation

◆ accessPixels()

◆ android_utils_clipAsRgn()

◆ android_utils_clipWithStencil()

◆ asGaneshDevice()

◆ asGraphiteDevice()

◆ bounds()

◆ checkLocalToDeviceDirty()

◆ clipPath()

◆ clipRect()

◆ clipRegion()

◆ clipRRect()

◆ clipShader()

◆ convertGlyphRunListToSlug()

◆ createDevice()

◆ createImageFilteringBackend()

◆ devClipBounds()

◆ deviceToGlobal()

◆ drawAnnotation()

◆ drawArc()

◆ drawAsTiledImageRect()

◆ drawAtlas()

◆ drawBlurredRRect()

◆ drawCoverageMask()

◆ drawDevice()

◆ drawDrawable()

◆ drawDRRect()

◆ drawEdgeAAImageSet()

◆ drawEdgeAAQuad()

◆ drawFilteredImage()

◆ drawGlyphRunList()

◆ drawImageLattice()

◆ drawImageRect()

◆ drawMesh()

◆ drawOval()

◆ drawPaint()

◆ drawPatch()

◆ drawPath()

◆ drawPoints()

◆ drawRect()

◆ drawRegion()

◆ drawRRect()

◆ drawShadow()

◆ drawSlug()

◆ drawSpecial()

◆ drawVertices()

◆ getGlobalBounds() [1/2]

◆ getGlobalBounds() [2/2]

◆ getOrigin()

◆ getRasterHandle()

◆ getRelativeTransform()

◆ globalToDevice()

◆ height()

◆ imageInfo()

◆ isClipAntiAliased()

◆ isClipEmpty()

◆ isClipRect()

◆ isClipWideOpen()

◆ isNoPixelsDevice()

◆ isOpaque()

◆ isPixelAlignedToGlobal()

◆ localToDevice()

◆ localToDevice44()

◆ makeSpecial() [1/2]

◆ makeSpecial() [2/2]

◆ makeSurface()

◆ onAccessPixels()

◆ onClipShader()

◆ onDrawGlyphRunList()

◆ onPeekPixels()

◆ onReadPixels()

◆ onWritePixels()