working on initial winding for cubics

src/pathops/SkPathOpsCurve.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 SkPathOpsCurve_DEFINE
 #define SkPathOpsCurve_DEFINE
 
 #include "SkIntersections.h"
 #include "SkPathOpsCubic.h"
 #include "SkPathOpsLine.h"
 #include "SkPathOpsQuad.h"
 
 #ifndef SK_RELEASE
 #include "SkPath.h"
 #endif
 
 struct SkOpCurve {
     SkPoint fPts[4];
     SkScalar fWeight;
     SkDEBUGCODE(SkPath::Verb fVerb);
 
     const SkPoint& operator[](int n) const {
         SkASSERT(n >= 0 && n <= SkPathOpsVerbToPoints(fVerb));
         return fPts[n];
     }
 
+    void dump() const;
+
+    void set(const SkDQuad& quad) {
+        for (int index = 0; index < SkDQuad::kPointCount; ++index) {
+            fPts[index] = quad[index].asSkPoint();
+        }
+        SkDEBUGCODE(fWeight = 1);
+        SkDEBUGCODE(fVerb = SkPath::kQuad_Verb);
+    }
+
     void set(const SkDCubic& cubic) {
         for (int index = 0; index < SkDCubic::kPointCount; ++index) {
             fPts[index] = cubic[index].asSkPoint();
         }
         SkDEBUGCODE(fWeight = 1);
         SkDEBUGCODE(fVerb = SkPath::kCubic_Verb);
     }
 };
 
 struct SkDCurve {
@@ skipping 123 matching lines @@
 }
 
 static SkVector (* const CurveSlopeAtT[])(const SkPoint[], SkScalar , double ) = {
     NULL,
     fline_dxdy_at_t,
     fquad_dxdy_at_t,
     fconic_dxdy_at_t,
     fcubic_dxdy_at_t
 };
 
-static SkPoint quad_top(const SkPoint a[3], SkScalar , double startT, double endT) {
+static SkPoint quad_top(const SkPoint a[3], SkScalar , double startT, double endT, double* topT) {
     SkDQuad quad;
     quad.set(a);
-    SkDPoint topPt = quad.top(startT, endT);
+    SkDPoint topPt = quad.top(startT, endT, topT);
     return topPt.asSkPoint();
 }
 
-static SkPoint conic_top(const SkPoint a[3], SkScalar weight, double startT, double endT) {
+static SkPoint conic_top(const SkPoint a[3], SkScalar weight, double startT, double endT,
+        double* topT) {
     SkDConic conic;
     conic.set(a, weight);
-    SkDPoint topPt = conic.top(startT, endT);
+    SkDPoint topPt = conic.top(startT, endT, topT);
     return topPt.asSkPoint();
 }
 
-static SkPoint cubic_top(const SkPoint a[4], SkScalar , double startT, double endT) {
+static SkPoint cubic_top(const SkPoint a[4], SkScalar , double startT, double endT, double* topT) {
     SkDCubic cubic;
     cubic.set(a);
-    SkDPoint topPt = cubic.top(startT, endT);
+    SkDPoint topPt = cubic.top(startT, endT, topT);
     return topPt.asSkPoint();
 }
 
-static SkPoint (* const CurveTop[])(const SkPoint[], SkScalar , double , double ) = {
+static SkPoint (* const CurveTop[])(const SkPoint[], SkScalar , double , double , double* ) = {
     NULL,
     NULL,
     quad_top,
     conic_top,
     cubic_top
 };
 
 static bool line_is_vertical(const SkPoint a[2], SkScalar , double startT, double endT) {
     SkDLine line;
     line.set(a);
@@ skipping 62 matching lines @@
 static void (* const CurveIntersectRay[])(const SkPoint[] , SkScalar , const SkDLine& ,
         SkIntersections* ) = {
     NULL,
     line_intersect_ray,
     quad_intersect_ray,
     conic_intersect_ray,
     cubic_intersect_ray
 };
 
 #endif