#include <SkDrawBase.h>

Inheritance diagram for SkDrawBase:

Public Types
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 &)

Public Member Functions
	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

Static Public Member Functions
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
SkPixmap	fDst

BlitterChooser *	fBlitterChooser {nullptr}

const SkMatrix *	fCTM {nullptr}

const SkRasterClip *	fRC {nullptr}

const SkSurfaceProps *	fProps {nullptr}

Detailed Description

Definition at line 40 of file SkDrawBase.h.

Member Typedef Documentation

◆ BlitterChooser

using SkDrawBase::BlitterChooser = SkBlitter* (const SkPixmap& dst, const SkMatrix& ctm, const SkPaint&, SkArenaAlloc*, bool drawCoverage, sk_sp<SkShader> clipShader, const SkSurfaceProps&)

Definition at line 113 of file SkDrawBase.h.

Member Enumeration Documentation

◆ RectType

enum SkDrawBase::RectType

Enumerator
kHair_RectType
kFill_RectType
kStroke_RectType
kPath_RectType

Definition at line 95 of file SkDrawBase.h.

                  {
        kHair_RectType,
        kFill_RectType,
        kStroke_RectType,
        kPath_RectType
    };

Constructor & Destructor Documentation

◆ SkDrawBase()

SkDrawBase::SkDrawBase ( )

Definition at line 53 of file SkDrawBase.cpp.

53{}

Member Function Documentation

◆ ComputeMaskBounds()

bool SkDrawBase::ComputeMaskBounds	(	const SkRect &	devPathBounds,
		const SkIRect &	clipBounds,
		const SkMaskFilter *	filter,
		const SkMatrix *	filterMatrix,
		SkIRect *	bounds
	)

static

Definition at line 494 of file SkDrawBase.cpp.

                                                {
    //  init our bounds from the path
    *bounds = devPathBounds.makeOutset(SK_ScalarHalf, SK_ScalarHalf).roundOut();
 
    SkIPoint margin = SkIPoint::Make(0, 0);
    if (filter) {
        SkASSERT(filterMatrix);
 
        SkMask srcM(nullptr, *bounds, 0, SkMask::kA8_Format);
        SkMaskBuilder dstM;
        if (!as_MFB(filter)->filterMask(&dstM, srcM, *filterMatrix, &margin)) {
            return false;
        }
    }
 
    // trim the bounds to reflect the clip (plus whatever slop the filter needs)
    // Ugh. Guard against gigantic margins from wacky filters. Without this
    // check we can request arbitrary amounts of slop beyond our visible
    // clip, and bring down the renderer (at least on finite RAM machines
    // like handsets, etc.). Need to balance this invented value between
    // quality of large filters like blurs, and the corresponding memory
    // requests.
    static constexpr int kMaxMargin = 128;
    if (!bounds->intersect(clipBounds.makeOutset(std::min(margin.fX, kMaxMargin),
                                                 std::min(margin.fY, kMaxMargin)))) {
        return false;
    }
 
    return true;
}

◆ ComputeRectType()

SkDrawBase::RectType SkDrawBase::ComputeRectType	(	const SkRect &	rect,
		const SkPaint &	paint,
		const SkMatrix &	matrix,
		SkPoint *	strokeSize
	)

static

Based on the paint's style, strokeWidth, and the matrix, classify how to draw the rect. If no special-case is available, returns kPath_RectType.

Iff RectType == kStroke_RectType, then strokeSize is set to the device width and height of the stroke.

Definition at line 111 of file SkDrawBase.cpp.

                                                              {
    RectType rtype;
    const SkScalar width = paint.getStrokeWidth();
    const bool zeroWidth = (0 == width);
    SkPaint::Style style = paint.getStyle();
 
    if ((SkPaint::kStrokeAndFill_Style == style) && zeroWidth) {
        style = SkPaint::kFill_Style;
    }
 
    if (paint.getPathEffect() || paint.getMaskFilter() ||
        !matrix.rectStaysRect() || SkPaint::kStrokeAndFill_Style == style) {
        rtype = kPath_RectType;
    } else if (SkPaint::kFill_Style == style) {
        rtype = kFill_RectType;
    } else if (zeroWidth) {
        rtype = kHair_RectType;
    } else if (easy_rect_join(rect, paint, matrix, strokeSize)) {
        rtype = kStroke_RectType;
    } else {
        rtype = kPath_RectType;
    }
    return rtype;
}

◆ drawDevicePoints()

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

Definition at line 597 of file SkDrawBase.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;
    }
 
    // needed?
    if (!SkIsFinite(&pts[0].fX, count * 2)) {
        return;
    }
 
    switch (mode) {
        case SkCanvas::kPoints_PointMode: {
            // temporarily mark the paint as filling.
            SkPaint newPaint(paint);
            newPaint.setStyle(SkPaint::kFill_Style);
 
            SkScalar width = newPaint.getStrokeWidth();
            SkScalar radius = SkScalarHalf(width);
 
            if (newPaint.getStrokeCap() == SkPaint::kRound_Cap) {
                if (device) {
                    for (size_t i = 0; i < count; ++i) {
                        SkRect r = SkRect::MakeLTRB(pts[i].fX - radius, pts[i].fY - radius,
                                                    pts[i].fX + radius, pts[i].fY + radius);
                        device->drawOval(r, newPaint);
                    }
                } else {
                    SkPath     path;
                    SkMatrix   preMatrix;
 
                    path.addCircle(0, 0, radius);
                    for (size_t i = 0; i < count; i++) {
                        preMatrix.setTranslate(pts[i].fX, pts[i].fY);
                        // pass true for the last point, since we can modify
                        // then path then
                        path.setIsVolatile((count-1) == i);
                        this->drawPath(path, newPaint, &preMatrix, (count-1) == i);
                    }
                }
            } else {
                SkRect  r;
 
                for (size_t i = 0; i < count; i++) {
                    r.fLeft = pts[i].fX - radius;
                    r.fTop = pts[i].fY - radius;
                    r.fRight = r.fLeft + width;
                    r.fBottom = r.fTop + width;
                    if (device) {
                        device->drawRect(r, newPaint);
                    } else {
                        this->drawRect(r, newPaint);
                    }
                }
            }
            break;
        }
        case SkCanvas::kLines_PointMode:
            if (2 == count && paint.getPathEffect()) {
                // most likely a dashed line - see if it is one of the ones
                // we can accelerate
                SkStrokeRec stroke(paint);
                SkPathEffectBase::PointData pointData;
 
                SkPath path = SkPath::Line(pts[0], pts[1]);
 
                SkRect cullRect = SkRect::Make(fRC->getBounds());
 
                if (as_PEB(paint.getPathEffect())->asPoints(&pointData, path, stroke, *fCTM,
                                                            &cullRect)) {
                    // 'asPoints' managed to find some fast path
 
                    SkPaint newP(paint);
                    newP.setPathEffect(nullptr);
                    newP.setStyle(SkPaint::kFill_Style);
 
                    if (!pointData.fFirst.isEmpty()) {
                        if (device) {
                            device->drawPath(pointData.fFirst, newP);
                        } else {
                            this->drawPath(pointData.fFirst, newP);
                        }
                    }
 
                    if (!pointData.fLast.isEmpty()) {
                        if (device) {
                            device->drawPath(pointData.fLast, newP);
                        } else {
                            this->drawPath(pointData.fLast, newP);
                        }
                    }
 
                    if (pointData.fSize.fX == pointData.fSize.fY) {
                        // The rest of the dashed line can just be drawn as points
                        SkASSERT(pointData.fSize.fX == SkScalarHalf(newP.getStrokeWidth()));
 
                        if (SkPathEffectBase::PointData::kCircles_PointFlag & pointData.fFlags) {
                            newP.setStrokeCap(SkPaint::kRound_Cap);
                        } else {
                            newP.setStrokeCap(SkPaint::kButt_Cap);
                        }
 
                        if (device) {
                            device->drawPoints(SkCanvas::kPoints_PointMode,
                                               pointData.fNumPoints,
                                               pointData.fPoints,
                                               newP);
                        } else {
                            this->drawDevicePoints(SkCanvas::kPoints_PointMode,
                                                   pointData.fNumPoints,
                                                   pointData.fPoints,
                                                   newP,
                                                   device);
                        }
                        break;
                    } else {
                        // The rest of the dashed line must be drawn as rects
                        SkASSERT(!(SkPathEffectBase::PointData::kCircles_PointFlag &
                                  pointData.fFlags));
 
                        SkRect r;
 
                        for (int i = 0; i < pointData.fNumPoints; ++i) {
                            r.setLTRB(pointData.fPoints[i].fX - pointData.fSize.fX,
                                      pointData.fPoints[i].fY - pointData.fSize.fY,
                                      pointData.fPoints[i].fX + pointData.fSize.fX,
                                      pointData.fPoints[i].fY + pointData.fSize.fY);
                            if (device) {
                                device->drawRect(r, newP);
                            } else {
                                this->drawRect(r, newP);
                            }
                        }
                    }
 
                    break;
                }
            }
            [[fallthrough]]; // couldn't take fast path
        case SkCanvas::kPolygon_PointMode: {
            count -= 1;
            SkPath path;
            SkPaint p(paint);
            p.setStyle(SkPaint::kStroke_Style);
            size_t inc = (SkCanvas::kLines_PointMode == mode) ? 2 : 1;
            path.setIsVolatile(true);
            for (size_t i = 0; i < count; i += inc) {
                path.moveTo(pts[i]);
                path.lineTo(pts[i+1]);
                if (device) {
                    device->drawPath(path, p, true);
                } else {
                    this->drawPath(path, p, nullptr, true);
                }
                path.rewind();
            }
            break;
        }
    }
}

◆ drawPaint()

void SkDrawBase::drawPaint ( const SkPaint & paint ) const

Definition at line 74 of file SkDrawBase.cpp.

                                                     {
    SkDEBUGCODE(this->validate();)
 
    if (fRC->isEmpty()) {
        return;
    }
 
    SkIRect    devRect;
    devRect.setWH(fDst.width(), fDst.height());
 
    SkAutoBlitterChoose blitter(*this, nullptr, paint);
    SkScan::FillIRect(devRect, *fRC, blitter.get());
}

◆ drawPath()

void SkDrawBase::drawPath	(	const SkPath &	path,
		const SkPaint &	paint,
		const SkMatrix *	prePathMatrix = `nullptr`,
		bool	pathIsMutable = `false`
	)		const

inline

To save on mallocs, we allow a flag that tells us that srcPath is mutable, so that we don't have to make copies of it as we transform it.

If prePathMatrix is not null, it should logically be applied before any stroking or other effects. If there are no effects on the paint that affect the geometry/rasterization, then the pre matrix can just be pre-concated with the current matrix.

Definition at line 60 of file SkDrawBase.h.

                                                                                                {
        this->drawPath(path, paint, prePathMatrix, pathIsMutable, false);
    }

◆ drawPathCoverage()

void SkDrawBase::drawPathCoverage	(	const SkPath &	src,
		const SkPaint &	paint,
		SkBlitter *	customBlitter = `nullptr`
	)		const

inline

Overwrite the target with the path's coverage (i.e. its mask). Will overwrite the entire device, so it need not be zero'd first.

Only device A8 is supported right now.

Definition at line 71 of file SkDrawBase.h.

                                                                    {
        bool isHairline = paint.getStyle() == SkPaint::kStroke_Style &&
                          paint.getStrokeWidth() == 0;
        this->drawPath(src, paint, nullptr, false, !isHairline, customBlitter);
    }

◆ drawRect() [1/2]

void SkDrawBase::drawRect	(	const SkRect &	prePaintRect,
		const SkPaint &	paint,
		const SkMatrix *	paintMatrix,
		const SkRect *	postPaintRect
	)		const

Definition at line 159 of file SkDrawBase.cpp.

                                                                                      {
    SkDEBUGCODE(this->validate();)
 
    // nothing to draw
    if (fRC->isEmpty()) {
        return;
    }
 
    SkTCopyOnFirstWrite<SkMatrix> matrix(fCTM);
    if (paintMatrix) {
        SkASSERT(postPaintRect);
        matrix.writable()->preConcat(*paintMatrix);
    } else {
        SkASSERT(!postPaintRect);
    }
 
    SkPoint strokeSize;
    RectType rtype = ComputeRectType(prePaintRect, paint, *fCTM, &strokeSize);
 
    if (kPath_RectType == rtype) {
        draw_rect_as_path(*this, prePaintRect, paint, *matrix);
        return;
    }
 
    SkRect devRect;
    const SkRect& paintRect = paintMatrix ? *postPaintRect : prePaintRect;
    // skip the paintMatrix when transforming the rect by the CTM
    fCTM->mapPoints(rect_points(devRect), rect_points(paintRect), 2);
    devRect.sort();
 
    // look for the quick exit, before we build a blitter
    SkRect bbox = devRect;
    if (paint.getStyle() != SkPaint::kFill_Style) {
        // extra space for hairlines
        if (paint.getStrokeWidth() == 0) {
            bbox.outset(1, 1);
        } else {
            // For kStroke_RectType, strokeSize is already computed.
            const SkPoint& ssize = (kStroke_RectType == rtype)
                ? strokeSize
                : compute_stroke_size(paint, *fCTM);
            bbox.outset(SkScalarHalf(ssize.x()), SkScalarHalf(ssize.y()));
        }
    }
    if (SkPathPriv::TooBigForMath(bbox)) {
        return;
    }
 
    if (!SkRectPriv::FitsInFixed(bbox) && rtype != kHair_RectType) {
        draw_rect_as_path(*this, prePaintRect, paint, *matrix);
        return;
    }
 
    SkIRect ir = bbox.roundOut();
    if (fRC->quickReject(ir)) {
        return;
    }
 
    SkAutoBlitterChoose blitterStorage(*this, matrix, paint);
    const SkRasterClip& clip = *fRC;
    SkBlitter*          blitter = blitterStorage.get();
 
    // we want to "fill" if we are kFill or kStrokeAndFill, since in the latter
    // case we are also hairline (if we've gotten to here), which devolves to
    // effectively just kFill
    switch (rtype) {
        case kFill_RectType:
            if (paint.isAntiAlias()) {
                SkScan::AntiFillRect(devRect, clip, blitter);
            } else {
                SkScan::FillRect(devRect, clip, blitter);
            }
            break;
        case kStroke_RectType:
            if (paint.isAntiAlias()) {
                SkScan::AntiFrameRect(devRect, strokeSize, clip, blitter);
            } else {
                SkScan::FrameRect(devRect, strokeSize, clip, blitter);
            }
            break;
        case kHair_RectType:
            if (paint.isAntiAlias()) {
                SkScan::AntiHairRect(devRect, clip, blitter);
            } else {
                SkScan::HairRect(devRect, clip, blitter);
            }
            break;
        default:
            SkDEBUGFAIL("bad rtype");
    }
}

◆ drawRect() [2/2]

void SkDrawBase::drawRect	(	const SkRect &	rect,
		const SkPaint &	paint
	)		const

inline

Definition at line 47 of file SkDrawBase.h.

                                                                     {
        this->drawRect(rect, paint, nullptr, nullptr);
    }

◆ drawRRect()

void SkDrawBase::drawRRect	(	const SkRRect &	rrect,
		const SkPaint &	paint
	)		const

Definition at line 286 of file SkDrawBase.cpp.

                                                                           {
    SkDEBUGCODE(this->validate());
 
    if (fRC->isEmpty()) {
        return;
    }
 
    {
        // TODO: Investigate optimizing these options. They are in the same
        // order as SkDrawBase::drawPath, which handles each case. It may be
        // that there is no way to optimize for these using the SkRRect path.
        SkScalar coverage;
        if (SkDrawTreatAsHairline(paint, *fCTM, &coverage)) {
            goto DRAW_PATH;
        }
 
        if (paint.getPathEffect() || paint.getStyle() != SkPaint::kFill_Style) {
            goto DRAW_PATH;
        }
    }
 
    if (paint.getMaskFilter()) {
        // Transform the rrect into device space.
        SkRRect devRRect;
        if (rrect.transform(*fCTM, &devRRect)) {
            SkAutoBlitterChoose blitter(*this, nullptr, paint);
            if (as_MFB(paint.getMaskFilter())->filterRRect(devRRect, *fCTM, *fRC, blitter.get())) {
                return;  // filterRRect() called the blitter, so we're done
            }
        }
    }
 
DRAW_PATH:
    // Now fall back to the default case of using a path.
    SkPath path;
    path.addRRect(rrect);
    this->drawPath(path, paint, nullptr, true);
}

◆ DrawToMask()

bool SkDrawBase::DrawToMask	(	const SkPath &	devPath,
		const SkIRect &	clipBounds,
		const SkMaskFilter *	filter,
		const SkMatrix *	filterMatrix,
		SkMaskBuilder *	dst,
		SkMaskBuilder::CreateMode	mode,
		SkStrokeRec::InitStyle	style
	)

static

Helper function that creates a mask from a path and an optional maskfilter. Note however, that the resulting mask will not have been actually filtered, that must be done afterwards (by calling filterMask). The maskfilter is provided solely to assist in computing the mask's bounds (if the mode requests that).

Definition at line 559 of file SkDrawBase.cpp.

                                                    {
    if (devPath.isEmpty()) {
        return false;
    }
 
    if (SkMaskBuilder::kJustRenderImage_CreateMode != mode) {
        // By using infinite bounds for inverse fills, ComputeMaskBounds is able to clip it to
        // 'clipBounds' outset by whatever extra margin the mask filter requires.
        static const SkRect kInverseBounds = { SK_ScalarNegativeInfinity, SK_ScalarNegativeInfinity,
                                               SK_ScalarInfinity, SK_ScalarInfinity};
        SkRect pathBounds = devPath.isInverseFillType() ? kInverseBounds
                                                        : devPath.getBounds();
        if (!ComputeMaskBounds(pathBounds, clipBounds, filter,
                               filterMatrix, &dst->bounds()))
            return false;
    }
 
    if (SkMaskBuilder::kComputeBoundsAndRenderImage_CreateMode == mode) {
        dst->format() = SkMask::kA8_Format;
        dst->rowBytes() = dst->fBounds.width();
        size_t size = dst->computeImageSize();
        if (0 == size) {
            // we're too big to allocate the mask, abort
            return false;
        }
        dst->image() = SkMaskBuilder::AllocImage(size, SkMaskBuilder::kZeroInit_Alloc);
    }
 
    if (SkMaskBuilder::kJustComputeBounds_CreateMode != mode) {
        draw_into_mask(*dst, devPath, style);
    }
 
    return true;
}

◆ validate()

void SkDrawBase::validate ( ) const

inline

Definition at line 162 of file SkDrawBase.h.

162{}

Member Data Documentation

◆ fBlitterChooser

BlitterChooser* SkDrawBase::fBlitterChooser {nullptr}

Definition at line 154 of file SkDrawBase.h.

◆ fCTM

const SkMatrix* SkDrawBase::fCTM {nullptr}

Definition at line 155 of file SkDrawBase.h.

◆ fDst

SkPixmap SkDrawBase::fDst

Definition at line 153 of file SkDrawBase.h.

◆ fProps

const SkSurfaceProps* SkDrawBase::fProps {nullptr}

Definition at line 157 of file SkDrawBase.h.

◆ fRC

const SkRasterClip* SkDrawBase::fRC {nullptr}

Definition at line 156 of file SkDrawBase.h.

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

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

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Detailed Description

Member Typedef Documentation

◆ BlitterChooser

Member Enumeration Documentation

◆ RectType

Constructor & Destructor Documentation

◆ SkDrawBase()

Member Function Documentation

◆ ComputeMaskBounds()

◆ ComputeRectType()

◆ drawDevicePoints()

◆ drawPaint()

◆ drawPath()

◆ drawPathCoverage()

◆ drawRect() [1/2]

◆ drawRect() [2/2]

◆ drawRRect()

◆ DrawToMask()

◆ validate()

Member Data Documentation

◆ fBlitterChooser

◆ fCTM

◆ fDst

◆ fProps

◆ fRC