SkDraw Class Reference

#include <SkDraw.h>

Inheritance diagram for SkDraw:

Public Member Functions
	SkDraw ()
void	drawBitmap (const SkBitmap &, const SkMatrix &, const SkRect *dstOrNull, const SkSamplingOptions &, const SkPaint &) const override
void	drawSprite (const SkBitmap &, int x, int y, const SkPaint &) const
void	drawGlyphRunList (SkCanvas *canvas, SkGlyphRunListPainterCPU *glyphPainter, const sktext::GlyphRunList &glyphRunList, const SkPaint &paint) const
void	paintMasks (SkZip< const SkGlyph *, SkPoint > accepted, const SkPaint &paint) const override
void	drawPoints (SkCanvas::PointMode, size_t count, const SkPoint[], const SkPaint &, SkDevice *) const
void	drawVertices (const SkVertices *, sk_sp< SkBlender >, const SkPaint &, bool skipColorXform) const
void	drawAtlas (const SkRSXform[], const SkRect[], const SkColor[], int count, sk_sp< SkBlender >, const SkPaint &)
Public Member Functions inherited from SkDrawBase
	SkDrawBase ()
void	drawPaint (const SkPaint &) const
void	drawRect (const SkRect &prePaintRect, const SkPaint &, const SkMatrix *paintMatrix, const SkRect *postPaintRect) const
void	drawRect (const SkRect &rect, const SkPaint &paint) const
void	drawRRect (const SkRRect &, const SkPaint &) const
void	drawPath (const SkPath &path, const SkPaint &paint, const SkMatrix *prePathMatrix=nullptr, bool pathIsMutable=false) const
void	drawPathCoverage (const SkPath &src, const SkPaint &paint, SkBlitter *customBlitter=nullptr) const
void	drawDevicePoints (SkCanvas::PointMode, size_t count, const SkPoint[], const SkPaint &, SkDevice *) const
void	validate () const
Public Member Functions inherited from SkGlyphRunListPainterCPU::BitmapDevicePainter
	BitmapDevicePainter ()=default
	BitmapDevicePainter (const BitmapDevicePainter &)=default
virtual	~BitmapDevicePainter ()=default
virtual void	paintMasks (SkZip< const SkGlyph *, SkPoint > accepted, const SkPaint &paint) const =0
virtual void	drawBitmap (const SkBitmap &, const SkMatrix &, const SkRect *dstOrNull, const SkSamplingOptions &, const SkPaint &) const =0

Additional Inherited Members
Public Types inherited from SkDrawBase
enum	RectType { kHair_RectType , kFill_RectType , kStroke_RectType , kPath_RectType }
using	BlitterChooser = SkBlitter *(const SkPixmap &dst, const SkMatrix &ctm, const SkPaint &, SkArenaAlloc *, bool drawCoverage, sk_sp< SkShader > clipShader, const SkSurfaceProps &)
Static Public Member Functions inherited from SkDrawBase
static bool	ComputeMaskBounds (const SkRect &devPathBounds, const SkIRect &clipBounds, const SkMaskFilter *filter, const SkMatrix *filterMatrix, SkIRect *bounds)
static bool	DrawToMask (const SkPath &devPath, const SkIRect &clipBounds, const SkMaskFilter *, const SkMatrix *filterMatrix, SkMaskBuilder *dst, SkMaskBuilder::CreateMode mode, SkStrokeRec::InitStyle style)
static RectType	ComputeRectType (const SkRect &, const SkPaint &, const SkMatrix &, SkPoint *strokeSize)
Public Attributes inherited from SkDrawBase
SkPixmap	fDst
BlitterChooser *	fBlitterChooser {nullptr}
const SkMatrix *	fCTM {nullptr}
const SkRasterClip *	fRC {nullptr}
const SkSurfaceProps *	fProps {nullptr}

Detailed Description

Definition at line 38 of file SkDraw.h.

Constructor & Destructor Documentation

SkDraw()

SkDraw::SkDraw

(

)

Definition at line 52 of file SkDraw.cpp.

               {
    fBlitterChooser = SkBlitter::Choose;
}

Member Function Documentation

drawAtlas()

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

Definition at line 71 of file SkDraw_atlas.cpp.

                                             {
    sk_sp<SkShader> atlasShader = paint.refShader();
    if (!atlasShader) {
        return;
    }
 
    SkSTArenaAlloc<256> alloc;
 
    SkPaint p(paint);
    p.setAntiAlias(false);  // we never respect this for drawAtlas(or drawVertices)
    p.setStyle(SkPaint::kFill_Style);
    p.setShader(nullptr);
    p.setMaskFilter(nullptr);
 
    // The RSXForms can't contain perspective - only the CTM can.
    const bool perspective = fCTM->hasPerspective();
 
    auto transformShader = alloc.make<SkTransformShader>(*as_SB(atlasShader), perspective);
 
    SkRasterPipeline pipeline(&alloc);
    SkSurfaceProps props = SkSurfacePropsCopyOrDefault(fProps);
    SkStageRec rec = {&pipeline, &alloc, fDst.colorType(), fDst.colorSpace(),
                      p.getColor4f(), props};
    // We pass an identity matrix here rather than the CTM. The CTM gets folded into the
    // per-triangle matrix.
    if (!as_SB(transformShader)->appendRootStages(rec, SkMatrix::I())) {
        return;
    }
 
    SkRasterPipeline_UniformColorCtx* uniformCtx = nullptr;
    SkColorSpaceXformSteps steps(sk_srgb_singleton(), kUnpremul_SkAlphaType,
                                 rec.fDstCS, kUnpremul_SkAlphaType);
    if (colors) {
        // we will late-bind the values in ctx, once for each color in the loop
        uniformCtx = alloc.make<SkRasterPipeline_UniformColorCtx>();
        rec.fPipeline->append(SkRasterPipelineOp::uniform_color_dst, uniformCtx);
        std::optional<SkBlendMode> bm = as_BB(blender)->asBlendMode();
        if (!bm.has_value()) {
            return;
        }
        SkBlendMode_AppendStages(*bm, rec.fPipeline);
    }
 
    bool isOpaque = !colors && transformShader->isOpaque();
    if (p.getAlphaf() != 1) {
        rec.fPipeline->append(SkRasterPipelineOp::scale_1_float, alloc.make<float>(p.getAlphaf()));
        isOpaque = false;
    }
 
    auto blitter = SkCreateRasterPipelineBlitter(fDst, p, pipeline, isOpaque, &alloc,
                                                 fRC->clipShader());
    if (!blitter) {
        return;
    }
    SkPath scratchPath;
 
    for (int i = 0; i < count; ++i) {
        if (colors) {
            SkColor4f c4 = SkColor4f::FromColor(colors[i]);
            steps.apply(c4.vec());
            load_color(uniformCtx, c4.premul().vec());
        }
 
        SkMatrix mx;
        mx.setRSXform(xform[i]);
        mx.preTranslate(-textures[i].fLeft, -textures[i].fTop);
        mx.postConcat(*fCTM);
        SkMatrix inv;
        if (!mx.invert(&inv)) {
            return;
        }
        if (transformShader->update(inv)) {
            fill_rect(mx, *fRC, textures[i], blitter, &scratchPath);
        }
    }
}

drawBitmap()

void SkDraw::drawBitmap ( const SkBitmap &  bitmap, const SkMatrix &  prematrix, const SkRect *  dstOrNull, const SkSamplingOptions &  sampling, const SkPaint &  origPaint  ) const

overridevirtual

Implements SkGlyphRunListPainterCPU::BitmapDevicePainter.

Definition at line 303 of file SkDraw.cpp.

                                                        {
    SkDEBUGCODE(this->validate();)
 
    // nothing to draw
    if (fRC->isEmpty() ||
            bitmap.width() == 0 || bitmap.height() == 0 ||
            bitmap.colorType() == kUnknown_SkColorType) {
        return;
    }
 
    SkTCopyOnFirstWrite<SkPaint> paint(origPaint);
    if (origPaint.getStyle() != SkPaint::kFill_Style) {
        paint.writable()->setStyle(SkPaint::kFill_Style);
    }
 
    SkMatrix matrix = *fCTM * prematrix;
 
    if (clipped_out(matrix, *fRC, bitmap.width(), bitmap.height())) {
        return;
    }
 
    if (!SkColorTypeIsAlphaOnly(bitmap.colorType()) &&
        SkTreatAsSprite(matrix, bitmap.dimensions(), sampling, paint->isAntiAlias())) {
        //
        // It is safe to call lock pixels now, since we know the matrix is
        // (more or less) identity.
        //
        SkPixmap pmap;
        if (!bitmap.peekPixels(&pmap)) {
            return;
        }
        int ix = SkScalarRoundToInt(matrix.getTranslateX());
        int iy = SkScalarRoundToInt(matrix.getTranslateY());
        if (clipHandlesSprite(*fRC, ix, iy, pmap)) {
            SkSTArenaAlloc<kSkBlitterContextSize> allocator;
            // blitter will be owned by the allocator.
            SkBlitter* blitter = SkBlitter::ChooseSprite(fDst, *paint, pmap, ix, iy, &allocator,
                                                         fRC->clipShader());
            if (blitter) {
                SkScan::FillIRect(SkIRect::MakeXYWH(ix, iy, pmap.width(), pmap.height()),
                                  *fRC, blitter);
                return;
            }
            // if !blitter, then we fall-through to the slower case
        }
    }
 
    // now make a temp draw on the stack, and use it
    //
    SkDraw draw(*this);
    draw.fCTM = &matrix;
 
    // For a long time, the CPU backend treated A8 bitmaps as coverage, rather than alpha. This was
    // inconsistent with the GPU backend (skbug.com/9692). When this was fixed, it altered behavior
    // for some Android apps (b/231400686). Thus: keep the old behavior in the framework.
#if defined(SK_SUPPORT_LEGACY_ALPHA_BITMAP_AS_COVERAGE)
    if (bitmap.colorType() == kAlpha_8_SkColorType && !paint->getColorFilter()) {
        draw.drawBitmapAsMask(bitmap, sampling, *paint);
        return;
    }
#endif
 
    SkPaint paintWithShader = make_paint_with_image(*paint, bitmap, sampling);
    const SkRect srcBounds = SkRect::MakeIWH(bitmap.width(), bitmap.height());
    if (dstBounds) {
        this->drawRect(srcBounds, paintWithShader, &prematrix, dstBounds);
    } else {
        draw.drawRect(srcBounds, paintWithShader);
    }
}

drawGlyphRunList()

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

Definition at line 126 of file SkDraw_text.cpp.

                                                          {
 
    SkDEBUGCODE(this->validate();)
 
    if (fRC->isEmpty()) {
        return;
    }
 
    glyphPainter->drawForBitmapDevice(canvas, this, glyphRunList, paint, *fCTM);
}

drawPoints()

void SkDraw::drawPoints	(	SkCanvas::PointMode	mode,
		size_t	count,
		const SkPoint	pts[],
		const SkPaint &	paint,
		SkDevice *	device
	)		const

Definition at line 237 of file SkDraw.cpp.

                                                {
    // if we're in lines mode, force count to be even
    if (SkCanvas::kLines_PointMode == mode) {
        count &= ~(size_t)1;
    }
 
    SkASSERT(pts != nullptr);
    SkDEBUGCODE(this->validate();)
 
     // nothing to draw
    if (!count || fRC->isEmpty()) {
        return;
    }
 
    PtProcRec rec;
    if (!device && rec.init(mode, paint, fCTM, fRC)) {
        SkAutoBlitterChoose blitter(*this, nullptr, paint);
 
        SkPoint             devPts[MAX_DEV_PTS];
        SkBlitter*          bltr = blitter.get();
        PtProcRec::Proc     proc = rec.chooseProc(&bltr);
        // we have to back up subsequent passes if we're in polygon mode
        const size_t backup = (SkCanvas::kPolygon_PointMode == mode);
 
        do {
            int n = SkToInt(count);
            if (n > MAX_DEV_PTS) {
                n = MAX_DEV_PTS;
            }
            fCTM->mapPoints(devPts, pts, n);
            if (!SkIsFinite(&devPts[0].fX, n * 2)) {
                return;
            }
            proc(rec, devPts, n, bltr);
            pts += n - backup;
            SkASSERT(SkToInt(count) >= n);
            count -= n;
            if (count > 0) {
                count += backup;
            }
        } while (count != 0);
    } else {
        this->drawDevicePoints(mode, count, pts, paint, device);
    }
}

drawSprite()

void SkDraw::drawSprite	(	const SkBitmap &	bitmap,
		int	x,
		int	y,
		const SkPaint &	origPaint
	)		const

Definition at line 376 of file SkDraw.cpp.

                                                                                            {
    SkDEBUGCODE(this->validate();)
 
    // nothing to draw
    if (fRC->isEmpty() ||
            bitmap.width() == 0 || bitmap.height() == 0 ||
            bitmap.colorType() == kUnknown_SkColorType) {
        return;
    }
 
    const SkIRect bounds = SkIRect::MakeXYWH(x, y, bitmap.width(), bitmap.height());
 
    if (fRC->quickReject(bounds)) {
        return; // nothing to draw
    }
 
    SkPaint paint(origPaint);
    paint.setStyle(SkPaint::kFill_Style);
 
    SkPixmap pmap;
    if (!bitmap.peekPixels(&pmap)) {
        return;
    }
 
    if (nullptr == paint.getColorFilter() && clipHandlesSprite(*fRC, x, y, pmap)) {
        // blitter will be owned by the allocator.
        SkSTArenaAlloc<kSkBlitterContextSize> allocator;
        SkBlitter* blitter = SkBlitter::ChooseSprite(fDst, paint, pmap, x, y, &allocator,
                                                     fRC->clipShader());
        if (blitter) {
            SkScan::FillIRect(bounds, *fRC, blitter);
            return;
        }
    }
 
    SkMatrix matrix;
    SkRect   r;
 
    // get a scalar version of our rect
    r.set(bounds);
 
    // create shader with offset
    matrix.setTranslate(r.fLeft, r.fTop);
    SkPaint paintWithShader = make_paint_with_image(paint, bitmap, SkSamplingOptions(), &matrix);
    SkDraw draw(*this);
    draw.fCTM = &SkMatrix::I();
    // call ourself with a rect
    draw.drawRect(r, paintWithShader);
}

drawVertices()

void SkDraw::drawVertices	(	const SkVertices *	vertices,
		sk_sp< SkBlender >	blender,
		const SkPaint &	paint,
		bool	skipColorXform
	)		const

Definition at line 309 of file SkDraw_vertices.cpp.

                                                     {
    SkVerticesPriv info(vertices->priv());
    const int vertexCount = info.vertexCount();
    const int indexCount = info.indexCount();
 
    // abort early if there is nothing to draw
    if (vertexCount < 3 || (indexCount > 0 && indexCount < 3) || fRC->isEmpty()) {
        return;
    }
    SkMatrix ctmInv;
    if (!fCTM->invert(&ctmInv)) {
        return;
    }
 
    constexpr size_t kDefVertexCount = 16;
    constexpr size_t kOuterSize = sizeof(SkTriColorShader) +
                                  (2 * sizeof(SkPoint) + sizeof(SkColor4f)) * kDefVertexCount;
    SkSTArenaAlloc<kOuterSize> outerAlloc;
 
    SkPoint*  dev2 = nullptr;
    SkPoint3* dev3 = nullptr;
 
    if (fCTM->hasPerspective()) {
        dev3 = outerAlloc.makeArray<SkPoint3>(vertexCount);
        fCTM->mapHomogeneousPoints(dev3, info.positions(), vertexCount);
        // similar to the bounds check for 2d points (below)
        if (!SkIsFinite((const SkScalar*)dev3, vertexCount * 3)) {
            return;
        }
    } else {
        dev2 = outerAlloc.makeArray<SkPoint>(vertexCount);
        fCTM->mapPoints(dev2, info.positions(), vertexCount);
 
        SkRect bounds;
        // this also sets bounds to empty if we see a non-finite value
        bounds.setBounds(dev2, vertexCount);
        if (bounds.isEmpty()) {
            return;
        }
    }
 
    this->drawFixedVertices(
            vertices, std::move(blender), paint, ctmInv, dev2, dev3, &outerAlloc, skipColorXform);
}

paintMasks()

void SkDraw::paintMasks ( SkZip< const SkGlyph *, SkPoint >  accepted, const SkPaint &  paint  ) const

overridevirtual

Implements SkGlyphRunListPainterCPU::BitmapDevicePainter.

Definition at line 52 of file SkDraw_text.cpp.

                                                                                           {
    // The size used for a typical blitter.
    SkSTArenaAlloc<3308> alloc;
    SkBlitter* blitter = SkBlitter::Choose(fDst,
                                           *fCTM,
                                           paint,
                                           &alloc,
                                           false,
                                           fRC->clipShader(),
                                           SkSurfacePropsCopyOrDefault(fProps));
 
    SkAAClipBlitterWrapper wrapper{*fRC, blitter};
    blitter = wrapper.getBlitter();
 
    bool useRegion = fRC->isBW() && !fRC->isRect();
 
    if (useRegion) {
        for (auto [glyph, pos] : accepted) {
            if (check_glyph_position(pos)) {
                SkMask mask = glyph->mask(pos);
 
                SkRegion::Cliperator clipper(fRC->bwRgn(), mask.fBounds);
 
                if (!clipper.done()) {
                    if (SkMask::kARGB32_Format == mask.fFormat) {
                        SkBitmap bm;
                        bm.installPixels(SkImageInfo::MakeN32Premul(mask.fBounds.size()),
                                         const_cast<uint8_t*>(mask.fImage),
                                         mask.fRowBytes);
                        bm.setImmutable();
                        this->drawSprite(bm, mask.fBounds.x(), mask.fBounds.y(), paint);
                    } else {
                        const SkIRect& cr = clipper.rect();
                        do {
                            blitter->blitMask(mask, cr);
                            clipper.next();
                        } while (!clipper.done());
                    }
                }
            }
        }
    } else {
        SkIRect clipBounds = fRC->isBW() ? fRC->bwRgn().getBounds()
                                         : fRC->aaRgn().getBounds();
        for (auto [glyph, pos] : accepted) {
            if (check_glyph_position(pos)) {
                SkMask mask = glyph->mask(pos);
                SkIRect storage;
                const SkIRect* bounds = &mask.fBounds;
 
                // this extra test is worth it, assuming that most of the time it succeeds
                // since we can avoid writing to storage
                if (!clipBounds.containsNoEmptyCheck(mask.fBounds)) {
                    if (!storage.intersect(mask.fBounds, clipBounds)) {
                        continue;
                    }
                    bounds = &storage;
                }
 
                if (SkMask::kARGB32_Format == mask.fFormat) {
                    SkBitmap bm;
                    bm.installPixels(SkImageInfo::MakeN32Premul(mask.fBounds.size()),
                                     const_cast<uint8_t*>(mask.fImage),
                                     mask.fRowBytes);
                    bm.setImmutable();
                    this->drawSprite(bm, mask.fBounds.x(), mask.fBounds.y(), paint);
                } else {
                    blitter->blitMask(mask, *bounds);
                }
            }
        }
    }
}

---

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

• third_party/skia/src/core/SkDraw.h
• third_party/skia/src/core/SkDraw.cpp
• third_party/skia/src/core/SkDraw_atlas.cpp
• third_party/skia/src/core/SkDraw_text.cpp
• third_party/skia/src/core/SkDraw_vertices.cpp