use conics

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 149 matching lines @@
         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);
     }
 
+    SkAutoConicToQuads quadder;
+    const SkScalar conicTol = (SK_Scalar1 / 4) * (1 << shiftUp);
+
     SkPath::Iter    iter(path, true);
     SkPoint         pts[4];
     SkPath::Verb    verb;
 
     if (iclip) {
         SkRect clip;
         setShiftedClip(&clip, *iclip, shiftUp);
         SkEdgeClipper clipper;
 
         while ((verb = iter.next(pts, false)) != SkPath::kDone_Verb) {
@@ skipping 10 matching lines @@
                         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)) {
+                    const SkPoint* quadPts = quadder.computeQuads(
+                                          pts, iter.conicWeight(), conicTol);
+                    for (int i = 0; i < quadder.countQuads(); ++i) {
+                        if (clipper.clipQuad(quadPts, clip)) {
                             this->addClipper(&clipper);
                         }
+                        quadPts += 2;
                     }
                 } 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: {
                     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);
-                    for (int i = 0; i < quadCount; ++i) {
-                        handle_quad(this, &storage[i * 2]);
+                    const SkPoint* quadPts = quadder.computeQuads(
+                                          pts, iter.conicWeight(), conicTol);
+                    for (int i = 0; i < quadder.countQuads(); ++i) {
+                        handle_quad(this, quadPts);
+                        quadPts += 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();
 }