Move seg_to to a new header, define SkSegType enum there

src/core/SkPathMeasure.cpp

 /*
  * Copyright 2008 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkPathMeasure.h"
+#include "SkPathMeasurePriv.h"
 #include "SkGeometry.h"
 #include "SkPath.h"
 #include "SkTSearch.h"
 
-// these must be 0,1,2,3 since they are in our 2-bit field
-enum {
-    kLine_SegType,
-    kQuad_SegType,
-    kCubic_SegType,
-    kConic_SegType,
-};
-
 #define kMaxTValue  0x3FFFFFFF
 
 static inline SkScalar tValue2Scalar(int t) {
     SkASSERT((unsigned)t <= kMaxTValue);
     const SkScalar kMaxTReciprocal = 1.0f / kMaxTValue;
     return t * kMaxTReciprocal;
 }
 
 SkScalar SkPathMeasure::Segment::getScalarT() const {
     return tValue2Scalar(fTValue);
 }
 
 const SkPathMeasure::Segment* SkPathMeasure::NextSegment(const Segment* seg) {
     unsigned ptIndex = seg->fPtIndex;
 
     do {
         ++seg;
     } while (seg->fPtIndex == ptIndex);
     return seg;
 }
 
+void SkPathMeasure_segTo(const SkPoint pts[], unsigned segType,
+                   SkScalar startT, SkScalar stopT, SkPath* dst) {
+    SkASSERT(startT >= 0 && startT <= SK_Scalar1);
+    SkASSERT(stopT >= 0 && stopT <= SK_Scalar1);
+    SkASSERT(startT <= stopT);
+
+    if (startT == stopT) {
+        /* if the dash as a zero-length on segment, add a corresponding zero-length line.
+           The stroke code will add end caps to zero length lines as appropriate */
+        SkPoint lastPt;
+        SkAssertResult(dst->getLastPt(&lastPt));
+        dst->lineTo(lastPt);
+        return;
+    }
+
+    SkPoint tmp0[7], tmp1[7];
+
+    switch (segType) {
+        case kLine_SegType:
+            if (SK_Scalar1 == stopT) {
+                dst->lineTo(pts[1]);
+            } else {
+                dst->lineTo(SkScalarInterp(pts[0].fX, pts[1].fX, stopT),
+                            SkScalarInterp(pts[0].fY, pts[1].fY, stopT));
+            }
+            break;
+        case kQuad_SegType:
+            if (0 == startT) {
+                if (SK_Scalar1 == stopT) {
+                    dst->quadTo(pts[1], pts[2]);
+                } else {
+                    SkChopQuadAt(pts, tmp0, stopT);
+                    dst->quadTo(tmp0[1], tmp0[2]);
+                }
+            } else {
+                SkChopQuadAt(pts, tmp0, startT);
+                if (SK_Scalar1 == stopT) {
+                    dst->quadTo(tmp0[3], tmp0[4]);
+                } else {
+                    SkChopQuadAt(&tmp0[2], tmp1, (stopT - startT) / (1 - startT));
+                    dst->quadTo(tmp1[1], tmp1[2]);
+                }
+            }
+            break;
+        case kConic_SegType: {
+            SkConic conic(pts[0], pts[2], pts[3], pts[1].fX);
+
+            if (0 == startT) {
+                if (SK_Scalar1 == stopT) {
+                    dst->conicTo(conic.fPts[1], conic.fPts[2], conic.fW);
+                } else {
+                    SkConic tmp[2];
+                    conic.chopAt(stopT, tmp);
+                    dst->conicTo(tmp[0].fPts[1], tmp[0].fPts[2], tmp[0].fW);
+                }
+            } else {
+                if (SK_Scalar1 == stopT) {
+                    SkConic tmp1[2];
+                    conic.chopAt(startT, tmp1);
+                    dst->conicTo(tmp1[1].fPts[1], tmp1[1].fPts[2], tmp1[1].fW);
+                } else {
+                    SkConic tmp;
+                    conic.chopAt(startT, stopT, &tmp);
+                    dst->conicTo(tmp.fPts[1], tmp.fPts[2], tmp.fW);
+                }
+            }
+        } break;
+        case kCubic_SegType:
+            if (0 == startT) {
+                if (SK_Scalar1 == stopT) {
+                    dst->cubicTo(pts[1], pts[2], pts[3]);
+                } else {
+                    SkChopCubicAt(pts, tmp0, stopT);
+                    dst->cubicTo(tmp0[1], tmp0[2], tmp0[3]);
+                }
+            } else {
+                SkChopCubicAt(pts, tmp0, startT);
+                if (SK_Scalar1 == stopT) {
+                    dst->cubicTo(tmp0[4], tmp0[5], tmp0[6]);
+                } else {
+                    SkChopCubicAt(&tmp0[3], tmp1, (stopT - startT) / (1 - startT));
+                    dst->cubicTo(tmp1[1], tmp1[2], tmp1[3]);
+                }
+            }
+            break;
+        default:
+            SkDEBUGFAIL("unknown segType");
+            sk_throw();
+    }
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 static inline int tspan_big_enough(int tspan) {
     SkASSERT((unsigned)tspan <= kMaxTValue);
     return tspan >> 10;
 }
 
 // can't use tangents, since we need [0..1..................2] to be seen
 // as definitely not a line (it is when drawn, but not parametrically)
 // so we compare midpoints
@@ skipping 285 matching lines @@
 
             distance = seg->fDistance;
             ptIndex = seg->fPtIndex;
             seg += 1;
         }
     //  SkDebugf("\n");
     }
 #endif
 }
 
-static void compute_pos_tan(const SkPoint pts[], int segType,
+static void compute_pos_tan(const SkPoint pts[], unsigned segType,
                             SkScalar t, SkPoint* pos, SkVector* tangent) {
     switch (segType) {
         case kLine_SegType:
             if (pos) {
                 pos->set(SkScalarInterp(pts[0].fX, pts[1].fX, t),
                          SkScalarInterp(pts[0].fY, pts[1].fY, t));
             }
             if (tangent) {
                 tangent->setNormalize(pts[1].fX - pts[0].fX, pts[1].fY - pts[0].fY);
             }
@@ skipping 14 matching lines @@
             SkEvalCubicAt(pts, t, pos, tangent, nullptr);
             if (tangent) {
                 tangent->normalize();
             }
             break;
         default:
             SkDEBUGFAIL("unknown segType");
     }
 }
 
-static void seg_to(const SkPoint pts[], int segType,
-                   SkScalar startT, SkScalar stopT, SkPath* dst) {
-    SkASSERT(startT >= 0 && startT <= SK_Scalar1);
-    SkASSERT(stopT >= 0 && stopT <= SK_Scalar1);
-    SkASSERT(startT <= stopT);
-
-    if (startT == stopT) {
-        /* if the dash as a zero-length on segment, add a corresponding zero-length line.
-           The stroke code will add end caps to zero length lines as appropriate */
-        SkPoint lastPt;
-        SkAssertResult(dst->getLastPt(&lastPt));
-        dst->lineTo(lastPt);
-        return;
-    }
-
-    SkPoint tmp0[7], tmp1[7];
-
-    switch (segType) {
-        case kLine_SegType:
-            if (SK_Scalar1 == stopT) {
-                dst->lineTo(pts[1]);
-            } else {
-                dst->lineTo(SkScalarInterp(pts[0].fX, pts[1].fX, stopT),
-                            SkScalarInterp(pts[0].fY, pts[1].fY, stopT));
-            }
-            break;
-        case kQuad_SegType:
-            if (0 == startT) {
-                if (SK_Scalar1 == stopT) {
-                    dst->quadTo(pts[1], pts[2]);
-                } else {
-                    SkChopQuadAt(pts, tmp0, stopT);
-                    dst->quadTo(tmp0[1], tmp0[2]);
-                }
-            } else {
-                SkChopQuadAt(pts, tmp0, startT);
-                if (SK_Scalar1 == stopT) {
-                    dst->quadTo(tmp0[3], tmp0[4]);
-                } else {
-                    SkChopQuadAt(&tmp0[2], tmp1, (stopT - startT) / (1 - startT));
-                    dst->quadTo(tmp1[1], tmp1[2]);
-                }
-            }
-            break;
-        case kConic_SegType: {
-            SkConic conic(pts[0], pts[2], pts[3], pts[1].fX);
-
-            if (0 == startT) {
-                if (SK_Scalar1 == stopT) {
-                    dst->conicTo(conic.fPts[1], conic.fPts[2], conic.fW);
-                } else {
-                    SkConic tmp[2];
-                    conic.chopAt(stopT, tmp);
-                    dst->conicTo(tmp[0].fPts[1], tmp[0].fPts[2], tmp[0].fW);
-                }
-            } else {
-                if (SK_Scalar1 == stopT) {
-                    SkConic tmp1[2];
-                    conic.chopAt(startT, tmp1);
-                    dst->conicTo(tmp1[1].fPts[1], tmp1[1].fPts[2], tmp1[1].fW);
-                } else {
-                    SkConic tmp;
-                    conic.chopAt(startT, stopT, &tmp);
-                    dst->conicTo(tmp.fPts[1], tmp.fPts[2], tmp.fW);
-                }
-            }
-        } break;
-        case kCubic_SegType:
-            if (0 == startT) {
-                if (SK_Scalar1 == stopT) {
-                    dst->cubicTo(pts[1], pts[2], pts[3]);
-                } else {
-                    SkChopCubicAt(pts, tmp0, stopT);
-                    dst->cubicTo(tmp0[1], tmp0[2], tmp0[3]);
-                }
-            } else {
-                SkChopCubicAt(pts, tmp0, startT);
-                if (SK_Scalar1 == stopT) {
-                    dst->cubicTo(tmp0[4], tmp0[5], tmp0[6]);
-                } else {
-                    SkChopCubicAt(&tmp0[3], tmp1, (stopT - startT) / (1 - startT));
-                    dst->cubicTo(tmp1[1], tmp1[2], tmp1[3]);
-                }
-            }
-            break;
-        default:
-            SkDEBUGFAIL("unknown segType");
-            sk_throw();
-    }
-}
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
 SkPathMeasure::SkPathMeasure() {
     fPath = nullptr;
     fTolerance = CHEAP_DIST_LIMIT;
     fLength = -1;   // signal we need to compute it
     fForceClosed = false;
     fFirstPtIndex = -1;
@@ skipping 177 matching lines @@
     const Segment* seg = this->distanceToSegment(startD, &startT);
     const Segment* stopSeg = this->distanceToSegment(stopD, &stopT);
     SkASSERT(seg <= stopSeg);
 
     if (startWithMoveTo) {
         compute_pos_tan(&fPts[seg->fPtIndex], seg->fType, startT, &p, nullptr);
         dst->moveTo(p);
     }
 
     if (seg->fPtIndex == stopSeg->fPtIndex) {
-        seg_to(&fPts[seg->fPtIndex], seg->fType, startT, stopT, dst);
+        SkPathMeasure_segTo(&fPts[seg->fPtIndex], seg->fType, startT, stopT, dst);
     } else {
         do {
-            seg_to(&fPts[seg->fPtIndex], seg->fType, startT, SK_Scalar1, dst);
+            SkPathMeasure_segTo(&fPts[seg->fPtIndex], seg->fType, startT, SK_Scalar1, dst);
             seg = SkPathMeasure::NextSegment(seg);
             startT = 0;
         } while (seg->fPtIndex < stopSeg->fPtIndex);
-        seg_to(&fPts[seg->fPtIndex], seg->fType, 0, stopT, dst);
+        SkPathMeasure_segTo(&fPts[seg->fPtIndex], seg->fType, 0, stopT, dst);
     }
     return true;
 }
 
 bool SkPathMeasure::isClosed() {
     (void)this->getLength();
     return fIsClosed;
 }
 
 /** Move to the next contour in the path. Return true if one exists, or false if
@@ skipping 14 matching lines @@
 
     for (int i = 0; i < fSegments.count(); i++) {
         const Segment* seg = &fSegments[i];
         SkDebugf("pathmeas: seg[%d] distance=%g, point=%d, t=%g, type=%d\n",
                 i, seg->fDistance, seg->fPtIndex, seg->getScalarT(),
                  seg->fType);
     }
 }
 
 #endif