#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

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