add conics to path ops

src/pathops/SkOpAngle.cpp

Index: src/pathops/SkOpAngle.cpp
diff --git a/src/pathops/SkOpAngle.cpp b/src/pathops/SkOpAngle.cpp
index c13a51a8cca39c6da63b725ba747c30a11648597..619421a3f7f74cb13961735f1b86912b189aebe9 100644
--- a/src/pathops/SkOpAngle.cpp
+++ b/src/pathops/SkOpAngle.cpp
@@ -189,7 +189,7 @@ int SkOpAngle::allOnOneSide(const SkOpAngle* test) {
     SkPath::Verb testVerb = test->segment()->verb();
     int iMax = SkPathOpsVerbToPoints(testVerb);
 //    SkASSERT(origin == test.fCurveHalf[0]);
-    const SkDCubic& testCurve = test->fCurvePart;
+    const SkDCurve& testCurve = test->fCurvePart;
     for (int index = 1; index <= iMax; ++index) {
         float xy1 = (float) (line.fX * (testCurve[index].fY - origin.fY));
         float xy2 = (float) (line.fY * (testCurve[index].fX - origin.fX));
@@ -445,14 +445,14 @@ bool SkOpAngle::endsIntersect(SkOpAngle* rh) {
     double smallTs[2] = {-1, -1};
     bool limited[2] = {false, false};
     for (int index = 0; index < 2; ++index) {
-        int cPts = index ? rPts : lPts;
+        SkPath::Verb cVerb = index ? rVerb : lVerb;
         // if the curve is a line, then the line and the ray intersect only at their crossing
-        if (cPts == 1) { // line
+        if (cVerb == SkPath::kLine_Verb) {
             continue;
         }
         const SkOpSegment& segment = index ? *rh->segment() : *this->segment();
         SkIntersections i;
-        (*CurveIntersectRay[cPts])(segment.pts(), rays[index], &i);
+        (*CurveIntersectRay[cVerb])(segment.pts(), segment.weight(), rays[index], &i);
         double tStart = index ? rh->fStart->t() : this->fStart->t();
         double tEnd = index ? rh->fComputedEnd->t() : this->fComputedEnd->t();
         bool testAscends = tStart < (index ? rh->fComputedEnd->t() : this->fComputedEnd->t());
@@ -509,7 +509,7 @@ bool SkOpAngle::endsIntersect(SkOpAngle* rh) {
         double minX, minY, maxX, maxY;
         minX = minY = SK_ScalarInfinity;
         maxX = maxY = -SK_ScalarInfinity;
-        const SkDCubic& curve = index ? rh->fCurvePart : this->fCurvePart;
+        const SkDCurve& curve = index ? rh->fCurvePart : this->fCurvePart;
         int ptCount = index ? rPts : lPts;
         for (int idx2 = 0; idx2 <= ptCount; ++idx2) {
             minX = SkTMin(minX, curve[idx2].fX);
@@ -527,7 +527,7 @@ bool SkOpAngle::endsIntersect(SkOpAngle* rh) {
         }
     }
     if (useIntersect) {
-        const SkDCubic& curve = sIndex ? rh->fCurvePart : this->fCurvePart;
+        const SkDCurve& curve = sIndex ? rh->fCurvePart : this->fCurvePart;
         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];
@@ -544,18 +544,17 @@ bool SkOpAngle::endsIntersect(SkOpAngle* rh) {
 bool SkOpAngle::endToSide(const SkOpAngle* rh, bool* inside) const {
     const SkOpSegment* segment = this->segment();
     SkPath::Verb verb = segment->verb();
-    int pts = SkPathOpsVerbToPoints(verb);
     SkDLine rayEnd;
     rayEnd[0].set(this->fEnd->pt());
     rayEnd[1] = rayEnd[0];
-    SkDVector slopeAtEnd = (*CurveDSlopeAtT[pts])(segment->pts(), this->fEnd->t());
+    SkDVector slopeAtEnd = (*CurveDSlopeAtT[verb])(segment->pts(), segment->weight(),
+            this->fEnd->t());
     rayEnd[1].fX += slopeAtEnd.fY;
     rayEnd[1].fY -= slopeAtEnd.fX;
     SkIntersections iEnd;
     const SkOpSegment* oppSegment = rh->segment();
     SkPath::Verb oppVerb = oppSegment->verb();
-    int oppPts = SkPathOpsVerbToPoints(oppVerb);
-    (*CurveIntersectRay[oppPts])(oppSegment->pts(), rayEnd, &iEnd);
+    (*CurveIntersectRay[oppVerb])(oppSegment->pts(), oppSegment->weight(), rayEnd, &iEnd);
     double endDist;
     int closestEnd = iEnd.closestTo(rh->fStart->t(), rh->fEnd->t(), rayEnd[0], &endDist);
     if (closestEnd < 0) {
@@ -570,7 +569,8 @@ bool SkOpAngle::endToSide(const SkOpAngle* rh, bool* inside) const {
     double minX, minY, maxX, maxY;
     minX = minY = SK_ScalarInfinity;
     maxX = maxY = -SK_ScalarInfinity;
-    const SkDCubic& curve = rh->fCurvePart;
+    const SkDCurve& curve = rh->fCurvePart;
+    int oppPts = SkPathOpsVerbToPoints(oppVerb);
     for (int idx2 = 0; idx2 <= oppPts; ++idx2) {
         minX = SkTMin(minX, curve[idx2].fX);
         minY = SkTMin(minY, curve[idx2].fY);
@@ -857,7 +857,6 @@ double SkOpAngle::midT() const {
 bool SkOpAngle::midToSide(const SkOpAngle* rh, bool* inside) const {
     const SkOpSegment* segment = this->segment();
     SkPath::Verb verb = segment->verb();
-    int pts = SkPathOpsVerbToPoints(verb);
     const SkPoint& startPt = this->fStart->pt();
     const SkPoint& endPt = this->fEnd->pt();
     SkDPoint dStartPt;
@@ -868,16 +867,15 @@ bool SkOpAngle::midToSide(const SkOpAngle* rh, bool* inside) const {
     rayMid[1].fX = rayMid[0].fX + (endPt.fY - startPt.fY);
     rayMid[1].fY = rayMid[0].fY - (endPt.fX - startPt.fX);
     SkIntersections iMid;
-    (*CurveIntersectRay[pts])(segment->pts(), rayMid, &iMid);
+    (*CurveIntersectRay[verb])(segment->pts(), segment->weight(), rayMid, &iMid);
     int iOutside = iMid.mostOutside(this->fStart->t(), this->fEnd->t(), dStartPt);
     if (iOutside < 0) {
         return false;
     }
     const SkOpSegment* oppSegment = rh->segment();
     SkPath::Verb oppVerb = oppSegment->verb();
-    int oppPts = SkPathOpsVerbToPoints(oppVerb);
     SkIntersections oppMid;
-    (*CurveIntersectRay[oppPts])(oppSegment->pts(), rayMid, &oppMid);
+    (*CurveIntersectRay[oppVerb])(oppSegment->pts(), oppSegment->weight(), rayMid, &oppMid);
     int oppOutside = oppMid.mostOutside(rh->fStart->t(), rh->fEnd->t(), dStartPt);
     if (oppOutside < 0) {
         return false;
@@ -966,7 +964,7 @@ void SkOpAngle::set(SkOpSpanBase* start, SkOpSpanBase* end) {
     fStop = false;
     setSpans();
     setSector();
-    PATH_OPS_DEBUG_CODE(fID = start->globalState()->nextAngleID());
+    SkDEBUGCODE(fID = start->globalState()->nextAngleID());
 }
 
 void SkOpAngle::setCurveHullSweep() {
@@ -1017,8 +1015,10 @@ void SkOpAngle::setSpans() {
     fLastMarked = NULL;
     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
             = SK_ScalarNaN);
+    SkDEBUGCODE(fCurvePart.fVerb = segment->verb());
     segment->subDivide(fStart, fEnd, &fCurvePart);
     setCurveHullSweep();
     const SkPath::Verb verb = segment->verb();
@@ -1041,15 +1041,15 @@ void SkOpAngle::setSpans() {
         fSide = 0;
         fIsCurve = false;
         } return;
-    case SkPath::kQuad_Verb: {
+    case SkPath::kQuad_Verb:
+    case SkPath::kConic_Verb: {
         SkLineParameters tangentPart;
-        SkDQuad& quad2 = *SkTCast<SkDQuad*>(&fCurvePart);
-        (void) tangentPart.quadEndPoints(quad2);
+        (void) tangentPart.quadEndPoints(fCurvePart.fQuad);
         fSide = -tangentPart.pointDistance(fCurvePart[2]);  // not normalized -- compare sign only
         } break;
     case SkPath::kCubic_Verb: {
         SkLineParameters tangentPart;
-        (void) tangentPart.cubicPart(fCurvePart);
+        (void) tangentPart.cubicPart(fCurvePart.fCubic);
         fSide = -tangentPart.pointDistance(fCurvePart[3]);
         double testTs[4];
         // OPTIMIZATION: keep inflections precomputed with cubic segment?
@@ -1080,9 +1080,9 @@ void SkOpAngle::setSpans() {
                 testT = (testT + testTs[testIndex + 1]) / 2;
             }
             // OPTIMIZE: could avoid call for t == startT, endT
-            SkDPoint pt = dcubic_xy_at_t(pts, testT);
+            SkDPoint pt = dcubic_xy_at_t(pts, segment->weight(), testT);
             SkLineParameters tangentPart;
-            tangentPart.cubicEndPoints(fCurvePart);
+            tangentPart.cubicEndPoints(fCurvePart.fCubic);
             double testSide = tangentPart.pointDistance(pt);
             if (fabs(bestSide) < fabs(testSide)) {
                 bestSide = testSide;