45 {{{{
F,
F}, {
F,
F}}, {{
T,
F}, {
T,
F}}}, {{{
T,
T}, {
F,
F}}, {{
F,
T}, {
T,
F}}}},
46 {{{{
F,
F}, {
F,
F}}, {{
F,
T}, {
F,
T}}}, {{{
F,
F}, {
T,
T}}, {{
F,
T}, {
T,
F}}}},
47 {{{{
F,
T}, {
T,
F}}, {{
T,
T}, {
F,
F}}}, {{{
T,
F}, {
T,
F}}, {{
F,
F}, {
F,
F}}}},
48 {{{{
F,
T}, {
T,
F}}, {{
T,
F}, {
F,
T}}}, {{{
T,
F}, {
F,
T}}, {{
F,
T}, {
T,
F}}}},
75 if (!upSpan->
done()) {
93 if (!downSpan->
done()) {
118#if DEBUG_LIMIT_WIND_SUM
124 swap(sumMiWinding, sumSuWinding);
126 return this->
activeOp(xorMiMask, xorSuMask,
start,
end, op, &sumMiWinding, &sumSuWinding);
130 SkPathOp op,
int* sumMiWinding,
int* sumSuWinding) {
131 int maxWinding, sumWinding, oppMaxWinding, oppSumWinding;
133 &maxWinding, &sumWinding, &oppMaxWinding, &oppSumWinding);
139 miFrom = (oppMaxWinding & xorMiMask) != 0;
140 miTo = (oppSumWinding & xorMiMask) != 0;
141 suFrom = (maxWinding & xorSuMask) != 0;
142 suTo = (sumWinding & xorSuMask) != 0;
144 miFrom = (maxWinding & xorMiMask) != 0;
145 miTo = (sumWinding & xorMiMask) != 0;
146 suFrom = (oppMaxWinding & xorSuMask) != 0;
147 suTo = (oppSumWinding & xorSuMask) != 0;
151 SkDebugf(
"%s id=%d t=%1.9g tEnd=%1.9g op=%s miFrom=%d miTo=%d suFrom=%d suTo=%d result=%d\n",
153 SkPathOpsDebug::kPathOpStr[op], miFrom, miTo, suFrom, suTo,
result);
166 bool from = maxWinding != 0;
167 bool to = *sumWinding != 0;
176 const_cast<SkOpSpan*
>(spanStart)->markAdded();
181 path->deferredMove(
start->ptT());
208 testPtT =
test->ptT();
209 if (testPtT->
fT == t) {
212 if (!this->
match(testPtT,
this, t, pt)) {
213 if (t < testPtT->fT) {
222 while (loop != testPtT) {
223 if (loop->
segment() ==
this && loop->
fT == t && loop->
fPt == pt) {
229 }
while ((
test =
test->upCast()->next()));
231 return opp && !
test->contains(opp) ? nullptr : testPtT;
252 writableTest->
ptT()->
addOpp(newPtT, oppPrev);
268 if (t < result->fT) {
276 SkDebugf(
"%s insert t=%1.9g segID=%d spanID=%d\n", __FUNCTION__, t,
283 }
while ((spanBase = spanBase->
upCast()->
next()));
294 if (activePrior && !fHead.
simple()) {
299 while (spanBase != &fTail) {
302 priorAngle->
set(spanBase, prior);
313 activePrior = active;
317 if (activePrior && !fTail.
simple()) {
359 swap(sumMiWinding, sumSuWinding);
363 int maxWinding, sumWinding;
366 int oppMaxWinding, oppSumWinding;
368 &sumSuWinding, &maxWinding, &sumWinding, &oppMaxWinding, &oppSumWinding);
369 if (!nextSegment->
markAngle(maxWinding, sumWinding, oppMaxWinding, oppSumWinding,
375 &maxWinding, &sumWinding);
376 if (!nextSegment->
markAngle(maxWinding, sumWinding, nextAngle, &last)) {
394 swap(sumMiWinding, sumSuWinding);
398 int maxWinding, sumWinding;
401 int oppMaxWinding, oppSumWinding;
403 &sumSuWinding, &maxWinding, &sumWinding, &oppMaxWinding, &oppSumWinding);
404 if (!nextSegment->
markAngle(maxWinding, sumWinding, oppMaxWinding, oppSumWinding,
410 &maxWinding, &sumWinding);
411 if (!nextSegment->
markAngle(maxWinding, sumWinding, nextAngle, &last)) {
424 if (
nullptr == firstAngle ||
nullptr == firstAngle->
next()) {
434 bool tryReverse =
false;
459 }
while (
next != firstAngle);
461 firstAngle = baseAngle;
485 }
while (prior != firstAngle);
496 if (spanBase == &fTail) {
514double SkOpSegment::distSq(
double t,
const SkOpAngle* oppAngle)
const {
516 SkDLine testPerp = {{ testPt, testPt }};
518 testPerp[1].fX += slope.
fY;
519 testPerp[1].fY -= slope.
fX;
524 for (
int index = 0; index < i.
used(); ++index) {
529 if (closestDistSq > testDistSq) {
530 closestDistSq = testDistSq;
533 return closestDistSq;
546 SkPathOp op,
int xorMiMask,
int xorSuMask) {
552 if ((*simple = other)) {
556 SkDebugf(
"%s simple\n", __FUNCTION__);
559 if (startSpan->
done()) {
573 bool sortable = calcWinding !=
SK_NaN32;
598 swap(sumMiWinding, sumSuWinding);
602 bool foundDone =
false;
607 nextSegment = nextAngle->
segment();
609 nextAngle->
end(), op, &sumMiWinding, &sumSuWinding);
612 if (!foundAngle || (foundDone && activeCount & 1)) {
613 foundAngle = nextAngle;
614 foundDone = nextSegment->
done(nextAngle);
617 if (nextSegment->
done()) {
628 SkDebugf(
"%s chase.append segment=%d span=%d", __FUNCTION__,
630 if (!last->
final()) {
636 }
while ((nextAngle = nextAngle->
next()) != angle);
641 *nextStart = foundAngle->
start();
642 *nextEnd = foundAngle->
end();
643 nextSegment = foundAngle->
segment();
645 SkDebugf(
"%s from:[%d] to:[%d] start=%p end=%p\n",
646 __FUNCTION__,
debugID(), nextSegment->
debugID(), *nextStart, *nextEnd);
662 SkDebugf(
"%s simple\n", __FUNCTION__);
665 if (startSpan->
done()) {
679 bool sortable = calcWinding !=
SK_NaN32;
698 bool foundDone =
false;
703 nextSegment = nextAngle->
segment();
708 if (!foundAngle || (foundDone && activeCount & 1)) {
709 foundAngle = nextAngle;
710 foundDone = nextSegment->
done(nextAngle);
713 if (nextSegment->
done()) {
724 SkDebugf(
"%s chase.append segment=%d span=%d", __FUNCTION__,
726 if (!last->
final()) {
732 }
while ((nextAngle = nextAngle->
next()) != angle);
737 *nextStart = foundAngle->
start();
738 *nextEnd = foundAngle->
end();
739 nextSegment = foundAngle->
segment();
741 SkDebugf(
"%s from:[%d] to:[%d] start=%p end=%p\n",
742 __FUNCTION__,
debugID(), nextSegment->
debugID(), *nextStart, *nextEnd);
758 SkDebugf(
"%s simple\n", __FUNCTION__);
761 if (startSpan->
done()) {
769 : (*nextStart)->prev());
786 bool foundDone =
false;
794 nextSegment = nextAngle->
segment();
796 if (!foundAngle || (foundDone && activeCount & 1)) {
797 foundAngle = nextAngle;
798 if (!(foundDone = nextSegment->
done(nextAngle))) {
802 nextAngle = nextAngle->
next();
803 }
while (nextAngle != angle);
808 *nextStart = foundAngle->
start();
809 *nextEnd = foundAngle->
end();
810 nextSegment = foundAngle->
segment();
812 SkDebugf(
"%s from:[%d] to:[%d] start=%p end=%p\n",
813 __FUNCTION__,
debugID(), nextSegment->
debugID(), *nextStart, *nextEnd);
832 zeroSpan->
init(
this,
nullptr, 0, fPts[0]);
846 for (
int index = 0; index < used; ++index) {
855 return fContour->
isXor();
873 int safetyNet = 100000;
882 if (lastDone == minSpan || priorDone == minSpan) {
889 priorDone = lastDone;
905 int safetyNet = 100000;
927 bool success =
markWinding(spanStart, winding, oppWinding);
930 int safetyNet = 100000;
937 if (spanStart->
windSum() != winding || spanStart->
oppSum() != oppWinding) {
949 (void) other->
markWinding(spanStart, winding, oppWinding);
951 (void) other->
markWinding(spanStart, oppWinding, winding);
964 maxWinding = sumWinding;
972 SkDebugf(
"%s last seg=%d span=%d", __FUNCTION__,
974 if (!last->
final()) {
988 maxWinding = sumWinding;
990 if (oppMaxWinding != oppSumWinding &&
UseInnerWinding(oppMaxWinding, oppSumWinding)) {
991 oppMaxWinding = oppSumWinding;
1001 SkDebugf(
"%s last segment=%d span=%d", __FUNCTION__,
1003 if (!last->
final()) {
1020 debugShowNewWinding(__FUNCTION__, span, span->
windSum(), span->
oppSum());
1034 debugShowNewWinding(__FUNCTION__, span, winding);
1048 debugShowNewWinding(__FUNCTION__, span, winding, oppWinding);
1057 const SkPoint& testPt)
const {
1059 if (
this == testParent) {
1067 return this != testParent || !this->
ptsDisjoint(base->
fT,
base->fPt, testT, testPt);
1080 int step = *stepPtr;
1087 if (angle ==
nullptr) {
1088 if (endSpan->
t() != 0 && endSpan->
t() != 1) {
1093 foundSpan = otherPtT->
span();
1096 : foundSpan->
prev();
1099 if (loopCount > 2) {
1103 if (
nullptr ==
next) {
1109 SkDebugf(
"%s mismatched signs\n", __FUNCTION__);
1112 other =
next->segment();
1113 foundSpan = endSpan =
next->start();
1114 otherEnd =
next->end();
1119 int foundStep = foundSpan->
step(otherEnd);
1120 if (*stepPtr != foundStep) {
1131 *startPtr = foundSpan;
1132 *stepPtr = foundStep;
1144 while ((ptT = ptT->
next()) != stopPtT) {
1168 int safetyNet = 100000;
1170 SkOpPtT* ptT = spanBase->
ptT(), * spanStopPtT = ptT;
1172 while ((ptT = ptT->
next()) != spanStopPtT) {
1187 if (spanBase == &fHead) {
1202 SkOpPtT* priorPtT =
nullptr, * priorStopPtT;
1206 while (!priorOpp && priorTest) {
1207 priorStopPtT = priorPtT = priorTest->
ptT();
1208 while ((priorPtT = priorPtT->
next()) != priorStopPtT) {
1213 if (segment == opp) {
1219 priorTest = priorTest->
prev();
1224 if (priorPtT == ptT) {
1229 bool swapped = priorPtT->
fT > ptT->
fT;
1232 swap(priorPtT, ptT);
1233 swap(oppStart, oppEnd);
1240 if (coincidences->
contains(rootPriorPtT, rootPtT, rootOppStart, rootOppEnd)) {
1245#if DEBUG_COINCIDENCE_VERBOSE
1246 SkDebugf(
"%s coinSpan=%d endSpan=%d oppSpan=%d oppEndSpan=%d\n", __FUNCTION__,
1250 if (!coincidences->
extend(rootPriorPtT, rootPtT, rootOppStart, rootOppEnd)) {
1251 coincidences->
add(rootPriorPtT, rootPtT, rootOppStart, rootOppEnd);
1253#if DEBUG_COINCIDENCE
1254 SkASSERT(coincidences->
contains(rootPriorPtT, rootPtT, rootOppStart, rootOppEnd));
1261 swap(priorPtT, ptT);
1264 }
while ((spanBase = spanBase->
final() ?
nullptr : spanBase->
upCast()->
next()));
1275 int addCount =
test->spanAddsCount();
1277 if (addCount <= 1) {
1282 int safetyHatch = 1000000;
1284 if (!--safetyHatch) {
1295 if (oppSegment ==
this) {
1301 while ((oppPrev = oppPrev->
prev())) {
1315 while ((oppNext = oppNext->
final() ?
nullptr : oppNext->
upCast()->
next())) {
1327 if (oppFirst == oppLast) {
1332 if (oppTest == oppSpan) {
1338 SkOpPtT* oppPtT = oppStartPtT;
1339 while ((oppPtT = oppPtT->
next()) != oppStartPtT) {
1341 if (oppPtTSegment ==
this) {
1346 if (matchPtT->
segment() == oppPtTSegment) {
1349 }
while ((matchPtT = matchPtT->
next()) != startPtT);
1354 oppTest->
addOpp(oppSpan);
1360 }
while (oppTest != oppLast && (oppTest = oppTest->
upCast()->
next()));
1361 }
while ((testPtT = testPtT->
next()) != startPtT);
1364 }
while ((
test =
test->final() ? nullptr :
test->upCast()->next()));
1371 bool* found)
const {
1376#if DEBUG_COINCIDENCE
1378 const SkOpPtT* dBugRef = refHead;
1380 const SkOpPtT* dBugCheck = checkHead;
1383 dBugCheck = dBugCheck->
next();
1384 }
while (dBugCheck != checkHead);
1385 dBugRef = dBugRef->
next();
1386 }
while (dBugRef != refHead);
1393 const SkOpPtT* refBest =
nullptr;
1394 const SkOpPtT* checkBest =
nullptr;
1402 if (ref == refHead) {
1403 goto doneCheckingDistance;
1408 int escapeHatch = 100000;
1410 if (
check->deleted()) {
1413 while (
check->ptAlreadySeen(checkHead)) {
1415 if (
check == checkHead) {
1420 if (distSqBest > distSq && (refSeg !=
check->segment()
1422 distSqBest = distSq;
1426 if (--escapeHatch <= 0) {
1429 }
while ((
check =
check->next()) != checkHead);
1432 }
while ((ref = ref->
next()) != refHead);
1433doneCheckingDistance:
1445 int escapeHatch = 9999;
1449 while ((ptT = ptT->
next()) != headPtT) {
1450 if (!--escapeHatch) {
1455 &&
test->ptT() == ptT) {
1456 if (
test->final()) {
1457 if (spanBase == &fHead) {
1462 }
else if (
test->prev()) {
1463 test->upCast()->release(headPtT);
1469 }
while (!spanBase->
final());
1479 if (
test->final()) {
1480 if (spanBase->
prev()) {
1491 }
while (!spanBase->
final());
1501 return fContour->
oppXor();
1514 double midT = (t1 + t2) / 2;
1522 int* maxWinding,
int* sumWinding) {
1524 *maxWinding = *sumMiWinding;
1525 *sumWinding = *sumMiWinding -= deltaSum;
1530 int* sumSuWinding,
int* maxWinding,
int* sumWinding,
int* oppMaxWinding,
1531 int* oppSumWinding) {
1535 *maxWinding = *sumSuWinding;
1536 *sumWinding = *sumSuWinding -= deltaSum;
1537 *oppMaxWinding = *sumMiWinding;
1538 *oppSumWinding = *sumMiWinding -= oppDeltaSum;
1540 *maxWinding = *sumMiWinding;
1541 *sumWinding = *sumMiWinding -= deltaSum;
1542 *oppMaxWinding = *sumSuWinding;
1543 *oppSumWinding = *sumSuWinding -= oppDeltaSum;
1554 if (!fromAngle && !toAngle) {
1558 bool wroteAfterHeader =
false;
1561 if (fromAngle && toAngle) {
1563 SkDebugf(
"%s [%d] tStart=%1.9g [%d]\n", __FUNCTION__,
debugID(), span->
t(),
1565 wroteAfterHeader =
true;
1568 }
else if (!fromAngle) {
1569 baseAngle = toAngle;
1572 int safetyNet = 1000000;
1578 if (oSpan == span) {
1584 if (!wroteAfterHeader) {
1587 wroteAfterHeader =
true;
1591 baseAngle->
insert(oAngle);
1594 if (!oSpan->
final()) {
1598 if (!wroteAfterHeader) {
1601 wroteAfterHeader =
true;
1605 baseAngle->
insert(oAngle);
1609 }
while ((ptT = ptT->
next()) != stopPtT);
1615 baseAngle =
nullptr;
1636 double startT = startPtT.
fT;
1637 double endT = endPtT.
fT;
1638 if ((startT == 0 || endT == 0) && (startT == 1 || endT == 1)) {
1674 double midT = (prior->
t() + spanBase->
t()) / 2;
1680 if (priorPtT->
span() == ptT->
span()) {
1686 this->
subDivide(prior, spanBase, &curvePart);
1694 for (
int index = 0; index < i.
used(); ++index) {
1695 if (!
between(0, i[0][index], 1)) {
1713 if (!span->
done()) {
1716 }
while (!
next->final() && (span =
next->upCast()));
1722 int oppWinding = lesser->
oppSum();
1724 if (oppSpanWinding &&
UseInnerWinding(oppWinding - oppSpanWinding, oppWinding)
1726 oppWinding -= oppSpanWinding;
1745 int winding = lesser->
windSum();
1755 winding -= spanWinding;
1778 int absOut =
SkTAbs(outerWinding);
1779 int absIn =
SkTAbs(innerWinding);
1780 bool result = absOut == absIn ? outerWinding < 0 : absOut < absIn;
static int step(int x, SkScalar min, SkScalar max)
static void done(const char *config, const char *src, const char *srcOptions, const char *name)
static bool coincident(const SkPoint &a, const SkPoint &b)
static const int points[]
#define check(reporter, ref, unref, make, kill)
void SK_SPI SkDebugf(const char format[],...) SK_PRINTF_LIKE(1
static bool between(SkScalar a, SkScalar b, SkScalar c)
static constexpr int32_t SK_NaN32
static constexpr int32_t SK_MinS32
static constexpr int32_t SK_MaxS32
static const bool gUnaryActiveEdge[2][2]
static const bool gActiveEdge[kXOR_SkPathOp+1][2][2][2][2]
static SkOpSegment * set_last(SkOpSpanBase **last, SkOpSpanBase *endSpan)
static SkDVector(*const CurveDDSlopeAtT[])(const SkDCurve &, double)
static SkDVector(*const CurveDSlopeAtT[])(const SkPoint[], SkScalar, double)
static void(*const CurveDIntersectRay[])(const SkDCurve &, const SkDLine &, SkIntersections *)
static SkDPoint(*const CurveDDPointAtT[])(const SkDCurve &, double)
static void(*const CurveIntersectRay[])(const SkPoint[], SkScalar, const SkDLine &, SkIntersections *)
#define FAIL_WITH_NULL_IF(cond, span)
#define DEBUG_LIMIT_WIND_SUM
bool roughly_equal(double x, double y)
bool precisely_equal(double x, double y)
bool zero_or_one(double x)
int SkPathOpsVerbToPoints(SkPath::Verb verb)
@ kXOR_SkPathOp
exclusive-or the two paths
void swap(sk_sp< T > &a, sk_sp< T > &b)
#define SK_ScalarInfinity
auto make(Ctor &&ctor) -> decltype(ctor(nullptr))
void setCurveHullSweep(SkPath::Verb verb)
const SkDPoint & pt(int index) const
bool loopContains(const SkOpAngle *) const
SkOpSegment * segment() const
SkOpSpanBase * end() const
void setLastMarked(SkOpSpanBase *marked)
SkOpAngle * previous() const
void set(SkOpSpanBase *start, SkOpSpanBase *end)
SkOpSpanBase * start() const
SkOpSpanBase * lastMarked() const
void add(SkOpPtT *coinPtTStart, SkOpPtT *coinPtTEnd, SkOpPtT *oppPtTStart, SkOpPtT *oppPtTEnd)
bool contains(const SkOpPtT *coinPtTStart, const SkOpPtT *coinPtTEnd, const SkOpPtT *oppPtTStart, const SkOpPtT *oppPtTEnd) const
bool extend(const SkOpPtT *coinPtTStart, const SkOpPtT *coinPtTEnd, const SkOpPtT *oppPtTStart, const SkOpPtT *oppPtTEnd)
void release(const SkOpSegment *)
SkOpGlobalState * globalState() const
bool allocatedOpSpan() const
SkArenaAlloc * allocator()
SkOpCoincidence * coincidence()
void resetAllocatedOpSpan()
const SkOpSpanBase * span() const
const SkOpPtT * next() const
void addOpp(SkOpPtT *opp, SkOpPtT *oppPrev)
bool ptAlreadySeen(const SkOpPtT *head) const
const SkOpSegment * segment() const
bool contains(const SkOpPtT *) const
SkDVector dSlopeAtT(double mid) const
bool markWinding(SkOpSpan *, int winding)
int computeSum(SkOpSpanBase *start, SkOpSpanBase *end, SkOpAngle::IncludeType includeType)
void debugValidate() const
SkOpSpanBase::Collapsed collapsed(double startT, double endT) const
bool match(const SkOpPtT *span, const SkOpSegment *parent, double t, const SkPoint &pt) const
SkPath::Verb verb() const
bool testForCoincidence(const SkOpPtT *priorPtT, const SkOpPtT *ptT, const SkOpSpanBase *prior, const SkOpSpanBase *spanBase, const SkOpSegment *opp) const
int windSum(const SkOpAngle *angle) const
SkOpSegment * findNextOp(SkTDArray< SkOpSpanBase * > *chase, SkOpSpanBase **nextStart, SkOpSpanBase **nextEnd, bool *unsortable, bool *simple, SkPathOp op, int xorMiMask, int xorSuMask)
bool ptsDisjoint(const SkOpPtT &span, const SkOpPtT &test) const
bool isClose(double t, const SkOpSegment *opp) const
SkPoint ptAtT(double mid) const
SkOpSegment * nextChase(SkOpSpanBase **, int *step, SkOpSpan **, SkOpSpanBase **last) const
SkOpSegment * isSimple(SkOpSpanBase **end, int *step) const
const SkOpSegment * prev() const
SkOpAngle * activeAngleOther(SkOpSpanBase *start, SkOpSpanBase **startPtr, SkOpSpanBase **endPtr, bool *done)
bool activeWinding(SkOpSpanBase *start, SkOpSpanBase *end)
int updateWindingReverse(const SkOpAngle *angle)
static int SpanSign(const SkOpSpanBase *start, const SkOpSpanBase *end)
void init(SkPoint pts[], SkScalar weight, SkOpContour *parent, SkPath::Verb verb)
bool markAndChaseDone(SkOpSpanBase *start, SkOpSpanBase *end, SkOpSpanBase **found)
void setUpWindings(SkOpSpanBase *start, SkOpSpanBase *end, int *sumMiWinding, int *maxWinding, int *sumWinding)
bool markAndChaseWinding(SkOpSpanBase *start, SkOpSpanBase *end, int winding, SkOpSpanBase **lastPtr)
SkOpGlobalState * globalState() const
SkOpAngle * activeAngleInner(SkOpSpanBase *start, SkOpSpanBase **startPtr, SkOpSpanBase **endPtr, bool *done)
SkOpSpan * insert(SkOpSpan *prev)
void setUpWinding(SkOpSpanBase *start, SkOpSpanBase *end, int *maxWinding, int *sumWinding)
void release(const SkOpSpan *)
static void ClearVisited(SkOpSpanBase *span)
static int OppSign(const SkOpSpanBase *start, const SkOpSpanBase *end)
int updateWinding(SkOpSpanBase *start, SkOpSpanBase *end)
bool subDivide(const SkOpSpanBase *start, const SkOpSpanBase *end, SkDCurve *result) const
const SkOpPtT * existing(double t, const SkOpSegment *opp) const
static bool ComputeOneSum(const SkOpAngle *baseAngle, SkOpAngle *nextAngle, SkOpAngle::IncludeType)
const SkOpSpan * head() const
bool addCurveTo(const SkOpSpanBase *start, const SkOpSpanBase *end, SkPathWriter *path) const
SkOpAngle * activeAngle(SkOpSpanBase *start, SkOpSpanBase **startPtr, SkOpSpanBase **endPtr, bool *done)
static bool UseInnerWinding(int outerWinding, int innerWinding)
bool activeOp(SkOpSpanBase *start, SkOpSpanBase *end, int xorMiMask, int xorSuMask, SkPathOp op)
SkOpAngle * spanToAngle(SkOpSpanBase *start, SkOpSpanBase *end)
SkDPoint dPtAtT(double mid) const
bool contains(double t) const
const SkPoint * pts() const
bool missingCoincidence()
void clearOne(SkOpSpan *span)
int updateOppWindingReverse(const SkOpAngle *angle) const
static bool ComputeOneSumReverse(SkOpAngle *baseAngle, SkOpAngle *nextAngle, SkOpAngle::IncludeType)
SkOpSegment * findNextWinding(SkTDArray< SkOpSpanBase * > *chase, SkOpSpanBase **nextStart, SkOpSpanBase **nextEnd, bool *unsortable)
SkOpSegment * next() const
SkOpAngle * addStartSpan()
SkOpContour * contour() const
bool spansNearby(const SkOpSpanBase *ref, const SkOpSpanBase *check, bool *found) const
bool markAngle(int maxWinding, int sumWinding, const SkOpAngle *angle, SkOpSpanBase **result)
void markDone(SkOpSpan *)
SkOpSegment * findNextXor(SkOpSpanBase **nextStart, SkOpSpanBase **nextEnd, bool *unsortable)
bool addExpanded(double newT, const SkOpSpanBase *test, bool *startOver)
int updateOppWinding(const SkOpSpanBase *start, const SkOpSpanBase *end) const
int step(const SkOpSpanBase *end) const
Collapsed collapsed(double s, double e) const
const SkOpSpan * prev() const
bool containsCoinEnd(const SkOpSpanBase *coin) const
void merge(SkOpSpan *span)
bool mergeMatches(SkOpSpanBase *opp)
void setFromAngle(SkOpAngle *angle)
int spanAddsCount() const
void initBase(SkOpSegment *parent, SkOpSpan *prev, double t, const SkPoint &pt)
bool addOpp(SkOpSpanBase *opp)
SkOpAngle * fromAngle() const
const SkOpSpan * starter(const SkOpSpanBase *end) const
void checkForCollapsedCoincidence()
SkOpSegment * segment() const
const SkOpPtT * ptT() const
void setToAngle(SkOpAngle *angle)
void setWindValue(int windValue)
SkOpSpanBase * next() const
void setNext(SkOpSpanBase *nextT)
void setOppValue(int oppValue)
bool alreadyAdded() const
void setWindSum(int windSum)
SkOpAngle * toAngle() const
bool containsCoincidence(const SkOpSegment *) const
void setOppSum(int oppSum)
void release(const SkOpPtT *)
void init(SkOpSegment *parent, SkOpSpan *prev, double t, const SkPoint &pt)
static bool ChaseContains(const SkTDArray< SkOpSpanBase * > &, const SkOpSpanBase *)
static void WindingPrintf(int winding)
static SkScalar DistanceToSqd(const SkPoint &pt, const SkPoint &a)
const SkDConic & set(const SkPoint pts[kPointCount], SkScalar weight SkDEBUGPARAMS(SkOpGlobalState *state=nullptr))
static SkDConic SubDivide(const SkPoint a[kPointCount], SkScalar weight, double t1, double t2)
static SkDCubic SubDivide(const SkPoint a[kPointCount], double t1, double t2)
const SkDCubic & set(const SkPoint pts[kPointCount] SkDEBUGPARAMS(SkOpGlobalState *state=nullptr))
const SkDLine & set(const SkPoint pts[2])
double distanceSquared(const SkDPoint &a) const
static bool ApproximatelyEqual(const SkPoint &a, const SkPoint &b)
bool approximatelyDEqual(const SkDPoint &a) const
static bool WayRoughlyEqual(const SkPoint &a, const SkPoint &b)
bool roughlyEqual(const SkDPoint &a) const
static SkDQuad SubDivide(const SkPoint a[kPointCount], double t1, double t2)