Rewriting path writer

src/pathops/SkOpAngle.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkOpAngle.h"
 #include "SkOpSegment.h"
 #include "SkPathOpsCurve.h"
 #include "SkTSort.h"
@@ skipping 44 matching lines @@
                               20         |         26
                                  21      |      25
                                      22 23 24
 */
 
 // return true if lh < this < rh
 bool SkOpAngle::after(SkOpAngle* test) {
     SkOpAngle* lh = test;
     SkOpAngle* rh = lh->fNext;
     SkASSERT(lh != rh);
-    fCurvePart = fOriginalCurvePart;
-    lh->fCurvePart = lh->fOriginalCurvePart;
-    lh->fCurvePart.offset(lh->segment()->verb(), fCurvePart[0] - lh->fCurvePart[0]);
-    rh->fCurvePart = rh->fOriginalCurvePart;
-    rh->fCurvePart.offset(rh->segment()->verb(), fCurvePart[0] - rh->fCurvePart[0]);
+    fPart.fCurve = fOriginalCurvePart;
+    lh->fPart.fCurve = lh->fOriginalCurvePart;
+    lh->fPart.fCurve.offset(lh->segment()->verb(), fPart.fCurve[0] - lh->fPart.fCurve[0]);
+    rh->fPart.fCurve = rh->fOriginalCurvePart;
+    rh->fPart.fCurve.offset(rh->segment()->verb(), fPart.fCurve[0] - rh->fPart.fCurve[0]);
 
 #if DEBUG_ANGLE
     SkString bugOut;
     bugOut.printf("%s [%d/%d] %d/%d tStart=%1.9g tEnd=%1.9g"
                   " < [%d/%d] %d/%d tStart=%1.9g tEnd=%1.9g"
                   " < [%d/%d] %d/%d tStart=%1.9g tEnd=%1.9g ", __FUNCTION__,
             lh->segment()->debugID(), lh->debugID(), lh->fSectorStart, lh->fSectorEnd,
             lh->fStart->t(), lh->fEnd->t(),
             segment()->debugID(), debugID(), fSectorStart, fSectorEnd, fStart->t(), fEnd->t(),
             rh->segment()->debugID(), rh->debugID(), rh->fSectorStart, rh->fSectorEnd,
@@ skipping 90 matching lines @@
             return COMPARE_RESULT(11, trOrder);
         }
         return COMPARE_RESULT(12, ltOrder);
     }
     return COMPARE_RESULT(13, !lrOrder);
 }
 
 // given a line, see if the opposite curve's convex hull is all on one side
 // returns -1=not on one side    0=this CW of test   1=this CCW of test
 int SkOpAngle::allOnOneSide(const SkOpAngle* test) {
-    SkASSERT(!fIsCurve);
-    SkASSERT(test->fIsCurve);
-    SkDPoint origin = fCurvePart[0];
-    SkDVector line = fCurvePart[1] - origin;
+    SkASSERT(!fPart.isCurve());
+    SkASSERT(test->fPart.isCurve());
+    SkDPoint origin = fPart.fCurve[0];
+    SkDVector line = fPart.fCurve[1] - origin;
     double crosses[3];
     SkPath::Verb testVerb = test->segment()->verb();
     int iMax = SkPathOpsVerbToPoints(testVerb);
 //    SkASSERT(origin == test.fCurveHalf[0]);
-    const SkDCurve& testCurve = test->fCurvePart;
+    const SkDCurve& testCurve = test->fPart.fCurve;
     for (int index = 1; index <= iMax; ++index) {
         double xy1 = line.fX * (testCurve[index].fY - origin.fY);
         double xy2 = line.fY * (testCurve[index].fX - origin.fX);
         crosses[index - 1] = AlmostBequalUlps(xy1, xy2) ? 0 : xy1 - xy2;
     }
     if (crosses[0] * crosses[1] < 0) {
         return -1;
     }
     if (SkPath::kCubic_Verb == testVerb) {
         if (crosses[0] * crosses[2] < 0 || crosses[1] * crosses[2] < 0) {
@@ skipping 16 matching lines @@
 bool SkOpAngle::checkCrossesZero() const {
     int start = SkTMin(fSectorStart, fSectorEnd);
     int end = SkTMax(fSectorStart, fSectorEnd);
     bool crossesZero = end - start > 16;
     return crossesZero;
 }
 
 bool SkOpAngle::checkParallel(SkOpAngle* rh) {
     SkDVector scratch[2];
     const SkDVector* sweep, * tweep;
-    if (!this->fUnorderedSweep) {
-        sweep = this->fSweep;
+    if (this->fPart.isOrdered()) {
+        sweep = this->fPart.fSweep;
     } else {
-        scratch[0] = this->fCurvePart[1] - this->fCurvePart[0];
+        scratch[0] = this->fPart.fCurve[1] - this->fPart.fCurve[0];
         sweep = &scratch[0];
     }
-    if (!rh->fUnorderedSweep) {
-        tweep = rh->fSweep;
+    if (rh->fPart.isOrdered()) {
+        tweep = rh->fPart.fSweep;
     } else {
-        scratch[1] = rh->fCurvePart[1] - rh->fCurvePart[0];
+        scratch[1] = rh->fPart.fCurve[1] - rh->fPart.fCurve[0];
         tweep = &scratch[1];
     }
     double s0xt0 = sweep->crossCheck(*tweep);
     if (tangentsDiverge(rh, s0xt0)) {
         return s0xt0 < 0;
     }
     // compute the perpendicular to the endpoints and see where it intersects the opposite curve
     // if the intersections within the t range, do a cross check on those
     bool inside;
     if (!fEnd->contains(rh->fEnd)) {
         if (this->endToSide(rh, &inside)) {
             return inside;
         }
         if (rh->endToSide(this, &inside)) {
             return !inside;
         }
     }
     if (this->midToSide(rh, &inside)) {
         return inside;
     }
     if (rh->midToSide(this, &inside)) {
         return !inside;
     }
     // compute the cross check from the mid T values (last resort)
-    SkDVector m0 = segment()->dPtAtT(this->midT()) - this->fCurvePart[0];
-    SkDVector m1 = rh->segment()->dPtAtT(rh->midT()) - rh->fCurvePart[0];
+    SkDVector m0 = segment()->dPtAtT(this->midT()) - this->fPart.fCurve[0];
+    SkDVector m1 = rh->segment()->dPtAtT(rh->midT()) - rh->fPart.fCurve[0];
     double m0xm1 = m0.crossCheck(m1);
     if (m0xm1 == 0) {
         this->fUnorderable = true;
         rh->fUnorderable = true;
         return true;
     }
     return m0xm1 < 0;
 }
 
 // the original angle is too short to get meaningful sector information
@@ skipping 43 matching lines @@
     }
     SkOpSpanBase* saveEnd = fEnd;
     fComputedEnd = fEnd = computedEnd;
     setSpans();
     setSector();
     fEnd = saveEnd;
     return !fUnorderable;
 }
 
 int SkOpAngle::convexHullOverlaps(const SkOpAngle* rh) const {
-    const SkDVector* sweep = this->fSweep;
-    const SkDVector* tweep = rh->fSweep;
+    const SkDVector* sweep = this->fPart.fSweep;
+    const SkDVector* tweep = rh->fPart.fSweep;
     double s0xs1 = sweep[0].crossCheck(sweep[1]);
     double s0xt0 = sweep[0].crossCheck(tweep[0]);
     double s1xt0 = sweep[1].crossCheck(tweep[0]);
     bool tBetweenS = s0xs1 > 0 ? s0xt0 > 0 && s1xt0 < 0 : s0xt0 < 0 && s1xt0 > 0;
     double s0xt1 = sweep[0].crossCheck(tweep[1]);
     double s1xt1 = sweep[1].crossCheck(tweep[1]);
     tBetweenS |= s0xs1 > 0 ? s0xt1 > 0 && s1xt1 < 0 : s0xt1 < 0 && s1xt1 > 0;
     double t0xt1 = tweep[0].crossCheck(tweep[1]);
     if (tBetweenS) {
         return -1;
     }
     if ((s0xt0 == 0 && s1xt1 == 0) || (s1xt0 == 0 && s0xt1 == 0)) {  // s0 to s1 equals t0 to t1
         return -1;
     }
     bool sBetweenT = t0xt1 > 0 ? s0xt0 < 0 && s0xt1 > 0 : s0xt0 > 0 && s0xt1 < 0;
     sBetweenT |= t0xt1 > 0 ? s1xt0 < 0 && s1xt1 > 0 : s1xt0 > 0 && s1xt1 < 0;
     if (sBetweenT) {
         return -1;
     }
     // if all of the sweeps are in the same half plane, then the order of any pair is enough
     if (s0xt0 >= 0 && s0xt1 >= 0 && s1xt0 >= 0 && s1xt1 >= 0) {
         return 0;
     }
     if (s0xt0 <= 0 && s0xt1 <= 0 && s1xt0 <= 0 && s1xt1 <= 0) {
         return 1;
     }
     // if the outside sweeps are greater than 180 degress:
         // first assume the inital tangents are the ordering
         // if the midpoint direction matches the inital order, that is enough
-    SkDVector m0 = this->segment()->dPtAtT(this->midT()) - this->fCurvePart[0];
-    SkDVector m1 = rh->segment()->dPtAtT(rh->midT()) - rh->fCurvePart[0];
+    SkDVector m0 = this->segment()->dPtAtT(this->midT()) - this->fPart.fCurve[0];
+    SkDVector m1 = rh->segment()->dPtAtT(rh->midT()) - rh->fPart.fCurve[0];
     double m0xm1 = m0.crossCheck(m1);
     if (s0xt0 > 0 && m0xm1 > 0) {
         return 0;
     }
     if (s0xt0 < 0 && m0xm1 < 0) {
         return 1;
     }
     if (tangentsDiverge(rh, s0xt0)) {
         return s0xt0 < 0;
     }
@@ skipping 18 matching lines @@
         }
     }
     return sqrt(longest) / dist;
 }
 
 bool SkOpAngle::endsIntersect(SkOpAngle* rh) {
     SkPath::Verb lVerb = this->segment()->verb();
     SkPath::Verb rVerb = rh->segment()->verb();
     int lPts = SkPathOpsVerbToPoints(lVerb);
     int rPts = SkPathOpsVerbToPoints(rVerb);
-    SkDLine rays[] = {{{this->fCurvePart[0], rh->fCurvePart[rPts]}},
-            {{this->fCurvePart[0], this->fCurvePart[lPts]}}};
+    SkDLine rays[] = {{{this->fPart.fCurve[0], rh->fPart.fCurve[rPts]}},
+            {{this->fPart.fCurve[0], this->fPart.fCurve[lPts]}}};
     if (this->fEnd->contains(rh->fEnd)) {
         return checkParallel(rh);
     }
     double smallTs[2] = {-1, -1};
     bool limited[2] = {false, false};
     for (int index = 0; index < 2; ++index) {
         SkPath::Verb cVerb = index ? rVerb : lVerb;
         // if the curve is a line, then the line and the ray intersect only at their crossing
         if (cVerb == SkPath::kLine_Verb) {
             continue;
@@ skipping 50 matching lines @@
             sRayLonger = rayLonger;
             sCept = cept;
             sCeptT = smallTs[index];
             sIndex = index;
             break;
         }
         double delta = fabs(rayDist - endDist);
         double minX, minY, maxX, maxY;
         minX = minY = SK_ScalarInfinity;
         maxX = maxY = -SK_ScalarInfinity;
-        const SkDCurve& curve = index ? rh->fCurvePart : this->fCurvePart;
+        const SkDCurve& curve = index ? rh->fPart.fCurve : this->fPart.fCurve;
         int ptCount = index ? rPts : lPts;
         for (int idx2 = 0; idx2 <= ptCount; ++idx2) {
             minX = SkTMin(minX, curve[idx2].fX);
             minY = SkTMin(minY, curve[idx2].fY);
             maxX = SkTMax(maxX, curve[idx2].fX);
             maxY = SkTMax(maxY, curve[idx2].fY);
         }
         double maxWidth = SkTMax(maxX - minX, maxY - minY);
         delta /= maxWidth;
         if (delta > 1e-3 && (useIntersect ^= true)) {  // FIXME: move this magic number
             sRayLonger = rayLonger;
             sCept = cept;
             sCeptT = smallTs[index];
             sIndex = index;
         }
     }
     if (useIntersect) {
-        const SkDCurve& curve = sIndex ? rh->fCurvePart : this->fCurvePart;
+        const SkDCurve& curve = sIndex ? rh->fPart.fCurve : this->fPart.fCurve;
         const SkOpSegment& segment = sIndex ? *rh->segment() : *this->segment();
         double tStart = sIndex ? rh->fStart->t() : fStart->t();
         SkDVector mid = segment.dPtAtT(tStart + (sCeptT - tStart) / 2) - curve[0];
         double septDir = mid.crossCheck(sCept);
         if (!septDir) {
             return checkParallel(rh);
         }
         return sRayLonger ^ (sIndex == 0) ^ (septDir < 0);
     } else {
         return checkParallel(rh);
@@ skipping 21 matching lines @@
     }
     if (!endDist) {
         return false;
     }
     SkDPoint start;
     start.set(this->fStart->pt());
     // OPTIMIZATION: multiple times in the code we find the max scalar
     double minX, minY, maxX, maxY;
     minX = minY = SK_ScalarInfinity;
     maxX = maxY = -SK_ScalarInfinity;
-    const SkDCurve& curve = rh->fCurvePart;
+    const SkDCurve& curve = rh->fPart.fCurve;
     int oppPts = SkPathOpsVerbToPoints(oppVerb);
     for (int idx2 = 0; idx2 <= oppPts; ++idx2) {
         minX = SkTMin(minX, curve[idx2].fX);
         minY = SkTMin(minY, curve[idx2].fY);
         maxX = SkTMax(maxX, curve[idx2].fX);
         maxY = SkTMax(maxY, curve[idx2].fY);
     }
     double maxWidth = SkTMax(maxX - minX, maxY - minY);
     endDist /= maxWidth;
     if (endDist < 5e-12) {  // empirically found
@@ skipping 219 matching lines @@
     return true;
 }
 
 bool SkOpAngle::oppositePlanes(const SkOpAngle* rh) const {
     int startSpan = SkTAbs(rh->fSectorStart - fSectorStart);
     return startSpan >= 8;
 }
 
 bool SkOpAngle::orderable(SkOpAngle* rh) {
     int result;
-    if (!fIsCurve) {
-        if (!rh->fIsCurve) {
+    if (!fPart.isCurve()) {
+        if (!rh->fPart.isCurve()) {
             double leftX = fTangentHalf.dx();
             double leftY = fTangentHalf.dy();
             double rightX = rh->fTangentHalf.dx();
             double rightY = rh->fTangentHalf.dy();
             double x_ry = leftX * rightY;
             double rx_y = rightX * leftY;
             if (x_ry == rx_y) {
                 if (leftX * rightX < 0 || leftY * rightY < 0) {
                     return true;  // exactly 180 degrees apart
                 }
                 goto unorderable;
             }
             SkASSERT(x_ry != rx_y); // indicates an undetected coincidence -- worth finding earlier
             return x_ry < rx_y;
         }
         if ((result = this->allOnOneSide(rh)) >= 0) {
             return result;
         }
         if (fUnorderable || approximately_zero(rh->fSide)) {
             goto unorderable;
         }
-    } else if (!rh->fIsCurve) {
+    } else if (!rh->fPart.isCurve()) {
         if ((result = rh->allOnOneSide(this)) >= 0) {
             return !result;
         }
         if (rh->fUnorderable || approximately_zero(fSide)) {
             goto unorderable;
         }
     } else if ((result = this->convexHullOverlaps(rh)) >= 0) {
         return result;
     }
     return this->endsIntersect(rh);
@@ skipping 24 matching lines @@
     fStart = start;
     fComputedEnd = fEnd = end;
     SkASSERT(start != end);
     fNext = nullptr;
     fComputeSector = fComputedSector = fCheckCoincidence = false;
     setSpans();
     setSector();
     SkDEBUGCODE(fID = start ? start->globalState()->nextAngleID() : -1);
 }
 
-void SkOpAngle::setCurveHullSweep() {
-    fUnorderedSweep = false;
-    fSweep[0] = fCurvePart[1] - fCurvePart[0];
-    const SkOpSegment* segment = fStart->segment();
-    if (SkPath::kLine_Verb == segment->verb()) {
-        fSweep[1] = fSweep[0];
-        return;
-    }
-    fSweep[1] = fCurvePart[2] - fCurvePart[0];
-    // OPTIMIZE: I do the following float check a lot -- probably need a
-    // central place for this val-is-small-compared-to-curve check
-    double maxVal = 0;
-    for (int index = 0; index < SkPathOpsVerbToPoints(segment->verb()); ++index) {
-        maxVal = SkTMax(maxVal, SkTMax(SkTAbs(fCurvePart[index].fX),
-                SkTAbs(fCurvePart[index].fY)));
-    }
-
-    if (SkPath::kCubic_Verb != segment->verb()) {
-        if (roughly_zero_when_compared_to(fSweep[0].fX, maxVal)
-                && roughly_zero_when_compared_to(fSweep[0].fY, maxVal)) {
-            fSweep[0] = fSweep[1];
-        }
-        return;
-    }
-    SkDVector thirdSweep = fCurvePart[3] - fCurvePart[0];
-    if (fSweep[0].fX == 0 && fSweep[0].fY == 0) {
-        fSweep[0] = fSweep[1];
-        fSweep[1] = thirdSweep;
-        if (roughly_zero_when_compared_to(fSweep[0].fX, maxVal)
-                && roughly_zero_when_compared_to(fSweep[0].fY, maxVal)) {
-            fSweep[0] = fSweep[1];
-            fCurvePart[1] = fCurvePart[3];
-            fIsCurve = false;
-        }
-        return;
-    }
-    double s1x3 = fSweep[0].crossCheck(thirdSweep);
-    double s3x2 = thirdSweep.crossCheck(fSweep[1]);
-    if (s1x3 * s3x2 >= 0) {  // if third vector is on or between first two vectors
-        return;
-    }
-    double s2x1 = fSweep[1].crossCheck(fSweep[0]);
-    // FIXME: If the sweep of the cubic is greater than 180 degrees, we're in trouble
-    // probably such wide sweeps should be artificially subdivided earlier so that never happens
-    SkASSERT(s1x3 * s2x1 < 0 || s1x3 * s3x2 < 0);
-    if (s3x2 * s2x1 < 0) {
-        SkASSERT(s2x1 * s1x3 > 0);
-        fSweep[0] = fSweep[1];
-        fUnorderedSweep = true;
-    }
-    fSweep[1] = thirdSweep;
-}
-
 void SkOpAngle::setSpans() {
     fUnorderable = false;
     fLastMarked = nullptr;
     if (!fStart) {
         fUnorderable = true;
         return;
     }
     const SkOpSegment* segment = fStart->segment();
     const SkPoint* pts = segment->pts();
-    SkDEBUGCODE(fCurvePart.fVerb = SkPath::kCubic_Verb);
-    SkDEBUGCODE(fCurvePart[2].fX = fCurvePart[2].fY = fCurvePart[3].fX = fCurvePart[3].fY
+    SkDEBUGCODE(fPart.fCurve.fVerb = SkPath::kCubic_Verb);
+    SkDEBUGCODE(fPart.fCurve[2].fX = fPart.fCurve[2].fY = fPart.fCurve[3].fX = fPart.fCurve[3].fY
             = SK_ScalarNaN);
-    SkDEBUGCODE(fCurvePart.fVerb = segment->verb());
-    segment->subDivide(fStart, fEnd, &fCurvePart);
-    fOriginalCurvePart = fCurvePart;
-    setCurveHullSweep();
+    SkDEBUGCODE(fPart.fCurve.fVerb = segment->verb());
+    segment->subDivide(fStart, fEnd, &fPart.fCurve);
+    fOriginalCurvePart = fPart.fCurve;
     const SkPath::Verb verb = segment->verb();
-    if (verb != SkPath::kLine_Verb
-            && !(fIsCurve = fSweep[0].crossCheck(fSweep[1]) != 0)) {
+    fPart.setCurveHullSweep(verb);
+    if (SkPath::kLine_Verb != verb && !fPart.isCurve()) {
         SkDLine lineHalf;
-        fCurvePart[1] = fCurvePart[SkPathOpsVerbToPoints(verb)];
-        fOriginalCurvePart[1] = fCurvePart[1];
-        lineHalf[0].set(fCurvePart[0].asSkPoint());
-        lineHalf[1].set(fCurvePart[1].asSkPoint());
+        fPart.fCurve[1] = fPart.fCurve[SkPathOpsVerbToPoints(verb)];
+        fOriginalCurvePart[1] = fPart.fCurve[1];
+        lineHalf[0].set(fPart.fCurve[0].asSkPoint());
+        lineHalf[1].set(fPart.fCurve[1].asSkPoint());
         fTangentHalf.lineEndPoints(lineHalf);
         fSide = 0;
     }
     switch (verb) {
     case SkPath::kLine_Verb: {
         SkASSERT(fStart != fEnd);
         const SkPoint& cP1 = pts[fStart->t() < fEnd->t()];
         SkDLine lineHalf;
         lineHalf[0].set(fStart->pt());
         lineHalf[1].set(cP1);
         fTangentHalf.lineEndPoints(lineHalf);
         fSide = 0;
-        fIsCurve = false;
         } return;
     case SkPath::kQuad_Verb:
     case SkPath::kConic_Verb: {
         SkLineParameters tangentPart;
-        (void) tangentPart.quadEndPoints(fCurvePart.fQuad);
-        fSide = -tangentPart.pointDistance(fCurvePart[2]);  // not normalized -- compare sign only
+        (void) tangentPart.quadEndPoints(fPart.fCurve.fQuad);
+        fSide = -tangentPart.pointDistance(fPart.fCurve[2]);  // not normalized -- compare sign only
         } break;
     case SkPath::kCubic_Verb: {
         SkLineParameters tangentPart;
-        (void) tangentPart.cubicPart(fCurvePart.fCubic);
-        fSide = -tangentPart.pointDistance(fCurvePart[3]);
+        (void) tangentPart.cubicPart(fPart.fCurve.fCubic);
+        fSide = -tangentPart.pointDistance(fPart.fCurve[3]);
         double testTs[4];
         // OPTIMIZATION: keep inflections precomputed with cubic segment?
         int testCount = SkDCubic::FindInflections(pts, testTs);
         double startT = fStart->t();
         double endT = fEnd->t();
         double limitT = endT;
         int index;
         for (index = 0; index < testCount; ++index) {
             if (!::between(startT, testTs[index], limitT)) {
                 testTs[index] = -1;
@@ skipping 11 matching lines @@
         index <<= 1;
         for (; index < testCases; ++index) {
             int testIndex = index >> 1;
             double testT = testTs[testIndex];
             if (index & 1) {
                 testT = (testT + testTs[testIndex + 1]) / 2;
             }
             // OPTIMIZE: could avoid call for t == startT, endT
             SkDPoint pt = dcubic_xy_at_t(pts, segment->weight(), testT);
             SkLineParameters tangentPart;
-            tangentPart.cubicEndPoints(fCurvePart.fCubic);
+            tangentPart.cubicEndPoints(fPart.fCurve.fCubic);
             double testSide = tangentPart.pointDistance(pt);
             if (fabs(bestSide) < fabs(testSide)) {
                 bestSide = testSide;
             }
         }
         fSide = -bestSide;  // compare sign only
         } break;
     default:
         SkASSERT(0);
     }
 }
 
 void SkOpAngle::setSector() {
     if (!fStart) {
         fUnorderable = true;
         return;
     }
     const SkOpSegment* segment = fStart->segment();
     SkPath::Verb verb = segment->verb();
-    fSectorStart = this->findSector(verb, fSweep[0].fX, fSweep[0].fY);
+    fSectorStart = this->findSector(verb, fPart.fSweep[0].fX, fPart.fSweep[0].fY);
     if (fSectorStart < 0) {
         goto deferTilLater;
     }
-    if (!fIsCurve) {  // if it's a line or line-like, note that both sectors are the same
+    if (!fPart.isCurve()) {  // if it's a line or line-like, note that both sectors are the same
         SkASSERT(fSectorStart >= 0);
         fSectorEnd = fSectorStart;
         fSectorMask = 1 << fSectorStart;
         return;
     }
     SkASSERT(SkPath::kLine_Verb != verb);
-    fSectorEnd = this->findSector(verb, fSweep[1].fX, fSweep[1].fY);
+    fSectorEnd = this->findSector(verb, fPart.fSweep[1].fX, fPart.fSweep[1].fY);
     if (fSectorEnd < 0) {
 deferTilLater:
         fSectorStart = fSectorEnd = -1;
         fSectorMask = 0;
         fComputeSector = true;  // can't determine sector until segment length can be found
         return;
     }
     if (fSectorEnd == fSectorStart
             && (fSectorStart & 3) != 3) { // if the sector has no span, it can't be an exact angle
         fSectorMask = 1 << fSectorStart;
@@ skipping 29 matching lines @@
     }
     // if the ctrl tangents are not nearly parallel, use them
     // solve for opposite direction displacement scale factor == m
     // initial dir = v1.cross(v2) == v2.x * v1.y - v2.y * v1.x
     // displacement of q1[1] : dq1 = { -m * v1.y, m * v1.x } + q1[1]
     // straight angle when : v2.x * (dq1.y - q1[0].y) == v2.y * (dq1.x - q1[0].x)
     //                       v2.x * (m * v1.x + v1.y) == v2.y * (-m * v1.y + v1.x)
     // - m * (v2.x * v1.x + v2.y * v1.y) == v2.x * v1.y - v2.y * v1.x
     // m = (v2.y * v1.x - v2.x * v1.y) / (v2.x * v1.x + v2.y * v1.y)
     // m = v1.cross(v2) / v1.dot(v2)
-    const SkDVector* sweep = fSweep;
-    const SkDVector* tweep = rh->fSweep;
+    const SkDVector* sweep = fPart.fSweep;
+    const SkDVector* tweep = rh->fPart.fSweep;
     double s0dt0 = sweep[0].dot(tweep[0]);
     if (!s0dt0) {
         return true;
     }
     SkASSERT(s0dt0 != 0);
     double m = s0xt0 / s0dt0;
     double sDist = sweep[0].length() * m;
     double tDist = tweep[0].length() * m;
     bool useS = fabs(sDist) < fabs(tDist);
     double mFactor = fabs(useS ? this->distEndRatio(sDist) : rh->distEndRatio(tDist));
     return mFactor < 50;   // empirically found limit
 }