Very rudimentary track editor... and headache spaghetti

math/path.ts

@@ -41,10 +41,12 @@ export class PathSegment {
   points: [Vector, Vector, Vector, Vector];
 
   length: number;
+  startingLength: number;
 
   constructor(points: [Vector, Vector, Vector, Vector]) {
     this.points = points;
     this.length = this.calculateApproxLength(100);
+    this.startingLength = Math.round(this.length);
   }
 
   getPointAtT(t: number) {
@@ -177,7 +179,11 @@ export class PathSegment {
     return this.length;
   }
 
-  calculateEvenlySpacedPoints(spacing: number, resolution = 1) {
+  calculateEvenlySpacedPoints(
+    spacing: number,
+    resolution = 1,
+    targetLength?: number,
+  ) {
     const points: Vector[] = [];
 
     points.push(this.points[0]);
@@ -206,6 +212,46 @@ export class PathSegment {
       prev = point;
     }
 
+    if (targetLength && points.length < targetLength) {
+      while (points.length < targetLength) {
+        t += 1 / div;
+        const point = this.getPointAtT(t);
+        distSinceLastEvenPoint += prev.dist(point);
+
+        if (distSinceLastEvenPoint >= spacing) {
+          const overshoot = distSinceLastEvenPoint - spacing;
+          const evenPoint = Vector.add(
+            point,
+            Vector.sub(point, prev).normalize().mult(overshoot),
+          );
+          distSinceLastEvenPoint = overshoot;
+          points.push(evenPoint);
+          prev = evenPoint;
+        }
+
+        prev = point;
+      }
+    }
+
     return points;
   }
+
+  calculateSubdividedPoints(numberOfPoints: number) {
+    const points: Vector[] = [];
+
+    for (let i = 0; i < numberOfPoints; i++) {
+      const point = this.getPointAtT(i / numberOfPoints);
+      points.push(point);
+    }
+
+    return points;
+  }
+
+  clampLength() {
+    const curveLength = this.startingLength;
+    const points = this.calculateEvenlySpacedPoints(1, 1, curveLength + 1);
+    if (points.length >= curveLength) {
+      this.points[3].set(points[curveLength]);
+    }
+  }
 }