#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)

void	saveXY (SkFixed x, SkFixed y, SkFixed dY)

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

SkAnalyticEdge *	fRiteE

SkFixed	fX

SkFixed	fDX

SkFixed	fUpperX

SkFixed	fY

SkFixed	fUpperY

SkFixed	fLowerY

SkFixed	fDY

SkFixed	fSavedX

SkFixed	fSavedY

SkFixed	fSavedDY

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 114 of file SkAnalyticEdge.h.

Member Function Documentation

◆ keepContinuous()

void SkAnalyticQuadraticEdge::keepContinuous ( )

inline

Definition at line 122 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 266 of file SkAnalyticEdge.cpp.

                                                               {
    fRiteE = nullptr;
 
    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 294 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 115 of file SkAnalyticEdge.h.

◆ fSnappedX

SkFixed SkAnalyticQuadraticEdge::fSnappedX

Definition at line 118 of file SkAnalyticEdge.h.

◆ fSnappedY

SkFixed SkAnalyticQuadraticEdge::fSnappedY