#include <SkBitmapDevice.h>

Inheritance diagram for SkBitmapDevice:

Classes
class	BDDraw

Public Member Functions
	SkBitmapDevice (const SkBitmap &bitmap)

	SkBitmapDevice (const SkBitmap &bitmap, const SkSurfaceProps &surfaceProps, void *externalHandle=nullptr)

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	drawOval (const SkRect &oval, const SkPaint &paint) override

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

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

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

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

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

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

void	pushClipStack () override

void	popClipStack () override

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

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

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

void	clipRegion (const SkRegion &deviceRgn, SkClipOp) override

void	replaceClip (const SkIRect &rect) override

bool	isClipAntiAliased () const override

bool	isClipEmpty () const override

bool	isClipRect () const override

bool	isClipWideOpen () const override

void	android_utils_clipAsRgn (SkRegion *) const override

SkIRect	devClipBounds () const override

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

sk_sp< SkSpecialImage >	makeSpecial (const SkBitmap &) override

sk_sp< SkSpecialImage >	makeSpecial (const SkImage *) override

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

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

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

void	setImmutable () override

void *	getRasterHandle () const override

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

const SkImageInfo &	imageInfo () const

int	width () const

int	height () const

bool	isOpaque () const

SkIRect	bounds () const

SkISize	size () const

const SkSurfaceProps &	surfaceProps () const

SkScalerContextFlags	scalerContextFlags () const

virtual SkStrikeDeviceInfo	strikeDeviceInfo () const

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

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

bool	accessPixels (SkPixmap *pmap)

bool	peekPixels (SkPixmap *)

const SkM44 &	localToDevice44 () const

const SkMatrix &	localToDevice () const

const SkM44 &	deviceToGlobal () const

const SkM44 &	globalToDevice () const

SkIPoint	getOrigin () const

bool	isPixelAlignedToGlobal () const

SkMatrix	getRelativeTransform (const SkDevice &) const

void	setLocalToDevice (const SkM44 &localToDevice)

void	setGlobalCTM (const SkM44 &ctm)

void	getGlobalBounds (SkIRect *bounds) const

SkIRect	getGlobalBounds () const

virtual SkIRect	devClipBounds () const =0

virtual void	pushClipStack ()=0

virtual void	popClipStack ()=0

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

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

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

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

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

virtual void	replaceClip (const SkIRect &rect)=0

virtual bool	isClipAntiAliased () const =0

virtual bool	isClipEmpty () const =0

virtual bool	isClipRect () const =0

virtual bool	isClipWideOpen () const =0

virtual void	android_utils_clipAsRgn (SkRegion *) const =0

virtual bool	android_utils_clipWithStencil ()

virtual bool	useDrawCoverageMaskForMaskFilters () const

virtual bool	isNoPixelsDevice () const

virtual void *	getRasterHandle () const

virtual GrRecordingContext *	recordingContext () const

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

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

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

virtual void	setImmutable ()

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

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

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

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

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

virtual void	drawPaint (const SkPaint &paint)=0

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

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

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

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

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

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

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

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

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

virtual bool	shouldDrawAsTiledImageRect () const

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

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

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

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

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

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

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

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

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

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

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

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

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

sk_sp< SkSpecialImage >	snapSpecial ()

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

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

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

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

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

Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()

virtual	~SkRefCntBase ()

bool	unique () const

void	ref () const

void	unref () const

Static Public Member Functions
static sk_sp< SkBitmapDevice >	Create (const SkImageInfo &, const SkSurfaceProps &, SkRasterHandleAllocator *=nullptr)

Friends
class	SkDraw

class	SkDrawBase

class	SkDrawTiler

class	SkSurface_Raster

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

virtual sk_sp< SkSpecialImage >	makeSpecial (const SkImage *)

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

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

bool	checkLocalToDeviceDirty ()

Detailed Description

Definition at line 45 of file SkBitmapDevice.h.

Constructor & Destructor Documentation

◆ SkBitmapDevice() [1/2]

SkBitmapDevice::SkBitmapDevice ( const SkBitmap & bitmap )

Construct a new device with the specified bitmap as its backend. It is valid for the bitmap to have no pixels associated with it. In that case, any drawing to this device will have no effect.

Definition at line 230 of file SkBitmapDevice.cpp.

        : SkDevice(bitmap.info(), SkSurfaceProps())
        , fBitmap(bitmap)
        , fRCStack(bitmap.width(), bitmap.height())
        , fGlyphPainter(this->surfaceProps(), bitmap.colorType(), bitmap.colorSpace()) {
    SkASSERT(valid_for_bitmap_device(bitmap.info(), nullptr));
}

◆ SkBitmapDevice() [2/2]

SkBitmapDevice::SkBitmapDevice	(	const SkBitmap &	bitmap,
		const SkSurfaceProps &	surfaceProps,
		void *	externalHandle = `nullptr`
	)

Construct a new device with the specified bitmap as its backend. It is valid for the bitmap to have no pixels associated with it. In that case, any drawing to this device will have no effect.

Member Function Documentation

◆ android_utils_clipAsRgn()

void SkBitmapDevice::android_utils_clipAsRgn ( SkRegion * rgn ) const

overridevirtual

Implements SkDevice.

Definition at line 681 of file SkBitmapDevice.cpp.

                                                                {
    const SkRasterClip& rc = fRCStack.rc();
    if (rc.isAA()) {
        rgn->setRect(   rc.getBounds());
    } else {
        *rgn = rc.bwRgn();
    }
}

◆ clipPath()

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

overridevirtual

Implements SkDevice.

Definition at line 634 of file SkBitmapDevice.cpp.

                                                                      {
    fRCStack.clipPath(this->localToDevice(), path, op, aa);
}

◆ clipRect()

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

overridevirtual

Implements SkDevice.

Definition at line 626 of file SkBitmapDevice.cpp.

                                                                      {
    fRCStack.clipRect(this->localToDevice(), rect, op, aa);
}

◆ clipRegion()

void SkBitmapDevice::clipRegion	(	const SkRegion &	deviceRgn,
		SkClipOp	op
	)

overridevirtual

Implements SkDevice.

Definition at line 642 of file SkBitmapDevice.cpp.

                                                                {
    SkIPoint origin = this->getOrigin();
    SkRegion tmp;
    const SkRegion* ptr = &rgn;
    if (origin.fX | origin.fY) {
        // translate from "global/canvas" coordinates to relative to this device
        rgn.translate(-origin.fX, -origin.fY, &tmp);
        ptr = &tmp;
    }
    fRCStack.clipRegion(*ptr, op);
}

◆ clipRRect()

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

overridevirtual

Implements SkDevice.

Definition at line 630 of file SkBitmapDevice.cpp.

                                                                         {
    fRCStack.clipRRect(this->localToDevice(), rrect, op, aa);
}

◆ Create()

sk_sp< SkBitmapDevice > SkBitmapDevice::Create	(	const SkImageInfo &	origInfo,
		const SkSurfaceProps &	surfaceProps,
		SkRasterHandleAllocator *	allocator = `nullptr`
	)

static

Definition at line 248 of file SkBitmapDevice.cpp.

                                                                                 {
    SkAlphaType newAT = origInfo.alphaType();
    if (!valid_for_bitmap_device(origInfo, &newAT)) {
        return nullptr;
    }
 
    SkRasterHandleAllocator::Handle hndl = nullptr;
    const SkImageInfo info = origInfo.makeAlphaType(newAT);
    SkBitmap bitmap;
 
    if (kUnknown_SkColorType == info.colorType()) {
        if (!bitmap.setInfo(info)) {
            return nullptr;
        }
    } else if (allocator) {
        hndl = allocator->allocBitmap(info, &bitmap);
        if (!hndl) {
            return nullptr;
        }
    } else if (info.isOpaque()) {
        // If this bitmap is opaque, we don't have any sensible default color,
        // so we just return uninitialized pixels.
        if (!bitmap.tryAllocPixels(info)) {
            return nullptr;
        }
    } else {
        // This bitmap has transparency, so we'll zero the pixels (to transparent).
        // We use the flag as a faster alloc-then-eraseColor(SK_ColorTRANSPARENT).
        if (!bitmap.tryAllocPixelsFlags(info, SkBitmap::kZeroPixels_AllocFlag)) {
            return nullptr;
        }
    }
 
    return sk_make_sp<SkBitmapDevice>(bitmap, surfaceProps, hndl);
}

◆ createDevice()

sk_sp< SkDevice > SkBitmapDevice::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 292 of file SkBitmapDevice.cpp.

                                                                                               {
    const SkSurfaceProps surfaceProps =
        this->surfaceProps().cloneWithPixelGeometry(cinfo.fPixelGeometry);
 
    // Need to force L32 for now if we have an image filter.
    // If filters ever support other colortypes, e.g. F16, we can modify this check.
    SkImageInfo info = cinfo.fInfo;
    if (layerPaint && layerPaint->getImageFilter()) {
        // TODO: can we query the imagefilter, to see if it can handle floats (so we don't always
        //       use N32 when the layer itself was float)?
        info = info.makeColorType(kN32_SkColorType);
    }
 
    return SkBitmapDevice::Create(info, surfaceProps, cinfo.fAllocator);
}

◆ devClipBounds()

SkIRect SkBitmapDevice::devClipBounds ( ) const

overridevirtual

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

Implements SkDevice.

Definition at line 690 of file SkBitmapDevice.cpp.

                                            {
    return fRCStack.rc().getBounds();
}

◆ drawAtlas()

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

overridevirtual

Reimplemented from SkDevice.

Definition at line 555 of file SkBitmapDevice.cpp.

                                                     {
    // set this to true for performance comparisons with the old drawVertices way
    if ((false)) {
        this->SkDevice::drawAtlas(xform, tex, colors, count, std::move(blender), paint);
        return;
    }
    BDDraw(this).drawAtlas(xform, tex, colors, count, std::move(blender), paint);
}

◆ drawImageRect()

void SkBitmapDevice::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 414 of file SkBitmapDevice.cpp.

                                                                         {
    SkASSERT(dst.isFinite());
    SkASSERT(dst.isSorted());
 
    SkBitmap bitmap;
    // TODO: Elevate direct context requirement to public API and remove cheat.
    auto dContext = as_IB(image)->directContext();
    if (!as_IB(image)->getROPixels(dContext, &bitmap)) {
        return;
    }
 
    SkRect      bitmapBounds, tmpSrc, tmpDst;
    SkBitmap    tmpBitmap;
 
    bitmapBounds.setIWH(bitmap.width(), bitmap.height());
 
    // Compute matrix from the two rectangles
    if (src) {
        tmpSrc = *src;
    } else {
        tmpSrc = bitmapBounds;
    }
    SkMatrix matrix = SkMatrix::RectToRect(tmpSrc, dst);
 
    const SkRect* dstPtr = &dst;
    const SkBitmap* bitmapPtr = &bitmap;
 
    // clip the tmpSrc to the bounds of the bitmap, and recompute dstRect if
    // needed (if the src was clipped). No check needed if src==null.
    bool srcIsSubset = false;
    if (src) {
        if (!bitmapBounds.contains(*src)) {
            if (!tmpSrc.intersect(bitmapBounds)) {
                return; // nothing to draw
            }
            // recompute dst, based on the smaller tmpSrc
            matrix.mapRect(&tmpDst, tmpSrc);
            if (!tmpDst.isFinite()) {
                return;
            }
            dstPtr = &tmpDst;
        }
        srcIsSubset = !tmpSrc.contains(bitmapBounds);
    }
 
    if (srcIsSubset &&
        SkCanvas::kFast_SrcRectConstraint == constraint &&
        sampling != SkSamplingOptions()) {
        // src is smaller than the bounds of the bitmap, and we are filtering, so we don't know
        // how much more of the bitmap we need, so we can't use extractSubset or drawBitmap,
        // but we must use a shader w/ dst bounds (which can access all of the bitmap needed).
        goto USE_SHADER;
    }
 
    if (srcIsSubset) {
        // since we may need to clamp to the borders of the src rect within
        // the bitmap, we extract a subset.
        const SkIRect srcIR = tmpSrc.roundOut();
        if (!bitmap.extractSubset(&tmpBitmap, srcIR)) {
            return;
        }
        bitmapPtr = &tmpBitmap;
 
        // Since we did an extract, we need to adjust the matrix accordingly
        SkScalar dx = 0, dy = 0;
        if (srcIR.fLeft > 0) {
            dx = SkIntToScalar(srcIR.fLeft);
        }
        if (srcIR.fTop > 0) {
            dy = SkIntToScalar(srcIR.fTop);
        }
        if (dx || dy) {
            matrix.preTranslate(dx, dy);
        }
 
#ifdef SK_DRAWBITMAPRECT_FAST_OFFSET
        SkRect extractedBitmapBounds = SkRect::MakeXYWH(dx, dy,
                                                        SkIntToScalar(bitmapPtr->width()),
                                                        SkIntToScalar(bitmapPtr->height()));
#else
        SkRect extractedBitmapBounds;
        extractedBitmapBounds.setIWH(bitmapPtr->width(), bitmapPtr->height());
#endif
        if (extractedBitmapBounds == tmpSrc) {
            // no fractional part in src, we can just call drawBitmap
            goto USE_DRAWBITMAP;
        }
    } else {
        USE_DRAWBITMAP:
        // We can go faster by just calling drawBitmap, which will concat the
        // matrix with the CTM, and try to call drawSprite if it can. If not,
        // it will make a shader and call drawRect, as we do below.
        if (CanApplyDstMatrixAsCTM(matrix, paint)) {
            this->drawBitmap(*bitmapPtr, matrix, dstPtr, sampling, paint);
            return;
        }
    }
 
    USE_SHADER:
 
    // construct a shader, so we can call drawRect with the dst
    auto s = SkMakeBitmapShaderForPaint(paint, *bitmapPtr, SkTileMode::kClamp, SkTileMode::kClamp,
                                        sampling, &matrix, kNever_SkCopyPixelsMode);
    if (!s) {
        return;
    }
 
    SkPaint paintWithShader(paint);
    paintWithShader.setStyle(SkPaint::kFill_Style);
    paintWithShader.setShader(std::move(s));
 
    // Call ourself, in case the subclass wanted to share this setup code
    // but handle the drawRect code themselves.
    this->drawRect(*dstPtr, paintWithShader);
}

◆ drawMesh()

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

overridevirtual

Implements SkDevice.

Definition at line 551 of file SkBitmapDevice.cpp.

                                                                             {
    // TODO(brianosman): Implement, maybe with a subclass of BitmapDevice that has SkSL support.
}

◆ drawOval()

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

overridevirtual

Implements SkDevice.

Definition at line 357 of file SkBitmapDevice.cpp.

                                                                      {
    // call the VIRTUAL version, so any subclasses who do handle drawPath aren't
    // required to override drawOval.
    this->drawPath(SkPath::Oval(oval), paint, true);
}

◆ drawPaint()

void SkBitmapDevice::drawPaint ( const SkPaint & paint )

overridevirtual

Implements SkDevice.

Definition at line 344 of file SkBitmapDevice.cpp.

                                                   {
    BDDraw(this).drawPaint(paint);
}

◆ drawPath()

void SkBitmapDevice::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 373 of file SkBitmapDevice.cpp.

                                                  {
    const SkRect* bounds = nullptr;
    if (SkDrawTiler::NeedsTiling(this) && !path.isInverseFillType()) {
        bounds = &path.getBounds();
    }
    SkDrawTiler tiler(this, bounds ? Bounder(*bounds, paint).bounds() : nullptr);
    if (tiler.needsTiling()) {
        pathIsMutable = false;
    }
    while (const SkDraw* draw = tiler.next()) {
        draw->drawPath(path, paint, nullptr, pathIsMutable);
    }
}

◆ drawPoints()

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

overridevirtual

Implements SkDevice.

Definition at line 348 of file SkBitmapDevice.cpp.

                                                                           {
    LOOP_TILER( drawPoints(mode, count, pts, paint, nullptr), nullptr)
}

◆ drawRect()

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

overridevirtual

Implements SkDevice.

Definition at line 353 of file SkBitmapDevice.cpp.

                                                                   {
    LOOP_TILER( drawRect(r, paint), Bounder(r, paint))
}

◆ drawRRect()

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

overridevirtual

Implements SkDevice.

Definition at line 363 of file SkBitmapDevice.cpp.

                                                                         {
#ifdef SK_IGNORE_BLURRED_RRECT_OPT
    // call the VIRTUAL version, so any subclasses who do handle drawPath aren't
    // required to override drawRRect.
    this->drawPath(SkPath::RRect(rrect), paint, true);
#else
    LOOP_TILER( drawRRect(rrect, paint), Bounder(rrect.getBounds(), paint))
#endif
}

◆ drawSpecial()

void SkBitmapDevice::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 571 of file SkBitmapDevice.cpp.

                                                            {
    SkASSERT(!paint.getImageFilter());
    SkASSERT(!paint.getMaskFilter());
    SkASSERT(!src->isGaneshBacked());
    SkASSERT(!src->isGraphiteBacked());
 
    SkBitmap resultBM;
    if (SkSpecialImages::AsBitmap(src, &resultBM)) {
        SkDraw draw;
        if (!this->accessPixels(&draw.fDst)) {
          return; // no pixels to draw to so skip it
        }
        draw.fCTM = &localToDevice;
        draw.fRC = &fRCStack.rc();
        draw.drawBitmap(resultBM, SkMatrix::I(), nullptr, sampling, paint);
    }
}

◆ drawVertices()

void SkBitmapDevice::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 539 of file SkBitmapDevice.cpp.

                                                       {
#ifdef SK_LEGACY_IGNORE_DRAW_VERTICES_BLEND_WITH_NO_SHADER
    if (!paint.getShader()) {
        blender = SkBlender::Mode(SkBlendMode::kDst);
    }
#endif
    BDDraw(this).drawVertices(vertices, std::move(blender), paint, skipColorXform);
}

◆ getRasterHandle()

void * SkBitmapDevice::getRasterHandle ( ) const

inlineoverridevirtual

Reimplemented from SkDevice.

Definition at line 116 of file SkBitmapDevice.h.

116{ return fRasterHandle; }

◆ isClipAntiAliased()

bool SkBitmapDevice::isClipAntiAliased ( ) const

overridevirtual

Implements SkDevice.

Definition at line 676 of file SkBitmapDevice.cpp.

                                             {
    const SkRasterClip& rc = fRCStack.rc();
    return !rc.isEmpty() && rc.isAA();
}

◆ isClipEmpty()

bool SkBitmapDevice::isClipEmpty ( ) const

overridevirtual

Implements SkDevice.

Definition at line 667 of file SkBitmapDevice.cpp.

                                       {
    return fRCStack.rc().isEmpty();
}

◆ isClipRect()

bool SkBitmapDevice::isClipRect ( ) const

overridevirtual

Implements SkDevice.

Definition at line 671 of file SkBitmapDevice.cpp.

                                      {
    const SkRasterClip& rc = fRCStack.rc();
    return !rc.isEmpty() && rc.isRect() && !SkToBool(rc.clipShader());
}

◆ isClipWideOpen()

bool SkBitmapDevice::isClipWideOpen ( ) const

overridevirtual

Implements SkDevice.

Definition at line 660 of file SkBitmapDevice.cpp.

                                          {
    const SkRasterClip& rc = fRCStack.rc();
    // If we're AA, we can't be wide-open (we would represent that as BW)
    return rc.isBW() && rc.bwRgn().isRect() &&
           rc.bwRgn().getBounds() == SkIRect{0, 0, this->width(), this->height()};
}

◆ makeSpecial() [1/2]

sk_sp< SkSpecialImage > SkBitmapDevice::makeSpecial ( const SkBitmap & bitmap )

overridevirtual

Reimplemented from SkDevice.

Definition at line 592 of file SkBitmapDevice.cpp.

                                                                        {
    return SkSpecialImages::MakeFromRaster(bitmap.bounds(), bitmap, this->surfaceProps());
}

◆ makeSpecial() [2/2]

sk_sp< SkSpecialImage > SkBitmapDevice::makeSpecial ( const SkImage * image )

overridevirtual

Reimplemented from SkDevice.

Definition at line 596 of file SkBitmapDevice.cpp.

                                                                      {
    return SkSpecialImages::MakeFromRaster(SkIRect::MakeWH(image->width(), image->height()),
                                           image->makeNonTextureImage(),
                                           this->surfaceProps());
}

◆ makeSurface()

sk_sp< SkSurface > SkBitmapDevice::makeSurface	(	const SkImageInfo &	info,
		const SkSurfaceProps &	props
	)

overridevirtual

Reimplemented from SkDevice.

Definition at line 612 of file SkBitmapDevice.cpp.

                                                                                                 {
    return SkSurfaces::Raster(info, &props);
}

◆ popClipStack()

void SkBitmapDevice::popClipStack ( )

overridevirtual

Implements SkDevice.

Definition at line 622 of file SkBitmapDevice.cpp.

                                  {
    fRCStack.restore();
}

◆ pushClipStack()

void SkBitmapDevice::pushClipStack ( )

overridevirtual

Implements SkDevice.

Definition at line 618 of file SkBitmapDevice.cpp.

                                   {
    fRCStack.save();
}

◆ replaceClip()

void SkBitmapDevice::replaceClip ( const SkIRect & rect )

overridevirtual

Implements SkDevice.

Definition at line 654 of file SkBitmapDevice.cpp.

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

◆ setImmutable()

void SkBitmapDevice::setImmutable ( )

inlineoverridevirtual

Reimplemented from SkDevice.

Definition at line 114 of file SkBitmapDevice.h.

114{ fBitmap.setImmutable(); }

SkBitmap::setImmutable

void setImmutable()

Definition: SkBitmap.cpp:400

◆ snapSpecial()

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

overridevirtual

Reimplemented from SkDevice.

Definition at line 602 of file SkBitmapDevice.cpp.

                                                                                       {
    if (forceCopy) {
        return SkSpecialImages::CopyFromRaster(bounds, fBitmap, this->surfaceProps());
    } else {
        return SkSpecialImages::MakeFromRaster(bounds, fBitmap, this->surfaceProps());
    }
}

Friends And Related Function Documentation

◆ SkDraw

friend class SkDraw

friend

Definition at line 120 of file SkBitmapDevice.h.

◆ SkDrawBase

friend class SkDrawBase

friend

Definition at line 121 of file SkBitmapDevice.h.

◆ SkDrawTiler

friend class SkDrawTiler

friend

Definition at line 122 of file SkBitmapDevice.h.

◆ SkSurface_Raster

friend class SkSurface_Raster

friend

Definition at line 123 of file SkBitmapDevice.h.

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

third_party/skia/src/core/SkBitmapDevice.h
third_party/skia/src/core/SkBitmapDevice.cpp

Classes

Public Member Functions

Static Public Member Functions

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ SkBitmapDevice() [1/2]

◆ SkBitmapDevice() [2/2]

Member Function Documentation

◆ android_utils_clipAsRgn()

◆ clipPath()

◆ clipRect()

◆ clipRegion()

◆ clipRRect()

◆ Create()

◆ createDevice()

◆ devClipBounds()

◆ drawAtlas()

◆ drawImageRect()

◆ drawMesh()

◆ drawOval()

◆ drawPaint()

◆ drawPath()

◆ drawPoints()

◆ drawRect()

◆ drawRRect()

◆ drawSpecial()

◆ drawVertices()

◆ getRasterHandle()

◆ isClipAntiAliased()

◆ isClipEmpty()

◆ isClipRect()

◆ isClipWideOpen()

◆ makeSpecial() [1/2]

◆ makeSpecial() [2/2]

◆ makeSurface()

◆ popClipStack()

◆ pushClipStack()

◆ replaceClip()

◆ setImmutable()

◆ snapSpecial()

Friends And Related Function Documentation

◆ SkDraw

◆ SkDrawBase

◆ SkDrawTiler

◆ SkSurface_Raster