SkDrawBase.cpp File Reference

#include "include/core/SkMatrix.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPath.h"
#include "include/core/SkPathEffect.h"
#include "include/core/SkPathTypes.h"
#include "include/core/SkPathUtils.h"
#include "include/core/SkPixmap.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRRect.h"
#include "include/core/SkRect.h"
#include "include/core/SkScalar.h"
#include "include/core/SkStrokeRec.h"
#include "include/private/base/SkAssert.h"
#include "include/private/base/SkCPUTypes.h"
#include "include/private/base/SkDebug.h"
#include "include/private/base/SkFloatingPoint.h"
#include "include/private/base/SkTemplates.h"
#include "src/base/SkTLazy.h"
#include "src/base/SkZip.h"
#include "src/core/SkAutoBlitterChoose.h"
#include "src/core/SkBlendModePriv.h"
#include "src/core/SkBlitter_A8.h"
#include "src/core/SkDevice.h"
#include "src/core/SkDrawBase.h"
#include "src/core/SkDrawProcs.h"
#include "src/core/SkMask.h"
#include "src/core/SkMaskFilterBase.h"
#include "src/core/SkPathEffectBase.h"
#include "src/core/SkPathPriv.h"
#include "src/core/SkRasterClip.h"
#include "src/core/SkRectPriv.h"
#include "src/core/SkScan.h"
#include <algorithm>
#include <cstddef>
#include <optional>

Go to the source code of this file.

Functions
static SkPoint	compute_stroke_size (const SkPaint &paint, const SkMatrix &matrix)
static bool	easy_rect_join (const SkRect &rect, const SkPaint &paint, const SkMatrix &matrix, SkPoint *strokeSize)
static const SkPoint *	rect_points (const SkRect &r)
static SkPoint *	rect_points (SkRect &r)
static void	draw_rect_as_path (const SkDrawBase &orig, const SkRect &prePaintRect, const SkPaint &paint, const SkMatrix &ctm)
static SkScalar	fast_len (const SkVector &vec)
bool	SkDrawTreatAAStrokeAsHairline (SkScalar strokeWidth, const SkMatrix &matrix, SkScalar *coverage)
static void	draw_into_mask (const SkMask &mask, const SkPath &devPath, SkStrokeRec::InitStyle style)

Function Documentation

compute_stroke_size()

static SkPoint compute_stroke_size ( const SkPaint &  paint, const SkMatrix &  matrix  )

inlinestatic

Definition at line 90 of file SkDrawBase.cpp.

                                                                                        {
    SkASSERT(matrix.rectStaysRect());
    SkASSERT(SkPaint::kFill_Style != paint.getStyle());
 
    SkVector size;
    SkPoint pt = { paint.getStrokeWidth(), paint.getStrokeWidth() };
    matrix.mapVectors(&size, &pt, 1);
    return SkPoint::Make(SkScalarAbs(size.fX), SkScalarAbs(size.fY));
}

draw_into_mask()

static void draw_into_mask ( const SkMask &  mask, const SkPath &  devPath, SkStrokeRec::InitStyle  style  )

static

Definition at line 527 of file SkDrawBase.cpp.

                                                       {
    SkDrawBase draw;
    draw.fBlitterChooser = SkA8Blitter_Choose;
    if (!draw.fDst.reset(mask)) {
        return;
    }
 
    SkRasterClip    clip;
    SkMatrix        matrix;
    SkPaint         paint;
 
    clip.setRect(SkIRect::MakeWH(mask.fBounds.width(), mask.fBounds.height()));
    matrix.setTranslate(-SkIntToScalar(mask.fBounds.fLeft),
                        -SkIntToScalar(mask.fBounds.fTop));
 
    draw.fRC  = &clip;
    draw.fCTM = &matrix;
    paint.setAntiAlias(true);
    switch (style) {
        case SkStrokeRec::kHairline_InitStyle:
            SkASSERT(!paint.getStrokeWidth());
            paint.setStyle(SkPaint::kStroke_Style);
            break;
        case SkStrokeRec::kFill_InitStyle:
            SkASSERT(paint.getStyle() == SkPaint::kFill_Style);
            break;
 
    }
    draw.drawPath(devPath, paint);
}

draw_rect_as_path()

static void draw_rect_as_path ( const SkDrawBase &  orig, const SkRect &  prePaintRect, const SkPaint &  paint, const SkMatrix &  ctm  )

static

Definition at line 147 of file SkDrawBase.cpp.

                                                   {
    SkDrawBase draw(orig);
    draw.fCTM = &ctm;
    SkPath  tmp;
    tmp.addRect(prePaintRect);
    tmp.setFillType(SkPathFillType::kWinding);
    draw.drawPath(tmp, paint, nullptr, true);
}

easy_rect_join()

static bool easy_rect_join ( const SkRect &  rect, const SkPaint &  paint, const SkMatrix &  matrix, SkPoint *  strokeSize  )

static

Definition at line 100 of file SkDrawBase.cpp.

                                                {
    if (rect.isEmpty() || SkPaint::kMiter_Join != paint.getStrokeJoin() ||
        paint.getStrokeMiter() < SK_ScalarSqrt2) {
        return false;
    }
 
    *strokeSize = compute_stroke_size(paint, matrix);
    return true;
}

fast_len()

static SkScalar fast_len ( const SkVector &  vec )

static

Definition at line 252 of file SkDrawBase.cpp.

                                              {
    SkScalar x = SkScalarAbs(vec.fX);
    SkScalar y = SkScalarAbs(vec.fY);
    if (x < y) {
        using std::swap;
        swap(x, y);
    }
    return x + SkScalarHalf(y);
}

rect_points() [1/2]

static const SkPoint * rect_points ( const SkRect &  r )

static

Definition at line 139 of file SkDrawBase.cpp.

                                                   {
    return reinterpret_cast<const SkPoint*>(&r);
}

rect_points() [2/2]

static SkPoint * rect_points ( SkRect &  r )

static

Definition at line 143 of file SkDrawBase.cpp.

                                       {
    return reinterpret_cast<SkPoint*>(&r);
}

SkDrawTreatAAStrokeAsHairline()

bool SkDrawTreatAAStrokeAsHairline	(	SkScalar	strokeWidth,
		const SkMatrix &	matrix,
		SkScalar *	coverage
	)

Definition at line 262 of file SkDrawBase.cpp.

                                                       {
    SkASSERT(strokeWidth > 0);
    // We need to try to fake a thick-stroke with a modulated hairline.
 
    if (matrix.hasPerspective()) {
        return false;
    }
 
    SkVector src[2], dst[2];
    src[0].set(strokeWidth, 0);
    src[1].set(0, strokeWidth);
    matrix.mapVectors(dst, src, 2);
    SkScalar len0 = fast_len(dst[0]);
    SkScalar len1 = fast_len(dst[1]);
    if (len0 <= SK_Scalar1 && len1 <= SK_Scalar1) {
        if (coverage) {
            *coverage = SkScalarAve(len0, len1);
        }
        return true;
    }
    return false;
}