segment->debugShowSort(__FUNCTION__, sorted, firstIndex, winding, oWinding);
#endif
winding -= segment->spanSign(angle);
+ oWinding -= segment->oppSign(angle);
bool firstOperand = segment->operand();
do {
SkASSERT(nextIndex != firstIndex);
angle = sorted[nextIndex];
segment = angle->segment();
int deltaSum = segment->spanSign(angle);
+ int deltaOppSum = segment->oppSign(angle);
bool angleIsOp = segment->operand() ^ firstOperand;
int maxWinding;
if (angleIsOp) {
maxWinding = oWinding;
oWinding -= deltaSum;
+ winding -= deltaOppSum;
} else {
maxWinding = winding;
winding -= deltaSum;
+ oWinding -= deltaOppSum;
}
#if DEBUG_SORT
SkDebugf("%s id=%d maxWinding=%d winding=%d oWinding=%d sign=%d\n", __FUNCTION__,
return NULL;
}
-static bool windingIsActive(int winding, int oppWinding, int spanWinding,
+static bool windingIsActive(int winding, int oppWinding, int spanWinding, int oppSpanWinding,
bool windingIsOp, ShapeOp op) {
bool active = windingIsActive(winding, spanWinding);
if (!active) {
return false;
}
+ if (oppSpanWinding && windingIsActive(oppWinding, oppSpanWinding)) {
+ return op == kIntersect_Op || op == kUnion_Op;
+ }
bool opActive = oppWinding != 0;
return gOpLookup[op][opActive][windingIsOp];
}
+static int updateWindings(const Segment* current, int index, int endIndex,
+ int& spanWinding, int& oppWinding, int& oppSpanWinding) {
+ int winding = updateWindings(current, index, endIndex, spanWinding);
+ int lesser = SkMin32(index, endIndex);
+ oppWinding = current->oppSum(lesser);
+ oppSpanWinding = current->oppSign(index, endIndex);
+ if (oppSpanWinding && useInnerWinding(oppWinding - oppSpanWinding, oppWinding)) {
+ oppWinding -= oppSpanWinding;
+ }
+ return winding;
+}
+
static bool bridgeOp(SkTDArray<Contour*>& contourList, const ShapeOp op,
const int aXorMask, const int bXorMask, PathWrapper& simple) {
bool firstContour = true;
int winding = contourWinding;
int oppWinding = oppContourWinding;
int spanWinding = current->spanSign(index, endIndex);
+ int oppSpanWinding = current->oppSign(index, endIndex);
SkTDArray<Span*> chaseArray;
do {
- bool active = windingIsActive(winding, oppWinding, spanWinding,
+ bool active = windingIsActive(winding, oppWinding, spanWinding, oppSpanWinding,
current->operand(), op);
#if DEBUG_WINDING
- SkDebugf("%s active=%s winding=%d oppWinding=%d spanWinding=%d\n",
+ SkDebugf("%s active=%s winding=%d oppWinding=%d spanWinding=%d oppSpanWinding=%d\n",
__FUNCTION__, active ? "true" : "false",
- winding, oppWinding, spanWinding);
+ winding, oppWinding, spanWinding, oppSpanWinding);
#endif
do {
#if DEBUG_ACTIVE_SPANS
int nextStart = index;
int nextEnd = endIndex;
Segment* next = current->findNextOp(chaseArray, active,
- nextStart, nextEnd, winding, oppWinding, spanWinding,
+ nextStart, nextEnd, winding, oppWinding, spanWinding, oppSpanWinding,
unsortable, op, aXorMask, bXorMask);
if (!next) {
SkASSERT(!unsortable);
if (!current) {
break;
}
- winding = updateWindings(current, index, endIndex, spanWinding, &oppWinding);
+ winding = updateWindings(current, index, endIndex, spanWinding, oppWinding,
+ oppSpanWinding);
} while (true);
} while (true);
return closable;
} while (addIntersectTs(current, next) && nextPtr != listEnd);
} while (currentPtr != listEnd);
// eat through coincident edges
- coincidenceCheck(contourList);
+ coincidenceCheck(contourList, (aXorMask == kEvenOdd_Mask)
+ ^ (bXorMask == kEvenOdd_Mask));
fixOtherTIndex(contourList);
sortSegments(contourList);
#if DEBUG_ACTIVE_SPANS
int fWindSum; // accumulated from contours surrounding this one.
int fOppSum; // for binary operators: the opposite winding sum
int fWindValue; // 0 == canceled; 1 == normal; >1 == coincident
+ int fOppValue; // normally 0 -- when binary coincident edges combine, opp value goes here
bool fDone; // if set, this span to next higher T has been processed
bool fUnsortableStart; // set when start is part of an unsortable pair
bool fUnsortableEnd; // set when end is part of an unsortable pair
{{true , true }, {true , true }}, // a ^ b
};
-static bool activeOp(bool angleIsOp, int otherNonZero, ShapeOp op) {
+static bool activeOp(bool angleIsOp, int otherNonZero, int otherCoin, ShapeOp op) {
+ if (otherNonZero != otherCoin) {
+ return op == kIntersect_Op || op == kUnion_Op;
+ }
return gOpLookup[op][otherNonZero][angleIsOp];
}
span->fWindSum = SK_MinS32;
span->fOppSum = SK_MinS32;
span->fWindValue = 1;
+ span->fOppValue = 0;
span->fTiny = false;
if ((span->fDone = newT == 1)) {
++fDoneSpans;
other.addCancelOutsides(tStart, oStart, *this, endT);
}
}
+
+ int bumpCoincidentThis(const Span* oTest, const bool transfer, const bool decrementThis,
+ const bool thisXor, const bool opp, int index, SkTDArray<double>& outsideTs,
+ SkTDArray<double>& xOutsideTs)
+ {
+ Span* const test = &fTs[index];
+ Span* end = test;
+ const int startIndex = index;
+ const double oStartT = oTest->fT;
+ do {
+ if (transfer) {
+ if (!decrementThis & !thisXor & !opp) {
+ #ifdef SK_DEBUG
+ SkASSERT(abs(end->fWindValue) < gDebugMaxWindValue);
+ #endif
+ ++(end->fWindValue);
+ } else if (decrementSpan(end)) {
+ TrackOutside(outsideTs, end->fT, oStartT);
+ }
+ } else if (opp) {
+ if (decrementThis) {
+ if (decrementSpan(end)) {
+ TrackOutside(outsideTs, end->fT, oStartT);
+ }
+ } else {
+ end->fOppValue += oTest->fWindValue;
+ }
+ } else if (oTest->fWindValue) {
+ SkASSERT(decrementThis);
+ if (startIndex > 0 && fTs[startIndex - 1].fWindValue) {
+ TrackOutside(xOutsideTs, end->fT, oStartT);
+ }
+ }
+ end = &fTs[++index];
+ } while (approximately_negative(end->fT - test->fT));
+ return index;
+ }
+
+ // 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)
+ // and walk other conditionally -- hoping that it catches up in the end
+ int bumpCoincidentOther(const Span* test, const bool transfer, const bool decrementThis,
+ const bool otherXor, const bool opp, const double tRatio, const double oEndT,
+ int& oIndex, SkTDArray<double>& oOutsideTs)
+ {
+ Span* const oTest = &fTs[oIndex];
+ Span* oEnd = oTest;
+ const double startT = test->fT;
+ const int oStartIndex = oIndex;
+ const double oStartT = oTest->fT;
+ double otherTMatch = (test->fT - startT) * tRatio + oStartT;
+ while (!approximately_negative(oEndT - oEnd->fT)
+ && approximately_negative(oEnd->fT - otherTMatch)) {
+ if (transfer) {
+ if (decrementThis & !otherXor & !opp) {
+ #ifdef SK_DEBUG
+ SkASSERT(abs(oEnd->fWindValue) < gDebugMaxWindValue);
+ #endif
+ ++(oEnd->fWindValue);
+ } else if (decrementSpan(oEnd)) {
+ TrackOutside(oOutsideTs, oEnd->fT, startT);
+ }
+ } else if (opp) {
+ if (decrementThis) {
+ oEnd->fOppValue += test->fWindValue;
+ } else {
+ if (decrementSpan(oEnd)) {
+ TrackOutside(oOutsideTs, oEnd->fT, startT);
+ }
+ }
+ } else if (test->fWindValue) {
+ SkASSERT(decrementThis);
+ if (oStartIndex > 0 && fTs[oStartIndex - 1].fWindValue) {
+ SkASSERT(0); // track for later?
+ }
+ }
+ oEnd = &fTs[++oIndex];
+ }
+ return oIndex;
+ }
+
+ // FIXME: need to test this case:
+ // contourA has two segments that are coincident
+ // contourB has two segments that are coincident in the same place
+ // each ends up with +2/0 pairs for winding count
+ // since logic below doesn't transfer count (only increments/decrements) can this be
+ // resolved to +4/0 ?
// set spans from start to end to increment the greater by one and decrement
// the lesser
- void addTCoincident(bool isXor, double startT, double endT,
+ void addTCoincident(bool thisXor, bool otherXor, double startT, double endT,
Segment& other, double oStartT, double oEndT) {
SkASSERT(!approximately_negative(endT - startT));
SkASSERT(!approximately_negative(oEndT - oStartT));
- isXor |= fOperand != other.fOperand;
+ bool opp = fOperand ^ other.fOperand;
+ if (!opp) {
+ otherXor = thisXor;
+ }
int index = 0;
while (!approximately_negative(startT - fTs[index].fT)) {
++index;
SkTDArray<double> outsideTs;
SkTDArray<double> xOutsideTs;
SkTDArray<double> oOutsideTs;
- SkTDArray<double> oxOutsideTs;
do {
- bool transfer = test->fWindValue && oTest->fWindValue;
- bool decrementThis = (test->fWindValue < oTest->fWindValue) & !isXor;
- bool decrementOther = (test->fWindValue >= oTest->fWindValue) & !isXor;
- Span* end = test;
- double startT = end->fT;
- int startIndex = index;
- double oStartT = oTest->fT;
- int oStartIndex = oIndex;
- do {
- if (transfer) {
- if (decrementOther) {
- #ifdef SK_DEBUG
- SkASSERT(abs(end->fWindValue) < gDebugMaxWindValue);
- #endif
- ++(end->fWindValue);
- } else if (decrementSpan(end)) {
- TrackOutside(outsideTs, end->fT, oStartT);
- }
- } else if (oTest->fWindValue) {
- SkASSERT(!decrementOther);
- if (startIndex > 0 && fTs[startIndex - 1].fWindValue) {
- TrackOutside(xOutsideTs, end->fT, oStartT);
- }
- }
- end = &fTs[++index];
- } while (approximately_negative(end->fT - test->fT));
- // 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)
- // and walk other conditionally -- hoping that it catches up in the end
- double otherTMatch = (test->fT - startT) * tRatio + oStartT;
- Span* oEnd = oTest;
- while (!approximately_negative(oEndT - oEnd->fT)
- && approximately_negative(oEnd->fT - otherTMatch)) {
- if (transfer) {
- if (decrementThis) {
- #ifdef SK_DEBUG
- SkASSERT(abs(oEnd->fWindValue) < gDebugMaxWindValue);
- #endif
- ++(oEnd->fWindValue);
- } else if (other.decrementSpan(oEnd)) {
- TrackOutside(oOutsideTs, oEnd->fT, startT);
- }
- } else if (test->fWindValue) {
- SkASSERT(!decrementOther);
- if (oStartIndex > 0 && other.fTs[oStartIndex - 1].fWindValue) {
- SkASSERT(0); // track for later?
- }
- }
- oEnd = &other.fTs[++oIndex];
+ bool transfer = test->fWindValue && oTest->fWindValue && !opp;
+ bool decrementThis = test->fWindValue < oTest->fWindValue;
+ if (decrementThis) {
+ oIndex = other.bumpCoincidentOther(test, transfer, decrementThis, otherXor, opp,
+ tRatio, oEndT, oIndex, oOutsideTs);
+ index = bumpCoincidentThis(oTest, transfer, decrementThis, thisXor, opp,
+ index, outsideTs, xOutsideTs);
+ } else {
+ index = bumpCoincidentThis(oTest, transfer, decrementThis, thisXor, opp,
+ index, outsideTs, xOutsideTs);
+ oIndex = other.bumpCoincidentOther(test, transfer, decrementThis, otherXor, opp,
+ tRatio, oEndT, oIndex, oOutsideTs);
}
- test = end;
- oTest = oEnd;
+ test = &fTs[index];
+ oTest = &other.fTs[oIndex];
} while (!approximately_negative(endT - test->fT));
SkASSERT(approximately_negative(oTest->fT - oEndT));
SkASSERT(approximately_negative(oEndT - oTest->fT));
Segment* findNextOp(SkTDArray<Span*>& chase, bool active,
int& nextStart, int& nextEnd, int& winding, int& oppWinding,
- int& spanWinding, bool& unsortable, ShapeOp op,
+ int& spanWinding, int& oppSpanWinding, bool& unsortable, ShapeOp op,
const int aXorMask, const int bXorMask) {
const int startIndex = nextStart;
const int endIndex = nextEnd;
if (useInnerWinding(outerWinding, innerWinding)) {
outerWinding = innerWinding;
}
+ int outerOppWinding = oppWinding;
+ if (oppSpanWinding) {
+ int innerOppWinding = oppWinding + oppSpanWinding;
+ if (useInnerWinding(oppWinding, innerOppWinding)) {
+ outerOppWinding = innerOppWinding;
+ }
+ }
SkASSERT(startIndex != endIndex);
int count = fTs.count();
SkASSERT(startIndex < endIndex ? startIndex < count - 1
#if DEBUG_WINDING
SkDebugf("%s simple\n", __FUNCTION__);
#endif
- markDone(SkMin32(startIndex, endIndex), outerWinding, oppWinding);
+ markDone(SkMin32(startIndex, endIndex), outerWinding, outerOppWinding);
other = endSpan->fOther;
nextStart = endSpan->fOtherIndex;
double startT = other->fTs[nextStart].fT;
}
SkASSERT(sorted[firstIndex]->segment() == this);
#if DEBUG_WINDING
- SkDebugf("%s [%d] sign=%d\n", __FUNCTION__, firstIndex, sorted[firstIndex]->sign());
+ SkDebugf("%s firstIndex=[%d] sign=%d\n", __FUNCTION__, firstIndex,
+ sorted[firstIndex]->sign());
#endif
int aSumWinding = winding;
int bSumWinding = oppWinding;
bool angleIsOp = sorted[firstIndex]->segment()->operand() ^ operand();
- int angleSpan = spanSign(sorted[firstIndex]);
+ const Angle* firstAngle = sorted[firstIndex];
+ int angleSpan = spanSign(firstAngle);
+ int oppoSign = oppSign(firstAngle);
if (angleIsOp) {
bSumWinding -= angleSpan;
+ aSumWinding -= oppoSign;
} else {
aSumWinding -= angleSpan;
+ bSumWinding -= oppoSign;
}
int nextIndex = firstIndex + 1;
int lastIndex = firstIndex != 0 ? firstIndex : angleCount;
bool nextTiny = nextSegment->tiny(*nextAngle);
angleIsOp = nextSegment->operand() ^ operand();
int deltaSum = nextSegment->spanSign(nextAngle);
+ int oppDeltaSum = nextSegment->oppSign(nextAngle);
int maxWinding, xorMask, sumWinding;
- bool otherNonZero, altFlipped;
+ bool otherNonZero, altFlipped, otherCoin;
if (angleIsOp) {
maxWinding = bSumWinding;
if (bSumWinding) {
xorMask = bXorMask;
bAltFlipped ^= bLastNonZeroSum * bSumWinding < 0; // flip if different signs
altFlipped = bAltFlipped;
+ aSumWinding -= oppDeltaSum;
+ otherCoin = aSumWinding & aXorMask;
} else {
maxWinding = aSumWinding;
if (aSumWinding) {
xorMask = aXorMask;
aAltFlipped ^= aLastNonZeroSum * aSumWinding < 0; // flip if different signs
altFlipped = aAltFlipped;
+ bSumWinding -= oppDeltaSum;
+ otherCoin = bSumWinding & bXorMask;
}
- bool opIsActive = activeOp(nextSegment->operand(), otherNonZero, op);
+ bool opIsActive = activeOp(nextSegment->operand(), otherNonZero, otherCoin, op);
int oWinding = angleIsOp ? aSumWinding : bSumWinding;
if (!(sumWinding & xorMask)) {
if (!active) {
- markAndChaseDone(startIndex, endIndex, outerWinding, oppWinding);
+ markAndChaseDone(startIndex, endIndex, outerWinding, outerOppWinding);
nextSegment->markAndChaseWinding(nextAngle, maxWinding, oWinding);
#if DEBUG_WINDING
SkDebugf("%s [%d] inactive\n", __FUNCTION__, nextIndex);
}
}
} while (++nextIndex != lastIndex);
- markDone(SkMin32(startIndex, endIndex), outerWinding, oppWinding);
+ markDone(SkMin32(startIndex, endIndex), outerWinding, outerOppWinding);
if (!foundAngle) {
return NULL;
}
nextEnd = foundAngle->end();
nextSegment = foundAngle->segment();
int flipped = foundFlipped ? -1 : 1;
- spanWinding = SkSign32(spanWinding) * flipped * nextSegment->windValue(
- SkMin32(nextStart, nextEnd));
+ int minStartEnd = SkMin32(nextStart, nextEnd);
+ spanWinding = SkSign32(spanWinding) * flipped * nextSegment->windValue(minStartEnd);
+ oppSpanWinding = SkSign32(oppSpanWinding) * flipped * nextSegment->oppValue(minStartEnd);
+
#if DEBUG_WINDING
SkDebugf("%s foundFlipped=%d spanWinding=%d oldSpanSign=%d spanSign=%d\n",
__FUNCTION__, foundFlipped, spanWinding, oldSpanSign,
nextSegment->spanSign(foundAngle));
- SkDebugf("%s foundOpp=%d oppWinding=%d foundOppWinding=%d winding=%d foundSum=",
- __FUNCTION__, foundOpp, oppWinding, foundOppWinding, winding);
+ SkDebugf("%s foundOpp=%d oppWinding=%d oppSpanWinding=%d foundOppWinding=%d winding=%d"
+ " foundSum=", __FUNCTION__, foundOpp, oppWinding, oppSpanWinding, foundOppWinding,
+ winding);
if (foundSum == SK_MinS32) {
SkDebugf("?");
} else {
SkASSERT(foundSum != SK_MinS32);
winding = foundSum;
spanWinding = nextSegment->spanSign(foundAngle);
+ oppSpanWinding = nextSegment->oppSign(foundAngle);
}
}
return nextSegment;
}
// FIXME: this is tricky code; needs its own unit test
- void findTooCloseToCall(bool isXor) {
+ void findTooCloseToCall(bool thisXor, bool otherXor) {
int count = fTs.count();
if (count < 3) { // require t=0, x, 1 at minimum
return;
// FIXME: this is bogus for multiple ops
// the xorMask needs to be accumulated from the union of the two
// edges -- which means that the segment must have its own copy of the mask
- mOther->addTCoincident(isXor, moStartT, moEndT, *tOther, toStartT, toEndT);
+ mOther->addTCoincident(thisXor, otherXor,
+ moStartT, moEndT, *tOther, toStartT, toEndT);
}
}
}
return fOperand;
}
+ int oppSign(const Angle* angle) const {
+ SkASSERT(angle->segment() == this);
+ return oppSign(angle->start(), angle->end());
+ }
+
+ int oppSign(int startIndex, int endIndex) const {
+ int result = startIndex < endIndex ? -fTs[startIndex].fOppValue
+ : fTs[endIndex].fOppValue;
+#if DEBUG_WIND_BUMP
+ SkDebugf("%s oppSign=%d\n", __FUNCTION__, result);
+#endif
+ return result;
+ }
+
int oppSum(int tIndex) const {
return fTs[tIndex].fOppSum;
}
return fTs[lesser].fOppSum;
}
+ int oppValue(int tIndex) const {
+ return fTs[tIndex].fOppValue;
+ }
+
const SkPoint* pts() const {
return fPts;
}
SkASSERT(angles.count() > 1);
int lastSum = contourWinding;
int oppLastSum = oppContourWinding;
- int windSum = lastSum - spanSign(angles[first]);
- int oppWindSum = oppLastSum;
+ const Angle* firstAngle = angles[first];
+ int windSum = lastSum - spanSign(firstAngle);
+ int oppoSign = oppSign(firstAngle);
+ int oppWindSum = oppLastSum - oppoSign;
SkDebugf("%s %s contourWinding=%d oppContourWinding=%d sign=%d\n", fun, __FUNCTION__,
contourWinding, oppContourWinding, spanSign(angles[first]));
int index = first;
const Span& mSpan = segment.fTs[SkMin32(start, end)];
bool opp = segment.fOperand ^ fOperand;
if (!firstTime) {
+ oppoSign = segment.oppSign(&angle);
if (opp) {
oppLastSum = oppWindSum;
oppWindSum -= segment.spanSign(&angle);
+ if (oppoSign) {
+ lastSum = windSum;
+ windSum -= oppoSign;
+ }
} else {
lastSum = windSum;
windSum -= segment.spanSign(&angle);
+ if (oppoSign) {
+ oppLastSum = oppWindSum;
+ oppWindSum -= oppoSign;
+ }
}
}
SkDebugf("%s [%d] %sid=%d %s start=%d (%1.9g,%,1.9g) end=%d (%1.9g,%,1.9g)"
last = lastSum;
wind = windSum;
}
- SkDebugf(" winding: %d->%d (max=%d) ", last, wind,
- useInnerWinding(last, wind) ? wind : last);
+ if (!oppoSign) {
+ SkDebugf(" %d->%d (max=%d)", last, wind,
+ useInnerWinding(last, wind) ? wind : last);
+ } else {
+ SkDebugf(" %d->%d (%d->%d)", last, wind, opp ? lastSum : oppLastSum,
+ opp ? windSum : oppWindSum);
+ }
SkDebugf(" done=%d tiny=%d opp=%d\n", mSpan.fDone, mSpan.fTiny, opp);
#if false && DEBUG_ANGLE
angle.debugShow(segment.xyAtT(&sSpan));
Contour* fContours[2];
int fSegments[2];
double fTs[2][2];
- bool fXor;
};
class Contour {
void addCoincident(int index, Contour* other, int otherIndex,
const Intersections& ts, bool swap) {
Coincidence& coincidence = *fCoincidences.append();
- coincidence.fContours[0] = this;
+ coincidence.fContours[0] = this; // FIXME: no need to store
coincidence.fContours[1] = other;
coincidence.fSegments[0] = index;
coincidence.fSegments[1] = otherIndex;
coincidence.fTs[!swap][0] = ts.fCoincidentT[1][0];
coincidence.fTs[!swap][1] = ts.fCoincidentT[1][1];
}
- coincidence.fXor = fOperand == other->fOperand ? fXor : true;
}
void addCross(const Contour* crosser) {
return segment.pts()[segment.verb()];
}
- void findTooCloseToCall() {
+ void findTooCloseToCall(bool otherXor) {
int segmentCount = fSegments.count();
+ otherXor ^= fXor;
for (int sIndex = 0; sIndex < segmentCount; ++sIndex) {
- fSegments[sIndex].findTooCloseToCall(fXor);
+ fSegments[sIndex].findTooCloseToCall(fXor, otherXor);
}
}
#endif
double startT = coincidence.fTs[0][0];
double endT = coincidence.fTs[0][1];
- bool opposite = false;
+ bool cancelers = false;
if (startT > endT) {
SkTSwap<double>(startT, endT);
- opposite ^= true;
+ cancelers ^= true; // FIXME: just assign true
}
SkASSERT(!approximately_negative(endT - startT));
double oStartT = coincidence.fTs[1][0];
double oEndT = coincidence.fTs[1][1];
if (oStartT > oEndT) {
SkTSwap<double>(oStartT, oEndT);
- opposite ^= true;
+ cancelers ^= true;
}
SkASSERT(!approximately_negative(oEndT - oStartT));
- if (opposite) {
- // make sure startT and endT have t entries
- SkASSERT(opposite);
+ bool opp = thisContour->fOperand ^ otherContour->fOperand;
+ if (cancelers && !opp) {
+ // make sure startT and endT have t entries
if (startT > 0 || oEndT < 1
|| thisOne.isMissing(startT) || other.isMissing(oEndT)) {
thisOne.addTPair(startT, other, oEndT, true);
|| thisOne.isMissing(endT) || other.isMissing(oEndT)) {
other.addTPair(oEndT, thisOne, endT, true);
}
- thisOne.addTCoincident(coincidence.fXor, startT, endT, other, oStartT, oEndT);
+ thisOne.addTCoincident(thisContour->fXor, otherContour->fXor,
+ startT, endT, other, oStartT, oEndT);
}
#if DEBUG_CONCIDENT
thisOne.debugShowTs();
// resolve any coincident pairs found while intersecting, and
// see if coincidence is formed by clipping non-concident segments
-static void coincidenceCheck(SkTDArray<Contour*>& contourList) {
+static void coincidenceCheck(SkTDArray<Contour*>& contourList, bool otherXor) {
int contourCount = contourList.count();
for (int cIndex = 0; cIndex < contourCount; ++cIndex) {
Contour* contour = contourList[cIndex];
}
for (int cIndex = 0; cIndex < contourCount; ++cIndex) {
Contour* contour = contourList[cIndex];
- contour->findTooCloseToCall();
+ contour->findTooCloseToCall(otherXor);
}
}
return result;
}
-static int updateWindings(const Segment* current, int index, int endIndex,
- int& spanWinding, int* oppWinding) {
+static int updateWindings(const Segment* current, int index, int endIndex, int& spanWinding) {
int lesser = SkMin32(index, endIndex);
spanWinding = current->spanSign(index, endIndex);
int winding = current->windSum(lesser);
if (inner) {
winding -= spanWinding;
}
- if (oppWinding) {
- *oppWinding = current->oppSum(lesser);
- }
return winding;
}
if (!current) {
break;
}
- winding = updateWindings(current, index, endIndex, spanWinding, NULL);
+ winding = updateWindings(current, index, endIndex, spanWinding);
} while (true);
} while (true);
return closable;
} while (addIntersectTs(current, next) && nextPtr != listEnd);
} while (currentPtr != listEnd);
// eat through coincident edges
- coincidenceCheck(contourList);
+ coincidenceCheck(contourList, false);
fixOtherTIndex(contourList);
sortSegments(contourList);
#if DEBUG_ACTIVE_SPANS
}
static void testIntersect1() {
- SkPath one, two, result;
- one.addRect(0, 0, 6, 6, (SkPath::Direction) 0);
- two.addRect(3, 3, 9, 9, (SkPath::Direction) 0);
- operate(one, two, kIntersect_Op, result);
- SkASSERT(result.countPoints() == 5);
- SkASSERT(result.countVerbs() == 6); // move, 4 lines, close
- SkRect bounds = result.getBounds();
- SkASSERT(bounds.fLeft == 3);
- SkASSERT(bounds.fTop == 3);
- SkASSERT(bounds.fRight == 6);
- SkASSERT(bounds.fBottom == 6);
+ SkPath one, two;
+ one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
+ two.addRect(3, 3, 9, 9, SkPath::kCW_Direction);
testShapeOp(one, two, kIntersect_Op);
}
static void testUnion1() {
- SkPath one, two, result;
- one.addRect(0, 0, 6, 6, (SkPath::Direction) 0);
- two.addRect(3, 3, 9, 9, (SkPath::Direction) 0);
- operate(one, two, kUnion_Op, result);
- SkASSERT(result.countPoints() == 9);
- SkASSERT(result.countVerbs() == 10); // move, 8 lines, close
- SkRect bounds = result.getBounds();
- SkASSERT(bounds.fLeft == 0);
- SkASSERT(bounds.fTop == 0);
- SkASSERT(bounds.fRight == 9);
- SkASSERT(bounds.fBottom == 9);
+ SkPath one, two;
+ one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
+ two.addRect(3, 3, 9, 9, SkPath::kCW_Direction);
testShapeOp(one, two, kUnion_Op);
}
static void testDiff1() {
- SkPath one, two, result;
- one.addRect(0, 0, 6, 6, (SkPath::Direction) 0);
- two.addRect(3, 3, 9, 9, (SkPath::Direction) 0);
- operate(one, two, kDifference_Op, result);
- SkASSERT(result.countPoints() == 7);
- SkASSERT(result.countVerbs() == 8); // move, 6 lines, close
- SkRect bounds = result.getBounds();
- SkASSERT(bounds.fLeft == 0);
- SkASSERT(bounds.fTop == 0);
- SkASSERT(bounds.fRight == 6);
- SkASSERT(bounds.fBottom == 6);
+ SkPath one, two;
+ one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
+ two.addRect(3, 3, 9, 9, SkPath::kCW_Direction);
testShapeOp(one, two, kDifference_Op);
}
static void testXor1() {
- SkPath one, two, result;
- one.addRect(0, 0, 6, 6, (SkPath::Direction) 0);
- two.addRect(3, 3, 9, 9, (SkPath::Direction) 0);
- operate(one, two, kXor_Op, result);
- SkASSERT(result.countPoints() == 14);
- SkASSERT(result.countVerbs() == 16); // move, 6 lines, close, move, 6 lines, close
- SkRect bounds = result.getBounds();
- SkASSERT(bounds.fLeft == 0);
- SkASSERT(bounds.fTop == 0);
- SkASSERT(bounds.fRight == 9);
- SkASSERT(bounds.fBottom == 9);
+ SkPath one, two;
+ one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
+ two.addRect(3, 3, 9, 9, SkPath::kCW_Direction);
+ testShapeOp(one, two, kXor_Op);
+}
+
+static void testIntersect2() {
+ SkPath one, two;
+ one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
+ two.addRect(0, 3, 9, 9, SkPath::kCW_Direction);
+ testShapeOp(one, two, kIntersect_Op);
+}
+
+static void testUnion2() {
+ SkPath one, two;
+ one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
+ two.addRect(0, 3, 9, 9, SkPath::kCW_Direction);
+ testShapeOp(one, two, kUnion_Op);
+}
+
+static void testDiff2() {
+ SkPath one, two;
+ one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
+ two.addRect(0, 3, 9, 9, SkPath::kCW_Direction);
+ testShapeOp(one, two, kDifference_Op);
+}
+
+static void testXor2() {
+ SkPath one, two;
+ one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
+ two.addRect(0, 3, 9, 9, SkPath::kCW_Direction);
testShapeOp(one, two, kXor_Op);
}
void (*fun)();
const char* str;
} subTests[] = {
- TEST(testXor1),
TEST(testDiff1),
TEST(testIntersect1),
TEST(testUnion1),
+ TEST(testXor1),
+ TEST(testDiff2),
+ TEST(testIntersect2),
+ TEST(testUnion2),
+ TEST(testXor2),
};
static const size_t subTestCount = sizeof(subTests) / sizeof(subTests[0]);
+static void (*firstBinaryTest)() = testUnion2;
+
static bool skipAll = false;
static bool runBinaryTestsFirst = true;
static bool runReverse = false;
gDebugMaxWindValue = 4;
size_t index;
#endif
+ if (firstBinaryTest) {
+ index = subTestCount - 1;
+ while (index > 0 && subTests[index].fun != firstBinaryTest) {
+ --index;
+ }
+ SkDebugf(" %s [%s]\n", __FUNCTION__, subTests[index].str);
+ (*subTests[index].fun)();
+ }
if (runBinaryTestsFirst) {
index = subTestCount - 1;
do {
projects / platform / upstream / libSkiaSharp.git / commitdiff