add conics to path ops

src/pathops/SkOpSegment.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef SkOpSegment_DEFINE
 #define SkOpSegment_DEFINE
 
 #include "SkOpAngle.h"
 #include "SkOpSpan.h"
 #include "SkOpTAllocator.h"
 #include "SkPathOpsBounds.h"
 #include "SkPathOpsCurve.h"
 
+struct SkDCurve;
 class SkOpCoincidence;
 class SkOpContour;
 class SkPathWriter;
 
 class SkOpSegment {
 public:
     enum AllowAlias {
         kAllowAlias,
         kNoAlias
     };
@@ skipping 11 matching lines @@
     bool activeOp(SkOpSpanBase* start, SkOpSpanBase* end, int xorMiMask, int xorSuMask,
                   SkPathOp op);
     bool activeOp(int xorMiMask, int xorSuMask, SkOpSpanBase* start, SkOpSpanBase* end, SkPathOp op,
                   int* sumMiWinding, int* sumSuWinding);
 
     SkPoint activeLeftTop(SkOpSpanBase** firstT);
 
     bool activeWinding(SkOpSpanBase* start, SkOpSpanBase* end);
     bool activeWinding(SkOpSpanBase* start, SkOpSpanBase* end, int* sumWinding);
 
+    void addConic(SkPoint pts[3], SkScalar weight, SkOpContour* parent) {
+        init(pts, weight, parent, SkPath::kConic_Verb);
+        fBounds.setConicBounds(pts, weight);
+    }
+
     void addCubic(SkPoint pts[4], SkOpContour* parent) {
-        init(pts, parent, SkPath::kCubic_Verb);
-        fBounds.setCubicBounds(pts);
+        init(pts, 1, parent, SkPath::kCubic_Verb);
+        fBounds.setCubicBounds(pts, 1);
     }
 
     void addCurveTo(const SkOpSpanBase* start, const SkOpSpanBase* end, SkPathWriter* path,
                     bool active) const;
 
     SkOpAngle* addEndSpan(SkChunkAlloc* allocator) {
         SkOpAngle* angle = SkOpTAllocator<SkOpAngle>::Allocate(allocator);
         angle->set(&fTail, fTail.prev());
         fTail.setFromAngle(angle);
         return angle;
     }
 
     void addLine(SkPoint pts[2], SkOpContour* parent) {
-        init(pts, parent, SkPath::kLine_Verb);
+        init(pts, 1, parent, SkPath::kLine_Verb);
         fBounds.set(pts, 2);
     }
 
     SkOpPtT* addMissing(double t, SkOpSegment* opp, SkChunkAlloc* );
     SkOpAngle* addSingletonAngleDown(SkOpSegment** otherPtr, SkOpAngle** , SkChunkAlloc* );
     SkOpAngle* addSingletonAngles(int step, SkChunkAlloc* );
     SkOpAngle* addSingletonAngleUp(SkOpSegment** otherPtr, SkOpAngle** , SkChunkAlloc* );
 
     SkOpAngle* addStartSpan(SkChunkAlloc* allocator) {
         SkOpAngle* angle = SkOpTAllocator<SkOpAngle>::Allocate(allocator);
         angle->set(&fHead, fHead.next());
         fHead.setToAngle(angle);
         return angle;
     }
 
     void addQuad(SkPoint pts[3], SkOpContour* parent) {
-        init(pts, parent, SkPath::kQuad_Verb);
-        fBounds.setQuadBounds(pts);
+        init(pts, 1, parent, SkPath::kQuad_Verb);
+        fBounds.setQuadBounds(pts, 1);
     }
 
     SkOpPtT* addT(double t, AllowAlias , SkChunkAlloc* );
 
     void align();
     static bool BetweenTs(const SkOpSpanBase* lesser, double testT, const SkOpSpanBase* greater);
 
     const SkPathOpsBounds& bounds() const {
         return fBounds;
     }
@@ skipping 21 matching lines @@
     }
 
     SkOpSpan* crossedSpanY(const SkPoint& basePt, double mid, bool opp, bool current,
                             SkScalar* bestY, double* hitT, bool* hitSomething, bool* vertical);
 
     void debugAddAngle(double startT, double endT, SkChunkAlloc*);
     const SkOpAngle* debugAngle(int id) const;
     SkOpContour* debugContour(int id);
 
     int debugID() const {
-        return PATH_OPS_DEBUG_RELEASE(fID, -1);
+        return SkDEBUGRELEASE(fID, -1);
     }
 
 #if DEBUG_SWAP_TOP
     int debugInflections(const SkOpSpanBase* start, const SkOpSpanBase* end) const;
 #endif
 
     SkOpAngle* debugLastAngle();
     const SkOpPtT* debugPtT(int id) const;
     void debugReset();
     const SkOpSegment* debugSegment(int id) const;
@@ skipping 14 matching lines @@
     bool done() const {
         SkASSERT(fDoneCount <= fCount);
         return fDoneCount == fCount;
     }
 
     bool done(const SkOpAngle* angle) const {
         return angle->start()->starter(angle->end())->done();
     }
 
     SkDPoint dPtAtT(double mid) const {
-        return (*CurveDPointAtT[SkPathOpsVerbToPoints(fVerb)])(fPts, mid);
+        return (*CurveDPointAtT[fVerb])(fPts, fWeight, mid);
     }
 
     SkDVector dSlopeAtT(double mid) const {
-        return (*CurveDSlopeAtT[SkPathOpsVerbToPoints(fVerb)])(fPts, mid);
+        return (*CurveDSlopeAtT[fVerb])(fPts, fWeight, mid);
     }
 
     void dump() const;
     void dumpAll() const;
     void dumpAngles() const;
     void dumpCoin() const;
     void dumpPts() const;
 
     SkOpSegment* findNextOp(SkTDArray<SkOpSpanBase*>* chase, SkOpSpanBase** nextStart,
                              SkOpSpanBase** nextEnd, bool* unsortable, SkPathOp op,
                              int xorMiMask, int xorSuMask);
     SkOpSegment* findNextWinding(SkTDArray<SkOpSpanBase*>* chase, SkOpSpanBase** nextStart,
                                   SkOpSpanBase** nextEnd, bool* unsortable);
     SkOpSegment* findNextXor(SkOpSpanBase** nextStart, SkOpSpanBase** nextEnd, bool* unsortable);
     SkOpSegment* findTop(bool firstPass, SkOpSpanBase** startPtr, SkOpSpanBase** endPtr,
                           bool* unsortable, SkChunkAlloc* );
     SkOpGlobalState* globalState() const;
 
     const SkOpSpan* head() const {
         return &fHead;
     }
 
     SkOpSpan* head() {
         return &fHead;
     }
 
-    void init(SkPoint pts[], SkOpContour* parent, SkPath::Verb verb);
+    void init(SkPoint pts[], SkScalar weight, SkOpContour* parent, SkPath::Verb verb);
     void initWinding(SkOpSpanBase* start, SkOpSpanBase* end,
                      SkOpAngle::IncludeType angleIncludeType);
     bool initWinding(SkOpSpanBase* start, SkOpSpanBase* end, double tHit, int winding,
             SkScalar hitDx, int oppWind, SkScalar hitOppDx);
 
     SkOpSpan* insert(SkOpSpan* prev, SkChunkAlloc* allocator) {
         SkOpSpan* result = SkOpTAllocator<SkOpSpan>::Allocate(allocator);
         SkOpSpanBase* next = prev->next();
         result->setPrev(prev);
         prev->setNext(result);
@@ skipping 13 matching lines @@
 
     SkOpSegment* isSimple(SkOpSpanBase** end, int* step) {
         return nextChase(end, step, NULL, NULL);
     }
 
     bool isVertical() const {
         return fBounds.fLeft == fBounds.fRight;
     }
 
     bool isVertical(SkOpSpanBase* start, SkOpSpanBase* end) const {
-        return (*CurveIsVertical[SkPathOpsVerbToPoints(fVerb)])(fPts, start->t(), end->t());
+        return (*CurveIsVertical[fVerb])(fPts, fWeight, start->t(), end->t());
     }
 
     bool isXor() const;
 
     const SkPoint& lastPt() const {
         return fPts[SkPathOpsVerbToPoints(fVerb)];
     }
 
     SkOpSpanBase* markAndChaseDone(SkOpSpanBase* start, SkOpSpanBase* end);
     bool markAndChaseWinding(SkOpSpanBase* start, SkOpSpanBase* end, int winding,
@@ skipping 25 matching lines @@
         return result;
     }
 
     bool oppXor() const;
 
     const SkOpSegment* prev() const {
         return fPrev;
     }
 
     SkPoint ptAtT(double mid) const {
-        return (*CurvePointAtT[SkPathOpsVerbToPoints(fVerb)])(fPts, mid);
+        return (*CurvePointAtT[fVerb])(fPts, fWeight, mid);
     }
 
     const SkPoint* pts() const {
         return fPts;
     }
 
     bool ptsDisjoint(const SkOpPtT& span, const SkOpPtT& test) const {
         return ptsDisjoint(span.fT, span.fPt, test.fT, test.fPt);
     }
 
@@ skipping 42 matching lines @@
         int result = start->t() < end->t() ? -start->upCast()->windValue()
                 : end->upCast()->windValue();
         return result;
     }
 
     SkOpAngle* spanToAngle(SkOpSpanBase* start, SkOpSpanBase* end) {
         SkASSERT(start != end);
         return start->t() < end->t() ? start->upCast()->toAngle() : start->fromAngle();
     }
 
-    bool subDivide(const SkOpSpanBase* start, const SkOpSpanBase* end, SkPoint edge[4]) const;
-    bool subDivide(const SkOpSpanBase* start, const SkOpSpanBase* end, SkDCubic* result) const;
+    bool subDivide(const SkOpSpanBase* start, const SkOpSpanBase* end, SkDCurve* result) const;
+    bool subDivide(const SkOpSpanBase* start, const SkOpSpanBase* end, SkOpCurve* result) const;
     void subDivideBounds(const SkOpSpanBase* start, const SkOpSpanBase* end,
                          SkPathOpsBounds* bounds) const;
 
     const SkOpSpanBase* tail() const {
         return &fTail;
     }
 
     SkOpSpanBase* tail() {
         return &fTail;
     }
 
     static double TAtMid(const SkOpSpanBase* start, const SkOpSpanBase* end, double mid) {
         return start->t() * (1 - mid) + end->t() * mid;
     }
 
     void undoneSpan(SkOpSpanBase** start, SkOpSpanBase** end);
     int updateOppWinding(const SkOpSpanBase* start, const SkOpSpanBase* end) const;
     int updateOppWinding(const SkOpAngle* angle) const;
     int updateOppWindingReverse(const SkOpAngle* angle) const;
     int updateWinding(const SkOpSpanBase* start, const SkOpSpanBase* end) const;
     int updateWinding(const SkOpAngle* angle) const;
     int updateWindingReverse(const SkOpAngle* angle) const;
 
     static bool UseInnerWinding(int outerWinding, int innerWinding);
 
     SkPath::Verb verb() const {
         return fVerb;
     }
 
+    SkScalar weight() const {
+        return fWeight;
+    }
+
     int windingAtT(double tHit, const SkOpSpan* span, bool crossOpp, SkScalar* dx) const;
     int windSum(const SkOpAngle* angle) const;
 
     SkPoint* writablePt(bool end) {
         return &fPts[end ? SkPathOpsVerbToPoints(fVerb) : 0];
     }
 
 private:
     SkOpSpan fHead;  // the head span always has its t set to zero
     SkOpSpanBase fTail;  // the tail span always has its t set to one
     SkOpContour* fContour;
     SkOpSegment* fNext;  // forward-only linked list used by contour to walk the segments
     const SkOpSegment* fPrev;
     SkPoint* fPts;  // pointer into array of points owned by edge builder that may be tweaked
     SkPathOpsBounds fBounds;  // tight bounds
+    SkScalar fWeight;
     int fCount;  // number of spans (one for a non-intersecting segment)
     int fDoneCount;  // number of processed spans (zero initially)
     SkPath::Verb fVerb;
     bool fVisited;  // used by missing coincidence check
-    PATH_OPS_DEBUG_CODE(int fID);
+    SkDEBUGCODE(int fID);
 };
 
 #endif