GrPathUtils Namespace Reference

Classes
class	QuadUVMatrix

Functions
SkScalar	scaleToleranceToSrc (SkScalar devTol, const SkMatrix &viewM, const SkRect &pathBounds)
uint32_t	quadraticPointCount (const SkPoint points[], SkScalar tol)
uint32_t	generateQuadraticPoints (const SkPoint &p0, const SkPoint &p1, const SkPoint &p2, SkScalar tolSqd, SkPoint **points, uint32_t pointsLeft)
uint32_t	cubicPointCount (const SkPoint points[], SkScalar tol)
uint32_t	generateCubicPoints (const SkPoint &p0, const SkPoint &p1, const SkPoint &p2, const SkPoint &p3, SkScalar tolSqd, SkPoint **points, uint32_t pointsLeft)
void	getConicKLM (const SkPoint p[3], const SkScalar weight, SkMatrix *klm)
void	convertCubicToQuads (const SkPoint p[4], SkScalar tolScale, skia_private::TArray< SkPoint, true > *quads)
void	convertCubicToQuadsConstrainToTangents (const SkPoint p[4], SkScalar tolScale, SkPathFirstDirection dir, skia_private::TArray< SkPoint, true > *quads)

Variables
static const SkScalar	kDefaultTolerance = SkDoubleToScalar(0.25)
static const int	kMaxPointsPerCurve = 1 << 10

Detailed Description

Utilities for evaluating paths.

Function Documentation

convertCubicToQuads()

void GrPathUtils::convertCubicToQuads	(	const SkPoint	p[4],
		SkScalar	tolScale,
		skia_private::TArray< SkPoint, true > *	quads
	)

Definition at line 494 of file GrPathUtils.cpp.

                                                                    {
    if (!p[0].isFinite() || !p[1].isFinite() || !p[2].isFinite() || !p[3].isFinite()) {
        return;
    }
    if (!SkIsFinite(tolScale)) {
        return;
    }
    SkPoint chopped[10];
    int count = SkChopCubicAtInflections(p, chopped);
 
    const SkScalar tolSqd = SkScalarSquare(tolScale);
 
    for (int i = 0; i < count; ++i) {
        SkPoint* cubic = chopped + 3*i;
        convert_noninflect_cubic_to_quads(cubic, tolSqd, quads);
    }
}

convertCubicToQuadsConstrainToTangents()

void GrPathUtils::convertCubicToQuadsConstrainToTangents	(	const SkPoint	p[4],
		SkScalar	tolScale,
		SkPathFirstDirection	dir,
		skia_private::TArray< SkPoint, true > *	quads
	)

Definition at line 514 of file GrPathUtils.cpp.

                                                                                       {
    if (!p[0].isFinite() || !p[1].isFinite() || !p[2].isFinite() || !p[3].isFinite()) {
        return;
    }
    if (!SkIsFinite(tolScale)) {
        return;
    }
    SkPoint chopped[10];
    int count = SkChopCubicAtInflections(p, chopped);
 
    const SkScalar tolSqd = SkScalarSquare(tolScale);
 
    for (int i = 0; i < count; ++i) {
        SkPoint* cubic = chopped + 3*i;
        convert_noninflect_cubic_to_quads_with_constraint(cubic, tolSqd, dir, quads);
    }
}

cubicPointCount()

uint32_t GrPathUtils::cubicPointCount	(	const SkPoint	points[],
		SkScalar	tol
	)

Definition at line 103 of file GrPathUtils.cpp.

                                                                          {
    return max_bezier_vertices(skgpu::wangs_formula::cubic_log2(
            tolerance_to_wangs_precision(tol), points));
}

generateCubicPoints()

uint32_t GrPathUtils::generateCubicPoints	(	const SkPoint &	p0,
		const SkPoint &	p1,
		const SkPoint &	p2,
		const SkPoint &	p3,
		SkScalar	tolSqd,
		SkPoint **	points,
		uint32_t	pointsLeft
	)

Definition at line 108 of file GrPathUtils.cpp.

                                                               {
    if (pointsLeft < 2 ||
        (SkPointPriv::DistanceToLineSegmentBetweenSqd(p1, p0, p3) < tolSqd &&
         SkPointPriv::DistanceToLineSegmentBetweenSqd(p2, p0, p3) < tolSqd)) {
        (*points)[0] = p3;
        *points += 1;
        return 1;
    }
    SkPoint q[] = {
        { SkScalarAve(p0.fX, p1.fX), SkScalarAve(p0.fY, p1.fY) },
        { SkScalarAve(p1.fX, p2.fX), SkScalarAve(p1.fY, p2.fY) },
        { SkScalarAve(p2.fX, p3.fX), SkScalarAve(p2.fY, p3.fY) }
    };
    SkPoint r[] = {
        { SkScalarAve(q[0].fX, q[1].fX), SkScalarAve(q[0].fY, q[1].fY) },
        { SkScalarAve(q[1].fX, q[2].fX), SkScalarAve(q[1].fY, q[2].fY) }
    };
    SkPoint s = { SkScalarAve(r[0].fX, r[1].fX), SkScalarAve(r[0].fY, r[1].fY) };
    pointsLeft >>= 1;
    uint32_t a = generateCubicPoints(p0, q[0], r[0], s, tolSqd, points, pointsLeft);
    uint32_t b = generateCubicPoints(s, r[1], q[2], p3, tolSqd, points, pointsLeft);
    return a + b;
}

generateQuadraticPoints()

uint32_t GrPathUtils::generateQuadraticPoints	(	const SkPoint &	p0,
		const SkPoint &	p1,
		const SkPoint &	p2,
		SkScalar	tolSqd,
		SkPoint **	points,
		uint32_t	pointsLeft
	)

Definition at line 78 of file GrPathUtils.cpp.

                                                                   {
    if (pointsLeft < 2 ||
        (SkPointPriv::DistanceToLineSegmentBetweenSqd(p1, p0, p2)) < tolSqd) {
        (*points)[0] = p2;
        *points += 1;
        return 1;
    }
 
    SkPoint q[] = {
        { SkScalarAve(p0.fX, p1.fX), SkScalarAve(p0.fY, p1.fY) },
        { SkScalarAve(p1.fX, p2.fX), SkScalarAve(p1.fY, p2.fY) },
    };
    SkPoint r = { SkScalarAve(q[0].fX, q[1].fX), SkScalarAve(q[0].fY, q[1].fY) };
 
    pointsLeft >>= 1;
    uint32_t a = generateQuadraticPoints(p0, q[0], r, tolSqd, points, pointsLeft);
    uint32_t b = generateQuadraticPoints(r, q[1], p2, tolSqd, points, pointsLeft);
    return a + b;
}

getConicKLM()

void GrPathUtils::getConicKLM	(	const SkPoint	p[3],
		const SkScalar	weight,
		SkMatrix *	klm
	)

Definition at line 228 of file GrPathUtils.cpp.

                                                                                      {
    SkMatrix& klm = *out;
    const SkScalar w2 = 2.f * weight;
    klm[0] = p[2].fY - p[0].fY;
    klm[1] = p[0].fX - p[2].fX;
    klm[2] = p[2].fX * p[0].fY - p[0].fX * p[2].fY;
 
    klm[3] = w2 * (p[1].fY - p[0].fY);
    klm[4] = w2 * (p[0].fX - p[1].fX);
    klm[5] = w2 * (p[1].fX * p[0].fY - p[0].fX * p[1].fY);
 
    klm[6] = w2 * (p[2].fY - p[1].fY);
    klm[7] = w2 * (p[1].fX - p[2].fX);
    klm[8] = w2 * (p[2].fX * p[1].fY - p[1].fX * p[2].fY);
 
    // scale the max absolute value of coeffs to 10
    SkScalar scale = 0.f;
    for (int i = 0; i < 9; ++i) {
       scale = std::max(scale, SkScalarAbs(klm[i]));
    }
    SkASSERT(scale > 0.f);
    scale = 10.f / scale;
    for (int i = 0; i < 9; ++i) {
        klm[i] *= scale;
    }
}

quadraticPointCount()

uint32_t GrPathUtils::quadraticPointCount	(	const SkPoint	points[],
		SkScalar	tol
	)

Definition at line 73 of file GrPathUtils.cpp.

                                                                              {
    return max_bezier_vertices(skgpu::wangs_formula::quadratic_log2(
            tolerance_to_wangs_precision(tol), points));
}

scaleToleranceToSrc()

SkScalar GrPathUtils::scaleToleranceToSrc	(	SkScalar	devTol,
		const SkMatrix &	viewM,
		const SkRect &	pathBounds
	)

Definition at line 41 of file GrPathUtils.cpp.

                                                                    {
    // In order to tesselate the path we get a bound on how much the matrix can
    // scale when mapping to screen coordinates.
    SkScalar stretch = viewM.getMaxScale();
 
    if (stretch < 0) {
        // take worst case mapRadius amoung four corners.
        // (less than perfect)
        for (int i = 0; i < 4; ++i) {
            SkMatrix mat;
            mat.setTranslate((i % 2) ? pathBounds.fLeft : pathBounds.fRight,
                             (i < 2) ? pathBounds.fTop : pathBounds.fBottom);
            mat.postConcat(viewM);
            stretch = std::max(stretch, mat.mapRadius(SK_Scalar1));
        }
    }
    SkScalar srcTol = 0;
    if (stretch <= 0) {
        // We have degenerate bounds or some degenerate matrix. Thus we set the tolerance to be the
        // max of the path pathBounds width and height.
        srcTol = std::max(pathBounds.width(), pathBounds.height());
    } else {
        srcTol = devTol / stretch;
    }
    if (srcTol < kMinCurveTol) {
        srcTol = kMinCurveTol;
    }
    return srcTol;
}

Variable Documentation

kDefaultTolerance

const SkScalar GrPathUtils::kDefaultTolerance = SkDoubleToScalar(0.25)

static

Definition at line 32 of file GrPathUtils.h.

kMaxPointsPerCurve

const int GrPathUtils::kMaxPointsPerCurve = 1 << 10

static

Definition at line 35 of file GrPathUtils.h.