SkCubicEdge Struct Reference

#include <SkEdge.h>

Inheritance diagram for SkCubicEdge:

Public Member Functions
bool	setCubicWithoutUpdate (const SkPoint pts[4], int shiftUp, bool sortY=true)
int	setCubic (const SkPoint pts[4], int shiftUp)
int	updateCubic ()
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	fCx
SkFixed	fCy
SkFixed	fCDx
SkFixed	fCDy
SkFixed	fCDDx
SkFixed	fCDDy
SkFixed	fCDDDx
SkFixed	fCDDDy
SkFixed	fCLastX
SkFixed	fCLastY
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 82 of file SkEdge.h.

Member Function Documentation

setCubic()

int SkCubicEdge::setCubic	(	const SkPoint	pts[4],
		int	shiftUp
	)

Definition at line 474 of file SkEdge.cpp.

                                                         {
    if (!this->setCubicWithoutUpdate(pts, shift)) {
        return 0;
    }
    return this->updateCubic();
}

setCubicWithoutUpdate()

bool SkCubicEdge::setCubicWithoutUpdate	(	const SkPoint	pts[4],
		int	shiftUp,
		bool	sortY = true
	)

Definition at line 373 of file SkEdge.cpp.

                                                                                   {
    SkFDot6 x0, y0, x1, y1, x2, y2, x3, y3;
 
    {
#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);
        x3 = SkScalarRoundToFDot6(pts[3].fX, shift);
        y3 = SkScalarRoundToFDot6(pts[3].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);
        x3 = int(pts[3].fX * scale);
        y3 = int(pts[3].fY * scale);
#endif
    }
 
    int winding = 1;
    if (sortY && y0 > y3)
    {
        using std::swap;
        swap(x0, x3);
        swap(x1, x2);
        swap(y0, y3);
        swap(y1, y2);
        winding = -1;
    }
 
    int top = SkFDot6Round(y0);
    int bot = SkFDot6Round(y3);
 
    // are we a zero-height cubic (line)?
    if (sortY && top == bot)
        return 0;
 
    // compute number of steps needed (1 << shift)
    {
        // Can't use (center of curve - center of baseline), since center-of-curve
        // need not be the max delta from the baseline (it could even be coincident)
        // so we try just looking at the two off-curve points
        SkFDot6 dx = cubic_delta_from_line(x0, x1, x2, x3);
        SkFDot6 dy = cubic_delta_from_line(y0, y1, y2, y3);
        // add 1 (by observation)
        shift = diff_to_shift(dx, dy) + 1;
    }
    // need at least 1 subdivision for our bias trick
    SkASSERT(shift > 0);
    if (shift > MAX_COEFF_SHIFT) {
        shift = MAX_COEFF_SHIFT;
    }
 
    /*  Since our in coming data is initially shifted down by 10 (or 8 in
        antialias). That means the most we can shift up is 8. However, we
        compute coefficients with a 3*, so the safest upshift is really 6
    */
    int upShift = 6;    // largest safe value
    int downShift = shift + upShift - 10;
    if (downShift < 0) {
        downShift = 0;
        upShift = 10 - shift;
    }
 
    fWinding    = SkToS8(winding);
    fEdgeType   = kCubic_Type;
    fCurveCount = SkToS8(SkLeftShift(-1, shift));
    fCurveShift = SkToU8(shift);
    fCubicDShift = SkToU8(downShift);
 
    SkFixed B = SkFDot6UpShift(3 * (x1 - x0), upShift);
    SkFixed C = SkFDot6UpShift(3 * (x0 - x1 - x1 + x2), upShift);
    SkFixed D = SkFDot6UpShift(x3 + 3 * (x1 - x2) - x0, upShift);
 
    fCx     = SkFDot6ToFixed(x0);
    fCDx    = B + (C >> shift) + (D >> 2*shift);    // biased by shift
    fCDDx   = 2*C + (3*D >> (shift - 1));           // biased by 2*shift
    fCDDDx  = 3*D >> (shift - 1);                   // biased by 2*shift
 
    B = SkFDot6UpShift(3 * (y1 - y0), upShift);
    C = SkFDot6UpShift(3 * (y0 - y1 - y1 + y2), upShift);
    D = SkFDot6UpShift(y3 + 3 * (y1 - y2) - y0, upShift);
 
    fCy     = SkFDot6ToFixed(y0);
    fCDy    = B + (C >> shift) + (D >> 2*shift);    // biased by shift
    fCDDy   = 2*C + (3*D >> (shift - 1));           // biased by 2*shift
    fCDDDy  = 3*D >> (shift - 1);                   // biased by 2*shift
 
    fCLastX = SkFDot6ToFixed(x3);
    fCLastY = SkFDot6ToFixed(y3);
 
    return true;
}

updateCubic()

int SkCubicEdge::updateCubic

(

)

Definition at line 481 of file SkEdge.cpp.

{
    int     success;
    int     count = fCurveCount;
    SkFixed oldx = fCx;
    SkFixed oldy = fCy;
    SkFixed newx, newy;
    const int ddshift = fCurveShift;
    const int dshift = fCubicDShift;
 
    SkASSERT(count < 0);
 
    do {
        if (++count < 0)
        {
            newx    = oldx + (fCDx >> dshift);
            fCDx    += fCDDx >> ddshift;
            fCDDx   += fCDDDx;
 
            newy    = oldy + (fCDy >> dshift);
            fCDy    += fCDDy >> ddshift;
            fCDDy   += fCDDDy;
        }
        else    // last segment
        {
        //  SkDebugf("LastX err=%d, LastY err=%d\n", (oldx + (fCDx >> shift) - fLastX), (oldy + (fCDy >> shift) - fLastY));
            newx    = fCLastX;
            newy    = fCLastY;
        }
 
        // we want to say SkASSERT(oldy <= newy), but our finite fixedpoint
        // doesn't always achieve that, so we have to explicitly pin it here.
        if (newy < oldy) {
            newy = oldy;
        }
 
        success = this->updateLine(oldx, oldy, newx, newy);
        oldx = newx;
        oldy = newy;
    } while (count < 0 && !success);
 
    fCx         = newx;
    fCy         = newy;
    fCurveCount = SkToS8(count);
    return success;
}

Member Data Documentation

fCDDDx

SkFixed SkCubicEdge::fCDDDx

Definition at line 86 of file SkEdge.h.

fCDDDy

SkFixed SkCubicEdge::fCDDDy

Definition at line 86 of file SkEdge.h.

fCDDx

SkFixed SkCubicEdge::fCDDx

Definition at line 85 of file SkEdge.h.

fCDDy

SkFixed SkCubicEdge::fCDDy

Definition at line 85 of file SkEdge.h.

fCDx

SkFixed SkCubicEdge::fCDx

Definition at line 84 of file SkEdge.h.

fCDy

SkFixed SkCubicEdge::fCDy

Definition at line 84 of file SkEdge.h.

fCLastX

SkFixed SkCubicEdge::fCLastX

Definition at line 87 of file SkEdge.h.

fCLastY

SkFixed SkCubicEdge::fCLastY

Definition at line 87 of file SkEdge.h.

fCx

SkFixed SkCubicEdge::fCx

Definition at line 83 of file SkEdge.h.

fCy

SkFixed SkCubicEdge::fCy

Definition at line 83 of file SkEdge.h.

---

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

• third_party/skia/src/core/SkEdge.h
• third_party/skia/src/core/SkEdge.cpp