#include <SkOpSegment.h>

Public Member Functions
bool	operator< (const SkOpSegment &rh) const

SkOpAngle *	activeAngle (SkOpSpanBase start, SkOpSpanBase startPtr, SkOpSpanBase endPtr, bool done)

SkOpAngle *	activeAngleInner (SkOpSpanBase start, SkOpSpanBase startPtr, SkOpSpanBase endPtr, bool done)

SkOpAngle *	activeAngleOther (SkOpSpanBase start, SkOpSpanBase startPtr, SkOpSpanBase endPtr, bool done)

bool	activeOp (SkOpSpanBase start, SkOpSpanBase end, int xorMiMask, int xorSuMask, SkPathOp op)

bool	activeOp (int xorMiMask, int xorSuMask, SkOpSpanBase start, SkOpSpanBase end, SkPathOp op, int sumMiWinding, int sumSuWinding)

bool	activeWinding (SkOpSpanBase start, SkOpSpanBase end)

bool	activeWinding (SkOpSpanBase start, SkOpSpanBase end, int *sumWinding)

SkOpSegment *	addConic (SkPoint pts[3], SkScalar weight, SkOpContour *parent)

SkOpSegment *	addCubic (SkPoint pts[4], SkOpContour *parent)

bool	addCurveTo (const SkOpSpanBase start, const SkOpSpanBase end, SkPathWriter *path) const

SkOpAngle *	addEndSpan ()

bool	addExpanded (double newT, const SkOpSpanBase test, bool startOver)

SkOpSegment *	addLine (SkPoint pts[2], SkOpContour *parent)

SkOpPtT *	addMissing (double t, SkOpSegment opp, bool allExist)

SkOpAngle *	addStartSpan ()

SkOpSegment *	addQuad (SkPoint pts[3], SkOpContour *parent)

SkOpPtT *	addT (double t)

SkOpPtT *	addT (double t, const SkPoint &pt)

const SkPathOpsBounds &	bounds () const

void	bumpCount ()

void	calcAngles ()

SkOpSpanBase::Collapsed	collapsed (double startT, double endT) const

int	computeSum (SkOpSpanBase start, SkOpSpanBase end, SkOpAngle::IncludeType includeType)

void	clearAll ()

void	clearOne (SkOpSpan *span)

bool	contains (double t) const

SkOpContour *	contour () const

int	count () const

void	debugAddAngle (double startT, double endT)

const SkOpAngle *	debugAngle (int id) const

const SkOpCoincidence *	debugCoincidence () const

SkOpContour *	debugContour (int id) const

int	debugID () const

SkOpAngle *	debugLastAngle ()

const SkOpPtT *	debugPtT (int id) const

void	debugReset ()

const SkOpSegment *	debugSegment (int id) const

const SkOpSpanBase *	debugSpan (int id) const

void	debugValidate () const

bool	done () const

bool	done (const SkOpAngle *angle) const

SkDPoint	dPtAtT (double mid) const

SkDVector	dSlopeAtT (double mid) const

void	dump () const

void	dumpAll () const

void	dumpAngles () const

void	dumpCoin () const

void	dumpPts (const char *prefix="seg") const

void	dumpPtsInner (const char *prefix="seg") const

const SkOpPtT *	existing (double t, const SkOpSegment *opp) const

SkOpSegment *	findNextOp (SkTDArray< SkOpSpanBase * > chase, SkOpSpanBase nextStart, SkOpSpanBase nextEnd, bool unsortable, bool *simple, SkPathOp op, int xorMiMask, int xorSuMask)

SkOpSegment *	findNextWinding (SkTDArray< SkOpSpanBase * > chase, SkOpSpanBase nextStart, SkOpSpanBase nextEnd, bool unsortable)

SkOpSegment *	findNextXor (SkOpSpanBase nextStart, SkOpSpanBase nextEnd, bool *unsortable)

SkOpSpan *	findSortableTop (SkOpContour *)

SkOpGlobalState *	globalState () const

const SkOpSpan *	head () const

SkOpSpan *	head ()

void	init (SkPoint pts[], SkScalar weight, SkOpContour *parent, SkPath::Verb verb)

SkOpSpan *	insert (SkOpSpan *prev)

bool	isClose (double t, const SkOpSegment *opp) const

bool	isHorizontal () const

SkOpSegment *	isSimple (SkOpSpanBase *end, int step) const

bool	isVertical () const

bool	isVertical (SkOpSpanBase start, SkOpSpanBase end) const

bool	isXor () const

void	joinEnds (SkOpSegment *start)

const SkPoint &	lastPt () const

void	markAllDone ()

bool	markAndChaseDone (SkOpSpanBase start, SkOpSpanBase end, SkOpSpanBase **found)

bool	markAndChaseWinding (SkOpSpanBase start, SkOpSpanBase end, int winding, SkOpSpanBase **lastPtr)

bool	markAndChaseWinding (SkOpSpanBase start, SkOpSpanBase end, int winding, int oppWinding, SkOpSpanBase **lastPtr)

bool	markAngle (int maxWinding, int sumWinding, const SkOpAngle angle, SkOpSpanBase *result)

bool	markAngle (int maxWinding, int sumWinding, int oppMaxWinding, int oppSumWinding, const SkOpAngle angle, SkOpSpanBase *result)

void	markDone (SkOpSpan *)

bool	markWinding (SkOpSpan *, int winding)

bool	markWinding (SkOpSpan *, int winding, int oppWinding)

bool	match (const SkOpPtT span, const SkOpSegment parent, double t, const SkPoint &pt) const

bool	missingCoincidence ()

bool	moveMultiples ()

bool	moveNearby ()

SkOpSegment *	next () const

SkOpSegment *	nextChase (SkOpSpanBase *, int step, SkOpSpan , SkOpSpanBase last) const

bool	operand () const

bool	oppXor () const

const SkOpSegment *	prev () const

SkPoint	ptAtT (double mid) const

const SkPoint *	pts () const

bool	ptsDisjoint (const SkOpPtT &span, const SkOpPtT &test) const

bool	ptsDisjoint (const SkOpPtT &span, double t, const SkPoint &pt) const

bool	ptsDisjoint (double t1, const SkPoint &pt1, double t2, const SkPoint &pt2) const

void	rayCheck (const SkOpRayHit &base, SkOpRayDir dir, SkOpRayHit *hits, SkArenaAlloc )

void	release (const SkOpSpan *)

void	resetVisited ()

void	setContour (SkOpContour *contour)

void	setNext (SkOpSegment *next)

void	setPrev (SkOpSegment *prev)

void	setUpWinding (SkOpSpanBase start, SkOpSpanBase end, int maxWinding, int sumWinding)

void	setUpWindings (SkOpSpanBase start, SkOpSpanBase end, int sumMiWinding, int maxWinding, int *sumWinding)

void	setUpWindings (SkOpSpanBase start, SkOpSpanBase end, int sumMiWinding, int sumSuWinding, int maxWinding, int sumWinding, int oppMaxWinding, int oppSumWinding)

bool	sortAngles ()

bool	spansNearby (const SkOpSpanBase ref, const SkOpSpanBase check, bool *found) const

SkOpAngle *	spanToAngle (SkOpSpanBase start, SkOpSpanBase end)

bool	subDivide (const SkOpSpanBase start, const SkOpSpanBase end, SkDCurve *result) const

const SkOpSpanBase *	tail () const

SkOpSpanBase *	tail ()

bool	testForCoincidence (const SkOpPtT priorPtT, const SkOpPtT ptT, const SkOpSpanBase prior, const SkOpSpanBase spanBase, const SkOpSegment *opp) const

SkOpSpan *	undoneSpan ()

int	updateOppWinding (const SkOpSpanBase start, const SkOpSpanBase end) const

int	updateOppWinding (const SkOpAngle *angle) const

int	updateOppWindingReverse (const SkOpAngle *angle) const

int	updateWinding (SkOpSpanBase start, SkOpSpanBase end)

int	updateWinding (SkOpAngle *angle)

int	updateWindingReverse (const SkOpAngle *angle)

SkPath::Verb	verb () const

bool	visited ()

SkScalar	weight () const

SkOpSpan *	windingSpanAtT (double tHit)

int	windSum (const SkOpAngle *angle) const

Static Public Member Functions
static bool	ComputeOneSum (const SkOpAngle baseAngle, SkOpAngle nextAngle, SkOpAngle::IncludeType)

static bool	ComputeOneSumReverse (SkOpAngle baseAngle, SkOpAngle nextAngle, SkOpAngle::IncludeType)

static void	ClearVisited (SkOpSpanBase *span)

static int	OppSign (const SkOpSpanBase start, const SkOpSpanBase end)

static int	SpanSign (const SkOpSpanBase start, const SkOpSpanBase end)

static bool	UseInnerWinding (int outerWinding, int innerWinding)

Detailed Description

Definition at line 35 of file SkOpSegment.h.

Member Function Documentation

◆ activeAngle()

SkOpAngle * SkOpSegment::activeAngle	(	SkOpSpanBase *	start,
		SkOpSpanBase **	startPtr,
		SkOpSpanBase **	endPtr,
		bool *	done
	)

Definition at line 54 of file SkOpSegment.cpp.

                                           {
    if (SkOpAngle* result = activeAngleInner(start, startPtr, endPtr, done)) {
        return result;
    }
    if (SkOpAngle* result = activeAngleOther(start, startPtr, endPtr, done)) {
        return result;
    }
    return nullptr;
}

◆ activeAngleInner()

SkOpAngle * SkOpSegment::activeAngleInner	(	SkOpSpanBase *	start,
		SkOpSpanBase **	startPtr,
		SkOpSpanBase **	endPtr,
		bool *	done
	)

Definition at line 65 of file SkOpSegment.cpp.

                                           {
    SkOpSpan* upSpan = start->upCastable();
    if (upSpan) {
        if (upSpan->windValue() || upSpan->oppValue()) {
            SkOpSpanBase* next = upSpan->next();
            if (!*endPtr) {
                *startPtr = start;
                *endPtr = next;
            }
            if (!upSpan->done()) {
                if (upSpan->windSum() != SK_MinS32) {
                    return spanToAngle(start, next);
                }
                *done = false;
            }
        } else {
            SkASSERT(upSpan->done());
        }
    }
    SkOpSpan* downSpan = start->prev();
    // edge leading into junction
    if (downSpan) {
        if (downSpan->windValue() || downSpan->oppValue()) {
            if (!*endPtr) {
                *startPtr = start;
                *endPtr = downSpan;
            }
            if (!downSpan->done()) {
                if (downSpan->windSum() != SK_MinS32) {
                    return spanToAngle(start, downSpan);
                }
                *done = false;
            }
        } else {
            SkASSERT(downSpan->done());
        }
    }
    return nullptr;
}

◆ activeAngleOther()

SkOpAngle * SkOpSegment::activeAngleOther	(	SkOpSpanBase *	start,
		SkOpSpanBase **	startPtr,
		SkOpSpanBase **	endPtr,
		bool *	done
	)

Definition at line 106 of file SkOpSegment.cpp.

                                           {
    SkOpPtT* oPtT = start->ptT()->next();
    SkOpSegment* other = oPtT->segment();
    SkOpSpanBase* oSpan = oPtT->span();
    return other->activeAngleInner(oSpan, startPtr, endPtr, done);
}

◆ activeOp() [1/2]

bool SkOpSegment::activeOp	(	int	xorMiMask,
		int	xorSuMask,
		SkOpSpanBase *	start,
		SkOpSpanBase *	end,
		SkPathOp	op,
		int *	sumMiWinding,
		int *	sumSuWinding
	)

Definition at line 129 of file SkOpSegment.cpp.

                                                           {
    int maxWinding, sumWinding, oppMaxWinding, oppSumWinding;
    this->setUpWindings(start, end, sumMiWinding, sumSuWinding,
            &maxWinding, &sumWinding, &oppMaxWinding, &oppSumWinding);
    bool miFrom;
    bool miTo;
    bool suFrom;
    bool suTo;
    if (operand()) {
        miFrom = (oppMaxWinding & xorMiMask) != 0;
        miTo = (oppSumWinding & xorMiMask) != 0;
        suFrom = (maxWinding & xorSuMask) != 0;
        suTo = (sumWinding & xorSuMask) != 0;
    } else {
        miFrom = (maxWinding & xorMiMask) != 0;
        miTo = (sumWinding & xorMiMask) != 0;
        suFrom = (oppMaxWinding & xorSuMask) != 0;
        suTo = (oppSumWinding & xorSuMask) != 0;
    }
    bool result = gActiveEdge[op][miFrom][miTo][suFrom][suTo];
#if DEBUG_ACTIVE_OP
    SkDebugf("%s id=%d t=%1.9g tEnd=%1.9g op=%s miFrom=%d miTo=%d suFrom=%d suTo=%d result=%d\n",
            __FUNCTION__, debugID(), start->t(), end->t(),
            SkPathOpsDebug::kPathOpStr[op], miFrom, miTo, suFrom, suTo, result);
#endif
    return result;
}

◆ activeOp() [2/2]

bool SkOpSegment::activeOp	(	SkOpSpanBase *	start,
		SkOpSpanBase *	end,
		int	xorMiMask,
		int	xorSuMask,
		SkPathOp	op
	)

Definition at line 114 of file SkOpSegment.cpp.

                     {
    int sumMiWinding = this->updateWinding(end, start);
    int sumSuWinding = this->updateOppWinding(end, start);
#if DEBUG_LIMIT_WIND_SUM
    SkASSERT(abs(sumMiWinding) <= DEBUG_LIMIT_WIND_SUM);
    SkASSERT(abs(sumSuWinding) <= DEBUG_LIMIT_WIND_SUM);
#endif
    if (this->operand()) {
        using std::swap;
        swap(sumMiWinding, sumSuWinding);
    }
    return this->activeOp(xorMiMask, xorSuMask, start, end, op, &sumMiWinding, &sumSuWinding);
}

◆ activeWinding() [1/2]

bool SkOpSegment::activeWinding	(	SkOpSpanBase *	start,
		SkOpSpanBase *	end
	)

Definition at line 158 of file SkOpSegment.cpp.

                                                                      {
    int sumWinding = updateWinding(end, start);
    return activeWinding(start, end, &sumWinding);
}

◆ activeWinding() [2/2]

bool SkOpSegment::activeWinding	(	SkOpSpanBase *	start,
		SkOpSpanBase *	end,
		int *	sumWinding
	)

Definition at line 163 of file SkOpSegment.cpp.

                                                                                       {
    int maxWinding;
    setUpWinding(start, end, &maxWinding, sumWinding);
    bool from = maxWinding != 0;
    bool to = *sumWinding  != 0;
    bool result = gUnaryActiveEdge[from][to];
    return result;
}

◆ addConic()

SkOpSegment * SkOpSegment::addConic	(	SkPoint	pts[3],
		SkScalar	weight,
		SkOpContour *	parent
	)

inline

Definition at line 55 of file SkOpSegment.h.

                                                                                {
        init(pts, weight, parent, SkPath::kConic_Verb);
        SkDCurve curve;
        curve.fConic.set(pts, weight);
        curve.setConicBounds(pts, weight, 0, 1, &fBounds);
        return this;
    }

◆ addCubic()

SkOpSegment * SkOpSegment::addCubic	(	SkPoint	pts[4],
		SkOpContour *	parent
	)

inline

Definition at line 63 of file SkOpSegment.h.

                                                               {
        init(pts, 1, parent, SkPath::kCubic_Verb);
        SkDCurve curve;
        curve.fCubic.set(pts);
        curve.setCubicBounds(pts, 1, 0, 1, &fBounds);
        return this;
    }

◆ addCurveTo()

bool SkOpSegment::addCurveTo	(	const SkOpSpanBase *	start,
		const SkOpSpanBase *	end,
		SkPathWriter *	path
	)		const

Definition at line 172 of file SkOpSegment.cpp.

                                  {
    const SkOpSpan* spanStart = start->starter(end);
    FAIL_IF(spanStart->alreadyAdded());
    const_cast<SkOpSpan*>(spanStart)->markAdded();
    SkDCurveSweep curvePart;
    start->segment()->subDivide(start, end, &curvePart.fCurve);
    curvePart.setCurveHullSweep(fVerb);
    SkPath::Verb verb = curvePart.isCurve() ? fVerb : SkPath::kLine_Verb;
    path->deferredMove(start->ptT());
    switch (verb) {
        case SkPath::kLine_Verb:
            FAIL_IF(!path->deferredLine(end->ptT()));
            break;
        case SkPath::kQuad_Verb:
            path->quadTo(curvePart.fCurve.fQuad[1].asSkPoint(), end->ptT());
            break;
        case SkPath::kConic_Verb:
            path->conicTo(curvePart.fCurve.fConic[1].asSkPoint(), end->ptT(),
                    curvePart.fCurve.fConic.fWeight);
            break;
        case SkPath::kCubic_Verb:
            path->cubicTo(curvePart.fCurve.fCubic[1].asSkPoint(),
                    curvePart.fCurve.fCubic[2].asSkPoint(), end->ptT());
            break;
        default:
            SkASSERT(0);
    }
    return true;
}

◆ addEndSpan()

SkOpAngle * SkOpSegment::addEndSpan ( )

inline

Definition at line 73 of file SkOpSegment.h.

                            {
        SkOpAngle* angle = this->globalState()->allocator()->make<SkOpAngle>();
        angle->set(&fTail, fTail.prev());
        fTail.setFromAngle(angle);
        return angle;
    }

◆ addExpanded()

bool SkOpSegment::addExpanded	(	double	newT,
		const SkOpSpanBase *	test,
		bool *	startOver
	)

Definition at line 235 of file SkOpSegment.cpp.

                                                                                    {
    if (this->contains(newT)) {
        return true;
    }
    this->globalState()->resetAllocatedOpSpan();
    FAIL_IF(!between(0, newT, 1));
    SkOpPtT* newPtT = this->addT(newT);
    *startOver |= this->globalState()->allocatedOpSpan();
    if (!newPtT) {
        return false;
    }
    newPtT->fPt = this->ptAtT(newT);
    SkOpPtT* oppPrev = test->ptT()->oppPrev(newPtT);
    if (oppPrev) {
        // const cast away to change linked list; pt/t values stays unchanged
        SkOpSpanBase* writableTest = const_cast<SkOpSpanBase*>(test);
        writableTest->mergeMatches(newPtT->span());
        writableTest->ptT()->addOpp(newPtT, oppPrev);
        writableTest->checkForCollapsedCoincidence();
    }
    return true;
}

◆ addLine()

SkOpSegment * SkOpSegment::addLine	(	SkPoint	pts[2],
		SkOpContour *	parent
	)

inline

Definition at line 82 of file SkOpSegment.h.

                                                              {
        SkASSERT(pts[0] != pts[1]);
        init(pts, 1, parent, SkPath::kLine_Verb);
        fBounds.setBounds(pts, 2);
        return this;
    }

◆ addMissing()

SkOpPtT * SkOpSegment::addMissing	(	double	t,
		SkOpSegment *	opp,
		bool *	allExist
	)

◆ addQuad()

SkOpSegment * SkOpSegment::addQuad	(	SkPoint	pts[3],
		SkOpContour *	parent
	)

inline

Definition at line 98 of file SkOpSegment.h.

                                                              {
        init(pts, 1, parent, SkPath::kQuad_Verb);
        SkDCurve curve;
        curve.fQuad.set(pts);
        curve.setQuadBounds(pts, 1, 0, 1, &fBounds);
        return this;
    }

◆ addStartSpan()

SkOpAngle * SkOpSegment::addStartSpan ( )

inline

Definition at line 91 of file SkOpSegment.h.

                              {
        SkOpAngle* angle = this->globalState()->allocator()->make<SkOpAngle>();
        angle->set(&fHead, fHead.next());
        fHead.setToAngle(angle);
        return angle;
    }

◆ addT() [1/2]

SkOpPtT * SkOpSegment::addT ( double t )

Definition at line 288 of file SkOpSegment.cpp.

                                   {
    return addT(t, this->ptAtT(t));
}

◆ addT() [2/2]

SkOpPtT * SkOpSegment::addT	(	double	t,
		const SkPoint &	pt
	)

Definition at line 259 of file SkOpSegment.cpp.

                                                      {
    debugValidate();
    SkOpSpanBase* spanBase = &fHead;
    do {
        SkOpPtT* result = spanBase->ptT();
        if (t == result->fT || (!zero_or_one(t) && this->match(result, this, t, pt))) {
            spanBase->bumpSpanAdds();
            return result;
        }
        if (t < result->fT) {
            SkOpSpan* prev = result->span()->prev();
            FAIL_WITH_NULL_IF(!prev);
            // marks in global state that new op span has been allocated
            SkOpSpan* span = this->insert(prev);
            span->init(this, prev, t, pt);
            this->debugValidate();
#if DEBUG_ADD_T
            SkDebugf("%s insert t=%1.9g segID=%d spanID=%d\n", __FUNCTION__, t,
                    span->segment()->debugID(), span->debugID());
#endif
            span->bumpSpanAdds();
            return span->ptT();
        }
        FAIL_WITH_NULL_IF(spanBase == &fTail);
    } while ((spanBase = spanBase->upCast()->next()));
    SkASSERT(0);
    return nullptr;  // we never get here, but need this to satisfy compiler
}

◆ bounds()

const SkPathOpsBounds & SkOpSegment::bounds ( ) const

inline

Definition at line 109 of file SkOpSegment.h.

                                          {
        return fBounds;
    }

◆ bumpCount()

void SkOpSegment::bumpCount ( )

inline

Definition at line 113 of file SkOpSegment.h.

                     {
        ++fCount;
    }

◆ calcAngles()

void SkOpSegment::calcAngles ( )

Definition at line 292 of file SkOpSegment.cpp.

                             {
    bool activePrior = !fHead.isCanceled();
    if (activePrior && !fHead.simple()) {
        addStartSpan();
    }
    SkOpSpan* prior = &fHead;
    SkOpSpanBase* spanBase = fHead.next();
    while (spanBase != &fTail) {
        if (activePrior) {
            SkOpAngle* priorAngle = this->globalState()->allocator()->make<SkOpAngle>();
            priorAngle->set(spanBase, prior);
            spanBase->setFromAngle(priorAngle);
        }
        SkOpSpan* span = spanBase->upCast();
        bool active = !span->isCanceled();
        SkOpSpanBase* next = span->next();
        if (active) {
            SkOpAngle* angle = this->globalState()->allocator()->make<SkOpAngle>();
            angle->set(span, next);
            span->setToAngle(angle);
        }
        activePrior = active;
        prior = span;
        spanBase = next;
    }
    if (activePrior && !fTail.simple()) {
        addEndSpan();
    }
}

◆ clearAll()

void SkOpSegment::clearAll ( )

Definition at line 323 of file SkOpSegment.cpp.

                           {
    SkOpSpan* span = &fHead;
    do {
        this->clearOne(span);
    } while ((span = span->next()->upCastable()));
    this->globalState()->coincidence()->release(this);
}

◆ clearOne()

void SkOpSegment::clearOne ( SkOpSpan * span )

Definition at line 332 of file SkOpSegment.cpp.

                                         {
    span->setWindValue(0);
    span->setOppValue(0);
    this->markDone(span);
}

◆ ClearVisited()

void SkOpSegment::ClearVisited ( SkOpSpanBase * span )

static

Definition at line 1140 of file SkOpSegment.cpp.

                                                 {
    // reset visited flag back to false
    do {
        SkOpPtT* ptT = span->ptT(), * stopPtT = ptT;
        while ((ptT = ptT->next()) != stopPtT) {
            SkOpSegment* opp = ptT->segment();
            opp->resetVisited();
        }
    } while (!span->final() && (span = span->upCast()->next()));
}

◆ collapsed()

SkOpSpanBase::Collapsed SkOpSegment::collapsed	(	double	startT,
		double	endT
	)		const

Definition at line 338 of file SkOpSegment.cpp.

                                                                     {
    const SkOpSpanBase* span = &fHead;
    do {
        SkOpSpanBase::Collapsed result = span->collapsed(s, e);
        if (SkOpSpanBase::Collapsed::kNo != result) {
            return result;
        }
    } while (span->upCastable() && (span = span->upCast()->next()));
    return SkOpSpanBase::Collapsed::kNo;
}

◆ ComputeOneSum()

bool SkOpSegment::ComputeOneSum	(	const SkOpAngle *	baseAngle,
		SkOpAngle *	nextAngle,
		SkOpAngle::IncludeType	includeType
	)

static

Definition at line 349 of file SkOpSegment.cpp.

                                          {
    SkOpSegment* baseSegment = baseAngle->segment();
    int sumMiWinding = baseSegment->updateWindingReverse(baseAngle);
    int sumSuWinding;
    bool binary = includeType >= SkOpAngle::kBinarySingle;
    if (binary) {
        sumSuWinding = baseSegment->updateOppWindingReverse(baseAngle);
        if (baseSegment->operand()) {
            using std::swap;
            swap(sumMiWinding, sumSuWinding);
        }
    }
    SkOpSegment* nextSegment = nextAngle->segment();
    int maxWinding, sumWinding;
    SkOpSpanBase* last = nullptr;
    if (binary) {
        int oppMaxWinding, oppSumWinding;
        nextSegment->setUpWindings(nextAngle->start(), nextAngle->end(), &sumMiWinding,
                &sumSuWinding, &maxWinding, &sumWinding, &oppMaxWinding, &oppSumWinding);
        if (!nextSegment->markAngle(maxWinding, sumWinding, oppMaxWinding, oppSumWinding,
                nextAngle, &last)) {
            return false;
        }
    } else {
        nextSegment->setUpWindings(nextAngle->start(), nextAngle->end(), &sumMiWinding,
                &maxWinding, &sumWinding);
        if (!nextSegment->markAngle(maxWinding, sumWinding, nextAngle, &last)) {
            return false;
        }
    }
    nextAngle->setLastMarked(last);
    return true;
}

◆ ComputeOneSumReverse()

bool SkOpSegment::ComputeOneSumReverse	(	SkOpAngle *	baseAngle,
		SkOpAngle *	nextAngle,
		SkOpAngle::IncludeType	includeType
	)

static

Definition at line 384 of file SkOpSegment.cpp.

                                          {
    SkOpSegment* baseSegment = baseAngle->segment();
    int sumMiWinding = baseSegment->updateWinding(baseAngle);
    int sumSuWinding;
    bool binary = includeType >= SkOpAngle::kBinarySingle;
    if (binary) {
        sumSuWinding = baseSegment->updateOppWinding(baseAngle);
        if (baseSegment->operand()) {
            using std::swap;
            swap(sumMiWinding, sumSuWinding);
        }
    }
    SkOpSegment* nextSegment = nextAngle->segment();
    int maxWinding, sumWinding;
    SkOpSpanBase* last = nullptr;
    if (binary) {
        int oppMaxWinding, oppSumWinding;
        nextSegment->setUpWindings(nextAngle->end(), nextAngle->start(), &sumMiWinding,
                &sumSuWinding, &maxWinding, &sumWinding, &oppMaxWinding, &oppSumWinding);
        if (!nextSegment->markAngle(maxWinding, sumWinding, oppMaxWinding, oppSumWinding,
                nextAngle, &last)) {
            return false;
        }
    } else {
        nextSegment->setUpWindings(nextAngle->end(), nextAngle->start(), &sumMiWinding,
                &maxWinding, &sumWinding);
        if (!nextSegment->markAngle(maxWinding, sumWinding, nextAngle, &last)) {
            return false;
        }
    }
    nextAngle->setLastMarked(last);
    return true;
}

◆ computeSum()

int SkOpSegment::computeSum	(	SkOpSpanBase *	start,
		SkOpSpanBase *	end,
		SkOpAngle::IncludeType	includeType
	)

Definition at line 420 of file SkOpSegment.cpp.

                                          {
    SkASSERT(includeType != SkOpAngle::kUnaryXor);
    SkOpAngle* firstAngle = this->spanToAngle(end, start);
    if (nullptr == firstAngle || nullptr == firstAngle->next()) {
        return SK_NaN32;
    }
    // if all angles have a computed winding,
    //  or if no adjacent angles are orderable,
    //  or if adjacent orderable angles have no computed winding,
    //  there's nothing to do
    // if two orderable angles are adjacent, and both are next to orderable angles,
    //  and one has winding computed, transfer to the other
    SkOpAngle* baseAngle = nullptr;
    bool tryReverse = false;
    // look for counterclockwise transfers
    SkOpAngle* angle = firstAngle->previous();
    SkOpAngle* next = angle->next();
    firstAngle = next;
    do {
        SkOpAngle* prior = angle;
        angle = next;
        next = angle->next();
        SkASSERT(prior->next() == angle);
        SkASSERT(angle->next() == next);
        if (prior->unorderable() || angle->unorderable() || next->unorderable()) {
            baseAngle = nullptr;
            continue;
        }
        int testWinding = angle->starter()->windSum();
        if (SK_MinS32 != testWinding) {
            baseAngle = angle;
            tryReverse = true;
            continue;
        }
        if (baseAngle) {
            ComputeOneSum(baseAngle, angle, includeType);
            baseAngle = SK_MinS32 != angle->starter()->windSum() ? angle : nullptr;
        }
    } while (next != firstAngle);
    if (baseAngle && SK_MinS32 == firstAngle->starter()->windSum()) {
        firstAngle = baseAngle;
        tryReverse = true;
    }
    if (tryReverse) {
        baseAngle = nullptr;
        SkOpAngle* prior = firstAngle;
        do {
            angle = prior;
            prior = angle->previous();
            SkASSERT(prior->next() == angle);
            next = angle->next();
            if (prior->unorderable() || angle->unorderable() || next->unorderable()) {
                baseAngle = nullptr;
                continue;
            }
            int testWinding = angle->starter()->windSum();
            if (SK_MinS32 != testWinding) {
                baseAngle = angle;
                continue;
            }
            if (baseAngle) {
                ComputeOneSumReverse(baseAngle, angle, includeType);
                baseAngle = SK_MinS32 != angle->starter()->windSum() ? angle : nullptr;
            }
        } while (prior != firstAngle);
    }
    return start->starter(end)->windSum();
}

◆ contains()

bool SkOpSegment::contains ( double t ) const

Definition at line 490 of file SkOpSegment.cpp.

                                            {
    const SkOpSpanBase* spanBase = &fHead;
    do {
        if (spanBase->ptT()->contains(this, newT)) {
            return true;
        }
        if (spanBase == &fTail) {
            break;
        }
        spanBase = spanBase->upCast()->next();
    } while (true);
    return false;
}

◆ contour()

SkOpContour * SkOpSegment::contour ( ) const

inline

Definition at line 130 of file SkOpSegment.h.

                                 {
        return fContour;
    }

◆ count()

int SkOpSegment::count ( ) const

inline

Definition at line 134 of file SkOpSegment.h.

                      {
        return fCount;
    }

◆ debugAddAngle()

void SkOpSegment::debugAddAngle	(	double	startT,
		double	endT
	)

Definition at line 1548 of file PathOpsDebug.cpp.

                                                          {
    SkOpPtT* startPtT = startT == 0 ? fHead.ptT() : startT == 1 ? fTail.ptT()
            : this->addT(startT);
    SkOpPtT* endPtT = endT == 0 ? fHead.ptT() : endT == 1 ? fTail.ptT()
            : this->addT(endT);
    SkOpAngle* angle = this->globalState()->allocator()->make<SkOpAngle>();
    SkOpSpanBase* startSpan = &fHead;
    while (startSpan->ptT() != startPtT) {
        startSpan = startSpan->upCast()->next();
    }
    SkOpSpanBase* endSpan = &fHead;
    while (endSpan->ptT() != endPtT) {
        endSpan = endSpan->upCast()->next();
    }
    angle->set(startSpan, endSpan);
    if (startT < endT) {
        startSpan->upCast()->setToAngle(angle);
        endSpan->setFromAngle(angle);
    } else {
        endSpan->upCast()->setToAngle(angle);
        startSpan->setFromAngle(angle);
    }
}

◆ debugAngle()

const SkOpAngle * SkOpSegment::debugAngle ( int id ) const

Definition at line 828 of file PathOpsDebug.cpp.

                                                     {
    return this->contour()->debugAngle(id);
}

◆ debugCoincidence()

const SkOpCoincidence * SkOpSegment::debugCoincidence ( ) const

Definition at line 832 of file PathOpsDebug.cpp.

                                                           {
    return this->contour()->debugCoincidence();
}

◆ debugContour()

SkOpContour * SkOpSegment::debugContour ( int id ) const

Definition at line 836 of file PathOpsDebug.cpp.

                                                   {
    return this->contour()->debugContour(id);
}

◆ debugID()

int SkOpSegment::debugID ( ) const

inline

Definition at line 154 of file SkOpSegment.h.

                        {
        return SkDEBUGRELEASE(fID, -1);
    }

◆ debugLastAngle()

SkOpAngle * SkOpSegment::debugLastAngle ( )

Definition at line 805 of file SkPathOpsDebug.cpp.

                                       {
    SkOpAngle* result = nullptr;
    SkOpSpan* span = this->head();
    do {
        if (span->toAngle()) {
            SkASSERT(!result);
            result = span->toAngle();
        }
    } while ((span = span->next()->upCastable()));
    SkASSERT(result);
    return result;
}

◆ debugPtT()

const SkOpPtT * SkOpSegment::debugPtT ( int id ) const

Definition at line 840 of file PathOpsDebug.cpp.

                                                 {
    return this->contour()->debugPtT(id);
}

◆ debugReset()

void SkOpSegment::debugReset ( )

Definition at line 1097 of file SkPathOpsDebug.cpp.

                             {
    this->init(this->fPts, this->fWeight, this->contour(), this->verb());
}

◆ debugSegment()

const SkOpSegment * SkOpSegment::debugSegment ( int id ) const

Definition at line 844 of file PathOpsDebug.cpp.

                                                         {
    return this->contour()->debugSegment(id);
}

◆ debugSpan()

const SkOpSpanBase * SkOpSegment::debugSpan ( int id ) const

Definition at line 848 of file PathOpsDebug.cpp.

                                                       {
    return this->contour()->debugSpan(id);
}

◆ debugValidate()

void SkOpSegment::debugValidate ( ) const

Definition at line 2333 of file SkPathOpsDebug.cpp.

                                      {
#if DEBUG_COINCIDENCE_ORDER
    {
        const SkOpSpanBase* span = &fHead;
        do {
            span->debugResetCoinT();
        } while (!span->final() && (span = span->upCast()->next()));
        span = &fHead;
        int index = 0;
        do {
            span->debugSetCoinT(index++);
        } while (!span->final() && (span = span->upCast()->next()));
    }
#endif
#if DEBUG_COINCIDENCE
    if (this->globalState()->debugCheckHealth()) {
        return;
    }
#endif
#if DEBUG_VALIDATE
    const SkOpSpanBase* span = &fHead;
    double lastT = -1;
    const SkOpSpanBase* prev = nullptr;
    int count = 0;
    int done = 0;
    do {
        if (!span->final()) {
            ++count;
            done += span->upCast()->done() ? 1 : 0;
        }
        SkASSERT(span->segment() == this);
        SkASSERT(!prev || prev->upCast()->next() == span);
        SkASSERT(!prev || prev == span->prev());
        prev = span;
        double t = span->ptT()->fT;
        SkASSERT(lastT < t);
        lastT = t;
        span->debugValidate();
    } while (!span->final() && (span = span->upCast()->next()));
    SkASSERT(count == fCount);
    SkASSERT(done == fDoneCount);
    SkASSERT(count >= fDoneCount);
    SkASSERT(span->final());
    span->debugValidate();
#endif
}

◆ done() [1/2]

bool SkOpSegment::done ( ) const

inline

Definition at line 200 of file SkOpSegment.h.

                      {
        SkOPASSERT(fDoneCount <= fCount);
        return fDoneCount == fCount;
    }

◆ done() [2/2]

bool SkOpSegment::done ( const SkOpAngle * angle ) const

inline

Definition at line 205 of file SkOpSegment.h.

                                            {
        return angle->start()->starter(angle->end())->done();
    }

◆ dPtAtT()

SkDPoint SkOpSegment::dPtAtT ( double mid ) const

inline

Definition at line 209 of file SkOpSegment.h.

                                      {
        return (*CurveDPointAtT[fVerb])(fPts, fWeight, mid);
    }

◆ dSlopeAtT()

SkDVector SkOpSegment::dSlopeAtT ( double mid ) const

inline

Definition at line 213 of file SkOpSegment.h.

                                          {
        return (*CurveDSlopeAtT[fVerb])(fPts, fWeight, mid);
    }

◆ dump()

void SkOpSegment::dump ( ) const

Definition at line 852 of file PathOpsDebug.cpp.

                             {
    SkDebugf("%.*s", contour()->debugIndent(), "        ");
    this->dumpPts();
    const SkOpSpanBase* span = &fHead;
    contour()->indentDump();
    do {
        SkDebugf("%.*s span=%d ", contour()->debugIndent(), "        ", span->debugID());
        span->ptT()->dumpBase();
        span->dumpBase();
        SkDebugf("\n");
    } while (!span->final() && (span = span->upCast()->next()));
    contour()->outdentDump();
}

◆ dumpAll()

void SkOpSegment::dumpAll ( ) const

Definition at line 866 of file PathOpsDebug.cpp.

                                {
    SkDebugf("%.*s", contour()->debugIndent(), "        ");
    this->dumpPts();
    const SkOpSpanBase* span = &fHead;
    contour()->indentDump();
    do {
        span->dumpAll();
    } while (!span->final() && (span = span->upCast()->next()));
    contour()->outdentDump();
}

◆ dumpAngles()

void SkOpSegment::dumpAngles ( ) const

Definition at line 877 of file PathOpsDebug.cpp.

                                   {
    SkDebugf("seg=%d\n", debugID());
    const SkOpSpanBase* span = &fHead;
    do {
        const SkOpAngle* fAngle = span->fromAngle();
        const SkOpAngle* tAngle = span->final() ? nullptr : span->upCast()->toAngle();
        if (fAngle) {
            SkDebugf("  span=%d from=%d ", span->debugID(), fAngle->debugID());
            fAngle->dumpTo(this, tAngle);
        }
        if (tAngle) {
            SkDebugf("  span=%d to=%d   ", span->debugID(), tAngle->debugID());
            tAngle->dumpTo(this, fAngle);
        }
    } while (!span->final() && (span = span->upCast()->next()));
}

◆ dumpCoin()

void SkOpSegment::dumpCoin ( ) const

Definition at line 894 of file PathOpsDebug.cpp.

                                 {
    const SkOpSpan* span = &fHead;
    do {
        span->dumpCoin();
    } while ((span = span->next()->upCastable()));
}

◆ dumpPts()

void SkOpSegment::dumpPts ( const char * prefix = "seg" ) const

Definition at line 919 of file PathOpsDebug.cpp.

                                                  {
    dumpPtsInner(prefix);
    SkDebugf("\n");
}

◆ dumpPtsInner()

void SkOpSegment::dumpPtsInner ( const char * prefix = "seg" ) const

Definition at line 901 of file PathOpsDebug.cpp.

                                                       {
    int last = SkPathOpsVerbToPoints(fVerb);
    SkDebugf("%s=%d {{", prefix, this->debugID());
    if (fVerb == SkPath::kConic_Verb) {
        SkDebugf("{");
    }
    int index = 0;
    do {
        SkDPoint::Dump(fPts[index]);
        SkDebugf(", ");
    } while (++index < last);
    SkDPoint::Dump(fPts[index]);
    SkDebugf("}}");
    if (fVerb == SkPath::kConic_Verb) {
        SkDebugf(", %1.9gf}", fWeight);
    }
}

◆ existing()

const SkOpPtT * SkOpSegment::existing	(	double	t,
		const SkOpSegment *	opp
	)		const

Definition at line 203 of file SkOpSegment.cpp.

                                                                           {
    const SkOpSpanBase* test = &fHead;
    const SkOpPtT* testPtT;
    SkPoint pt = this->ptAtT(t);
    do {
        testPtT = test->ptT();
        if (testPtT->fT == t) {
            break;
        }
        if (!this->match(testPtT, this, t, pt)) {
            if (t < testPtT->fT) {
                return nullptr;
            }
            continue;
        }
        if (!opp) {
            return testPtT;
        }
        const SkOpPtT* loop = testPtT->next();
        while (loop != testPtT) {
            if (loop->segment() == this && loop->fT == t && loop->fPt == pt) {
                goto foundMatch;
            }
            loop = loop->next();
        }
        return nullptr;
    } while ((test = test->upCast()->next()));
foundMatch:
    return opp && !test->contains(opp) ? nullptr : testPtT;
}

◆ findNextOp()

SkOpSegment * SkOpSegment::findNextOp	(	SkTDArray< SkOpSpanBase * > *	chase,
		SkOpSpanBase **	nextStart,
		SkOpSpanBase **	nextEnd,
		bool *	unsortable,
		bool *	simple,
		SkPathOp	op,
		int	xorMiMask,
		int	xorSuMask
	)

Definition at line 544 of file SkOpSegment.cpp.

                                                   {
    SkOpSpanBase* start = *nextStart;
    SkOpSpanBase* end = *nextEnd;
    SkASSERT(start != end);
    int step = start->step(end);
    SkOpSegment* other = this->isSimple(nextStart, &step);  // advances nextStart
    if ((*simple = other)) {
    // mark the smaller of startIndex, endIndex done, and all adjacent
    // spans with the same T value (but not 'other' spans)
#if DEBUG_WINDING
        SkDebugf("%s simple\n", __FUNCTION__);
#endif
        SkOpSpan* startSpan = start->starter(end);
        if (startSpan->done()) {
            return nullptr;
        }
        markDone(startSpan);
        *nextEnd = step > 0 ? (*nextStart)->upCast()->next() : (*nextStart)->prev();
        return other;
    }
    SkOpSpanBase* endNear = step > 0 ? (*nextStart)->upCast()->next() : (*nextStart)->prev();
    SkASSERT(endNear == end);  // is this ever not end?
    SkASSERT(endNear);
    SkASSERT(start != endNear);
    SkASSERT((start->t() < endNear->t()) ^ (step < 0));
    // more than one viable candidate -- measure angles to find best
    int calcWinding = computeSum(start, endNear, SkOpAngle::kBinaryOpp);
    bool sortable = calcWinding != SK_NaN32;
    if (!sortable) {
        *unsortable = true;
        markDone(start->starter(end));
        return nullptr;
    }
    SkOpAngle* angle = this->spanToAngle(end, start);
    if (angle->unorderable()) {
        *unsortable = true;
        markDone(start->starter(end));
        return nullptr;
    }
#if DEBUG_SORT
    SkDebugf("%s\n", __FUNCTION__);
    angle->debugLoop();
#endif
    int sumMiWinding = updateWinding(end, start);
    if (sumMiWinding == SK_MinS32) {
        *unsortable = true;
        markDone(start->starter(end));
        return nullptr;
    }
    int sumSuWinding = updateOppWinding(end, start);
    if (operand()) {
        using std::swap;
        swap(sumMiWinding, sumSuWinding);
    }
    SkOpAngle* nextAngle = angle->next();
    const SkOpAngle* foundAngle = nullptr;
    bool foundDone = false;
    // iterate through the angle, and compute everyone's winding
    SkOpSegment* nextSegment;
    int activeCount = 0;
    do {
        nextSegment = nextAngle->segment();
        bool activeAngle = nextSegment->activeOp(xorMiMask, xorSuMask, nextAngle->start(),
                nextAngle->end(), op, &sumMiWinding, &sumSuWinding);
        if (activeAngle) {
            ++activeCount;
            if (!foundAngle || (foundDone && activeCount & 1)) {
                foundAngle = nextAngle;
                foundDone = nextSegment->done(nextAngle);
            }
        }
        if (nextSegment->done()) {
            continue;
        }
        if (!activeAngle) {
            (void) nextSegment->markAndChaseDone(nextAngle->start(), nextAngle->end(), nullptr);
        }
        SkOpSpanBase* last = nextAngle->lastMarked();
        if (last) {
            SkASSERT(!SkPathOpsDebug::ChaseContains(*chase, last));
            *chase->append() = last;
#if DEBUG_WINDING
            SkDebugf("%s chase.append segment=%d span=%d", __FUNCTION__,
                    last->segment()->debugID(), last->debugID());
            if (!last->final()) {
                SkDebugf(" windSum=%d", last->upCast()->windSum());
            }
            SkDebugf("\n");
#endif
        }
    } while ((nextAngle = nextAngle->next()) != angle);
    start->segment()->markDone(start->starter(end));
    if (!foundAngle) {
        return nullptr;
    }
    *nextStart = foundAngle->start();
    *nextEnd = foundAngle->end();
    nextSegment = foundAngle->segment();
#if DEBUG_WINDING
    SkDebugf("%s from:[%d] to:[%d] start=%p end=%p\n",
            __FUNCTION__, debugID(), nextSegment->debugID(), *nextStart, *nextEnd);
 #endif
    return nextSegment;
}

◆ findNextWinding()

SkOpSegment * SkOpSegment::findNextWinding	(	SkTDArray< SkOpSpanBase * > *	chase,
		SkOpSpanBase **	nextStart,
		SkOpSpanBase **	nextEnd,
		bool *	unsortable
	)

Definition at line 651 of file SkOpSegment.cpp.

                                                                            {
    SkOpSpanBase* start = *nextStart;
    SkOpSpanBase* end = *nextEnd;
    SkASSERT(start != end);
    int step = start->step(end);
    SkOpSegment* other = this->isSimple(nextStart, &step);  // advances nextStart
    if (other) {
    // mark the smaller of startIndex, endIndex done, and all adjacent
    // spans with the same T value (but not 'other' spans)
#if DEBUG_WINDING
        SkDebugf("%s simple\n", __FUNCTION__);
#endif
        SkOpSpan* startSpan = start->starter(end);
        if (startSpan->done()) {
            return nullptr;
        }
        markDone(startSpan);
        *nextEnd = step > 0 ? (*nextStart)->upCast()->next() : (*nextStart)->prev();
        return other;
    }
    SkOpSpanBase* endNear = step > 0 ? (*nextStart)->upCast()->next() : (*nextStart)->prev();
    SkASSERT(endNear == end);  // is this ever not end?
    SkASSERT(endNear);
    SkASSERT(start != endNear);
    SkASSERT((start->t() < endNear->t()) ^ (step < 0));
    // more than one viable candidate -- measure angles to find best
    int calcWinding = computeSum(start, endNear, SkOpAngle::kUnaryWinding);
    bool sortable = calcWinding != SK_NaN32;
    if (!sortable) {
        *unsortable = true;
        markDone(start->starter(end));
        return nullptr;
    }
    SkOpAngle* angle = this->spanToAngle(end, start);
    if (angle->unorderable()) {
        *unsortable = true;
        markDone(start->starter(end));
        return nullptr;
    }
#if DEBUG_SORT
    SkDebugf("%s\n", __FUNCTION__);
    angle->debugLoop();
#endif
    int sumWinding = updateWinding(end, start);
    SkOpAngle* nextAngle = angle->next();
    const SkOpAngle* foundAngle = nullptr;
    bool foundDone = false;
    // iterate through the angle, and compute everyone's winding
    SkOpSegment* nextSegment;
    int activeCount = 0;
    do {
        nextSegment = nextAngle->segment();
        bool activeAngle = nextSegment->activeWinding(nextAngle->start(), nextAngle->end(),
                &sumWinding);
        if (activeAngle) {
            ++activeCount;
            if (!foundAngle || (foundDone && activeCount & 1)) {
                foundAngle = nextAngle;
                foundDone = nextSegment->done(nextAngle);
            }
        }
        if (nextSegment->done()) {
            continue;
        }
        if (!activeAngle) {
            (void) nextSegment->markAndChaseDone(nextAngle->start(), nextAngle->end(), nullptr);
        }
        SkOpSpanBase* last = nextAngle->lastMarked();
        if (last) {
            SkASSERT(!SkPathOpsDebug::ChaseContains(*chase, last));
            *chase->append() = last;
#if DEBUG_WINDING
            SkDebugf("%s chase.append segment=%d span=%d", __FUNCTION__,
                    last->segment()->debugID(), last->debugID());
            if (!last->final()) {
                SkDebugf(" windSum=%d", last->upCast()->windSum());
            }
            SkDebugf("\n");
#endif
        }
    } while ((nextAngle = nextAngle->next()) != angle);
    start->segment()->markDone(start->starter(end));
    if (!foundAngle) {
        return nullptr;
    }
    *nextStart = foundAngle->start();
    *nextEnd = foundAngle->end();
    nextSegment = foundAngle->segment();
#if DEBUG_WINDING
    SkDebugf("%s from:[%d] to:[%d] start=%p end=%p\n",
            __FUNCTION__, debugID(), nextSegment->debugID(), *nextStart, *nextEnd);
 #endif
    return nextSegment;
}

◆ findNextXor()

SkOpSegment * SkOpSegment::findNextXor	(	SkOpSpanBase **	nextStart,
		SkOpSpanBase **	nextEnd,
		bool *	unsortable
	)

Definition at line 747 of file SkOpSegment.cpp.

                          {
    SkOpSpanBase* start = *nextStart;
    SkOpSpanBase* end = *nextEnd;
    SkASSERT(start != end);
    int step = start->step(end);
    SkOpSegment* other = this->isSimple(nextStart, &step);  // advances nextStart
    if (other) {
    // mark the smaller of startIndex, endIndex done, and all adjacent
    // spans with the same T value (but not 'other' spans)
#if DEBUG_WINDING
        SkDebugf("%s simple\n", __FUNCTION__);
#endif
        SkOpSpan* startSpan = start->starter(end);
        if (startSpan->done()) {
            return nullptr;
        }
        markDone(startSpan);
        *nextEnd = step > 0 ? (*nextStart)->upCast()->next() : (*nextStart)->prev();
        return other;
    }
    SkDEBUGCODE(SkOpSpanBase* endNear = step > 0 ? (*nextStart)->upCast()->next() \
            : (*nextStart)->prev());
    SkASSERT(endNear == end);  // is this ever not end?
    SkASSERT(endNear);
    SkASSERT(start != endNear);
    SkASSERT((start->t() < endNear->t()) ^ (step < 0));
    SkOpAngle* angle = this->spanToAngle(end, start);
    if (!angle || angle->unorderable()) {
        *unsortable = true;
        markDone(start->starter(end));
        return nullptr;
    }
#if DEBUG_SORT
    SkDebugf("%s\n", __FUNCTION__);
    angle->debugLoop();
#endif
    SkOpAngle* nextAngle = angle->next();
    const SkOpAngle* foundAngle = nullptr;
    bool foundDone = false;
    // iterate through the angle, and compute everyone's winding
    SkOpSegment* nextSegment;
    int activeCount = 0;
    do {
        if (!nextAngle) {
            return nullptr;
        }
        nextSegment = nextAngle->segment();
        ++activeCount;
        if (!foundAngle || (foundDone && activeCount & 1)) {
            foundAngle = nextAngle;
            if (!(foundDone = nextSegment->done(nextAngle))) {
                break;
            }
        }
        nextAngle = nextAngle->next();
    } while (nextAngle != angle);
    start->segment()->markDone(start->starter(end));
    if (!foundAngle) {
        return nullptr;
    }
    *nextStart = foundAngle->start();
    *nextEnd = foundAngle->end();
    nextSegment = foundAngle->segment();
#if DEBUG_WINDING
    SkDebugf("%s from:[%d] to:[%d] start=%p end=%p\n",
            __FUNCTION__, debugID(), nextSegment->debugID(), *nextStart, *nextEnd);
 #endif
    return nextSegment;
}

◆ findSortableTop()

SkOpSpan * SkOpSegment::findSortableTop ( SkOpContour * contourHead )

Definition at line 390 of file SkPathOpsWinding.cpp.

                                                               {
    SkOpSpan* span = &fHead;
    SkOpSpanBase* next;
    do {
        next = span->next();
        if (span->done()) {
            continue;
        }
        if (span->windSum() != SK_MinS32) {
            return span;
        }
        if (span->sortableTop(contourHead)) {
            return span;
        }
    } while (!next->final() && (span = next->upCast()));
    return nullptr;
}

◆ globalState()

SkOpGlobalState * SkOpSegment::globalState ( ) const

Definition at line 818 of file SkOpSegment.cpp.

                                                {
    return contour()->globalState();
}

◆ head() [1/2]

SkOpSpan * SkOpSegment::head ( )

inline

Definition at line 238 of file SkOpSegment.h.

                     {
        return &fHead;
    }

◆ head() [2/2]

const SkOpSpan * SkOpSegment::head ( ) const

inline

Definition at line 234 of file SkOpSegment.h.

                                 {
        return &fHead;
    }

◆ init()

void SkOpSegment::init	(	SkPoint	pts[],
		SkScalar	weight,
		SkOpContour *	parent,
		SkPath::Verb	verb
	)

Definition at line 822 of file SkOpSegment.cpp.

                                                                                            {
    fContour = contour;
    fNext = nullptr;
    fPts = pts;
    fWeight = weight;
    fVerb = verb;
    fCount = 0;
    fDoneCount = 0;
    fVisited = false;
    SkOpSpan* zeroSpan = &fHead;
    zeroSpan->init(this, nullptr, 0, fPts[0]);
    SkOpSpanBase* oneSpan = &fTail;
    zeroSpan->setNext(oneSpan);
    oneSpan->initBase(this, zeroSpan, 1, fPts[SkPathOpsVerbToPoints(fVerb)]);
    SkDEBUGCODE(fID = globalState()->nextSegmentID());
}

◆ insert()

SkOpSpan * SkOpSegment::insert ( SkOpSpan * prev )

inline

Definition at line 244 of file SkOpSegment.h.

                                     {
        SkOpGlobalState* globalState = this->globalState();
        globalState->setAllocatedOpSpan();
        SkOpSpan* result = globalState->allocator()->make<SkOpSpan>();
        SkOpSpanBase* next = prev->next();
        result->setPrev(prev);
        prev->setNext(result);
        SkDEBUGCODE(result->ptT()->fT = 0);
        result->setNext(next);
        if (next) {
            next->setPrev(result);
        }
        return result;
    }

◆ isClose()

bool SkOpSegment::isClose	(	double	t,
		const SkOpSegment *	opp
	)		const

Definition at line 839 of file SkOpSegment.cpp.

                                                                {
    SkDPoint cPt = this->dPtAtT(t);
    SkDVector dxdy = (*CurveDSlopeAtT[this->verb()])(this->pts(), this->weight(), t);
    SkDLine perp = {{ cPt, {cPt.fX + dxdy.fY, cPt.fY - dxdy.fX} }};
    SkIntersections i;
    (*CurveIntersectRay[opp->verb()])(opp->pts(), opp->weight(), perp, &i);
    int used = i.used();
    for (int index = 0; index < used; ++index) {
        if (cPt.roughlyEqual(i.pt(index))) {
            return true;
        }
    }
    return false;
}

◆ isHorizontal()

bool SkOpSegment::isHorizontal ( ) const

inline

Definition at line 261 of file SkOpSegment.h.

                              {
        return fBounds.fTop == fBounds.fBottom;
    }

◆ isSimple()

SkOpSegment * SkOpSegment::isSimple	(	SkOpSpanBase **	end,
		int *	step
	)		const

inline

Definition at line 265 of file SkOpSegment.h.

                                                               {
        return nextChase(end, step, nullptr, nullptr);
    }

◆ isVertical() [1/2]

bool SkOpSegment::isVertical ( ) const

inline

Definition at line 269 of file SkOpSegment.h.

                            {
        return fBounds.fLeft == fBounds.fRight;
    }

◆ isVertical() [2/2]

bool SkOpSegment::isVertical	(	SkOpSpanBase *	start,
		SkOpSpanBase *	end
	)		const

inline

Definition at line 273 of file SkOpSegment.h.

                                                                  {
        return (*CurveIsVertical[fVerb])(fPts, fWeight, start->t(), end->t());
    }

◆ isXor()

bool SkOpSegment::isXor ( ) const

Definition at line 854 of file SkOpSegment.cpp.

                              {
    return fContour->isXor();
}

◆ joinEnds()

void SkOpSegment::joinEnds ( SkOpSegment * start )

inline

Definition at line 279 of file SkOpSegment.h.

                                      {
        fTail.ptT()->addOpp(start->fHead.ptT(), start->fHead.ptT());
    }

◆ lastPt()

const SkPoint & SkOpSegment::lastPt ( ) const

inline

Definition at line 283 of file SkOpSegment.h.

                                  {
        return fPts[SkPathOpsVerbToPoints(fVerb)];
    }

◆ markAllDone()

void SkOpSegment::markAllDone ( )

Definition at line 858 of file SkOpSegment.cpp.

                              {
    SkOpSpan* span = this->head();
    do {
        this->markDone(span);
    } while ((span = span->next()->upCastable()));
}

◆ markAndChaseDone()

bool SkOpSegment::markAndChaseDone	(	SkOpSpanBase *	start,
		SkOpSpanBase *	end,
		SkOpSpanBase **	found
	)

Definition at line 865 of file SkOpSegment.cpp.

                                                                                                {
    int step = start->step(end);
    SkOpSpan* minSpan = start->starter(end);
    markDone(minSpan);
    SkOpSpanBase* last = nullptr;
    SkOpSegment* other = this;
    SkOpSpan* priorDone = nullptr;
    SkOpSpan* lastDone = nullptr;
    int safetyNet = 100000;
    while ((other = other->nextChase(&start, &step, &minSpan, &last))) {
        if (!--safetyNet) {
            return false;
        }
        if (other->done()) {
            SkASSERT(!last);
            break;
        }
        if (lastDone == minSpan || priorDone == minSpan) {
            if (found) {
                *found = nullptr;
            }
            return true;
        }
        other->markDone(minSpan);
        priorDone = lastDone;
        lastDone = minSpan;
    }
    if (found) {
        *found = last;
    }
    return true;
}

◆ markAndChaseWinding() [1/2]

bool SkOpSegment::markAndChaseWinding	(	SkOpSpanBase *	start,
		SkOpSpanBase *	end,
		int	winding,
		int	oppWinding,
		SkOpSpanBase **	lastPtr
	)

Definition at line 923 of file SkOpSegment.cpp.

                                                             {
    SkOpSpan* spanStart = start->starter(end);
    int step = start->step(end);
    bool success = markWinding(spanStart, winding, oppWinding);
    SkOpSpanBase* last = nullptr;
    SkOpSegment* other = this;
    int safetyNet = 100000;
    while ((other = other->nextChase(&start, &step, &spanStart, &last))) {
        if (!--safetyNet) {
            return false;
        }
        if (spanStart->windSum() != SK_MinS32) {
            if (this->operand() == other->operand()) {
                if (spanStart->windSum() != winding || spanStart->oppSum() != oppWinding) {
                    this->globalState()->setWindingFailed();
                    return true;  // ... but let it succeed anyway
                }
            } else {
                FAIL_IF(spanStart->windSum() != oppWinding);
                FAIL_IF(spanStart->oppSum() != winding);
            }
            SkASSERT(!last);
            break;
        }
        if (this->operand() == other->operand()) {
            (void) other->markWinding(spanStart, winding, oppWinding);
        } else {
            (void) other->markWinding(spanStart, oppWinding, winding);
        }
    }
    if (lastPtr) {
        *lastPtr = last;
    }
    return success;
}

◆ markAndChaseWinding() [2/2]

bool SkOpSegment::markAndChaseWinding	(	SkOpSpanBase *	start,
		SkOpSpanBase *	end,
		int	winding,
		SkOpSpanBase **	lastPtr
	)

Definition at line 898 of file SkOpSegment.cpp.

                                {
    SkOpSpan* spanStart = start->starter(end);
    int step = start->step(end);
    bool success = markWinding(spanStart, winding);
    SkOpSpanBase* last = nullptr;
    SkOpSegment* other = this;
    int safetyNet = 100000;
    while ((other = other->nextChase(&start, &step, &spanStart, &last))) {
        if (!--safetyNet) {
            return false;
        }
        if (spanStart->windSum() != SK_MinS32) {
//            SkASSERT(spanStart->windSum() == winding);   // FIXME: is this assert too aggressive?
            SkASSERT(!last);
            break;
        }
        (void) other->markWinding(spanStart, winding);
    }
    if (lastPtr) {
        *lastPtr = last;
    }
    return success;
}

◆ markAngle() [1/2]

bool SkOpSegment::markAngle	(	int	maxWinding,
		int	sumWinding,
		const SkOpAngle *	angle,
		SkOpSpanBase **	result
	)

Definition at line 960 of file SkOpSegment.cpp.

                                                   {
    SkASSERT(angle->segment() == this);
    if (UseInnerWinding(maxWinding, sumWinding)) {
        maxWinding = sumWinding;
    }
    if (!markAndChaseWinding(angle->start(), angle->end(), maxWinding, result)) {
        return false;
    }
#if DEBUG_WINDING
    SkOpSpanBase* last = *result;
    if (last) {
        SkDebugf("%s last seg=%d span=%d", __FUNCTION__,
                last->segment()->debugID(), last->debugID());
        if (!last->final()) {
            SkDebugf(" windSum=");
            SkPathOpsDebug::WindingPrintf(last->upCast()->windSum());
        }
        SkDebugf("\n");
    }
#endif
    return true;
}

◆ markAngle() [2/2]

bool SkOpSegment::markAngle	(	int	maxWinding,
		int	sumWinding,
		int	oppMaxWinding,
		int	oppSumWinding,
		const SkOpAngle *	angle,
		SkOpSpanBase **	result
	)

Definition at line 984 of file SkOpSegment.cpp.

                                                                                              {
    SkASSERT(angle->segment() == this);
    if (UseInnerWinding(maxWinding, sumWinding)) {
        maxWinding = sumWinding;
    }
    if (oppMaxWinding != oppSumWinding && UseInnerWinding(oppMaxWinding, oppSumWinding)) {
        oppMaxWinding = oppSumWinding;
    }
    // caller doesn't require that this marks anything
    if (!markAndChaseWinding(angle->start(), angle->end(), maxWinding, oppMaxWinding, result)) {
        return false;
    }
#if DEBUG_WINDING
    if (result) {
        SkOpSpanBase* last = *result;
        if (last) {
            SkDebugf("%s last segment=%d span=%d", __FUNCTION__,
                    last->segment()->debugID(), last->debugID());
            if (!last->final()) {
                SkDebugf(" windSum=");
                SkPathOpsDebug::WindingPrintf(last->upCast()->windSum());
            }
            SkDebugf(" \n");
        }
    }
#endif
    return true;
}

◆ markDone()

void SkOpSegment::markDone ( SkOpSpan * span )

Definition at line 1014 of file SkOpSegment.cpp.

                                         {
    SkASSERT(this == span->segment());
    if (span->done()) {
        return;
    }
#if DEBUG_MARK_DONE
    debugShowNewWinding(__FUNCTION__, span, span->windSum(), span->oppSum());
#endif
    span->setDone(true);
    ++fDoneCount;
    debugValidate();
}

◆ markWinding() [1/2]

bool SkOpSegment::markWinding	(	SkOpSpan *	span,
		int	winding
	)

Definition at line 1027 of file SkOpSegment.cpp.

                                                         {
    SkASSERT(this == span->segment());
    SkASSERT(winding);
    if (span->done()) {
        return false;
    }
#if DEBUG_MARK_DONE
    debugShowNewWinding(__FUNCTION__, span, winding);
#endif
    span->setWindSum(winding);
    debugValidate();
    return true;
}

◆ markWinding() [2/2]

bool SkOpSegment::markWinding	(	SkOpSpan *	span,
		int	winding,
		int	oppWinding
	)

Definition at line 1041 of file SkOpSegment.cpp.

                                                                         {
    SkASSERT(this == span->segment());
    SkASSERT(winding || oppWinding);
    if (span->done()) {
        return false;
    }
#if DEBUG_MARK_DONE
    debugShowNewWinding(__FUNCTION__, span, winding, oppWinding);
#endif
    span->setWindSum(winding);
    span->setOppSum(oppWinding);
    debugValidate();
    return true;
}

◆ match()

bool SkOpSegment::match	(	const SkOpPtT *	span,
		const SkOpSegment *	parent,
		double	t,
		const SkPoint &	pt
	)		const

Definition at line 1056 of file SkOpSegment.cpp.

                                     {
    SkASSERT(this == base->segment());
    if (this == testParent) {
        if (precisely_equal(base->fT, testT)) {
            return true;
        }
    }
    if (!SkDPoint::ApproximatelyEqual(testPt, base->fPt)) {
        return false;
    }
    return this != testParent || !this->ptsDisjoint(base->fT, base->fPt, testT, testPt);
}

◆ missingCoincidence()

bool SkOpSegment::missingCoincidence ( )

Definition at line 1161 of file SkOpSegment.cpp.

                                     {
    if (this->done()) {
        return false;
    }
    SkOpSpan* prior = nullptr;
    SkOpSpanBase* spanBase = &fHead;
    bool result = false;
    int safetyNet = 100000;
    do {
        SkOpPtT* ptT = spanBase->ptT(), * spanStopPtT = ptT;
        SkOPASSERT(ptT->span() == spanBase);
        while ((ptT = ptT->next()) != spanStopPtT) {
            if (!--safetyNet) {
                return false;
            }
            if (ptT->deleted()) {
                continue;
            }
            SkOpSegment* opp = ptT->span()->segment();
            if (opp->done()) {
                continue;
            }
            // when opp is encounted the 1st time, continue; on 2nd encounter, look for coincidence
            if (!opp->visited()) {
                continue;
            }
            if (spanBase == &fHead) {
                continue;
            }
            if (ptT->segment() == this) {
                continue;
            }
            SkOpSpan* span = spanBase->upCastable();
            // FIXME?: this assumes that if the opposite segment is coincident then no more
            // coincidence needs to be detected. This may not be true.
            if (span && span->containsCoincidence(opp)) {
                continue;
            }
            if (spanBase->containsCoinEnd(opp)) {
                continue;
            }
            SkOpPtT* priorPtT = nullptr, * priorStopPtT;
            // find prior span containing opp segment
            SkOpSegment* priorOpp = nullptr;
            SkOpSpan* priorTest = spanBase->prev();
            while (!priorOpp && priorTest) {
                priorStopPtT = priorPtT = priorTest->ptT();
                while ((priorPtT = priorPtT->next()) != priorStopPtT) {
                    if (priorPtT->deleted()) {
                        continue;
                    }
                    SkOpSegment* segment = priorPtT->span()->segment();
                    if (segment == opp) {
                        prior = priorTest;
                        priorOpp = opp;
                        break;
                    }
                }
                priorTest = priorTest->prev();
            }
            if (!priorOpp) {
                continue;
            }
            if (priorPtT == ptT) {
                continue;
            }
            SkOpPtT* oppStart = prior->ptT();
            SkOpPtT* oppEnd = spanBase->ptT();
            bool swapped = priorPtT->fT > ptT->fT;
            if (swapped) {
                using std::swap;
                swap(priorPtT, ptT);
                swap(oppStart, oppEnd);
            }
            SkOpCoincidence* coincidences = this->globalState()->coincidence();
            SkOpPtT* rootPriorPtT = priorPtT->span()->ptT();
            SkOpPtT* rootPtT = ptT->span()->ptT();
            SkOpPtT* rootOppStart = oppStart->span()->ptT();
            SkOpPtT* rootOppEnd = oppEnd->span()->ptT();
            if (coincidences->contains(rootPriorPtT, rootPtT, rootOppStart, rootOppEnd)) {
                goto swapBack;
            }
            if (this->testForCoincidence(rootPriorPtT, rootPtT, prior, spanBase, opp)) {
            // mark coincidence
#if DEBUG_COINCIDENCE_VERBOSE
                SkDebugf("%s coinSpan=%d endSpan=%d oppSpan=%d oppEndSpan=%d\n", __FUNCTION__,
                        rootPriorPtT->debugID(), rootPtT->debugID(), rootOppStart->debugID(),
                        rootOppEnd->debugID());
#endif
                if (!coincidences->extend(rootPriorPtT, rootPtT, rootOppStart, rootOppEnd)) {
                    coincidences->add(rootPriorPtT, rootPtT, rootOppStart, rootOppEnd);
                }
#if DEBUG_COINCIDENCE
                SkASSERT(coincidences->contains(rootPriorPtT, rootPtT, rootOppStart, rootOppEnd));
#endif
                result = true;
            }
    swapBack:
            if (swapped) {
                using std::swap;
                swap(priorPtT, ptT);
            }
        }
    } while ((spanBase = spanBase->final() ? nullptr : spanBase->upCast()->next()));
    ClearVisited(&fHead);
    return result;
}

◆ moveMultiples()

bool SkOpSegment::moveMultiples ( )

Definition at line 1271 of file SkOpSegment.cpp.

                                {
    debugValidate();
    SkOpSpanBase* test = &fHead;
    do {
        int addCount = test->spanAddsCount();
//        FAIL_IF(addCount < 1);
        if (addCount <= 1) {
            continue;
        }
        SkOpPtT* startPtT = test->ptT();
        SkOpPtT* testPtT = startPtT;
        int safetyHatch = 1000000;
        do {  // iterate through all spans associated with start
            if (!--safetyHatch) {
                return false;
            }
            SkOpSpanBase* oppSpan = testPtT->span();
            if (oppSpan->spanAddsCount() == addCount) {
                continue;
            }
            if (oppSpan->deleted()) {
                continue;
            }
            SkOpSegment* oppSegment = oppSpan->segment();
            if (oppSegment == this) {
                continue;
            }
            // find range of spans to consider merging
            SkOpSpanBase* oppPrev = oppSpan;
            SkOpSpanBase* oppFirst = oppSpan;
            while ((oppPrev = oppPrev->prev())) {
                if (!roughly_equal(oppPrev->t(), oppSpan->t())) {
                    break;
                }
                if (oppPrev->spanAddsCount() == addCount) {
                    continue;
                }
                if (oppPrev->deleted()) {
                    continue;
                }
                oppFirst = oppPrev;
            }
            SkOpSpanBase* oppNext = oppSpan;
            SkOpSpanBase* oppLast = oppSpan;
            while ((oppNext = oppNext->final() ? nullptr : oppNext->upCast()->next())) {
                if (!roughly_equal(oppNext->t(), oppSpan->t())) {
                    break;
                }
                if (oppNext->spanAddsCount() == addCount) {
                    continue;
                }
                if (oppNext->deleted()) {
                    continue;
                }
                oppLast = oppNext;
            }
            if (oppFirst == oppLast) {
                continue;
            }
            SkOpSpanBase* oppTest = oppFirst;
            do {
                if (oppTest == oppSpan) {
                    continue;
                }
                // check to see if the candidate meets specific criteria:
                // it contains spans of segments in test's loop but not including 'this'
                SkOpPtT* oppStartPtT = oppTest->ptT();
                SkOpPtT* oppPtT = oppStartPtT;
                while ((oppPtT = oppPtT->next()) != oppStartPtT) {
                    SkOpSegment* oppPtTSegment = oppPtT->segment();
                    if (oppPtTSegment == this) {
                        goto tryNextSpan;
                    }
                    SkOpPtT* matchPtT = startPtT;
                    do {
                        if (matchPtT->segment() == oppPtTSegment) {
                            goto foundMatch;
                        }
                    } while ((matchPtT = matchPtT->next()) != startPtT);
                    goto tryNextSpan;
            foundMatch:  // merge oppTest and oppSpan
                    oppSegment->debugValidate();
                    oppTest->mergeMatches(oppSpan);
                    oppTest->addOpp(oppSpan);
                    oppSegment->debugValidate();
                    goto checkNextSpan;
                }
        tryNextSpan:
                ;
            } while (oppTest != oppLast && (oppTest = oppTest->upCast()->next()));
        } while ((testPtT = testPtT->next()) != startPtT);
checkNextSpan:
        ;
    } while ((test = test->final() ? nullptr : test->upCast()->next()));
    debugValidate();
    return true;
}

◆ moveNearby()

bool SkOpSegment::moveNearby ( )

Definition at line 1441 of file SkOpSegment.cpp.

                             {
    debugValidate();
    // release undeleted spans pointing to this seg that are linked to the primary span
    SkOpSpanBase* spanBase = &fHead;
    int escapeHatch = 9999;  // the largest count for a regular test is 50; for a fuzzer, 500
    do {
        SkOpPtT* ptT = spanBase->ptT();
        const SkOpPtT* headPtT = ptT;
        while ((ptT = ptT->next()) != headPtT) {
            if (!--escapeHatch) {
                return false;
            }
            SkOpSpanBase* test = ptT->span();
            if (ptT->segment() == this && !ptT->deleted() && test != spanBase
                    && test->ptT() == ptT) {
                if (test->final()) {
                    if (spanBase == &fHead) {
                        this->clearAll();
                        return true;
                    }
                    spanBase->upCast()->release(ptT);
                } else if (test->prev()) {
                    test->upCast()->release(headPtT);
                }
                break;
            }
        }
        spanBase = spanBase->upCast()->next();
    } while (!spanBase->final());
    // This loop looks for adjacent spans which are near by
    spanBase = &fHead;
    do {  // iterate through all spans associated with start
        SkOpSpanBase* test = spanBase->upCast()->next();
        bool found;
        if (!this->spansNearby(spanBase, test, &found)) {
            return false;
        }
        if (found) {
            if (test->final()) {
                if (spanBase->prev()) {
                    test->merge(spanBase->upCast());
                } else {
                    this->clearAll();
                    return true;
                }
            } else {
                spanBase->merge(test->upCast());
            }
        }
        spanBase = test;
    } while (!spanBase->final());
    debugValidate();
    return true;
}

◆ next()

SkOpSegment * SkOpSegment::next ( ) const

inline

Definition at line 304 of file SkOpSegment.h.

                              {
        return fNext;
    }

◆ nextChase()

SkOpSegment * SkOpSegment::nextChase	(	SkOpSpanBase **	startPtr,
		int *	step,
		SkOpSpan **	minPtr,
		SkOpSpanBase **	last
	)		const

Definition at line 1077 of file SkOpSegment.cpp.

                                   {
    SkOpSpanBase* origStart = *startPtr;
    int step = *stepPtr;
    SkOpSpanBase* endSpan = step > 0 ? origStart->upCast()->next() : origStart->prev();
    SkASSERT(endSpan);
    SkOpAngle* angle = step > 0 ? endSpan->fromAngle() : endSpan->upCast()->toAngle();
    SkOpSpanBase* foundSpan;
    SkOpSpanBase* otherEnd;
    SkOpSegment* other;
    if (angle == nullptr) {
        if (endSpan->t() != 0 && endSpan->t() != 1) {
            return nullptr;
        }
        SkOpPtT* otherPtT = endSpan->ptT()->next();
        other = otherPtT->segment();
        foundSpan = otherPtT->span();
        otherEnd = step > 0
                ? foundSpan->upCastable() ? foundSpan->upCast()->next() : nullptr
                : foundSpan->prev();
    } else {
        int loopCount = angle->loopCount();
        if (loopCount > 2) {
            return set_last(last, endSpan);
        }
        const SkOpAngle* next = angle->next();
        if (nullptr == next) {
            return nullptr;
        }
#if DEBUG_WINDING
        if (angle->debugSign() != next->debugSign() && !angle->segment()->contour()->isXor()
                && !next->segment()->contour()->isXor()) {
            SkDebugf("%s mismatched signs\n", __FUNCTION__);
        }
#endif
        other = next->segment();
        foundSpan = endSpan = next->start();
        otherEnd = next->end();
    }
    if (!otherEnd) {
        return nullptr;
    }
    int foundStep = foundSpan->step(otherEnd);
    if (*stepPtr != foundStep) {
        return set_last(last, endSpan);
    }
    SkASSERT(*startPtr);
//    SkASSERT(otherEnd >= 0);
    SkOpSpan* origMin = step < 0 ? origStart->prev() : origStart->upCast();
    SkOpSpan* foundMin = foundSpan->starter(otherEnd);
    if (foundMin->windValue() != origMin->windValue()
            || foundMin->oppValue() != origMin->oppValue()) {
          return set_last(last, endSpan);
    }
    *startPtr = foundSpan;
    *stepPtr = foundStep;
    if (minPtr) {
        *minPtr = foundMin;
    }
    return other;
}

◆ operand()

bool SkOpSegment::operand ( ) const

Definition at line 1496 of file SkOpSegment.cpp.

                                {
    return fContour->operand();
}

◆ operator<()

bool SkOpSegment::operator< ( const SkOpSegment & rh ) const

inline

Definition at line 37 of file SkOpSegment.h.

                                                {
        return fBounds.fTop < rh.fBounds.fTop;
    }

◆ OppSign()

static int SkOpSegment::OppSign	(	const SkOpSpanBase *	start,
		const SkOpSpanBase *	end
	)

inlinestatic

Definition at line 311 of file SkOpSegment.h.

                                                                           {
        int result = start->t() < end->t() ? -start->upCast()->oppValue()
                : end->upCast()->oppValue();
        return result;
    }

◆ oppXor()

bool SkOpSegment::oppXor ( ) const

Definition at line 1500 of file SkOpSegment.cpp.

                               {
    return fContour->oppXor();
}

◆ prev()

const SkOpSegment * SkOpSegment::prev ( ) const

inline

Definition at line 319 of file SkOpSegment.h.

                                    {
        return fPrev;
    }

◆ ptAtT()

SkPoint SkOpSegment::ptAtT ( double mid ) const

inline

Definition at line 323 of file SkOpSegment.h.

                                    {
        return (*CurvePointAtT[fVerb])(fPts, fWeight, mid);
    }

◆ pts()

const SkPoint * SkOpSegment::pts ( ) const

inline

Definition at line 327 of file SkOpSegment.h.

                               {
        return fPts;
    }

◆ ptsDisjoint() [1/3]

bool SkOpSegment::ptsDisjoint	(	const SkOpPtT &	span,
		const SkOpPtT &	test
	)		const

inline

Definition at line 331 of file SkOpSegment.h.

                                                                     {
        SkASSERT(this == span.segment());
        SkASSERT(this == test.segment());
        return ptsDisjoint(span.fT, span.fPt, test.fT, test.fPt);
    }

◆ ptsDisjoint() [2/3]

bool SkOpSegment::ptsDisjoint	(	const SkOpPtT &	span,
		double	t,
		const SkPoint &	pt
	)		const

inline

Definition at line 337 of file SkOpSegment.h.

                                                                             {
        SkASSERT(this == span.segment());
        return ptsDisjoint(span.fT, span.fPt, t, pt);
    }

◆ ptsDisjoint() [3/3]

bool SkOpSegment::ptsDisjoint	(	double	t1,
		const SkPoint &	pt1,
		double	t2,
		const SkPoint &	pt2
	)		const

Definition at line 1504 of file SkOpSegment.cpp.

                                                                                                {
    if (fVerb == SkPath::kLine_Verb) {
        return false;
    }
    // quads (and cubics) can loop back to nearly a line so that an opposite curve
    // hits in two places with very different t values.
    // OPTIMIZATION: curves could be preflighted so that, for example, something like
    // 'controls contained by ends' could avoid this check for common curves
    // 'ends are extremes in x or y' is cheaper to compute and real-world common
    // on the other hand, the below check is relatively inexpensive
    double midT = (t1 + t2) / 2;
    SkPoint midPt = this->ptAtT(midT);
    double seDistSq = std::max(SkPointPriv::DistanceToSqd(pt1, pt2) * 2, FLT_EPSILON * 2);
    return SkPointPriv::DistanceToSqd(midPt, pt1) > seDistSq ||
           SkPointPriv::DistanceToSqd(midPt, pt2) > seDistSq;
}

◆ rayCheck()

void SkOpSegment::rayCheck	(	const SkOpRayHit &	base,
		SkOpRayDir	dir,
		SkOpRayHit **	hits,
		SkArenaAlloc *	allocator
	)

Definition at line 138 of file SkPathOpsWinding.cpp.

                                                    {
    if (!sideways_overlap(fBounds, base.fPt, dir)) {
        return;
    }
    SkScalar baseXY = pt_xy(base.fPt, dir);
    SkScalar boundsXY = rect_side(fBounds, dir);
    bool checkLessThan = less_than(dir);
    if (!approximately_equal(baseXY, boundsXY) && (baseXY < boundsXY) == checkLessThan) {
        return;
    }
    double tVals[3];
    SkScalar baseYX = pt_yx(base.fPt, dir);
    int roots = (*CurveIntercept[fVerb * 2 + xy_index(dir)])(fPts, fWeight, baseYX, tVals);
    for (int index = 0; index < roots; ++index) {
        double t = tVals[index];
        if (base.fSpan->segment() == this && approximately_equal(base.fT, t)) {
            continue;
        }
        SkDVector slope;
        SkPoint pt;
        SkDEBUGCODE(sk_bzero(&slope, sizeof(slope)));
        bool valid = false;
        if (approximately_zero(t)) {
            pt = fPts[0];
        } else if (approximately_equal(t, 1)) {
            pt = fPts[SkPathOpsVerbToPoints(fVerb)];
        } else {
            SkASSERT(between(0, t, 1));
            pt = this->ptAtT(t);
            if (SkDPoint::ApproximatelyEqual(pt, base.fPt)) {
                if (base.fSpan->segment() == this) {
                    continue;
                }
            } else {
                SkScalar ptXY = pt_xy(pt, dir);
                if (!approximately_equal(baseXY, ptXY) && (baseXY < ptXY) == checkLessThan) {
                    continue;
                }
                slope = this->dSlopeAtT(t);
                if (fVerb == SkPath::kCubic_Verb && base.fSpan->segment() == this
                        && roughly_equal(base.fT, t)
                        && SkDPoint::RoughlyEqual(pt, base.fPt)) {
    #if DEBUG_WINDING
                    SkDebugf("%s (rarely expect this)\n", __FUNCTION__);
    #endif
                    continue;
                }
                if (fabs(pt_dydx(slope, dir) * 10000) > fabs(pt_dxdy(slope, dir))) {
                    valid = true;
                }
            }
        }
        SkOpSpan* span = this->windingSpanAtT(t);
        if (!span) {
            valid = false;
        } else if (!span->windValue() && !span->oppValue()) {
            continue;
        }
        SkOpRayHit* newHit = allocator->make<SkOpRayHit>();
        newHit->fNext = *hits;
        newHit->fPt = pt;
        newHit->fSlope = slope;
        newHit->fSpan = span;
        newHit->fT = t;
        newHit->fValid = valid;
        *hits = newHit;
    }
}

◆ release()

void SkOpSegment::release ( const SkOpSpan * span )

Definition at line 504 of file SkOpSegment.cpp.

                                              {
    if (span->done()) {
        --fDoneCount;
    }
    --fCount;
    SkOPASSERT(fCount >= fDoneCount);
}

◆ resetVisited()

void SkOpSegment::resetVisited ( )

inline

Definition at line 353 of file SkOpSegment.h.

                        {
        fVisited = false;
    }

◆ setContour()

void SkOpSegment::setContour ( SkOpContour * contour )

inline

Definition at line 357 of file SkOpSegment.h.

                                          {
        fContour = contour;
    }

◆ setNext()

void SkOpSegment::setNext ( SkOpSegment * next )

inline

Definition at line 361 of file SkOpSegment.h.

                                    {
        fNext = next;
    }

◆ setPrev()

void SkOpSegment::setPrev ( SkOpSegment * prev )

inline

Definition at line 365 of file SkOpSegment.h.

                                    {
        fPrev = prev;
    }

◆ setUpWinding()

void SkOpSegment::setUpWinding	(	SkOpSpanBase *	start,
		SkOpSpanBase *	end,
		int *	maxWinding,
		int *	sumWinding
	)

inline

Definition at line 369 of file SkOpSegment.h.

                                                                                                {
        int deltaSum = SpanSign(start, end);
        *maxWinding = *sumWinding;
        if (*sumWinding == SK_MinS32) {
          return;
        }
        *sumWinding -= deltaSum;
    }

◆ setUpWindings() [1/2]

void SkOpSegment::setUpWindings	(	SkOpSpanBase *	start,
		SkOpSpanBase *	end,
		int *	sumMiWinding,
		int *	maxWinding,
		int *	sumWinding
	)

Definition at line 1521 of file SkOpSegment.cpp.

                                          {
    int deltaSum = SpanSign(start, end);
    *maxWinding = *sumMiWinding;
    *sumWinding = *sumMiWinding -= deltaSum;
    SkASSERT(!DEBUG_LIMIT_WIND_SUM || SkTAbs(*sumWinding) <= DEBUG_LIMIT_WIND_SUM);
}

◆ setUpWindings() [2/2]

void SkOpSegment::setUpWindings	(	SkOpSpanBase *	start,
		SkOpSpanBase *	end,
		int *	sumMiWinding,
		int *	sumSuWinding,
		int *	maxWinding,
		int *	sumWinding,
		int *	oppMaxWinding,
		int *	oppSumWinding
	)

Definition at line 1529 of file SkOpSegment.cpp.

                            {
    int deltaSum = SpanSign(start, end);
    int oppDeltaSum = OppSign(start, end);
    if (operand()) {
        *maxWinding = *sumSuWinding;
        *sumWinding = *sumSuWinding -= deltaSum;
        *oppMaxWinding = *sumMiWinding;
        *oppSumWinding = *sumMiWinding -= oppDeltaSum;
    } else {
        *maxWinding = *sumMiWinding;
        *sumWinding = *sumMiWinding -= deltaSum;
        *oppMaxWinding = *sumSuWinding;
        *oppSumWinding = *sumSuWinding -= oppDeltaSum;
    }
    SkASSERT(!DEBUG_LIMIT_WIND_SUM || SkTAbs(*sumWinding) <= DEBUG_LIMIT_WIND_SUM);
    SkASSERT(!DEBUG_LIMIT_WIND_SUM || SkTAbs(*oppSumWinding) <= DEBUG_LIMIT_WIND_SUM);
}

◆ sortAngles()

bool SkOpSegment::sortAngles ( )

Definition at line 1549 of file SkOpSegment.cpp.

                             {
    SkOpSpanBase* span = &this->fHead;
    do {
        SkOpAngle* fromAngle = span->fromAngle();
        SkOpAngle* toAngle = span->final() ? nullptr : span->upCast()->toAngle();
        if (!fromAngle && !toAngle) {
            continue;
        }
#if DEBUG_ANGLE
        bool wroteAfterHeader = false;
#endif
        SkOpAngle* baseAngle = fromAngle;
        if (fromAngle && toAngle) {
#if DEBUG_ANGLE
            SkDebugf("%s [%d] tStart=%1.9g [%d]\n", __FUNCTION__, debugID(), span->t(),
                    span->debugID());
            wroteAfterHeader = true;
#endif
            FAIL_IF(!fromAngle->insert(toAngle));
        } else if (!fromAngle) {
            baseAngle = toAngle;
        }
        SkOpPtT* ptT = span->ptT(), * stopPtT = ptT;
        int safetyNet = 1000000;
        do {
            if (!--safetyNet) {
                return false;
            }
            SkOpSpanBase* oSpan = ptT->span();
            if (oSpan == span) {
                continue;
            }
            SkOpAngle* oAngle = oSpan->fromAngle();
            if (oAngle) {
#if DEBUG_ANGLE
                if (!wroteAfterHeader) {
                    SkDebugf("%s [%d] tStart=%1.9g [%d]\n", __FUNCTION__, debugID(),
                            span->t(), span->debugID());
                    wroteAfterHeader = true;
                }
#endif
                if (!oAngle->loopContains(baseAngle)) {
                    baseAngle->insert(oAngle);
                }
            }
            if (!oSpan->final()) {
                oAngle = oSpan->upCast()->toAngle();
                if (oAngle) {
#if DEBUG_ANGLE
                    if (!wroteAfterHeader) {
                        SkDebugf("%s [%d] tStart=%1.9g [%d]\n", __FUNCTION__, debugID(),
                                span->t(), span->debugID());
                        wroteAfterHeader = true;
                    }
#endif
                    if (!oAngle->loopContains(baseAngle)) {
                        baseAngle->insert(oAngle);
                    }
                }
            }
        } while ((ptT = ptT->next()) != stopPtT);
        if (baseAngle->loopCount() == 1) {
            span->setFromAngle(nullptr);
            if (toAngle) {
                span->upCast()->setToAngle(nullptr);
            }
            baseAngle = nullptr;
        }
#if DEBUG_SORT
        SkASSERT(!baseAngle || baseAngle->loopCount() > 1);
#endif
    } while (!span->final() && (span = span->upCast()->next()));
    return true;
}

◆ SpanSign()

static int SkOpSegment::SpanSign	(	const SkOpSpanBase *	start,
		const SkOpSpanBase *	end
	)

inlinestatic

Definition at line 385 of file SkOpSegment.h.

                                                                            {
        int result = start->t() < end->t() ? -start->upCast()->windValue()
                : end->upCast()->windValue();
        return result;
    }

◆ spansNearby()

bool SkOpSegment::spansNearby	(	const SkOpSpanBase *	ref,
		const SkOpSpanBase *	check,
		bool *	found
	)		const

Definition at line 1370 of file SkOpSegment.cpp.

                           {
    const SkOpPtT* refHead = refSpan->ptT();
    const SkOpPtT* checkHead = checkSpan->ptT();
// if the first pt pair from adjacent spans are far apart, assume that all are far enough apart
    if (!SkDPoint::WayRoughlyEqual(refHead->fPt, checkHead->fPt)) {
#if DEBUG_COINCIDENCE
        // verify that no combination of points are close
        const SkOpPtT* dBugRef = refHead;
        do {
            const SkOpPtT* dBugCheck = checkHead;
            do {
                SkOPASSERT(!SkDPoint::ApproximatelyEqual(dBugRef->fPt, dBugCheck->fPt));
                dBugCheck = dBugCheck->next();
            } while (dBugCheck != checkHead);
            dBugRef = dBugRef->next();
        } while (dBugRef != refHead);
#endif
        *found = false;
        return true;
    }
    // check only unique points
    SkScalar distSqBest = SK_ScalarMax;
    const SkOpPtT* refBest = nullptr;
    const SkOpPtT* checkBest = nullptr;
    const SkOpPtT* ref = refHead;
    do {
        if (ref->deleted()) {
            continue;
        }
        while (ref->ptAlreadySeen(refHead)) {
            ref = ref->next();
            if (ref == refHead) {
                goto doneCheckingDistance;
            }
        }
        const SkOpPtT* check = checkHead;
        const SkOpSegment* refSeg = ref->segment();
        int escapeHatch = 100000;  // defend against infinite loops
        do {
            if (check->deleted()) {
                continue;
            }
            while (check->ptAlreadySeen(checkHead)) {
                check = check->next();
                if (check == checkHead) {
                    goto nextRef;
                }
            }
            SkScalar distSq = SkPointPriv::DistanceToSqd(ref->fPt, check->fPt);
            if (distSqBest > distSq && (refSeg != check->segment()
                    || !refSeg->ptsDisjoint(*ref, *check))) {
                distSqBest = distSq;
                refBest = ref;
                checkBest = check;
            }
            if (--escapeHatch <= 0) {
                return false;
            }
        } while ((check = check->next()) != checkHead);
    nextRef:
        ;
   } while ((ref = ref->next()) != refHead);
doneCheckingDistance:
    *found = checkBest && refBest->segment()->match(refBest, checkBest->segment(), checkBest->fT,
            checkBest->fPt);
    return true;
}

◆ spanToAngle()

SkOpAngle * SkOpSegment::spanToAngle	(	SkOpSpanBase *	start,
		SkOpSpanBase *	end
	)

inline

Definition at line 391 of file SkOpSegment.h.

                                                                   {
        SkASSERT(start != end);
        return start->t() < end->t() ? start->upCast()->toAngle() : start->fromAngle();
    }

◆ subDivide()

bool SkOpSegment::subDivide	(	const SkOpSpanBase *	start,
		const SkOpSpanBase *	end,
		SkDCurve *	result
	)		const

Definition at line 1624 of file SkOpSegment.cpp.

                              {
    SkASSERT(start != end);
    const SkOpPtT& startPtT = *start->ptT();
    const SkOpPtT& endPtT = *end->ptT();
    SkDEBUGCODE(edge->fVerb = fVerb);
    edge->fCubic[0].set(startPtT.fPt);
    int points = SkPathOpsVerbToPoints(fVerb);
    edge->fCubic[points].set(endPtT.fPt);
    if (fVerb == SkPath::kLine_Verb) {
        return false;
    }
    double startT = startPtT.fT;
    double endT = endPtT.fT;
    if ((startT == 0 || endT == 0) && (startT == 1 || endT == 1)) {
        // don't compute midpoints if we already have them
        if (fVerb == SkPath::kQuad_Verb) {
            edge->fLine[1].set(fPts[1]);
            return false;
        }
        if (fVerb == SkPath::kConic_Verb) {
            edge->fConic[1].set(fPts[1]);
            edge->fConic.fWeight = fWeight;
            return false;
        }
        SkASSERT(fVerb == SkPath::kCubic_Verb);
        if (startT == 0) {
            edge->fCubic[1].set(fPts[1]);
            edge->fCubic[2].set(fPts[2]);
            return false;
        }
        edge->fCubic[1].set(fPts[2]);
        edge->fCubic[2].set(fPts[1]);
        return false;
    }
    if (fVerb == SkPath::kQuad_Verb) {
        edge->fQuad[1] = SkDQuad::SubDivide(fPts, edge->fQuad[0], edge->fQuad[2], startT, endT);
    } else if (fVerb == SkPath::kConic_Verb) {
        edge->fConic[1] = SkDConic::SubDivide(fPts, fWeight, edge->fQuad[0], edge->fQuad[2],
            startT, endT, &edge->fConic.fWeight);
    } else {
        SkASSERT(fVerb == SkPath::kCubic_Verb);
        SkDCubic::SubDivide(fPts, edge->fCubic[0], edge->fCubic[3], startT, endT, &edge->fCubic[1]);
    }
    return true;
}

◆ tail() [1/2]

SkOpSpanBase * SkOpSegment::tail ( )

inline

Definition at line 402 of file SkOpSegment.h.

                         {
        return &fTail;
    }

◆ tail() [2/2]

const SkOpSpanBase * SkOpSegment::tail ( ) const

inline

Definition at line 398 of file SkOpSegment.h.

                                     {
        return &fTail;
    }

◆ testForCoincidence()

bool SkOpSegment::testForCoincidence	(	const SkOpPtT *	priorPtT,
		const SkOpPtT *	ptT,
		const SkOpSpanBase *	prior,
		const SkOpSpanBase *	spanBase,
		const SkOpSegment *	opp
	)		const

Definition at line 1671 of file SkOpSegment.cpp.

                                                                                               {
    // average t, find mid pt
    double midT = (prior->t() + spanBase->t()) / 2;
    SkPoint midPt = this->ptAtT(midT);
    bool coincident = true;
    // if the mid pt is not near either end pt, project perpendicular through opp seg
    if (!SkDPoint::ApproximatelyEqual(priorPtT->fPt, midPt)
            && !SkDPoint::ApproximatelyEqual(ptT->fPt, midPt)) {
        if (priorPtT->span() == ptT->span()) {
          return false;
        }
        coincident = false;
        SkIntersections i;
        SkDCurve curvePart;
        this->subDivide(prior, spanBase, &curvePart);
        SkDVector dxdy = (*CurveDDSlopeAtT[fVerb])(curvePart, 0.5f);
        SkDPoint partMidPt = (*CurveDDPointAtT[fVerb])(curvePart, 0.5f);
        SkDLine ray = {{{midPt.fX, midPt.fY}, {partMidPt.fX + dxdy.fY, partMidPt.fY - dxdy.fX}}};
        SkDCurve oppPart;
        opp->subDivide(priorPtT->span(), ptT->span(), &oppPart);
        (*CurveDIntersectRay[opp->verb()])(oppPart, ray, &i);
        // measure distance and see if it's small enough to denote coincidence
        for (int index = 0; index < i.used(); ++index) {
            if (!between(0, i[0][index], 1)) {
                continue;
            }
            SkDPoint oppPt = i.pt(index);
            if (oppPt.approximatelyDEqual(midPt)) {
                // the coincidence can occur at almost any angle
                coincident = true;
            }
        }
    }
    return coincident;
}

◆ undoneSpan()

SkOpSpan * SkOpSegment::undoneSpan ( )

Definition at line 1708 of file SkOpSegment.cpp.

                                  {
    SkOpSpan* span = &fHead;
    SkOpSpanBase* next;
    do {
        next = span->next();
        if (!span->done()) {
            return span;
        }
    } while (!next->final() && (span = next->upCast()));
    return nullptr;
}

◆ updateOppWinding() [1/2]

int SkOpSegment::updateOppWinding ( const SkOpAngle * angle ) const

Definition at line 1731 of file SkOpSegment.cpp.

                                                              {
    const SkOpSpanBase* startSpan = angle->start();
    const SkOpSpanBase* endSpan = angle->end();
    return updateOppWinding(endSpan, startSpan);
}

◆ updateOppWinding() [2/2]

int SkOpSegment::updateOppWinding	(	const SkOpSpanBase *	start,
		const SkOpSpanBase *	end
	)		const

Definition at line 1720 of file SkOpSegment.cpp.

                                                                                          {
    const SkOpSpan* lesser = start->starter(end);
    int oppWinding = lesser->oppSum();
    int oppSpanWinding = SkOpSegment::OppSign(start, end);
    if (oppSpanWinding && UseInnerWinding(oppWinding - oppSpanWinding, oppWinding)
            && oppWinding != SK_MaxS32) {
        oppWinding -= oppSpanWinding;
    }
    return oppWinding;
}

◆ updateOppWindingReverse()

int SkOpSegment::updateOppWindingReverse ( const SkOpAngle * angle ) const

Definition at line 1737 of file SkOpSegment.cpp.

                                                                     {
    const SkOpSpanBase* startSpan = angle->start();
    const SkOpSpanBase* endSpan = angle->end();
    return updateOppWinding(startSpan, endSpan);
}

◆ updateWinding() [1/2]

int SkOpSegment::updateWinding ( SkOpAngle * angle )

Definition at line 1760 of file SkOpSegment.cpp.

                                               {
    SkOpSpanBase* startSpan = angle->start();
    SkOpSpanBase* endSpan = angle->end();
    return updateWinding(endSpan, startSpan);
}

◆ updateWinding() [2/2]

int SkOpSegment::updateWinding	(	SkOpSpanBase *	start,
		SkOpSpanBase *	end
	)

Definition at line 1743 of file SkOpSegment.cpp.

                                                                     {
    SkOpSpan* lesser = start->starter(end);
    int winding = lesser->windSum();
    if (winding == SK_MinS32) {
        winding = lesser->computeWindSum();
    }
    if (winding == SK_MinS32) {
        return winding;
    }
    int spanWinding = SkOpSegment::SpanSign(start, end);
    if (winding && UseInnerWinding(winding - spanWinding, winding)
            && winding != SK_MaxS32) {
        winding -= spanWinding;
    }
    return winding;
}

◆ updateWindingReverse()

int SkOpSegment::updateWindingReverse ( const SkOpAngle * angle )

Definition at line 1766 of file SkOpSegment.cpp.

                                                            {
    SkOpSpanBase* startSpan = angle->start();
    SkOpSpanBase* endSpan = angle->end();
    return updateWinding(startSpan, endSpan);
}

◆ UseInnerWinding()

bool SkOpSegment::UseInnerWinding	(	int	outerWinding,
		int	innerWinding
	)

static

Definition at line 1775 of file SkOpSegment.cpp.

                                                                    {
    SkASSERT(outerWinding != SK_MaxS32);
    SkASSERT(innerWinding != SK_MaxS32);
    int absOut = SkTAbs(outerWinding);
    int absIn = SkTAbs(innerWinding);
    bool result = absOut == absIn ? outerWinding < 0 : absOut < absIn;
    return result;
}

◆ verb()

SkPath::Verb SkOpSegment::verb ( ) const

inline

Definition at line 419 of file SkOpSegment.h.

                            {
        return fVerb;
    }

◆ visited()

bool SkOpSegment::visited ( )

inline

Definition at line 424 of file SkOpSegment.h.

                   {
        if (!fVisited) {
            fVisited = true;
            return false;
        }
        return true;
    }

◆ weight()

SkScalar SkOpSegment::weight ( ) const

inline

Definition at line 432 of file SkOpSegment.h.

                            {
        return fWeight;
    }

◆ windingSpanAtT()

SkOpSpan * SkOpSegment::windingSpanAtT ( double tHit )

Definition at line 208 of file SkPathOpsWinding.cpp.

                                                 {
    SkOpSpan* span = &fHead;
    SkOpSpanBase* next;
    do {
        next = span->next();
        if (approximately_equal(tHit, next->t())) {
            return nullptr;
        }
        if (tHit < next->t()) {
            return span;
        }
    } while (!next->final() && (span = next->upCast()));
    return nullptr;
}

◆ windSum()

int SkOpSegment::windSum ( const SkOpAngle * angle ) const

Definition at line 1784 of file SkOpSegment.cpp.

                                                     {
    const SkOpSpan* minSpan = angle->start()->starter(angle->end());
    return minSpan->windSum();
}

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

third_party/skia/src/pathops/SkOpSegment.h
third_party/skia/src/pathops/SkOpSegment.cpp
third_party/skia/src/pathops/SkPathOpsDebug.cpp
third_party/skia/src/pathops/SkPathOpsWinding.cpp
third_party/skia/tests/PathOpsDebug.cpp

Public Member Functions

Static Public Member Functions

Detailed Description

Member Function Documentation

◆ activeAngle()

◆ activeAngleInner()

◆ activeAngleOther()

◆ activeOp() [1/2]

◆ activeOp() [2/2]

◆ activeWinding() [1/2]

◆ activeWinding() [2/2]

◆ addConic()

◆ addCubic()

◆ addCurveTo()

◆ addEndSpan()

◆ addExpanded()

◆ addLine()

◆ addMissing()

◆ addQuad()

◆ addStartSpan()

◆ addT() [1/2]

◆ addT() [2/2]

◆ bounds()

◆ bumpCount()

◆ calcAngles()

◆ clearAll()

◆ clearOne()

◆ ClearVisited()

◆ collapsed()

◆ ComputeOneSum()

◆ ComputeOneSumReverse()

◆ computeSum()

◆ contains()

◆ contour()

◆ count()

◆ debugAddAngle()

◆ debugAngle()

◆ debugCoincidence()

◆ debugContour()

◆ debugID()

◆ debugLastAngle()

◆ debugPtT()

◆ debugReset()

◆ debugSegment()

◆ debugSpan()

◆ debugValidate()

◆ done() [1/2]

◆ done() [2/2]

◆ dPtAtT()

◆ dSlopeAtT()

◆ dump()

◆ dumpAll()

◆ dumpAngles()

◆ dumpCoin()

◆ dumpPts()

◆ dumpPtsInner()

◆ existing()

◆ findNextOp()

◆ findNextWinding()

◆ findNextXor()

◆ findSortableTop()

◆ globalState()

◆ head() [1/2]

◆ head() [2/2]

◆ init()

◆ insert()

◆ isClose()

◆ isHorizontal()

◆ isSimple()

◆ isVertical() [1/2]

◆ isVertical() [2/2]

◆ isXor()

◆ joinEnds()

◆ lastPt()

◆ markAllDone()

◆ markAndChaseDone()

◆ markAndChaseWinding() [1/2]

◆ markAndChaseWinding() [2/2]

◆ markAngle() [1/2]

◆ markAngle() [2/2]