align top and bounds computations

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 SkPathOpsBounds;
+
 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 {
     union {
         SkDLine fLine;
         SkDQuad fQuad;
         SkDConic fConic;
         SkDCubic fCubic;
     };
     SkDEBUGCODE(SkPath::Verb fVerb);
 
     const SkDPoint& operator[](int n) const {
         SkASSERT(n >= 0 && n <= SkPathOpsVerbToPoints(fVerb));
         return fCubic[n];
     }
 
     SkDPoint& operator[](int n) {
         SkASSERT(n >= 0 && n <= SkPathOpsVerbToPoints(fVerb));
         return fCubic[n];
     }
 
+    SkDPoint conicTop(const SkPoint curve[3], SkScalar curveWeight, 
+                      double s, double e, double* topT);
+    SkDPoint cubicTop(const SkPoint curve[4], SkScalar , double s, double e, double* topT);
     void dumpID(int ) const;
+    SkDPoint lineTop(const SkPoint[2], SkScalar , double , double , double* topT);
+    SkDPoint quadTop(const SkPoint curve[3], SkScalar , double s, double e, double* topT);
+
+    void setConicBounds(const SkPoint curve[3], SkScalar curveWeight, 
+                        double s, double e, SkPathOpsBounds* );
+    void setCubicBounds(const SkPoint curve[4], SkScalar ,
+                        double s, double e, SkPathOpsBounds* );
+    void setLineBounds(const SkPoint[2], SkScalar , double , double , SkPathOpsBounds* );
+    void setQuadBounds(const SkPoint curve[3], SkScalar ,
+                       double s, double e, SkPathOpsBounds*);
 };
 
+
+extern void (SkDCurve::* const SetBounds[])(const SkPoint curve[], SkScalar cWeight,
+        double tStart, double tEnd, SkPathOpsBounds* );
+
+extern SkDPoint (SkDCurve::* const Top[])(const SkPoint curve[], SkScalar cWeight,
+    double tStart, double tEnd, double* topT);
+
 static SkDPoint dline_xy_at_t(const SkPoint a[2], SkScalar , double t) {
     SkDLine line;
     line.set(a);
     return line.ptAtT(t);
 }
 
 static SkDPoint dquad_xy_at_t(const SkPoint a[3], SkScalar , double t) {
     SkDQuad quad;
     quad.set(a);
     return quad.ptAtT(t);
@@ skipping 92 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, double* topT) {
-    SkDQuad quad;
-    quad.set(a);
-    SkDPoint topPt = quad.top(startT, endT, topT);
-    return topPt.asSkPoint();
-}
-
-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, topT);
-    return topPt.asSkPoint();
-}
-
-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, topT);
-    return topPt.asSkPoint();
-}
-
-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);
     SkDPoint dst[2] = { line.ptAtT(startT), line.ptAtT(endT) };
     return AlmostEqualUlps(dst[0].fX, dst[1].fX);
 }
 
 static bool quad_is_vertical(const SkPoint a[3], SkScalar , double startT, double endT) {
     SkDQuad quad;
     quad.set(a);
@@ skipping 55 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