add asserts to point<-->verb helpers

src/core/SkEdgeBuilder.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkEdgeBuilder.h"
 #include "SkPath.h"
 #include "SkEdge.h"
@@ skipping 135 matching lines @@
                     SkDEBUGFAIL("unexpected verb");
                     break;
             }
         }
     }
     SkASSERT((char*)edge <= (char*)fEdgeList);
     SkASSERT(edgePtr - fEdgeList <= maxEdgeCount);
     return edgePtr - fEdgeList;
 }
 
+static void handle_quad(SkEdgeBuilder* builder, const SkPoint pts[3]) {
+    SkPoint monoX[5];
+    int n = SkChopQuadAtYExtrema(pts, monoX);
+    for (int i = 0; i <= n; i++) {
+        builder->addQuad(&monoX[i * 2]);
+    }
+}
+
 int SkEdgeBuilder::build(const SkPath& path, const SkIRect* iclip,
                          int shiftUp) {
     fAlloc.reset();
     fList.reset();
     fShiftUp = shiftUp;
 
+    SkScalar conicTol = SK_ScalarHalf * (1 << shiftUp);
+    
     if (SkPath::kLine_SegmentMask == path.getSegmentMasks()) {
         return this->buildPoly(path, iclip, shiftUp);
     }
 
     SkPath::Iter    iter(path, true);
     SkPoint         pts[4];
     SkPath::Verb    verb;
 
     if (iclip) {
         SkRect clip;
@@ skipping 13 matching lines @@
                     for (int i = 0; i < lineCount; i++) {
                         this->addLine(&lines[i]);
                     }
                     break;
                 }
                 case SkPath::kQuad_Verb:
                     if (clipper.clipQuad(pts, clip)) {
                         this->addClipper(&clipper);
                     }
                     break;
+                case SkPath::kConic_Verb: {
+                    const int MAX_POW2 = 4;
+                    const int MAX_QUADS = 1 << MAX_POW2;
+                    const int MAX_QUAD_PTS = 1 + 2 * MAX_QUADS;
+                    SkPoint storage[MAX_QUAD_PTS];
+
+                    SkConic conic;
+                    conic.set(pts, iter.conicWeight());
+                    int pow2 = conic.computeQuadPOW2(conicTol);
+                    pow2 = SkMin32(pow2, MAX_POW2);
+                    int quadCount = conic.chopIntoQuadsPOW2(storage, pow2);
+                    SkASSERT(quadCount <= MAX_QUADS);
+                    for (int i = 0; i < quadCount; ++i) {
+                        if (clipper.clipQuad(&storage[i * 2], clip)) {
+                            this->addClipper(&clipper);
+                        }
+                    }
+                } break;
                 case SkPath::kCubic_Verb:
                     if (clipper.clipCubic(pts, clip)) {
                         this->addClipper(&clipper);
                     }
                     break;
                 default:
                     SkDEBUGFAIL("unexpected verb");
                     break;
             }
         }
     } else {
         while ((verb = iter.next(pts, false)) != SkPath::kDone_Verb) {
             switch (verb) {
                 case SkPath::kMove_Verb:
                 case SkPath::kClose_Verb:
                     // we ignore these, and just get the whole segment from
                     // the corresponding line/quad/cubic verbs
                     break;
                 case SkPath::kLine_Verb:
                     this->addLine(pts);
                     break;
                 case SkPath::kQuad_Verb: {
-                    SkPoint monoX[5];
-                    int n = SkChopQuadAtYExtrema(pts, monoX);
-                    for (int i = 0; i <= n; i++) {
-                        this->addQuad(&monoX[i * 2]);
-                    }
+                    handle_quad(this, pts);
                     break;
                 }
+                case SkPath::kConic_Verb: {
+                    const int MAX_POW2 = 4;
+                    const int MAX_QUADS = 1 << MAX_POW2;
+                    const int MAX_QUAD_PTS = 1 + 2 * MAX_QUADS;
+                    SkPoint storage[MAX_QUAD_PTS];
+                    
+                    SkConic conic;
+                    conic.set(pts, iter.conicWeight());
+                    int pow2 = conic.computeQuadPOW2(conicTol);
+                    pow2 = SkMin32(pow2, MAX_POW2);
+                    int quadCount = conic.chopIntoQuadsPOW2(storage, pow2);
+                    SkASSERT(quadCount <= MAX_QUADS);
+                    SkDebugf("--- quadCount = %d\n", quadCount);
+                    for (int i = 0; i < quadCount; ++i) {
+                        handle_quad(this, &storage[i * 2]);
+                    }
+                } break;
                 case SkPath::kCubic_Verb: {
                     SkPoint monoY[10];
                     int n = SkChopCubicAtYExtrema(pts, monoY);
                     for (int i = 0; i <= n; i++) {
                         this->addCubic(&monoY[i * 3]);
                     }
                     break;
                 }
                 default:
                     SkDEBUGFAIL("unexpected verb");
                     break;
             }
         }
     }
     fEdgeList = fList.begin();
     return fList.count();
 }