compute initial winding from projected rays

src/pathops/SkOpSpan.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 SkOpSpan_DEFINED
 #define SkOpSpan_DEFINED
 
 #include "SkPathOpsDebug.h"
@@ skipping 106 matching lines @@
 protected:
     SkOpSpanBase* fSpan;  // contains winding data
     SkOpPtT* fNext;  // intersection on opposite curve or alias on this curve
     bool fDeleted;  // set if removed from span list 
     bool fDuplicatePt;  // set if identical pt is somewhere in the next loop
     SkDEBUGCODE(int fID);
 };
 
 class SkOpSpanBase {
 public:
-    bool addSimpleAngle(bool checkFrom , SkChunkAlloc* );
     void align();
 
     bool aligned() const {
         return fAligned;
     }
 
     void alignEnd(double t, const SkPoint& pt);
 
     void bumpSpanAdds() {
         ++fSpanAdds;
@@ skipping 188 matching lines @@
     SkOpSpan* fPrev;  // previous intersection point
     int fSpanAdds;  // number of times intersections have been added to span
     bool fAligned;
     bool fChased;  // set after span has been added to chase array
     SkDEBUGCODE(int fCount);  // number of pt/t pairs added
     SkDEBUGCODE(int fID);
 };
 
 class SkOpSpan : public SkOpSpanBase {
 public:
-    void applyCoincidence(SkOpSpan* opp);
-
     bool clearCoincident() {
         SkASSERT(!final());
         if (fCoincident == this) {
             return false;
         }
         fCoincident = this;
         return true;
     }
 
     bool containsCoincidence(const SkOpSegment* ) const;
@@ skipping 77 matching lines @@
         SkASSERT(!final());
         SkASSERT(fOppSum == SK_MinS32);
         fOppValue = oppValue;
     }
 
     void setToAngle(SkOpAngle* angle) {
         SkASSERT(!final());
         fToAngle = angle;
     }
 
-    void setWindSum(int windSum) {
-        SkASSERT(!final());
-        SkASSERT(fWindSum == SK_MinS32 || fWindSum == windSum);
-        SkASSERT(!DEBUG_LIMIT_WIND_SUM || abs(windSum) <= DEBUG_LIMIT_WIND_SUM);
-        fWindSum = windSum;
-    }
+    void setWindSum(int windSum);
 
     void setWindValue(int windValue) {
         SkASSERT(!final());
         SkASSERT(windValue >= 0);
         SkASSERT(fWindSum == SK_MinS32);
         fWindValue = windValue;
     }
 
+    bool sortableTop(SkOpContour* );
+
     SkOpAngle* toAngle() const {
         SkASSERT(!final());
         return fToAngle;
     }
 
     int windSum() const {
         SkASSERT(!final());
         return fWindSum;
     }
 
     int windValue() const {
         SkASSERT(!final());
         return fWindValue;
     }
 
 private:  // no direct access to internals to avoid treating a span base as a span
     SkOpSpan* fCoincident;  // linked list of spans coincident with this one (may point to itself)
     SkOpAngle* fToAngle;  // points to next angle from span start to end
     SkOpSpanBase* fNext;  // next intersection point
     int fWindSum;  // accumulated from contours surrounding this one.
     int fOppSum;  // for binary operators: the opposite winding sum
     int fWindValue;  // 0 == canceled; 1 == normal; >1 == coincident
     int fOppValue;  // normally 0 -- when binary coincident edges combine, opp value goes here
+    int fTopTTry; // specifies direction and t value to try next
     bool fDone;  // if set, this span to next higher T has been processed
 };
 
 #endif