add conics to path ops

src/pathops/SkOpEdgeBuilder.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 "SkGeometry.h"
 #include "SkOpEdgeBuilder.h"
 #include "SkReduceOrder.h"
 
@@ skipping 96 matching lines @@
             case SkPath::kQuad_Verb:
                 force_small_to_zero(&pts[1]);
                 force_small_to_zero(&pts[2]);
                 curve[1] = pts[1];
                 curve[2] = pts[2];
                 verb = SkReduceOrder::Quad(curve, pts);
                 if (verb == SkPath::kMove_Verb) {
                     continue;  // skip degenerate points
                 }
                 break;
-            case SkPath::kConic_Verb: {
+            case SkPath::kConic_Verb:
+                if (true) {

[reed1, 2015/04/15 20:06:24]

do we need to keep the "else" code?

+                    force_small_to_zero(&pts[1]);
+                    force_small_to_zero(&pts[2]);
+                    curve[1] = pts[1];
+                    curve[2] = pts[2];
+                    verb = SkReduceOrder::Conic(curve, iter.conicWeight(), pts);
+                    if (verb == SkPath::kMove_Verb) {
+                        continue;  // skip degenerate points
+                    }
+                    break;
+                } else {
                     const SkPoint* quadPts = quadder.computeQuads(pts, iter.conicWeight(),
                             quadderTol);
                     const int nQuads = quadder.countQuads();
                     for (int i = 0; i < nQuads; ++i) {
                        *fPathVerbs.append() = SkPath::kQuad_Verb;
                     }
                     fPathPts.append(nQuads * 2, &quadPts[1]);
                     curve[0] = pts[2];
                     lastCurve = true;
+                    verb = SkPath::kQuad_Verb;
+                    continue;
                 }
-                continue;
             case SkPath::kCubic_Verb:
                 force_small_to_zero(&pts[1]);
                 force_small_to_zero(&pts[2]);
                 force_small_to_zero(&pts[3]);
                 curve[1] = pts[1];
                 curve[2] = pts[2];
                 curve[3] = pts[3];
                 verb = SkReduceOrder::Cubic(curve, pts);
                 if (verb == SkPath::kMove_Verb) {
                     continue;  // skip degenerate points
                 }
                 break;
             case SkPath::kClose_Verb:
                 closeContour(curve[0], curveStart);
                 lastCurve = false;
                 continue;
             case SkPath::kDone_Verb:
                 continue;
         }
         *fPathVerbs.append() = verb;
         int ptCount = SkPathOpsVerbToPoints(verb);
         fPathPts.append(ptCount, &pts[1]);
+        if (verb == SkPath::kConic_Verb) {
+            *fWeights.append() = iter.conicWeight();
+        }
         curve[0] = pts[ptCount];
         lastCurve = true;
     } while (verb != SkPath::kDone_Verb);
     if (!fAllowOpenContours && lastCurve) {
         closeContour(curve[0], curveStart);
     }
     *fPathVerbs.append() = SkPath::kDone_Verb;
     return fPathVerbs.count() - 1;
 }
 
 bool SkOpEdgeBuilder::close() {
     complete();
     return true;
 }
 
 bool SkOpEdgeBuilder::walk(SkChunkAlloc* allocator) {
     uint8_t* verbPtr = fPathVerbs.begin();
     uint8_t* endOfFirstHalf = &verbPtr[fSecondHalf];
     SkPoint* pointsPtr = fPathPts.begin() - 1;
+    SkScalar* weightPtr = fWeights.begin();
     SkPath::Verb verb;
     while ((verb = (SkPath::Verb) *verbPtr) != SkPath::kDone_Verb) {
         if (verbPtr == endOfFirstHalf) {
             fOperand = true;
         }
         verbPtr++;
         switch (verb) {
             case SkPath::kMove_Verb:
                 if (fCurrentContour && fCurrentContour->count()) {
                     if (fAllowOpenContours) {
                         complete();
                     } else if (!close()) {
                         return false;
                     }
                 }
                 if (!fCurrentContour) {
                     fCurrentContour = fContoursHead->appendContour(allocator);
                 }
                 fCurrentContour->init(fGlobalState, fOperand,
                     fXorMask[fOperand] == kEvenOdd_PathOpsMask);
                 pointsPtr += 1;
                 continue;
             case SkPath::kLine_Verb:
                 fCurrentContour->addLine(pointsPtr, fAllocator);
                 break;
             case SkPath::kQuad_Verb:
                 fCurrentContour->addQuad(pointsPtr, fAllocator);
                 break;
+            case SkPath::kConic_Verb:
+                fCurrentContour->addConic(pointsPtr, *weightPtr++, fAllocator);
+                break;
             case SkPath::kCubic_Verb: {
                 // split self-intersecting cubics in two before proceeding
                 // if the cubic is convex, it doesn't self intersect.
                 SkScalar loopT;
                 if (SkDCubic::ComplexBreak(pointsPtr, &loopT)) {
                     SkPoint cubicPair[7]; 
                     SkChopCubicAt(pointsPtr, cubicPair, loopT);
                     SkPoint cStorage[2][4];
                     SkPath::Verb v1 = SkReduceOrder::Cubic(&cubicPair[0], cStorage[0]);
                     SkPath::Verb v2 = SkReduceOrder::Cubic(&cubicPair[3], cStorage[1]);
@@ skipping 27 matching lines @@
         }
         SkASSERT(fCurrentContour);
         fCurrentContour->debugValidate();
         pointsPtr += SkPathOpsVerbToPoints(verb);
     }
    if (fCurrentContour && fCurrentContour->count() &&!fAllowOpenContours && !close()) {
        return false;
    }
    return true;
 }