SkAnalyticEdge Struct Reference

#include <SkAnalyticEdge.h>

Inheritance diagram for SkAnalyticEdge:

Public Types
enum	Type { kLine_Type , kQuad_Type , kCubic_Type }

Public Member Functions
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)

Static Public Member Functions
static SkFixed	SnapY (SkFixed y)

Public Attributes
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

Static Public Attributes
static const int	kDefaultAccuracy = 2

Detailed Description

Definition at line 21 of file SkAnalyticEdge.h.

Member Enumeration Documentation

Type

enum SkAnalyticEdge::Type

Enumerator
kLine_Type
kQuad_Type
kCubic_Type

Definition at line 23 of file SkAnalyticEdge.h.

              {
        kLine_Type,
        kQuad_Type,
        kCubic_Type
    };

Member Function Documentation

goY() [1/2]

void SkAnalyticEdge::goY ( SkFixed  y )

inline

Definition at line 57 of file SkAnalyticEdge.h.

                               {
        if (y == fY + SK_Fixed1) {
            fX = fX + fDX;
            fY = y;
        } else if (y != fY) {
            // Drop lower digits as our alpha only has 8 bits
            // (fDX and y - fUpperY may be greater than SK_Fixed1)
            fX = fUpperX + SkFixedMul(fDX, y - fUpperY);
            fY = y;
        }
    }

goY() [2/2]

void SkAnalyticEdge::goY ( SkFixed  y, int  yShift  )

inline

Definition at line 69 of file SkAnalyticEdge.h.

                                           {
        SkASSERT(yShift >= 0 && yShift <= kDefaultAccuracy);
        SkASSERT(fDX == 0 || y - fY == SK_Fixed1 >> yShift);
        fY = y;
        fX += fDX >> yShift;
    }

setLine()

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

Definition at line 155 of file SkAnalyticEdge.cpp.

                                                                 {
    // We must set X/Y using the same way (e.g., times 4, to FDot6, then to Fixed) as Quads/Cubics.
    // Otherwise the order of the edge might be wrong due to precision limit.
    const int accuracy = kDefaultAccuracy;
#ifdef SK_RASTERIZE_EVEN_ROUNDING
    SkFixed x0 = SkFDot6ToFixed(SkScalarRoundToFDot6(p0.fX, accuracy)) >> accuracy;
    SkFixed y0 = SnapY(SkFDot6ToFixed(SkScalarRoundToFDot6(p0.fY, accuracy)) >> accuracy);
    SkFixed x1 = SkFDot6ToFixed(SkScalarRoundToFDot6(p1.fX, accuracy)) >> accuracy;
    SkFixed y1 = SnapY(SkFDot6ToFixed(SkScalarRoundToFDot6(p1.fY, accuracy)) >> accuracy);
#else
    const int multiplier = (1 << kDefaultAccuracy);
    SkFixed x0 = SkFDot6ToFixed(SkScalarToFDot6(p0.fX * multiplier)) >> accuracy;
    SkFixed y0 = SnapY(SkFDot6ToFixed(SkScalarToFDot6(p0.fY * multiplier)) >> accuracy);
    SkFixed x1 = SkFDot6ToFixed(SkScalarToFDot6(p1.fX * multiplier)) >> accuracy;
    SkFixed y1 = SnapY(SkFDot6ToFixed(SkScalarToFDot6(p1.fY * multiplier)) >> accuracy);
#endif
 
    int winding = 1;
 
    if (y0 > y1) {
        using std::swap;
        swap(x0, x1);
        swap(y0, y1);
        winding = -1;
    }
 
    // are we a zero-height line?
    SkFDot6 dy = SkFixedToFDot6(y1 - y0);
    if (dy == 0) {
        return false;
    }
    SkFDot6 dx = SkFixedToFDot6(x1 - x0);
    SkFixed slope = quick_div(dx, dy);
    SkFixed absSlope = SkAbs32(slope);
 
    fX          = x0;
    fDX         = slope;
    fUpperX     = x0;
    fY          = y0;
    fUpperY     = y0;
    fLowerY     = y1;
    fDY         = dx == 0 || slope == 0 ? SK_MaxS32 : absSlope < kInverseTableSize
                                                    ? quick_inverse(absSlope)
                                                    : SkAbs32(quick_div(dy, dx));
    fEdgeType   = kLine_Type;
    fCurveCount = 0;
    fWinding    = SkToS8(winding);
    fCurveShift = 0;
 
    return true;
}

SnapY()

static SkFixed SkAnalyticEdge::SnapY ( SkFixed  y )

inlinestatic

Definition at line 50 of file SkAnalyticEdge.h.

                                           {
        const int accuracy = kDefaultAccuracy;
        // This approach is safer than left shift, round, then right shift
        return ((unsigned)y + (SK_Fixed1 >> (accuracy + 1))) >> (16 - accuracy) << (16 - accuracy);
    }

update()

bool SkAnalyticEdge::update	(	SkFixed	last_y,
		bool	sortY = true
	)

Definition at line 254 of file SkAnalyticEdge.cpp.

                                                      {
    SkASSERT(last_y >= fLowerY); // we shouldn't update edge if last_y < fLowerY
    if (fCurveCount < 0) {
        return static_cast<SkAnalyticCubicEdge*>(this)->updateCubic(sortY);
    } else if (fCurveCount > 0) {
        return static_cast<SkAnalyticQuadraticEdge*>(this)->updateQuadratic();
    }
    return false;
}

updateLine()

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

Definition at line 210 of file SkAnalyticEdge.cpp.

                                                                                             {
    // Since we send in the slope, we can no longer snap y inside this function.
    // If we don't send in the slope, or we do some more sophisticated snapping, this function
    // could be a performance bottleneck.
    SkASSERT(fWinding == 1 || fWinding == -1);
    SkASSERT(fCurveCount != 0);
 
    // We don't chop at y extrema for cubics so the y is not guaranteed to be increasing for them.
    // In that case, we have to swap x/y and negate the winding.
    if (y0 > y1) {
        using std::swap;
        swap(x0, x1);
        swap(y0, y1);
        fWinding = -fWinding;
    }
 
    SkASSERT(y0 <= y1);
 
    SkFDot6 dx = SkFixedToFDot6(x1 - x0);
    SkFDot6 dy = SkFixedToFDot6(y1 - y0);
 
    // are we a zero-height line?
    if (dy == 0) {
        return false;
    }
 
    SkASSERT(slope < SK_MaxS32);
 
    SkFDot6     absSlope = SkAbs32(SkFixedToFDot6(slope));
    fX          = x0;
    fDX         = slope;
    fUpperX     = x0;
    fY          = y0;
    fUpperY     = y0;
    fLowerY     = y1;
    fDY         = (dx == 0 || slope == 0)
                  ? SK_MaxS32
                  : absSlope < kInverseTableSize
                    ? quick_inverse(absSlope)
                    : SkAbs32(quick_div(dy, dx));
 
    return true;
}

Member Data Documentation

fCubicDShift

uint8_t SkAnalyticEdge::fCubicDShift

Definition at line 45 of file SkAnalyticEdge.h.

fCurveCount

int8_t SkAnalyticEdge::fCurveCount

Definition at line 43 of file SkAnalyticEdge.h.

fCurveShift

uint8_t SkAnalyticEdge::fCurveShift

Definition at line 44 of file SkAnalyticEdge.h.

fDX

SkFixed SkAnalyticEdge::fDX

Definition at line 33 of file SkAnalyticEdge.h.

fDY

SkFixed SkAnalyticEdge::fDY

Definition at line 38 of file SkAnalyticEdge.h.

fEdgeType

Type SkAnalyticEdge::fEdgeType

Definition at line 41 of file SkAnalyticEdge.h.

fLowerY

SkFixed SkAnalyticEdge::fLowerY

Definition at line 37 of file SkAnalyticEdge.h.

fNext

SkAnalyticEdge* SkAnalyticEdge::fNext

Definition at line 29 of file SkAnalyticEdge.h.

fPrev

SkAnalyticEdge* SkAnalyticEdge::fPrev

Definition at line 30 of file SkAnalyticEdge.h.

fUpperX

SkFixed SkAnalyticEdge::fUpperX

Definition at line 34 of file SkAnalyticEdge.h.

fUpperY

SkFixed SkAnalyticEdge::fUpperY

Definition at line 36 of file SkAnalyticEdge.h.

fWinding

int8_t SkAnalyticEdge::fWinding

Definition at line 46 of file SkAnalyticEdge.h.

fX

SkFixed SkAnalyticEdge::fX

Definition at line 32 of file SkAnalyticEdge.h.

fY

SkFixed SkAnalyticEdge::fY

Definition at line 35 of file SkAnalyticEdge.h.

kDefaultAccuracy

const int SkAnalyticEdge::kDefaultAccuracy = 2

static

Definition at line 48 of file SkAnalyticEdge.h.

---

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

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