@woosh/meep-engine 2.126.28 → 2.126.30

package/src/core/math/spline/spline3_hermite_bounds.js

@@ -0,0 +1,102 @@
+import { assert } from "../../assert.js";
+import { max2 } from "../max2.js";
+import { min2 } from "../min2.js";
+import { spline3_hermite } from "./spline3_hermite.js";
+
+/**
+ * Compute `y0,y1` bounds of a cubic hermite spline.
+ * Lower bound will be written into result[offset], upper bounds will be written into result[offset+result_stride]
+ *
+ * @param {number[]|Float32Array} result output will be written here, only y0 and y1
+ * @param {number} result_offset offset into the result array
+ * @param {number} result_stride useful for mixing multidimensional results
+ * @param {number} p0
+ * @param {number} p1
+ * @param {number} m0
+ * @param {number} m1
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2025
+ */
+export function spline3_hermite_bounds(
+    result,
+    result_offset,
+    result_stride,
+    p0, p1, m0, m1) {
+
+    /*
+     Solution is based on https://stackoverflow.com/questions/24809978/calculating-the-bounding-box-of-cubic-bezier-curve
+     Differentiation of hermite polynomial is done in WolframAlpha:
+     0 = 3 t^2 (m0 + m1 + 2 p0 - 2 p1) - 2 t (2 m0 + m1 + 3 p0 - 3 p1) + m0
+    */
+
+    assert.greaterThan(result_stride, 0, 'result_stride must be greater than 0');
+    assert.isInteger(result_stride, 'result_stride');
+
+    const a = 3 * (m0 + m1 + 2 * p0 - 2 * p1);
+    const b = -2 * (2 * m0 + m1 + 3 * p0 - 3 * p1);
+    const c = m0;
+
+    let min = min2(p0, p1);
+    let max = max2(p0, p1);
+
+    if (Math.abs(a) < 1e-12) {
+
+        if (Math.abs(b) >= 1e-12) {
+            const t = -c / b;
+
+            if (0 < t && t < 1) {
+                const value = spline3_hermite(t, p0, p1, m0, m1);
+
+                if (value < min) {
+                    min = value;
+                }
+                if (value > max) {
+                    max = value;
+                }
+
+            }
+
+        }
+
+    } else {
+
+        const b2ac = b * b - 4 * c * a;
+        const sqrtb2ac = Math.sqrt(b2ac);
+
+        if (b2ac >= 0) {
+
+            const t1 = (-b + sqrtb2ac) / (2 * a);
+
+            if (0 < t1 && t1 < 1) {
+                const value = spline3_hermite(t1, p0, p1, m0, m1);
+
+                if (value < min) {
+                    min = value;
+                }
+                if (value > max) {
+                    max = value;
+                }
+            }
+
+            const t2 = (-b - sqrtb2ac) / (2 * a);
+
+            if (0 < t2 && t2 < 1) {
+                const value = spline3_hermite(t2, p0, p1, m0, m1);
+
+                if (value < min) {
+                    min = value;
+                }
+                if (value > max) {
+                    max = value;
+                }
+            }
+
+        }
+
+    }
+
+    result[result_offset] = min;
+    result[result_offset + result_stride] = max;
+}
+

package/src/core/math/spline/spline3_hermite_to_bezier.d.ts

@@ -0,0 +1,13 @@
+/**
+ * One-dimensional cubic curve conversion from Hermite to bezier
+ * @param {Float32Array|number[]} result where to put results
+ * @param {number} result_offset offset to start writing at in result array
+ * @param {number} result_stride how far to step between each written value. Necessary for N-dimensional curves where we want to interleave multiple curves together, such as for color or quaternions
+ * @param {number} p0
+ * @param {number} p1
+ * @param {number} m0 tangent at p0
+ * @param {number} m1 tangent at p1
+ * @see spline3_bezier_to_hermite
+ */
+export function spline3_hermite_to_bezier(result: Float32Array | number[], result_offset: number, result_stride: number, p0: number, p1: number, m0: number, m1: number): void;
+//# sourceMappingURL=spline3_hermite_to_bezier.d.ts.map

package/src/core/math/spline/spline3_hermite_to_bezier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spline3_hermite_to_bezier.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline3_hermite_to_bezier.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,kDATW,YAAY,GAAC,MAAM,EAAE,iBACrB,MAAM,iBACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAsBhB"}

package/src/core/math/spline/spline3_hermite_to_bezier.js

@@ -0,0 +1,32 @@
+/**
+ * One-dimensional cubic curve conversion from Hermite to bezier
+ * @param {Float32Array|number[]} result where to put results
+ * @param {number} result_offset offset to start writing at in result array
+ * @param {number} result_stride how far to step between each written value. Necessary for N-dimensional curves where we want to interleave multiple curves together, such as for color or quaternions
+ * @param {number} p0
+ * @param {number} p1
+ * @param {number} m0 tangent at p0
+ * @param {number} m1 tangent at p1
+ * @see spline3_bezier_to_hermite
+ */
+export function spline3_hermite_to_bezier(
+    result,
+    result_offset,
+    result_stride,
+    p0, p1,
+    m0, m1
+) {
+
+    // see https://stackoverflow.com/questions/42574940/draw-hermite-curve-on-browser-canvas-javascript
+    // see https://pomax.github.io/bezierinfo/#catmullconv
+    // see https://github.com/haiku/haiku/blob/eb5f74847eb9d7e1cbfa484064b35f833102f9c5/headers/libs/agg/agg_curves.h#L340
+
+    const TENSION_FACTOR = 3;
+
+    result[result_offset + 0 * result_stride] = p0;
+    result[result_offset + 1 * result_stride] = p0 + m0 / TENSION_FACTOR;
+    result[result_offset + 2 * result_stride] = p1 - m1 / TENSION_FACTOR;
+    result[result_offset + 3 * result_stride] = p1;
+
+}
+

package/src/core/math/spline/spline_bezier2.d.ts

@@ -1,10 +1,6 @@
 /**
- * 2-nd (quadratic) degree bezier curve
- * @param {number} t
- * @param {number} p0
- * @param {number} p1
- * @param {number} p2
- * @return {number}
+ * @deprecated use {@link spline2_bezier}
  */
-export function spline_bezier2(t: number, p0: number, p1: number, p2: number): number;
+export const spline_bezier2: typeof spline2_bezier;
+import { spline2_bezier } from "./spline2_bezier.js";
 //# sourceMappingURL=spline_bezier2.d.ts.map

package/src/core/math/spline/spline_bezier2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spline_bezier2.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline_bezier2.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,kCANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACL,MAAM,CAMjB"}
+{"version":3,"file":"spline_bezier2.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline_bezier2.js"],"names":[],"mappings":"AAEA;;GAEG;AACH,mDAA6C;+BALd,qBAAqB"}

package/src/core/math/spline/spline_bezier2.js

@@ -1,13 +1,6 @@
+import { spline2_bezier } from "./spline2_bezier.js";
+
 /**
- * 2-nd (quadratic) degree bezier curve
- * @param {number} t
- * @param {number} p0
- * @param {number} p1
- * @param {number} p2
- * @return {number}
+ * @deprecated use {@link spline2_bezier}
  */
-export function spline_bezier2(t, p0, p1, p2) {
-    const inv_t = 1 - t;
-
-    return inv_t * inv_t * p0 + 2 * inv_t * t * p1 + t * t * p2;
-}
+export const spline_bezier2 = spline2_bezier;

package/src/core/math/spline/spline_bezier3.d.ts

@@ -1,13 +1,6 @@
 /**
- * 3-rd (cubic) degree bezier curve
- * @see https://www.youtube.com/watch?v=jvPPXbo87ds&t=234s
- * @see https://en.wikipedia.org/wiki/B%C3%A9zier_curve
- * @param {number} t factor value between 0..1
- * @param {number} p0 start point
- * @param {number} p1 control point
- * @param {number} p2 control point
- * @param {number} p3 end point
- * @returns {number}
+ * @deprecated use {@link spline3_bezier}
  */
-export function spline_bezier3(t: number, p0: number, p1: number, p2: number, p3: number): number;
+export const spline_bezier3: typeof spline3_bezier;
+import { spline3_bezier } from "./spline3_bezier.js";
 //# sourceMappingURL=spline_bezier3.d.ts.map

package/src/core/math/spline/spline_bezier3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spline_bezier3.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline_bezier3.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,kCAPW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAgBlB"}
+{"version":3,"file":"spline_bezier3.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline_bezier3.js"],"names":[],"mappings":"AAEA;;GAEG;AACH,mDAA6C;+BALd,qBAAqB"}

package/src/core/math/spline/spline_bezier3.js

@@ -1,26 +1,6 @@
+import { spline3_bezier } from "./spline3_bezier.js";
+
 /**
- * 3-rd (cubic) degree bezier curve
- * @see https://www.youtube.com/watch?v=jvPPXbo87ds&t=234s
- * @see https://en.wikipedia.org/wiki/B%C3%A9zier_curve
- * @param {number} t factor value between 0..1
- * @param {number} p0 start point
- * @param {number} p1 control point
- * @param {number} p2 control point
- * @param {number} p3 end point
- * @returns {number}
+ * @deprecated use {@link spline3_bezier}
  */
-export function spline_bezier3(t, p0, p1, p2, p3) {
-    // first we compute necessary factors for each point
-    const nt = 1 - t;
-
-    const nt_2 = nt * nt;
-
-    const nt_3 = nt_2 * nt;
-
-    const t_2 = t * t;
-
-    const t_3 = t_2 * t;
-
-    // combine factors with point values to produce final result
-    return nt_3 * p0 + 3 * nt_2 * t * p1 + 3 * nt * t_2 * p2 + t_3 * p3;
-}
+export const spline_bezier3 = spline3_bezier;

package/src/core/math/spline/spline_bezier3_bounds.d.ts

@@ -1,15 +1,6 @@
 /**
- * Compute bounds of a 3-rd degree bezier curve
- * Note that this is a 1d case solver
- * Lower bound will be written into result[offset], upper bounds will be written into result[offset+result_stride]
- * @see https://github.com/adobe-webplatform/Snap.svg/blob/c8e483c9694517e24b282f8f59f985629f4994ce/src/path.js#L856
- * @param {number[]|Float32Array} result
- * @param {number} result_offset offset into the result array
- * @param {number} result_stride
- * @param {number} p0
- * @param {number} p1
- * @param {number} p2
- * @param {number} p3
+ * @deprecated use {@link spline3_bezier_bounds}
  */
-export function spline_bezier3_bounds(result: number[] | Float32Array, result_offset: number, result_stride: number, p0: number, p1: number, p2: number, p3: number): void;
+export const spline_bezier3_bounds: typeof spline3_bezier_bounds;
+import { spline3_bezier_bounds } from "./spline3_bezier_bounds.js";
 //# sourceMappingURL=spline_bezier3_bounds.d.ts.map

package/src/core/math/spline/spline_bezier3_bounds.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spline_bezier3_bounds.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline_bezier3_bounds.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;GAYG;AACH,8CARW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,iBACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAuEhB"}
+{"version":3,"file":"spline_bezier3_bounds.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline_bezier3_bounds.js"],"names":[],"mappings":"AAEA;;GAEG;AACH,iEAA2D;sCALrB,4BAA4B"}

package/src/core/math/spline/spline_bezier3_bounds.js

@@ -1,88 +1,6 @@
-import { assert } from "../../assert.js";
-import { max2 } from "../max2.js";
-import { min2 } from "../min2.js";
-import { spline_bezier3 } from './spline_bezier3.js'
+import { spline3_bezier_bounds } from "./spline3_bezier_bounds.js";
 
 /**
- * Compute bounds of a 3-rd degree bezier curve
- * Note that this is a 1d case solver
- * Lower bound will be written into result[offset], upper bounds will be written into result[offset+result_stride]
- * @see https://github.com/adobe-webplatform/Snap.svg/blob/c8e483c9694517e24b282f8f59f985629f4994ce/src/path.js#L856
- * @param {number[]|Float32Array} result
- * @param {number} result_offset offset into the result array
- * @param {number} result_stride
- * @param {number} p0
- * @param {number} p1
- * @param {number} p2
- * @param {number} p3
+ * @deprecated use {@link spline3_bezier_bounds}
  */
-export function spline_bezier3_bounds(result, result_offset, result_stride, p0, p1, p2, p3) {
-    assert.greaterThan(result_stride, 0, 'result_stride must be greater than 0');
-    assert.isInteger(result_stride, 'result_stride');
-
-    const b = 6 * p0 - 12 * p1 + 6 * p2;
-    const a = -3 * p0 + 9 * p1 - 9 * p2 + 3 * p3;
-    const c = 3 * p1 - 3 * p0;
-
-    let min = min2(p0, p3);
-    let max = max2(p0, p3);
-
-    if (Math.abs(a) < 1e-12) {
-
-        if (Math.abs(b) >= 1e-12) {
-            const t = -c / b;
-
-            if (0 < t && t < 1) {
-                const value = spline_bezier3(t, p0, p1, p2, p3);
-
-                if (value < min) {
-                    min = value;
-                }
-                if (value > max) {
-                    max = value;
-                }
-
-            }
-
-        }
-
-    } else {
-
-        const b2ac = b * b - 4 * c * a;
-        const sqrtb2ac = Math.sqrt(b2ac);
-
-        if (b2ac >= 0) {
-
-            const t1 = (-b + sqrtb2ac) / (2 * a);
-
-            if (0 < t1 && t1 < 1) {
-                const value = spline_bezier3(t1, p0, p1, p2, p3);
-
-                if (value < min) {
-                    min = value;
-                }
-                if (value > max) {
-                    max = value;
-                }
-            }
-
-            const t2 = (-b - sqrtb2ac) / (2 * a);
-
-            if (0 < t2 && t2 < 1) {
-                const value = spline_bezier3(t2, p0, p1, p2, p3);
-
-                if (value < min) {
-                    min = value;
-                }
-                if (value > max) {
-                    max = value;
-                }
-            }
-
-        }
-
-    }
-
-    result[result_offset] = min;
-    result[result_offset + result_stride] = max;
-}
+export const spline_bezier3_bounds = spline3_bezier_bounds;

package/src/core/math/spline/spline_hermite3.d.ts

@@ -1,15 +1,6 @@
 /**
- * Perform cubic hermite interpolation
- * @see https://en.wikipedia.org/wiki/Cubic_Hermite_spline
- * @param {number} t normalized interpolation position in interval [0,1]
- * @param {number} p0 first value
- * @param {number} p1 second value
- * @param {number} m0 first tangent (tangent exiting from first value)
- * @param {number} m1 second tangent (tangent entering into second value)
- * @return {number}
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2025
+ * @deprecated use {@link spline3_hermite}
  */
-export function spline_hermite3(t: number, p0: number, p1: number, m0: number, m1: number): number;
+export const spline_hermite3: typeof spline3_hermite;
+import { spline3_hermite } from "./spline3_hermite.js";
 //# sourceMappingURL=spline_hermite3.d.ts.map

package/src/core/math/spline/spline_hermite3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spline_hermite3.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline_hermite3.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,mCAVW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACL,MAAM,CAgBjB"}
+{"version":3,"file":"spline_hermite3.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline_hermite3.js"],"names":[],"mappings":"AAEA;;GAEG;AACH,qDAA+C;gCALf,sBAAsB"}

package/src/core/math/spline/spline_hermite3.js

@@ -1,26 +1,6 @@
+import { spline3_hermite } from "./spline3_hermite.js";
+
 /**
- * Perform cubic hermite interpolation
- * @see https://en.wikipedia.org/wiki/Cubic_Hermite_spline
- * @param {number} t normalized interpolation position in interval [0,1]
- * @param {number} p0 first value
- * @param {number} p1 second value
- * @param {number} m0 first tangent (tangent exiting from first value)
- * @param {number} m1 second tangent (tangent entering into second value)
- * @return {number}
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2025
+ * @deprecated use {@link spline3_hermite}
  */
-export function spline_hermite3(t, p0, p1, m0, m1) {
-
-    const t2 = t * t;
-    const t3 = t2 * t;
-
-    const a = 2 * t3 - 3 * t2 + 1;
-    const b = t3 - 2 * t2 + t;
-    const c = t3 - t2;
-    const d = -2 * t3 + 3 * t2;
-
-    return a * p0 + b * m0 + c * m1 + d * p1;
-}
-
+export const spline_hermite3 = spline3_hermite;

package/src/core/math/spline/spline_hermite3_bounds.d.ts

@@ -1,17 +1,6 @@
 /**
- * Compute `y0,y1` bounds of a cubic hermite spline.
- * Lower bound will be written into result[offset], upper bounds will be written into result[offset+result_stride]
- *
- * @param {number[]|Float32Array} result output will be written here, only y0 and y1
- * @param {number} result_offset offset into the result array
- * @param {number} result_stride useful for mixing multidimensional results
- * @param {number} p0
- * @param {number} p1
- * @param {number} m0
- * @param {number} m1
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2025
+ * @deprecated use {@link spline3_hermite_bounds}
  */
-export function spline_hermite3_bounds(result: number[] | Float32Array, result_offset: number, result_stride: number, p0: number, p1: number, m0: number, m1: number): void;
+export const spline_hermite3_bounds: typeof spline3_hermite_bounds;
+import { spline3_hermite_bounds } from "./spline3_hermite_bounds.js";
 //# sourceMappingURL=spline_hermite3_bounds.d.ts.map

package/src/core/math/spline/spline_hermite3_bounds.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spline_hermite3_bounds.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline_hermite3_bounds.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;GAcG;AACH,+CAXW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,iBACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAqFhB"}
+{"version":3,"file":"spline_hermite3_bounds.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline_hermite3_bounds.js"],"names":[],"mappings":"AAEA;;GAEG;AACH,mEAA6D;uCALtB,6BAA6B"}

package/src/core/math/spline/spline_hermite3_bounds.js

@@ -1,101 +1,6 @@
-import { assert } from "../../assert.js";
-import { max2 } from "../max2.js";
-import { min2 } from "../min2.js";
-import { spline_hermite3 } from "./spline_hermite3.js";
+import { spline3_hermite_bounds } from "./spline3_hermite_bounds.js";
 
 /**
- * Compute `y0,y1` bounds of a cubic hermite spline.
- * Lower bound will be written into result[offset], upper bounds will be written into result[offset+result_stride]
- *
- * @param {number[]|Float32Array} result output will be written here, only y0 and y1
- * @param {number} result_offset offset into the result array
- * @param {number} result_stride useful for mixing multidimensional results
- * @param {number} p0
- * @param {number} p1
- * @param {number} m0
- * @param {number} m1
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2025
+ * @deprecated use {@link spline3_hermite_bounds}
  */
-export function spline_hermite3_bounds(
-    result,
-    result_offset,
-    result_stride,
-    p0, p1, m0, m1) {
-
-    /*
-     Solution is based on https://stackoverflow.com/questions/24809978/calculating-the-bounding-box-of-cubic-bezier-curve
-     Differentiation of hermite polynomial is done in WolframAlpha:
-     0 = 3 t^2 (m0 + m1 + 2 p0 - 2 p1) - 2 t (2 m0 + m1 + 3 p0 - 3 p1) + m0
-    */
-
-    assert.greaterThan(result_stride, 0, 'result_stride must be greater than 0');
-    assert.isInteger(result_stride, 'result_stride');
-
-    const a = 3 * (m0 + m1 + 2 * p0 - 2 * p1);
-    const b = -2 * (2 * m0 + m1 + 3 * p0 - 3 * p1);
-    const c = m0;
-
-    let min = min2(p0, p1);
-    let max = max2(p0, p1);
-
-    if (Math.abs(a) < 1e-12) {
-
-        if (Math.abs(b) >= 1e-12) {
-            const t = -c / b;
-
-            if (0 < t && t < 1) {
-                const value = spline_hermite3(t, p0, p1, m0, m1);
-
-                if (value < min) {
-                    min = value;
-                }
-                if (value > max) {
-                    max = value;
-                }
-
-            }
-
-        }
-
-    } else {
-
-        const b2ac = b * b - 4 * c * a;
-        const sqrtb2ac = Math.sqrt(b2ac);
-
-        if (b2ac >= 0) {
-
-            const t1 = (-b + sqrtb2ac) / (2 * a);
-
-            if (0 < t1 && t1 < 1) {
-                const value = spline_hermite3(t1, p0, p1, m0, m1);
-
-                if (value < min) {
-                    min = value;
-                }
-                if (value > max) {
-                    max = value;
-                }
-            }
-
-            const t2 = (-b - sqrtb2ac) / (2 * a);
-
-            if (0 < t2 && t2 < 1) {
-                const value = spline_hermite3(t2, p0, p1, m0, m1);
-
-                if (value < min) {
-                    min = value;
-                }
-                if (value > max) {
-                    max = value;
-                }
-            }
-
-        }
-
-    }
-
-    result[result_offset] = min;
-    result[result_offset + result_stride] = max;
-}
+export const spline_hermite3_bounds = spline3_hermite_bounds;

package/src/core/math/spline/spline_hermite3_to_bezier.d.ts

@@ -1,13 +1,2 @@
-/**
- * One-dimensional curve conversion from cubic Hermite to bezier
- * TODO: not tested
- * @param {Float32Array|number[]} result where to put results
- * @param {number} result_offset offset to start writing at in result array
- * @param {number} result_stride how far to step between each written value. Necessary for N-dimensional curves where we want to interleave multiple curves together, such as for color or quaternions
- * @param {number} p0
- * @param {number} p1
- * @param {number} m0 tangent at p0
- * @param {number} m1 tangent at p1
- */
-export function spline_hermite3_to_bezier(result: Float32Array | number[], result_offset: number, result_stride: number, p0: number, p1: number, m0: number, m1: number): void;
+export {};
 //# sourceMappingURL=spline_hermite3_to_bezier.d.ts.map

package/src/core/math/spline/spline_hermite3_to_bezier.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spline_hermite3_to_bezier.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline_hermite3_to_bezier.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,kDARW,YAAY,GAAC,MAAM,EAAE,iBACrB,MAAM,iBACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAkBhB"}
+{"version":3,"file":"spline_hermite3_to_bezier.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline_hermite3_to_bezier.js"],"names":[],"mappings":""}

package/src/core/math/spline/spline_hermite3_to_bezier.js

@@ -1,28 +1,6 @@
+import { spline3_hermite_to_bezier } from "./spline3_hermite_to_bezier.js";
+
 /**
- * One-dimensional curve conversion from cubic Hermite to bezier
- * TODO: not tested
- * @param {Float32Array|number[]} result where to put results
- * @param {number} result_offset offset to start writing at in result array
- * @param {number} result_stride how far to step between each written value. Necessary for N-dimensional curves where we want to interleave multiple curves together, such as for color or quaternions
- * @param {number} p0
- * @param {number} p1
- * @param {number} m0 tangent at p0
- * @param {number} m1 tangent at p1
+ * @deprecated use {@link spline3_hermite_to_bezier}
  */
-export function spline_hermite3_to_bezier(
-    result,
-    result_offset,
-    result_stride,
-    p0, p1,
-    m0, m1
-) {
-
-    // see https://stackoverflow.com/questions/42574940/draw-hermite-curve-on-browser-canvas-javascript
-    // see https://pomax.github.io/bezierinfo/#catmullconv
-
-    result[result_offset + 0 * result_stride] = p0;
-    result[result_offset + 1 * result_stride] = p0 + m0 / 3;
-    result[result_offset + 2 * result_stride] = p1 - m1 / 3;
-    result[result_offset + 3 * result_stride] = p1;
-
-}
+const spline_hermite3_to_bezier = spline3_hermite_to_bezier;

package/src/engine/animation/curve/animation_curve_compute_aabb.js

@@ -1,6 +1,6 @@
 import { max2 } from "../../../core/math/max2.js";
 import { min2 } from "../../../core/math/min2.js";
-import { spline_hermite3_bounds } from "../../../core/math/spline/spline_hermite3_bounds.js";
+import { spline3_hermite_bounds } from "../../../core/math/spline/spline3_hermite_bounds.js";
 
 const temp_bounds = new Float32Array(2);
 
@@ -33,7 +33,7 @@ export function animation_curve_compute_aabb(out, curve) {
 
             const time_delta = keyframe.time - previous.time;
 
-            spline_hermite3_bounds(temp_bounds, 0, 1,
+            spline3_hermite_bounds(temp_bounds, 0, 1,
                 previous.value, keyframe.value,
                 previous.outTangent * time_delta,
                 keyframe.inTangent * time_delta

package/src/engine/animation/curve/evaluate_two_key_curve.js

@@ -1,5 +1,5 @@
 import { inverseLerp } from "../../../core/math/inverseLerp.js";
-import { spline_hermite3 } from "../../../core/math/spline/spline_hermite3.js";
+import { spline3_hermite } from "../../../core/math/spline/spline3_hermite.js";
 
 /**
  *
@@ -14,7 +14,7 @@ export function evaluate_two_key_curve(time, keyframe0, keyframe1) {
 
     const time_distance = keyframe1.time - keyframe0.time;
 
-    return spline_hermite3(
+    return spline3_hermite(
         normalized_time,
         keyframe0.value, keyframe1.value,
         keyframe0.outTangent * time_distance,