Index: src/pathops/SkOpSegment.cpp |
diff --git a/src/pathops/SkOpSegment.cpp b/src/pathops/SkOpSegment.cpp |
index 6fe1fbb49d46d893c08da9fa9cfac2cf35c30425..00963403b7b04de2503d5448d7ce4fdfe4b902ce 100644 |
--- a/src/pathops/SkOpSegment.cpp |
+++ b/src/pathops/SkOpSegment.cpp |
@@ -407,7 +407,7 @@ void SkOpSegment::addQuad(const SkPoint pts[3], bool operand, bool evenOdd) { |
// resolve overlapping ts when considering coincidence later |
// add non-coincident intersection. Resulting edges are sorted in T. |
-int SkOpSegment::addT(SkOpSegment* other, const SkPoint& pt, double newT, bool isNear) { |
+int SkOpSegment::addT(SkOpSegment* other, const SkPoint& pt, double newT) { |
if (precisely_zero(newT)) { |
newT = 0; |
} else if (precisely_equal(newT, 1)) { |
@@ -452,7 +452,6 @@ int SkOpSegment::addT(SkOpSegment* other, const SkPoint& pt, double newT, bool i |
span->fT = newT; |
span->fOther = other; |
span->fPt = pt; |
- span->fNear = isNear; |
#if 0 |
// cubics, for instance, may not be exact enough to satisfy this check (e.g., cubicOp69d) |
SkASSERT(approximately_equal(xyAtT(newT).fX, pt.fX) |
@@ -646,7 +645,7 @@ void SkOpSegment::addTCancel(const SkPoint& startPt, const SkPoint& endPt, SkOpS |
int SkOpSegment::addSelfT(SkOpSegment* other, const SkPoint& pt, double newT) { |
// if the tail nearly intersects itself but not quite, the caller records this separately |
- int result = addT(other, pt, newT, SkOpSpan::kPointIsExact); |
+ int result = addT(other, pt, newT); |
SkOpSpan* span = &fTs[result]; |
span->fLoop = true; |
return result; |
@@ -672,31 +671,6 @@ void SkOpSegment::bumpCoincidentThis(const SkOpSpan& oTest, bool binary, int* in |
*indexPtr = index; |
} |
-bool SkOpSegment::bumpCoincident(SkOpSpan* test, bool bigger, bool binary) { |
- if (bigger) { |
- if (binary) { |
- if (fOppXor) { |
- test->fOppValue ^= 1; |
- } else { |
- test->fOppValue++; |
- } |
- } else { |
- if (fXor) { |
- test->fWindValue ^= 1; |
- } else { |
- test->fWindValue++; |
- } |
- } |
- if (!test->fWindValue && !test->fOppValue) { |
- test->fDone = true; |
- ++fDoneSpans; |
- return true; |
- } |
- return false; |
- } |
- return decrementSpan(test); |
-} |
- |
// because of the order in which coincidences are resolved, this and other |
// may not have the same intermediate points. Compute the corresponding |
// intermediate T values (using this as the master, other as the follower) |
@@ -850,8 +824,8 @@ void SkOpSegment::addTPair(double t, SkOpSegment* other, double otherT, bool bor |
SkDebugf("%s addTPair this=%d %1.9g other=%d %1.9g\n", |
__FUNCTION__, fID, t, other->fID, otherT); |
#endif |
- int insertedAt = addT(other, pt, t, SkOpSpan::kPointIsExact); |
- int otherInsertedAt = other->addT(this, pt, otherT, SkOpSpan::kPointIsExact); |
+ int insertedAt = addT(other, pt, t); |
+ int otherInsertedAt = other->addT(this, pt, otherT); |
addOtherT(insertedAt, otherT, otherInsertedAt); |
other->addOtherT(otherInsertedAt, t, insertedAt); |
matchWindingValue(insertedAt, t, borrowWind); |
@@ -873,170 +847,6 @@ void SkOpSegment::addTwoAngles(int start, int end, SkTArray<SkOpAngle, true>* an |
} |
} |
-SkOpSegment::MissingSpan::Command SkOpSegment::adjustThisNear(double startT, const SkPoint& startPt, |
- const SkPoint& endPt, SkTArray<MissingSpan, true>* missingSpans) { |
- // see if endPt exists on this curve, and if it has the same t or a different T than the startT |
- int count = this->count(); |
- SkASSERT(count > 0); |
- int startIndex, endIndex, step; |
- if (startT == 0) { |
- startIndex = 0; |
- endIndex = count; |
- step = 1; |
- } else { |
- SkASSERT(startT == 1); |
- startIndex = count - 1; |
- endIndex = -1; |
- step = -1; |
- } |
- int index = startIndex; |
- do { |
- const SkOpSpan& span = fTs[index]; |
- if (span.fPt != endPt) { |
- continue; |
- } |
- if (span.fT == startT) { |
- // check to see if otherT matches some other mid curve intersection |
- int inner = startIndex; |
- do { |
- if (inner == index) { |
- continue; |
- } |
- const SkOpSpan& matchSpan = fTs[inner]; |
- double matchT = span.fOther->missingNear(span.fOtherT, matchSpan.fOther, startPt, |
- endPt); |
- if (matchT >= 0) { |
- SkASSERT(missingSpans); |
- MissingSpan& missingSpan = missingSpans->push_back(); |
- SkDEBUGCODE(sk_bzero(&missingSpan, sizeof(missingSpan))); |
- missingSpan.fCommand = MissingSpan::kRemoveNear; |
- missingSpan.fT = startT; |
- missingSpan.fSegment = this; |
- missingSpan.fOther = span.fOther; |
- missingSpan.fOtherT = matchT; |
- return missingSpan.fCommand; |
- } |
- } while ((inner += step) != endIndex); |
- break; |
- } |
- double midT = (startT + span.fT) / 2; |
- if (betweenPoints(midT, startPt, endPt)) { |
- if (!missingSpans) { |
- return MissingSpan::kZeroSpan; |
- } |
- MissingSpan& missingSpan = missingSpans->push_back(); |
- SkDEBUGCODE(sk_bzero(&missingSpan, sizeof(missingSpan))); |
- missingSpan.fCommand = MissingSpan::kZeroSpan; |
- missingSpan.fT = SkTMin(startT, span.fT); |
- missingSpan.fEndT = SkTMax(startT, span.fT); |
- missingSpan.fSegment = this; |
- return missingSpan.fCommand; |
- } |
- } while ((index += step) != endIndex); |
- return MissingSpan::kNoAction; |
-} |
- |
-void SkOpSegment::adjustOtherNear(double startT, const SkPoint& startPt, const SkPoint& endPt, |
- SkTArray<MissingSpan, true>* missingSpans) { |
- int count = this->count(); |
- SkASSERT(count > 0); |
- int startIndex, endIndex, step; |
- if (startT == 0) { |
- startIndex = 0; |
- endIndex = count; |
- step = 1; |
- } else { |
- SkASSERT(startT == 1); |
- startIndex = count - 1; |
- endIndex = -1; |
- step = -1; |
- } |
- int index = startIndex; |
- do { |
- const SkOpSpan& span = fTs[index]; |
- if (span.fT != startT) { |
- return; |
- } |
- SkOpSegment* other = span.fOther; |
- if (other->fPts[0] == endPt) { |
- other->adjustThisNear(0, endPt, startPt, missingSpans); |
- } else if (other->fPts[0] == startPt) { |
- other->adjustThisNear(0, startPt, endPt, missingSpans); |
- } |
- if (other->ptAtT(1) == endPt) { |
- other->adjustThisNear(1, endPt, startPt, missingSpans); |
- } else if (other->ptAtT(1) == startPt) { |
- other->adjustThisNear(1, startPt, endPt, missingSpans); |
- } |
- } while ((index += step) != endIndex); |
-} |
- |
-void SkOpSegment::adjustMissingNear(const SkPoint& startPt, const SkPoint& endPt, |
- SkTArray<MissingSpan, true>* missingSpans) { |
- int count = missingSpans->count(); |
- for (int index = 0; index < count; ) { |
- MissingSpan& missing = (*missingSpans)[index]; |
- SkOpSegment* other = missing.fOther; |
- MissingSpan::Command command = MissingSpan::kNoAction; |
- if (missing.fPt == startPt) { |
- if (missingNear(missing.fT, other, startPt, endPt) >= 0) { |
- command = MissingSpan::kZeroSpan; |
- } else if (other->ptAtT(0) == endPt) { |
- command = other->adjustThisNear(0, endPt, startPt, NULL); |
- } else if (other->ptAtT(1) == endPt) { |
- command = other->adjustThisNear(1, endPt, startPt, NULL); |
- } |
- } else if (missing.fPt == endPt) { |
- if (missingNear(missing.fT, other, endPt, startPt) >= 0) { |
- command = MissingSpan::kZeroSpan; |
- } else if (other->ptAtT(0) == startPt) { |
- command = other->adjustThisNear(0, startPt, endPt, NULL); |
- } else if (other->ptAtT(1) == startPt) { |
- command = other->adjustThisNear(1, startPt, endPt, NULL); |
- } |
- } |
- if (command == MissingSpan::kZeroSpan) { |
-#if 1 |
- missing = missingSpans->back(); |
- missingSpans->pop_back(); |
-#else // if this is supported in the future ... |
- missingSpans->removeShuffle(index); |
-#endif |
- --count; |
- continue; |
- } |
- ++index; |
- } |
-} |
- |
-void SkOpSegment::adjustNear(double startT, const SkPoint& endPt, |
- SkTArray<MissingSpan, true>* missingSpans) { |
- const SkPoint startPt = ptAtT(startT); |
- adjustMissingNear(startPt, endPt, missingSpans); |
- adjustThisNear(startT, startPt, endPt, missingSpans); |
- adjustOtherNear(startT, startPt, endPt, missingSpans); |
-} |
- |
-int SkOpSegment::advanceCoincidentThis(int index) { |
- SkOpSpan* const test = &fTs[index]; |
- SkOpSpan* end; |
- do { |
- end = &fTs[++index]; |
- } while (approximately_negative(end->fT - test->fT)); |
- return index; |
-} |
- |
-int SkOpSegment::advanceCoincidentOther(double oEndT, int oIndex) { |
- SkOpSpan* const oTest = &fTs[oIndex]; |
- SkOpSpan* oEnd = oTest; |
- const double oStartT = oTest->fT; |
- while (!approximately_negative(oEndT - oEnd->fT) |
- && approximately_negative(oEnd->fT - oStartT)) { |
- oEnd = &fTs[++oIndex]; |
- } |
- return oIndex; |
-} |
- |
bool SkOpSegment::betweenPoints(double midT, const SkPoint& pt1, const SkPoint& pt2) const { |
const SkPoint midPt = ptAtT(midT); |
SkPathOpsBounds bounds; |
@@ -1235,11 +1045,11 @@ void SkOpSegment::ComputeOneSum(const SkOpAngle* baseAngle, SkOpAngle* nextAngle |
nextSegment->setUpWindings(nextAngle->start(), nextAngle->end(), &sumMiWinding, |
&sumSuWinding, &maxWinding, &sumWinding, &oppMaxWinding, &oppSumWinding); |
last = nextSegment->markAngle(maxWinding, sumWinding, oppMaxWinding, oppSumWinding, |
- true, nextAngle); |
+ nextAngle); |
} else { |
nextSegment->setUpWindings(nextAngle->start(), nextAngle->end(), &sumMiWinding, |
&maxWinding, &sumWinding); |
- last = nextSegment->markAngle(maxWinding, sumWinding, true, nextAngle); |
+ last = nextSegment->markAngle(maxWinding, sumWinding, nextAngle); |
} |
nextAngle->setLastMarked(last); |
} |
@@ -1264,11 +1074,11 @@ void SkOpSegment::ComputeOneSumReverse(const SkOpAngle* baseAngle, SkOpAngle* ne |
nextSegment->setUpWindings(nextAngle->end(), nextAngle->start(), &sumMiWinding, |
&sumSuWinding, &maxWinding, &sumWinding, &oppMaxWinding, &oppSumWinding); |
last = nextSegment->markAngle(maxWinding, sumWinding, oppMaxWinding, oppSumWinding, |
- true, nextAngle); |
+ nextAngle); |
} else { |
nextSegment->setUpWindings(nextAngle->end(), nextAngle->start(), &sumMiWinding, |
&maxWinding, &sumWinding); |
- last = nextSegment->markAngle(maxWinding, sumWinding, true, nextAngle); |
+ last = nextSegment->markAngle(maxWinding, sumWinding, nextAngle); |
} |
nextAngle->setLastMarked(last); |
} |
@@ -1469,8 +1279,7 @@ void SkOpSegment::checkEnds() { |
} |
if (missingSpans.count() > 0) { |
const MissingSpan& lastMissing = missingSpans.back(); |
- if (lastMissing.fCommand == MissingSpan::kAddMissing |
- && lastMissing.fT == t |
+ if (lastMissing.fT == t |
&& lastMissing.fOther == match |
&& lastMissing.fOtherT == matchT) { |
SkASSERT(lastMissing.fPt == peekSpan.fPt); |
@@ -1486,7 +1295,6 @@ void SkOpSegment::checkEnds() { |
{ |
MissingSpan& missing = missingSpans.push_back(); |
SkDEBUGCODE(sk_bzero(&missing, sizeof(missing))); |
- missing.fCommand = MissingSpan::kAddMissing; |
missing.fT = t; |
missing.fOther = match; |
missing.fOtherT = matchT; |
@@ -1501,125 +1309,17 @@ nextPeekIndex: |
debugValidate(); |
return; |
} |
- // if one end is near the other point, look for a coincident span |
- for (int index = 0; index < count; ++index) { |
- const SkOpSpan& span = fTs[index]; |
- if (span.fT > 0) { |
- break; |
- } |
- const SkOpSpan& otherSpan = span.fOther->span(span.fOtherIndex); |
- if (span.fNear) { |
- SkASSERT(otherSpan.fPt == fPts[0]); |
- adjustNear(0, span.fPt, &missingSpans); |
- continue; |
- } |
- if (otherSpan.fNear) { |
- SkASSERT(span.fPt == fPts[0]); |
- adjustNear(0, otherSpan.fPt, &missingSpans); |
- } |
- } |
- for (int index = count; --index >= 0; ) { |
- const SkOpSpan& span = fTs[index]; |
- if (span.fT < 1) { |
- break; |
- } |
- const SkOpSegment* other = span.fOther; |
- if (span.fNear) { |
- SkASSERT(other->ptAtT(span.fOtherT) == ptAtT(1)); |
- const SkPoint& otherPt = other->xyAtT(span.fOtherIndex); |
- SkASSERT(otherPt != ptAtT(1)); |
- adjustNear(1, otherPt, &missingSpans); |
- continue; |
- } |
- const SkOpSpan& otherSpan = other->span(span.fOtherIndex); |
- if (otherSpan.fNear) { |
- SkASSERT(otherSpan.fPt == ptAtT(1)); |
- SkPoint otherPt = other->ptAtT(span.fOtherT); |
- SkASSERT(otherPt != ptAtT(1)); |
- adjustNear(1, otherPt, &missingSpans); |
- } |
- } |
debugValidate(); |
int missingCount = missingSpans.count(); |
for (int index = 0; index < missingCount; ++index) { |
MissingSpan& missing = missingSpans[index]; |
- switch (missing.fCommand) { |
- case MissingSpan::kNoAction: |
- break; |
- case MissingSpan::kAddMissing: |
- addTPair(missing.fT, missing.fOther, missing.fOtherT, false, missing.fPt); |
- break; |
- case MissingSpan::kRemoveNear: { |
- SkOpSegment* segment = missing.fSegment; |
- int count = segment->count(); |
- for (int inner = 0; inner < count; ++inner) { |
- const SkOpSpan& span = segment->span(inner); |
- if (span.fT != missing.fT && span.fOther != missing.fOther) { |
- continue; |
- } |
- SkASSERT(span.fNear); |
- SkOpSegment* other = span.fOther; |
- int otherCount = other->count(); |
- for (int otherIndex = 0; otherIndex < otherCount; ++otherIndex) { |
- const SkOpSpan& otherSpan = other->span(otherIndex); |
- if (otherSpan.fT == span.fOtherT && otherSpan.fOther == segment |
- && otherSpan.fOtherT == span.fT) { |
- if (otherSpan.fDone) { |
- other->fDoneSpans--; |
- } |
- other->fTs.remove(otherIndex); |
- // FIXME: remove may leave a tiny dangling -- recompute tiny w/index |
- break; |
- } |
- } |
- if (span.fDone) { |
- segment->fDoneSpans--; |
- } |
- segment->fTs.remove(inner); |
- // FIXME: remove may leave a tiny dangling -- recompute tiny w/index |
- break; |
- } |
- break; |
- } |
- case MissingSpan::kZeroSpan: { |
- SkOpSegment* segment = missing.fSegment; |
- int count = segment->count(); |
- for (int inner = 0; inner < count; ++inner) { |
- SkOpSpan& span = segment->fTs[inner]; |
- if (span.fT < missing.fT) { |
- continue; |
- } |
- if (span.fT >= missing.fEndT) { |
- break; |
- } |
- span.fWindValue = span.fOppValue = 0; |
- if (!span.fDone) { |
- span.fDone = true; |
- ++segment->fDoneSpans; |
- } |
- } |
- break; |
- } |
- } |
+ addTPair(missing.fT, missing.fOther, missing.fOtherT, false, missing.fPt); |
} |
fixOtherTIndex(); |
// OPTIMIZATION: this may fix indices more than once. Build an array of unique segments to |
// avoid this |
for (int index = 0; index < missingCount; ++index) { |
- const MissingSpan& missing = missingSpans[index]; |
- switch (missing.fCommand) { |
- case MissingSpan::kNoAction: |
- break; |
- case MissingSpan::kAddMissing: |
- missing.fOther->fixOtherTIndex(); |
- break; |
- case MissingSpan::kRemoveNear: |
- missing.fSegment->fixOtherTIndex(); |
- missing.fOther->fixOtherTIndex(); |
- break; |
- case MissingSpan::kZeroSpan: |
- break; |
- } |
+ missingSpans[index].fOther->fixOtherTIndex(); |
} |
debugValidate(); |
} |
@@ -1687,7 +1387,6 @@ void SkOpSegment::checkTiny() { |
// remember so we can add the missing one and recompute the indices |
MissingSpan& missing = missingSpans.push_back(); |
SkDEBUGCODE(sk_bzero(&missing, sizeof(missing))); |
- missing.fCommand = MissingSpan::kAddMissing; |
missing.fSegment = thisOther; |
missing.fT = thisSpan->fOtherT; |
missing.fOther = nextOther; |
@@ -2406,7 +2105,7 @@ bool SkOpSegment::isTiny(int index) const { |
// if both are active, look to see if they both the connect to another coincident pair |
// if one at least one is a line, then make the pair coincident |
// if neither is a line, test for coincidence |
-bool SkOpSegment::joinCoincidence(bool end, SkOpSegment* other, double otherT, int step, |
+bool SkOpSegment::joinCoincidence(SkOpSegment* other, double otherT, int step, |
bool cancel) { |
int otherTIndex = other->findT(otherT, this); |
int next = other->nextExactSpan(otherTIndex, step); |
@@ -2416,78 +2115,31 @@ bool SkOpSegment::joinCoincidence(bool end, SkOpSegment* other, double otherT, i |
return false; |
} |
SkASSERT(next >= 0); |
- if (end) { |
- int tIndex = count() - 1; |
- do { |
- SkOpSpan* test = &fTs[tIndex]; |
- SkASSERT(test->fT == 1); |
- if (test->fOther == other || test->fOtherT != 0) { |
- continue; |
- } |
- SkPoint startPt, endPt; |
- double endT; |
- if (findCoincidentMatch(test, other, otherTIndex, next, step, &startPt, &endPt, &endT)) { |
- SkOpSegment* match = test->fOther; |
- if (cancel) { |
- match->addTCancel(startPt, endPt, other); |
- } else { |
- match->addTCoincident(startPt, endPt, endT, other); |
- } |
- return true; |
- } |
- } while (fTs[--tIndex].fT == 1); |
- } else { |
- int tIndex = 0; |
- do { |
- SkOpSpan* test = &fTs[tIndex]; |
- SkASSERT(test->fT == 0); |
- if (test->fOther == other || test->fOtherT != 1) { |
- continue; |
- } |
- SkPoint startPt, endPt; |
- double endT; |
- if (findCoincidentMatch(test, other, otherTIndex, next, step, &startPt, &endPt, &endT)) { |
- SkOpSegment* match = test->fOther; |
- if (cancel) { |
- match->addTCancel(startPt, endPt, other); |
- } else { |
- match->addTCoincident(startPt, endPt, endT, other); |
- } |
- return true; |
+ int tIndex = 0; |
+ do { |
+ SkOpSpan* test = &fTs[tIndex]; |
+ SkASSERT(test->fT == 0); |
+ if (test->fOther == other || test->fOtherT != 1) { |
+ continue; |
+ } |
+ SkPoint startPt, endPt; |
+ double endT; |
+ if (findCoincidentMatch(test, other, otherTIndex, next, step, &startPt, &endPt, &endT)) { |
+ SkOpSegment* match = test->fOther; |
+ if (cancel) { |
+ match->addTCancel(startPt, endPt, other); |
+ } else { |
+ match->addTCoincident(startPt, endPt, endT, other); |
} |
- } while (fTs[++tIndex].fT == 0); |
- } |
+ return true; |
+ } |
+ } while (fTs[++tIndex].fT == 0); |
return false; |
} |
// this span is excluded by the winding rule -- chase the ends |
// as long as they are unambiguous to mark connections as done |
// and give them the same winding value |
-SkOpSpan* SkOpSegment::markAndChaseDone(int index, int endIndex, int winding) { |
- int step = SkSign32(endIndex - index); |
- int min = SkMin32(index, endIndex); |
- markDone(min, winding); |
- SkOpSpan* last; |
- SkOpSegment* other = this; |
- while ((other = other->nextChase(&index, step, &min, &last))) { |
- other->markDone(min, winding); |
- } |
- return last; |
-} |
- |
-SkOpSpan* SkOpSegment::markAndChaseDoneBinary(const SkOpAngle* angle, int winding, int oppWinding) { |
- int index = angle->start(); |
- int endIndex = angle->end(); |
- int step = SkSign32(endIndex - index); |
- int min = SkMin32(index, endIndex); |
- markDoneBinary(min, winding, oppWinding); |
- SkOpSpan* last; |
- SkOpSegment* other = this; |
- while ((other = other->nextChase(&index, step, &min, &last))) { |
- other->markDoneBinary(min, winding, oppWinding); |
- } |
- return last; |
-} |
SkOpSpan* SkOpSegment::markAndChaseDoneBinary(int index, int endIndex) { |
int step = SkSign32(endIndex - index); |
@@ -2519,12 +2171,6 @@ SkOpSpan* SkOpSegment::markAndChaseDoneUnary(int index, int endIndex) { |
return last; |
} |
-SkOpSpan* SkOpSegment::markAndChaseDoneUnary(const SkOpAngle* angle, int winding) { |
- int index = angle->start(); |
- int endIndex = angle->end(); |
- return markAndChaseDone(index, endIndex, winding); |
-} |
- |
SkOpSpan* SkOpSegment::markAndChaseWinding(const SkOpAngle* angle, const int winding) { |
int index = angle->start(); |
int endIndex = angle->end(); |
@@ -2565,18 +2211,12 @@ SkOpSpan* SkOpSegment::markAndChaseWinding(const SkOpAngle* angle, int winding, |
return markAndChaseWinding(start, end, winding, oppWinding); |
} |
-SkOpSpan* SkOpSegment::markAngle(int maxWinding, int sumWinding, bool activeAngle, |
- const SkOpAngle* angle) { |
+SkOpSpan* SkOpSegment::markAngle(int maxWinding, int sumWinding, const SkOpAngle* angle) { |
SkASSERT(angle->segment() == this); |
if (UseInnerWinding(maxWinding, sumWinding)) { |
maxWinding = sumWinding; |
} |
- SkOpSpan* last; |
- if (activeAngle) { |
- last = markAndChaseWinding(angle, maxWinding); |
- } else { |
- last = markAndChaseDoneUnary(angle, maxWinding); |
- } |
+ SkOpSpan* last = markAndChaseWinding(angle, maxWinding); |
#if DEBUG_WINDING |
if (last) { |
SkDebugf("%s last id=%d windSum=", __FUNCTION__, |
@@ -2589,7 +2229,7 @@ SkOpSpan* SkOpSegment::markAngle(int maxWinding, int sumWinding, bool activeAngl |
} |
SkOpSpan* SkOpSegment::markAngle(int maxWinding, int sumWinding, int oppMaxWinding, |
- int oppSumWinding, bool activeAngle, const SkOpAngle* angle) { |
+ int oppSumWinding, const SkOpAngle* angle) { |
SkASSERT(angle->segment() == this); |
if (UseInnerWinding(maxWinding, sumWinding)) { |
maxWinding = sumWinding; |
@@ -2597,12 +2237,7 @@ SkOpSpan* SkOpSegment::markAngle(int maxWinding, int sumWinding, int oppMaxWindi |
if (oppMaxWinding != oppSumWinding && UseInnerWinding(oppMaxWinding, oppSumWinding)) { |
oppMaxWinding = oppSumWinding; |
} |
- SkOpSpan* last; |
- if (activeAngle) { |
- last = markAndChaseWinding(angle, maxWinding, oppMaxWinding); |
- } else { |
- last = markAndChaseDoneBinary(angle, maxWinding, oppMaxWinding); |
- } |
+ SkOpSpan* last = markAndChaseWinding(angle, maxWinding, oppMaxWinding); |
#if DEBUG_WINDING |
if (last) { |
SkDebugf("%s last id=%d windSum=", __FUNCTION__, |
@@ -2632,19 +2267,6 @@ void SkOpSegment::markDone(int index, int winding) { |
} while (++index < fTs.count() && precisely_negative(fTs[index].fT - referenceT)); |
} |
-void SkOpSegment::markDoneBinary(int index, int winding, int oppWinding) { |
- // SkASSERT(!done()); |
- SkASSERT(winding || oppWinding); |
- double referenceT = fTs[index].fT; |
- int lesser = index; |
- while (--lesser >= 0 && precisely_negative(referenceT - fTs[lesser].fT)) { |
- markOneDoneBinary(__FUNCTION__, lesser, winding, oppWinding); |
- } |
- do { |
- markOneDoneBinary(__FUNCTION__, index, winding, oppWinding); |
- } while (++index < fTs.count() && precisely_negative(fTs[index].fT - referenceT)); |
-} |
- |
void SkOpSegment::markDoneBinary(int index) { |
double referenceT = fTs[index].fT; |
int lesser = index; |
@@ -2685,15 +2307,6 @@ void SkOpSegment::markOneDoneBinary(const char* funName, int tIndex) { |
fDoneSpans++; |
} |
-void SkOpSegment::markOneDoneBinary(const char* funName, int tIndex, int winding, int oppWinding) { |
- SkOpSpan* span = markOneWinding(funName, tIndex, winding, oppWinding); |
- if (!span) { |
- return; |
- } |
- span->fDone = true; |
- fDoneSpans++; |
-} |
- |
void SkOpSegment::markOneDoneUnary(const char* funName, int tIndex) { |
SkOpSpan* span = verifyOneWindingU(funName, tIndex); |
if (!span) { |
@@ -2790,8 +2403,12 @@ SkOpSpan* SkOpSegment::verifyOneWinding(const char* funName, int tIndex) { |
#if DEBUG_MARK_DONE |
debugShowNewWinding(funName, span, span.fWindSum, span.fOppSum); |
#endif |
- SkASSERT(span.fWindSum != SK_MinS32); |
- SkASSERT(span.fOppSum != SK_MinS32); |
+// If the prior angle in the sort is unorderable, the winding sum may not be computable. |
+// To enable the assert, the 'prior is unorderable' state could be |
+// piped down to this test, but not sure it's worth it. |
+// (Once the sort order is stored in the span, this test may be feasible.) |
+// SkASSERT(span.fWindSum != SK_MinS32); |
+// SkASSERT(span.fOppSum != SK_MinS32); |
return &span; |
} |
@@ -2803,7 +2420,11 @@ SkOpSpan* SkOpSegment::verifyOneWindingU(const char* funName, int tIndex) { |
#if DEBUG_MARK_DONE |
debugShowNewWinding(funName, span, span.fWindSum); |
#endif |
- SkASSERT(span.fWindSum != SK_MinS32); |
+// If the prior angle in the sort is unorderable, the winding sum may not be computable. |
+// To enable the assert, the 'prior is unorderable' state could be |
+// piped down to this test, but not sure it's worth it. |
+// (Once the sort order is stored in the span, this test may be feasible.) |
+// SkASSERT(span.fWindSum != SK_MinS32); |
return &span; |
} |
@@ -2891,21 +2512,6 @@ void SkOpSegment::matchWindingValue(int tIndex, double t, bool borrowWind) { |
} |
} |
-double SkOpSegment::missingNear(double t, const SkOpSegment* other, const SkPoint& startPt, |
- const SkPoint& endPt) const { |
- int count = this->count(); |
- for (int index = 0; index < count; ++index) { |
- const SkOpSpan& span = this->span(index); |
- if (span.fOther == other && span.fPt == startPt) { |
- double midT = (t + span.fT) / 2; |
- if (betweenPoints(midT, startPt, endPt)) { |
- return span.fT; |
- } |
- } |
- } |
- return -1; |
-} |
- |
// return span if when chasing, two or more radiating spans are not done |
// OPTIMIZATION: ? multiple spans is detected when there is only one valid |
// candidate and the remaining spans have windValue == 0 (canceled by |
@@ -3330,24 +2936,6 @@ int SkOpSegment::windSum(const SkOpAngle* angle) const { |
return windSum(index); |
} |
-int SkOpSegment::windValue(const SkOpAngle* angle) const { |
- int start = angle->start(); |
- int end = angle->end(); |
- int index = SkMin32(start, end); |
- return windValue(index); |
-} |
- |
-int SkOpSegment::windValueAt(double t) const { |
- int count = fTs.count(); |
- for (int index = 0; index < count; ++index) { |
- if (fTs[index].fT == t) { |
- return fTs[index].fWindValue; |
- } |
- } |
- SkASSERT(0); |
- return 0; |
-} |
- |
void SkOpSegment::zeroSpan(SkOpSpan* span) { |
SkASSERT(span->fWindValue > 0 || span->fOppValue != 0); |
span->fWindValue = 0; |