#include <SkEdge.h>

Inheritance diagram for SkQuadraticEdge:

Public Member Functions
bool	setQuadraticWithoutUpdate (const SkPoint pts[3], int shiftUp)

int	setQuadratic (const SkPoint pts[3], int shiftUp)

int	updateQuadratic ()

Public Member Functions inherited from SkEdge
int	setLine (const SkPoint &p0, const SkPoint &p1, const SkIRect *clip, int shiftUp)

int	setLine (const SkPoint &p0, const SkPoint &p1, int shiftUp)

int	updateLine (SkFixed ax, SkFixed ay, SkFixed bx, SkFixed by)

void	chopLineWithClip (const SkIRect &clip)

bool	intersectsClip (const SkIRect &clip) const

Public Attributes
SkFixed	fQx

SkFixed	fQy

SkFixed	fQDx

SkFixed	fQDy

SkFixed	fQDDx

SkFixed	fQDDy

SkFixed	fQLastX

SkFixed	fQLastY

Public Attributes inherited from SkEdge
SkEdge *	fNext

SkEdge *	fPrev

SkFixed	fX

SkFixed	fDX

int32_t	fFirstY

int32_t	fLastY

Type	fEdgeType

int8_t	fCurveCount

uint8_t	fCurveShift

uint8_t	fCubicDShift

int8_t	fWinding

Additional Inherited Members
Public Types inherited from SkEdge
enum	Type { kLine_Type , kQuad_Type , kCubic_Type }

Detailed Description

Definition at line 71 of file SkEdge.h.

Member Function Documentation

◆ setQuadratic()

int SkQuadraticEdge::setQuadratic	(	const SkPoint	pts[3],
		int	shiftUp
	)

Definition at line 303 of file SkEdge.cpp.

                                                                 {
    if (!setQuadraticWithoutUpdate(pts, shift)) {
        return 0;
    }
    return this->updateQuadratic();
}

◆ setQuadraticWithoutUpdate()

bool SkQuadraticEdge::setQuadraticWithoutUpdate	(	const SkPoint	pts[3],
		int	shiftUp
	)

Definition at line 202 of file SkEdge.cpp.

                                                                               {
    SkFDot6 x0, y0, x1, y1, x2, y2;
 
    {
#ifdef SK_RASTERIZE_EVEN_ROUNDING
        x0 = SkScalarRoundToFDot6(pts[0].fX, shift);
        y0 = SkScalarRoundToFDot6(pts[0].fY, shift);
        x1 = SkScalarRoundToFDot6(pts[1].fX, shift);
        y1 = SkScalarRoundToFDot6(pts[1].fY, shift);
        x2 = SkScalarRoundToFDot6(pts[2].fX, shift);
        y2 = SkScalarRoundToFDot6(pts[2].fY, shift);
#else
        float scale = float(1 << (shift + 6));
        x0 = int(pts[0].fX * scale);
        y0 = int(pts[0].fY * scale);
        x1 = int(pts[1].fX * scale);
        y1 = int(pts[1].fY * scale);
        x2 = int(pts[2].fX * scale);
        y2 = int(pts[2].fY * scale);
#endif
    }
 
    int winding = 1;
    if (y0 > y2)
    {
        using std::swap;
        swap(x0, x2);
        swap(y0, y2);
        winding = -1;
    }
    SkASSERT(y0 <= y1 && y1 <= y2);
 
    int top = SkFDot6Round(y0);
    int bot = SkFDot6Round(y2);
 
    // are we a zero-height quad (line)?
    if (top == bot)
        return 0;
 
    // compute number of steps needed (1 << shift)
    {
        SkFDot6 dx = (SkLeftShift(x1, 1) - x0 - x2) >> 2;
        SkFDot6 dy = (SkLeftShift(y1, 1) - y0 - y2) >> 2;
        // This is a little confusing:
        // before this line, shift is the scale up factor for AA;
        // after this line, shift is the fCurveShift.
        shift = diff_to_shift(dx, dy, shift);
        SkASSERT(shift >= 0);
    }
    // need at least 1 subdivision for our bias trick
    if (shift == 0) {
        shift = 1;
    } else if (shift > MAX_COEFF_SHIFT) {
        shift = MAX_COEFF_SHIFT;
    }
 
    fWinding    = SkToS8(winding);
    //fCubicDShift only set for cubics
    fEdgeType   = kQuad_Type;
    fCurveCount = SkToS8(1 << shift);
 
    /*
     *  We want to reformulate into polynomial form, to make it clear how we
     *  should forward-difference.
     *
     *  p0 (1 - t)^2 + p1 t(1 - t) + p2 t^2 ==> At^2 + Bt + C
     *
     *  A = p0 - 2p1 + p2
     *  B = 2(p1 - p0)
     *  C = p0
     *
     *  Our caller must have constrained our inputs (p0..p2) to all fit into
     *  16.16. However, as seen above, we sometimes compute values that can be
     *  larger (e.g. B = 2*(p1 - p0)). To guard against overflow, we will store
     *  A and B at 1/2 of their actual value, and just apply a 2x scale during
     *  application in updateQuadratic(). Hence we store (shift - 1) in
     *  fCurveShift.
     */
 
    fCurveShift = SkToU8(shift - 1);
 
    SkFixed A = SkFDot6ToFixedDiv2(x0 - x1 - x1 + x2);  // 1/2 the real value
    SkFixed B = SkFDot6ToFixed(x1 - x0);                // 1/2 the real value
 
    fQx     = SkFDot6ToFixed(x0);
    fQDx    = B + (A >> shift);     // biased by shift
    fQDDx   = A >> (shift - 1);     // biased by shift
 
    A = SkFDot6ToFixedDiv2(y0 - y1 - y1 + y2);  // 1/2 the real value
    B = SkFDot6ToFixed(y1 - y0);                // 1/2 the real value
 
    fQy     = SkFDot6ToFixed(y0);
    fQDy    = B + (A >> shift);     // biased by shift
    fQDDy   = A >> (shift - 1);     // biased by shift
 
    fQLastX = SkFDot6ToFixed(x2);
    fQLastY = SkFDot6ToFixed(y2);
 
    return true;
}

◆ updateQuadratic()

int SkQuadraticEdge::updateQuadratic ( )

Definition at line 310 of file SkEdge.cpp.

{
    int     success;
    int     count = fCurveCount;
    SkFixed oldx = fQx;
    SkFixed oldy = fQy;
    SkFixed dx = fQDx;
    SkFixed dy = fQDy;
    SkFixed newx, newy;
    int     shift = fCurveShift;
 
    SkASSERT(count > 0);
 
    do {
        if (--count > 0)
        {
            newx    = oldx + (dx >> shift);
            dx    += fQDDx;
            newy    = oldy + (dy >> shift);
            dy    += fQDDy;
        }
        else    // last segment
        {
            newx    = fQLastX;
            newy    = fQLastY;
        }
        success = this->updateLine(oldx, oldy, newx, newy);
        oldx = newx;
        oldy = newy;
    } while (count > 0 && !success);
 
    fQx         = newx;
    fQy         = newy;
    fQDx        = dx;
    fQDy        = dy;
    fCurveCount = SkToS8(count);
    return success;
}

Member Data Documentation

◆ fQDDx

SkFixed SkQuadraticEdge::fQDDx

Definition at line 74 of file SkEdge.h.

◆ fQDDy

SkFixed SkQuadraticEdge::fQDDy

Definition at line 74 of file SkEdge.h.

◆ fQDx

SkFixed SkQuadraticEdge::fQDx

Definition at line 73 of file SkEdge.h.

◆ fQDy

SkFixed SkQuadraticEdge::fQDy

Definition at line 73 of file SkEdge.h.

◆ fQLastX

SkFixed SkQuadraticEdge::fQLastX

Definition at line 75 of file SkEdge.h.

◆ fQLastY

SkFixed SkQuadraticEdge::fQLastY

Definition at line 75 of file SkEdge.h.

◆ fQx

SkFixed SkQuadraticEdge::fQx

Definition at line 72 of file SkEdge.h.

◆ fQy

SkFixed SkQuadraticEdge::fQy