#include <SkAnalyticEdge.h>

Inheritance diagram for SkAnalyticQuadraticEdge:

Public Member Functions
bool	setQuadratic (const SkPoint pts[3])

bool	updateQuadratic ()

void	keepContinuous ()

Public Member Functions inherited from SkAnalyticEdge
void	goY (SkFixed y)

void	goY (SkFixed y, int yShift)

bool	setLine (const SkPoint &p0, const SkPoint &p1)

bool	updateLine (SkFixed ax, SkFixed ay, SkFixed bx, SkFixed by, SkFixed slope)

bool	update (SkFixed last_y, bool sortY=true)

Public Attributes
SkQuadraticEdge	fQEdge

SkFixed	fSnappedX

SkFixed	fSnappedY

Public Attributes inherited from SkAnalyticEdge
SkAnalyticEdge *	fNext

SkAnalyticEdge *	fPrev

SkFixed	fX

SkFixed	fDX

SkFixed	fUpperX

SkFixed	fY

SkFixed	fUpperY

SkFixed	fLowerY

SkFixed	fDY

Type	fEdgeType

int8_t	fCurveCount

uint8_t	fCurveShift

uint8_t	fCubicDShift

int8_t	fWinding

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

Static Public Member Functions inherited from SkAnalyticEdge
static SkFixed	SnapY (SkFixed y)

Static Public Attributes inherited from SkAnalyticEdge
static const int	kDefaultAccuracy = 2

Detailed Description

Definition at line 100 of file SkAnalyticEdge.h.

Member Function Documentation

◆ keepContinuous()

void SkAnalyticQuadraticEdge::keepContinuous ( )

inline

Definition at line 108 of file SkAnalyticEdge.h.

                                 {
        // We use fX as the starting x to ensure the continuouty.
        // Without it, we may break the sorted edge list.
        SkASSERT(SkAbs32(fX - SkFixedMul(fY - fSnappedY, fDX) - fSnappedX) < SK_Fixed1);
        SkASSERT(SkAbs32(fY - fSnappedY) < SK_Fixed1); // This may differ due to smooth jump
        fSnappedX = fX;
        fSnappedY = fY;
    }

◆ setQuadratic()

bool SkAnalyticQuadraticEdge::setQuadratic ( const SkPoint pts[3] )

Definition at line 264 of file SkAnalyticEdge.cpp.

                                                               {
    if (!fQEdge.setQuadraticWithoutUpdate(pts, kDefaultAccuracy)) {
        return false;
    }
    fQEdge.fQx >>= kDefaultAccuracy;
    fQEdge.fQy >>= kDefaultAccuracy;
    fQEdge.fQDx >>= kDefaultAccuracy;
    fQEdge.fQDy >>= kDefaultAccuracy;
    fQEdge.fQDDx >>= kDefaultAccuracy;
    fQEdge.fQDDy >>= kDefaultAccuracy;
    fQEdge.fQLastX >>= kDefaultAccuracy;
    fQEdge.fQLastY >>= kDefaultAccuracy;
    fQEdge.fQy = SnapY(fQEdge.fQy);
    fQEdge.fQLastY = SnapY(fQEdge.fQLastY);
 
    fWinding = fQEdge.fWinding;
    fEdgeType = kQuad_Type;
    fCurveCount = fQEdge.fCurveCount;
    fCurveShift = fQEdge.fCurveShift;
 
    fSnappedX = fQEdge.fQx;
    fSnappedY = fQEdge.fQy;
 
    return this->updateQuadratic();
}

◆ updateQuadratic()

bool SkAnalyticQuadraticEdge::updateQuadratic ( )

Definition at line 290 of file SkAnalyticEdge.cpp.

                                              {
    int     success = 0; // initialize to fail!
    int     count = fCurveCount;
    SkFixed oldx = fQEdge.fQx;
    SkFixed oldy = fQEdge.fQy;
    SkFixed dx = fQEdge.fQDx;
    SkFixed dy = fQEdge.fQDy;
    SkFixed newx, newy, newSnappedX, newSnappedY;
    int     shift = fCurveShift;
 
    SkASSERT(count > 0);
 
    do {
        SkFixed slope;
        if (--count > 0)
        {
            newx    = oldx + (dx >> shift);
            newy    = oldy + (dy >> shift);
            if (SkAbs32(dy >> shift) >= SK_Fixed1 * 2) { // only snap when dy is large enough
                SkFDot6 diffY = SkFixedToFDot6(newy - fSnappedY);
                slope = diffY ? quick_div(SkFixedToFDot6(newx - fSnappedX), diffY)
                              : SK_MaxS32;
                newSnappedY = std::min<SkFixed>(fQEdge.fQLastY, SkFixedRoundToFixed(newy));
                newSnappedX = newx - SkFixedMul(slope, newy - newSnappedY);
            } else {
                newSnappedY = std::min(fQEdge.fQLastY, SnapY(newy));
                newSnappedX = newx;
                SkFDot6 diffY = SkFixedToFDot6(newSnappedY - fSnappedY);
                slope = diffY ? quick_div(SkFixedToFDot6(newx - fSnappedX), diffY)
                              : SK_MaxS32;
            }
            dx += fQEdge.fQDDx;
            dy += fQEdge.fQDDy;
        }
        else    // last segment
        {
            newx    = fQEdge.fQLastX;
            newy    = fQEdge.fQLastY;
            newSnappedY = newy;
            newSnappedX = newx;
            SkFDot6 diffY = (newy - fSnappedY) >> 10;
            slope = diffY ? quick_div((newx - fSnappedX) >> 10, diffY) : SK_MaxS32;
        }
        if (slope < SK_MaxS32) {
            success = this->updateLine(fSnappedX, fSnappedY, newSnappedX, newSnappedY, slope);
        }
        oldx = newx;
        oldy = newy;
    } while (count > 0 && !success);
 
    SkASSERT(newSnappedY <= fQEdge.fQLastY);
 
    fQEdge.fQx  = newx;
    fQEdge.fQy  = newy;
    fQEdge.fQDx = dx;
    fQEdge.fQDy = dy;
    fSnappedX   = newSnappedX;
    fSnappedY   = newSnappedY;
    fCurveCount = SkToS8(count);
    return success;
}

Member Data Documentation

◆ fQEdge

SkQuadraticEdge SkAnalyticQuadraticEdge::fQEdge

Definition at line 101 of file SkAnalyticEdge.h.

◆ fSnappedX

SkFixed SkAnalyticQuadraticEdge::fSnappedX

Definition at line 104 of file SkAnalyticEdge.h.

◆ fSnappedY

SkFixed SkAnalyticQuadraticEdge::fSnappedY