toosoon-utils 4.1.9 → 4.2.1

package/lib/extras/curves/LineCurve3.d.ts

@@ -0,0 +1,87 @@
+import type { Point3 } from '../../types';
+import { Vector3 } from '../geometry';
+import Curve from './Curve';
+/**
+ * Utility class for manipulating 3D lines
+ *
+ * @exports
+ * @class LineCurve3
+ * @extends Curve
+ */
+export default class LineCurve3 extends Curve<Vector3> {
+    readonly type: string;
+    /**
+     * X-axis coordinate of the start point
+     */
+    x1: number;
+    /**
+     * Y-axis coordinate of the start point
+     */
+    y1: number;
+    /**
+     * Z-axis coordinate of the start point
+     */
+    z1: number;
+    /**
+     * X-axis coordinate of the end point
+     */
+    x2: number;
+    /**
+     * Y-axis coordinate of the end point
+     */
+    y2: number;
+    /**
+     * Z-axis coordinate of the end point
+     */
+    z2: number;
+    /**
+     * @param {number} x1 X-axis coordinate of the start point
+     * @param {number} y1 Y-axis coordinate of the start point
+     * @param {number} z1 Z-axis coordinate of the start point
+     * @param {number} x2 X-axis coordinate of the end point
+     * @param {number} y2 Y-axis coordinate of the end point
+     * @param {number} z2 Z-axis coordinate of the end point
+     */
+    constructor(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number);
+    /**
+     * Interpolate a point on this curve
+     *
+     * @param {number} t Normalized time value to interpolate
+     * @returns {Vector3} Interpolated coordinates on this curve
+     */
+    getPoint(t: number): Vector3;
+    /**
+     * Interpolate a point on this curve
+     *
+     * @param {number} u Normalized position value to interpolate
+     * @returns {Vector3} Interpolated coordinates on this curve
+     */
+    getPointAt(u: number): Vector3;
+    /**
+     * Compute an unit vector tangent for a given normalized time value
+     *
+     * @param {number} t Normalized time value
+     * @returns {Vector3} Tangent vector
+     */
+    getTangent(t?: number): Vector3;
+    /**
+     * Compute an unit vector tangent for a given normalized position value
+     *
+     * @param {number} u Normalized position value
+     * @returns {Vector3} Tangent vector
+     */
+    getTangentAt(u?: number): Vector3;
+    /**
+     * Interpolate a point on a 3D line
+     *
+     * @param {number} t  Normalized time value to interpolate
+     * @param {number} x1 X-axis coordinate of the start point
+     * @param {number} y1 Y-axis coordinate of the start point
+     * @param {number} z1 Z-axis coordinate of the start point
+     * @param {number} x2 X-axis coordinate of the end point
+     * @param {number} y2 Y-axis coordinate of the end point
+     * @param {number} z2 Z-axis coordinate of the end point
+     * @returns {Point3} Interpolated coordinates on the line
+     */
+    static interpolate(t: number, x1: number, y1: number, z1: number, x2: number, y2: number, z2: number): Point3;
+}

package/lib/extras/curves/LineCurve3.js

@@ -0,0 +1,108 @@
+import { lerp } from '../../maths';
+import { Vector3 } from '../geometry';
+import Curve from './Curve';
+/**
+ * Utility class for manipulating 3D lines
+ *
+ * @exports
+ * @class LineCurve3
+ * @extends Curve
+ */
+export default class LineCurve3 extends Curve {
+    type = 'LineCurve3';
+    /**
+     * X-axis coordinate of the start point
+     */
+    x1;
+    /**
+     * Y-axis coordinate of the start point
+     */
+    y1;
+    /**
+     * Z-axis coordinate of the start point
+     */
+    z1;
+    /**
+     * X-axis coordinate of the end point
+     */
+    x2;
+    /**
+     * Y-axis coordinate of the end point
+     */
+    y2;
+    /**
+     * Z-axis coordinate of the end point
+     */
+    z2;
+    /**
+     * @param {number} x1 X-axis coordinate of the start point
+     * @param {number} y1 Y-axis coordinate of the start point
+     * @param {number} z1 Z-axis coordinate of the start point
+     * @param {number} x2 X-axis coordinate of the end point
+     * @param {number} y2 Y-axis coordinate of the end point
+     * @param {number} z2 Z-axis coordinate of the end point
+     */
+    constructor(x1, y1, z1, x2, y2, z2) {
+        super();
+        this.x1 = x1;
+        this.y1 = y1;
+        this.z1 = z1;
+        this.x2 = x2;
+        this.y2 = y2;
+        this.z2 = z2;
+    }
+    /**
+     * Interpolate a point on this curve
+     *
+     * @param {number} t Normalized time value to interpolate
+     * @returns {Vector3} Interpolated coordinates on this curve
+     */
+    getPoint(t) {
+        return new Vector3(...LineCurve3.interpolate(t, this.x1, this.y1, this.z1, this.x2, this.y2, this.z2));
+    }
+    /**
+     * Interpolate a point on this curve
+     *
+     * @param {number} u Normalized position value to interpolate
+     * @returns {Vector3} Interpolated coordinates on this curve
+     */
+    getPointAt(u) {
+        return this.getPoint(u);
+    }
+    /**
+     * Compute an unit vector tangent for a given normalized time value
+     *
+     * @param {number} t Normalized time value
+     * @returns {Vector3} Tangent vector
+     */
+    getTangent(t) {
+        return new Vector3(...Vector3.sub([this.x1, this.y1, this.z1], [this.x2, this.y2, this.z2])).normalize();
+    }
+    /**
+     * Compute an unit vector tangent for a given normalized position value
+     *
+     * @param {number} u Normalized position value
+     * @returns {Vector3} Tangent vector
+     */
+    getTangentAt(u) {
+        return this.getTangent(u);
+    }
+    /**
+     * Interpolate a point on a 3D line
+     *
+     * @param {number} t  Normalized time value to interpolate
+     * @param {number} x1 X-axis coordinate of the start point
+     * @param {number} y1 Y-axis coordinate of the start point
+     * @param {number} z1 Z-axis coordinate of the start point
+     * @param {number} x2 X-axis coordinate of the end point
+     * @param {number} y2 Y-axis coordinate of the end point
+     * @param {number} z2 Z-axis coordinate of the end point
+     * @returns {Point3} Interpolated coordinates on the line
+     */
+    static interpolate(t, x1, y1, z1, x2, y2, z2) {
+        const x = lerp(t, x1, x2);
+        const y = lerp(t, y1, y2);
+        const z = lerp(t, z1, z2);
+        return [x, y, z];
+    }
+}

package/lib/extras/curves/PolylineCurve.d.ts

@@ -1,4 +1,5 @@
-import type { Point } from '../../types';
+import type { Point2 } from '../../types';
+import { Vector2 } from '../geometry';
 import Curve from './Curve';
 /**
  * Utility class for manipulating polylines
@@ -7,21 +8,21 @@ import Curve from './Curve';
  * @class PolylineCurve
  * @extends Curve
  */
-export default class PolylineCurve extends Curve {
+export default class PolylineCurve extends Curve<Vector2> {
     readonly type: string;
     /**
      * Array of points defining the curve
      */
-    points: Point[];
+    points: Point2[];
     /**
-     * @param {Point[]} [points] Array of points defining the curve
+     * @param {Point2[]} [points] Array of points defining the curve
      */
-    constructor(points?: Point[]);
+    constructor(points?: Point2[]);
     /**
-     * Interpolate a point on the Spline curve
+     * Interpolate a point on this curve
      *
      * @param {number} t Normalized time value to interpolate
-     * @returns {Point} Interpolated coordinates on the curve
+     * @returns {Vector2} Interpolated coordinates on this curve
      */
-    getPoint(t: number): Point;
+    getPoint(t: number): Vector2;
 }

package/lib/extras/curves/PolylineCurve.js

@@ -1,4 +1,5 @@
-import { line } from '../../geometry';
+import { Vector2 } from '../geometry';
+import LineCurve from './LineCurve';
 import Curve from './Curve';
 /**
  * Utility class for manipulating polylines
@@ -14,17 +15,17 @@ export default class PolylineCurve extends Curve {
      */
     points = [];
     /**
-     * @param {Point[]} [points] Array of points defining the curve
+     * @param {Point2[]} [points] Array of points defining the curve
      */
     constructor(points = []) {
         super();
         this.points = points;
     }
     /**
-     * Interpolate a point on the Spline curve
+     * Interpolate a point on this curve
      *
      * @param {number} t Normalized time value to interpolate
-     * @returns {Point} Interpolated coordinates on the curve
+     * @returns {Vector2} Interpolated coordinates on this curve
      */
     getPoint(t) {
         const points = this.points;
@@ -33,7 +34,6 @@ export default class PolylineCurve extends Curve {
         const weight = p - index;
         const p1 = points[index === 0 ? index : index - 1];
         const p2 = points[index];
-        const point = line(weight, ...p1, ...p2);
-        return point;
+        return new Vector2(...LineCurve.interpolate(weight, ...p1, ...p2));
     }
 }

package/lib/extras/curves/PolylineCurve3.d.ts

@@ -0,0 +1,28 @@
+import type { Point3 } from '../../types';
+import { Vector3 } from '../geometry';
+import Curve from './Curve';
+/**
+ * Utility class for manipulating 3D polylines
+ *
+ * @exports
+ * @class PolylineCurve3
+ * @extends Curve
+ */
+export default class PolylineCurve3 extends Curve<Vector3> {
+    readonly type: string;
+    /**
+     * Array of points defining the curve
+     */
+    points: Point3[];
+    /**
+     * @param {Point3[]} [points] Array of points defining the curve
+     */
+    constructor(points?: Point3[]);
+    /**
+     * Interpolate a point on this curve
+     *
+     * @param {number} t Normalized time value to interpolate
+     * @returns {Vector3} Interpolated coordinates on this curve
+     */
+    getPoint(t: number): Vector3;
+}

package/lib/extras/curves/PolylineCurve3.js

@@ -0,0 +1,39 @@
+import { Vector3 } from '../geometry';
+import LineCurve3 from './LineCurve3';
+import Curve from './Curve';
+/**
+ * Utility class for manipulating 3D polylines
+ *
+ * @exports
+ * @class PolylineCurve3
+ * @extends Curve
+ */
+export default class PolylineCurve3 extends Curve {
+    type = 'PolylineCurve3';
+    /**
+     * Array of points defining the curve
+     */
+    points = [];
+    /**
+     * @param {Point3[]} [points] Array of points defining the curve
+     */
+    constructor(points = []) {
+        super();
+        this.points = points;
+    }
+    /**
+     * Interpolate a point on this curve
+     *
+     * @param {number} t Normalized time value to interpolate
+     * @returns {Vector3} Interpolated coordinates on this curve
+     */
+    getPoint(t) {
+        const points = this.points;
+        const p = (points.length - 1) * t;
+        const index = Math.floor(p);
+        const weight = p - index;
+        const p1 = points[index === 0 ? index : index - 1];
+        const p2 = points[index];
+        return new Vector3(...LineCurve3.interpolate(weight, ...p1, ...p2));
+    }
+}

package/lib/extras/curves/QuadraticBezierCurve.d.ts

@@ -1,4 +1,5 @@
-import type { Point } from '../../types';
+import type { Point2 } from '../../types';
+import { Vector2 } from '../geometry';
 import Curve from './Curve';
 /**
  * Utility class for manipulating Quadratic Bézier curves
@@ -7,7 +8,7 @@ import Curve from './Curve';
  * @class QuadraticBezierCurve
  * @extends Curve
  */
-export default class QuadraticBezierCurve extends Curve {
+export default class QuadraticBezierCurve extends Curve<Vector2> {
     readonly type: string;
     /**
      *  X-axis coordinate of the start point
@@ -43,10 +44,23 @@ export default class QuadraticBezierCurve extends Curve {
      */
     constructor(x1: number, y1: number, cpx: number, cpy: number, x2: number, y2: number);
     /**
-     * Interpolate a point on the Quadratic Bézier curve
+     * Interpolate a point on this Quadratic Bézier curve
      *
      * @param {number} t Normalized time value to interpolate
-     * @returns {Point} Interpolated coordinates on the curve
+     * @returns {Vector2} Interpolated coordinates on this curve
      */
-    getPoint(t: number): Point;
+    getPoint(t: number): Vector2;
+    /**
+     * Interpolate a point on a Quadratic Bézier curve
+     *
+     * @param {number} t   Normalized time value to interpolate
+     * @param {number} x1  X-axis coordinate of the start point
+     * @param {number} y1  Y-axis coordinate of the start point
+     * @param {number} cpx X-axis coordinate of the control point
+     * @param {number} cpy Y-axis coordinate of the control point
+     * @param {number} x2  X-axis coordinate of the end point
+     * @param {number} y2  Y-axis coordinate of the end point
+     * @returns {Point2} Interpolated coordinates on the curve
+     */
+    static interpolate(t: number, x1: number, y1: number, cpx: number, cpy: number, x2: number, y2: number): Point2;
 }

package/lib/extras/curves/QuadraticBezierCurve.js

@@ -1,4 +1,5 @@
-import { quadraticBezier } from '../../geometry';
+import { quadraticBezier } from '../../maths';
+import { Vector2 } from '../geometry';
 import Curve from './Curve';
 /**
  * Utility class for manipulating Quadratic Bézier curves
@@ -51,13 +52,29 @@ export default class QuadraticBezierCurve extends Curve {
         this.y2 = y2;
     }
     /**
-     * Interpolate a point on the Quadratic Bézier curve
+     * Interpolate a point on this Quadratic Bézier curve
      *
      * @param {number} t Normalized time value to interpolate
-     * @returns {Point} Interpolated coordinates on the curve
+     * @returns {Vector2} Interpolated coordinates on this curve
      */
     getPoint(t) {
-        const point = quadraticBezier(t, this.x1, this.y1, this.cpx, this.cpy, this.x2, this.y2);
-        return point;
+        return new Vector2(...QuadraticBezierCurve.interpolate(t, this.x1, this.y1, this.cpx, this.cpy, this.x2, this.y2));
+    }
+    /**
+     * Interpolate a point on a Quadratic Bézier curve
+     *
+     * @param {number} t   Normalized time value to interpolate
+     * @param {number} x1  X-axis coordinate of the start point
+     * @param {number} y1  Y-axis coordinate of the start point
+     * @param {number} cpx X-axis coordinate of the control point
+     * @param {number} cpy Y-axis coordinate of the control point
+     * @param {number} x2  X-axis coordinate of the end point
+     * @param {number} y2  Y-axis coordinate of the end point
+     * @returns {Point2} Interpolated coordinates on the curve
+     */
+    static interpolate(t, x1, y1, cpx, cpy, x2, y2) {
+        const x = quadraticBezier(t, x1, cpx, x2);
+        const y = quadraticBezier(t, y1, cpy, y2);
+        return [x, y];
     }
 }

package/lib/extras/curves/QuadraticBezierCurve3.d.ts

@@ -0,0 +1,84 @@
+import type { Point3 } from '../../types';
+import { Vector3 } from '../geometry';
+import Curve from './Curve';
+/**
+ * Utility class for manipulating Quadratic Bézier 3D curves
+ *
+ * @exports
+ * @class QuadraticBezierCurve3
+ * @extends Curve
+ */
+export default class QuadraticBezierCurve3 extends Curve<Vector3> {
+    readonly type: string;
+    /**
+     *  X-axis coordinate of the start point
+     */
+    x1: number;
+    /**
+     *  Y-axis coordinate of the start point
+     */
+    y1: number;
+    /**
+     *  Z-axis coordinate of the start point
+     */
+    z1: number;
+    /**
+     * X-axis coordinate of the control point
+     */
+    cpx: number;
+    /**
+     * Y-axis coordinate of the control point
+     */
+    cpy: number;
+    /**
+     * Z-axis coordinate of the control point
+     */
+    cpz: number;
+    /**
+     *  X-axis coordinate of the end point
+     */
+    x2: number;
+    /**
+     *  Y-axis coordinate of the end point
+     */
+    y2: number;
+    /**
+     *  Z-axis coordinate of the end point
+     */
+    z2: number;
+    /**
+     * @param {number} x1  X-axis coordinate of the start point
+     * @param {number} y1  Y-axis coordinate of the start point
+     * @param {number} z1  Z-axis coordinate of the start point
+     * @param {number} cpx X-axis coordinate of the control point
+     * @param {number} cpy Y-axis coordinate of the control point
+     * @param {number} cpz Z-axis coordinate of the control point
+     * @param {number} x2  X-axis coordinate of the end point
+     * @param {number} y2  Y-axis coordinate of the end point
+     * @param {number} z2  Z-axis coordinate of the end point
+     */
+    constructor(x1: number, y1: number, z1: number, cpx: number, cpy: number, cpz: number, x2: number, y2: number, z2: number);
+    /**
+     * Interpolate a point on this curve
+     *
+     * @param {number} t Normalized time value to interpolate
+     * @returns {Vector3} Interpolated coordinates on this curve
+     */
+    getPoint(t: number): Vector3;
+    /**
+     * Interpolate a point on a Quadratic Bézier 3D curve
+     *
+     * @param {number} t   Normalized time value to interpolate
+     * @param {number} x1  X-axis coordinate of the start point
+     * @param {number} y1  Y-axis coordinate of the start point
+     * @param {number} z1  Z-axis coordinate of the start point
+     * @param {number} cpx X-axis coordinate of the control point
+     * @param {number} cpy Y-axis coordinate of the control point
+     * @param {number} cpz Z-axis coordinate of the control point
+     * @param {number} x2  X-axis coordinate of the end point
+     * @param {number} y2  Y-axis coordinate of the end point
+     * @param {number} z2  Z-axis coordinate of the end point
+     * @returns {Point3} Interpolated coordinates on the curve
+     */
+    static interpolate(t: number, x1: number, y1: number, z1: number, cpx: number, cpy: number, cpz: number, x2: number, y2: number, z2: number): Point3;
+}

package/lib/extras/curves/QuadraticBezierCurve3.js

@@ -0,0 +1,102 @@
+import { quadraticBezier } from '../../maths';
+import { Vector3 } from '../geometry';
+import Curve from './Curve';
+/**
+ * Utility class for manipulating Quadratic Bézier 3D curves
+ *
+ * @exports
+ * @class QuadraticBezierCurve3
+ * @extends Curve
+ */
+export default class QuadraticBezierCurve3 extends Curve {
+    type = 'QuadraticBezierCurve3';
+    /**
+     *  X-axis coordinate of the start point
+     */
+    x1;
+    /**
+     *  Y-axis coordinate of the start point
+     */
+    y1;
+    /**
+     *  Z-axis coordinate of the start point
+     */
+    z1;
+    /**
+     * X-axis coordinate of the control point
+     */
+    cpx;
+    /**
+     * Y-axis coordinate of the control point
+     */
+    cpy;
+    /**
+     * Z-axis coordinate of the control point
+     */
+    cpz;
+    /**
+     *  X-axis coordinate of the end point
+     */
+    x2;
+    /**
+     *  Y-axis coordinate of the end point
+     */
+    y2;
+    /**
+     *  Z-axis coordinate of the end point
+     */
+    z2;
+    /**
+     * @param {number} x1  X-axis coordinate of the start point
+     * @param {number} y1  Y-axis coordinate of the start point
+     * @param {number} z1  Z-axis coordinate of the start point
+     * @param {number} cpx X-axis coordinate of the control point
+     * @param {number} cpy Y-axis coordinate of the control point
+     * @param {number} cpz Z-axis coordinate of the control point
+     * @param {number} x2  X-axis coordinate of the end point
+     * @param {number} y2  Y-axis coordinate of the end point
+     * @param {number} z2  Z-axis coordinate of the end point
+     */
+    constructor(x1, y1, z1, cpx, cpy, cpz, x2, y2, z2) {
+        super();
+        this.x1 = x1;
+        this.y1 = y1;
+        this.z1 = z1;
+        this.cpx = cpx;
+        this.cpy = cpy;
+        this.cpz = cpz;
+        this.x2 = x2;
+        this.y2 = y2;
+        this.z2 = z2;
+    }
+    /**
+     * Interpolate a point on this curve
+     *
+     * @param {number} t Normalized time value to interpolate
+     * @returns {Vector3} Interpolated coordinates on this curve
+     */
+    getPoint(t) {
+        return new Vector3(...QuadraticBezierCurve3.interpolate(t, this.x1, this.y1, this.z1, this.cpx, this.cpy, this.cpz, this.x2, this.y2, this.z2));
+    }
+    /**
+     * Interpolate a point on a Quadratic Bézier 3D curve
+     *
+     * @param {number} t   Normalized time value to interpolate
+     * @param {number} x1  X-axis coordinate of the start point
+     * @param {number} y1  Y-axis coordinate of the start point
+     * @param {number} z1  Z-axis coordinate of the start point
+     * @param {number} cpx X-axis coordinate of the control point
+     * @param {number} cpy Y-axis coordinate of the control point
+     * @param {number} cpz Z-axis coordinate of the control point
+     * @param {number} x2  X-axis coordinate of the end point
+     * @param {number} y2  Y-axis coordinate of the end point
+     * @param {number} z2  Z-axis coordinate of the end point
+     * @returns {Point3} Interpolated coordinates on the curve
+     */
+    static interpolate(t, x1, y1, z1, cpx, cpy, cpz, x2, y2, z2) {
+        const x = quadraticBezier(t, x1, cpx, x2);
+        const y = quadraticBezier(t, y1, cpy, y2);
+        const z = quadraticBezier(t, z1, cpz, z2);
+        return [x, y, z];
+    }
+}

package/lib/extras/curves/SplineCurve.d.ts

@@ -1,4 +1,5 @@
-import type { Point } from '../../types';
+import type { Point2 } from '../../types';
+import { Vector2 } from '../geometry';
 import Curve from './Curve';
 /**
  * Utility class for manipulating splines
@@ -7,18 +8,21 @@ import Curve from './Curve';
  * @class SplineCurve
  * @extends Curve
  */
-export default class SplineCurve extends Curve {
+export default class SplineCurve extends Curve<Vector2> {
     readonly type: string;
-    points: Point[];
     /**
-     * @param {Point[]} [points] Array of points defining the curve
+     * Array of points defining the curve
      */
-    constructor(points?: Point[]);
+    points: Point2[];
     /**
-     * Interpolate a point on the Spline curve
+     * @param {Point2[]} [points] Array of points defining the curve
+     */
+    constructor(points?: Point2[]);
+    /**
+     * Interpolate a point on this curve
      *
      * @param {number} t Normalized time value to interpolate
-     * @returns {Point} Interpolated coordinates on the curve
+     * @returns {Vector2} Interpolated coordinates on this curve
      */
-    getPoint(t: number): Point;
+    getPoint(t: number): Vector2;
 }

package/lib/extras/curves/SplineCurve.js

@@ -1,4 +1,5 @@
-import { catmullRom } from '../../geometry';
+import { Vector2 } from '../geometry';
+import CatmullRomCurve from './CatmullRomCurve';
 import Curve from './Curve';
 /**
  * Utility class for manipulating splines
@@ -9,19 +10,22 @@ import Curve from './Curve';
  */
 export default class SplineCurve extends Curve {
     type = 'SplineCurve';
+    /**
+     * Array of points defining the curve
+     */
     points = [];
     /**
-     * @param {Point[]} [points] Array of points defining the curve
+     * @param {Point2[]} [points] Array of points defining the curve
      */
     constructor(points = []) {
         super();
         this.points = points;
     }
     /**
-     * Interpolate a point on the Spline curve
+     * Interpolate a point on this curve
      *
      * @param {number} t Normalized time value to interpolate
-     * @returns {Point} Interpolated coordinates on the curve
+     * @returns {Vector2} Interpolated coordinates on this curve
      */
     getPoint(t) {
         const points = this.points;
@@ -32,7 +36,6 @@ export default class SplineCurve extends Curve {
         const cp1 = points[index];
         const cp2 = points[index > points.length - 2 ? points.length - 1 : index + 1];
         const p2 = points[index > points.length - 3 ? points.length - 1 : index + 2];
-        const point = catmullRom(weight, ...p1, ...cp1, ...cp2, ...p2);
-        return point;
+        return new Vector2(...CatmullRomCurve.interpolate(weight, ...p1, ...cp1, ...cp2, ...p2));
     }
 }