@woosh/meep-engine 2.110.7 → 2.110.9

package/src/core/geom/3d/tetrahedra/delaunay/tetrahedral_mesh_build_from_grid.spec.js

@@ -0,0 +1,38 @@
+import { AABB3 } from "../../aabb/AABB3.js";
+import { TetrahedralMesh } from "../TetrahedralMesh.js";
+import { tetrahedral_mesh_build_from_grid } from "./tetrahedral_mesh_build_from_grid.js";
+
+test("Single cube", () => {
+
+    const mesh = new TetrahedralMesh();
+
+    const points = [];
+
+    tetrahedral_mesh_build_from_grid(
+        mesh,
+        points,
+        new AABB3(0, 0, 0, 1, 1, 1),
+        2, 2, 2
+    );
+
+    // number of points
+    expect(points.length).toBe(8 * 3);
+
+    expect(mesh.count).toBeGreaterThanOrEqual(5);
+    expect(mesh.count).toBeLessThanOrEqual(6);
+
+    // mesh should only reference created points
+    const tetrahedrons = mesh.getLive();
+
+    for (let i = 0; i < tetrahedrons.length; i++) {
+        const tet = tetrahedrons[i];
+
+        for (let vertex_index = 0; vertex_index < 4; vertex_index++) {
+
+            const vert = mesh.getVertexIndex(tet, vertex_index);
+
+            expect(vert).toBeGreaterThanOrEqual(0);
+            expect(vert).toBeLessThan(8);
+        }
+    }
+});

package/src/core/geom/3d/tetrahedra/prototypeTetrahedraBuilder.js

@@ -7,6 +7,7 @@ import { ShadedGeometry } from "../../../../engine/graphics/ecs/mesh-v2/ShadedGe
 import { ShadedGeometrySystem } from "../../../../engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.js";
 import { Gizmo } from "../../../../engine/graphics/render/gizmo/Gizmo.js";
 import { GizmoRenderingPlugin } from "../../../../engine/graphics/render/gizmo/GizmoRenderingPlugin.js";
+import { randomFloatBetween } from "../../../math/random/randomFloatBetween.js";
 import { seededRandom } from "../../../math/random/seededRandom.js";
 import { number_pretty_print } from "../../../primitives/numbers/number_pretty_print.js";
 import { delay } from "../../../process/delay.js";
@@ -14,8 +15,38 @@ import { AABB3 } from "../aabb/AABB3.js";
 import { make_justified_point_grid } from "../util/make_justified_point_grid.js";
 import { build_tetrahedral_mesh_buffer_geometry } from "./build_tetrahedral_mesh_buffer_geometry.js";
 import { compute_delaunay_tetrahedral_mesh } from "./delaunay/compute_delaunay_tetrahedral_mesh.js";
+import { tetrahedral_mesh_build_from_grid } from "./delaunay/tetrahedral_mesh_build_from_grid.js";
 import { TetrahedralMesh } from "./TetrahedralMesh.js";
 
+
+/**
+ *
+ * @param {TetrahedralMesh} tetrahedra
+ * @param {number[]} points
+ */
+function make_delaunay_grid(tetrahedra, points) {
+
+    const random = seededRandom();
+
+    for (let i = 0; i < 600; i++) {
+        points.push(
+            randomFloatBetween(random, -100, 100),
+            randomFloatBetween(random, 0, 150),
+            randomFloatBetween(random, -100, 100),
+        );
+    }
+
+    make_justified_point_grid(
+        new AABB3(-100, 0, -100, 100, 150, 100),
+        20,
+        (x, y, z) => {
+            points.push(x, y, z);
+        }
+    );
+
+    compute_delaunay_tetrahedral_mesh(tetrahedra, points, points.length / 3);
+}
+
 /**
  *
  * @param {Engine} engine
@@ -30,51 +61,23 @@ async function main(engine) {
     const offset = [7.5, 1, 7.5];
     const scale = [.5, .5, .5];
 
+    /**
+     *
+     * @type {number[]}
+     */
     const points = [];
 
-    // points.push(
-    //     0, 0, 0,
-    //     10, 0, 0,
-    //     10, 0, 10,
-    //     0, 0, 10,
-    //
-    //     0, 10, 0,
-    //     10, 10, 0,
-    //     10, 10, 10,
-    //     0, 10, 10,
-    // );
-
-    const random = seededRandom();
-
-    // for (let i = 0; i < 600; i++) {
-    //     points.push(
-    //         randomFloatBetween(random, -100, 100),
-    //         randomFloatBetween(random, 0, 150),
-    //         randomFloatBetween(random, -100, 100),
-    //     );
-    // }
-
-    make_justified_point_grid(
-        new AABB3(-100, 0, -100, 100, 150, 100),
-        20,
-        (x, y, z) => {
-            points.push(x, y, z);
-        }
-    );
+    const tetrahedra = new TetrahedralMesh();
 
     await delay(1000);
 
-    const tetrahedra = new TetrahedralMesh();
     console.time('mesh build');
-    // console.profile('mesh build');
-    compute_delaunay_tetrahedral_mesh(tetrahedra, points, points.length / 3);
-    // tetrahedral_mesh_build_from_grid(
-    //     tetrahedra,
-    //     points,
-    //     new AABB3(-100, 0, -100, 100, 100, 100),
-    //     64, 32, 64
-    // )
-    // console.profileEnd('mesh build');
+    tetrahedral_mesh_build_from_grid(
+        tetrahedra,
+        points,
+        new AABB3(-10, 0, -10, 10, 10, 10),
+        8, 4, 8
+    )
     console.timeEnd('mesh build');
     console.log(`Mesh build for ${number_pretty_print(points.length / 3)} points`)
 

package/src/core/geom/3d/v3_compute_triangle_normal.js

@@ -54,4 +54,4 @@ export function v3_compute_triangle_normal(
     result[result_offset] = x;
     result[result_offset + 1] = y;
     result[result_offset + 2] = z;
-}
+}

package/src/core/geom/3d/v3_negate_array.d.ts

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {number[]|Float32Array} result
+ * @param {number} result_offset
+ * @param {number[]|Float32Array} input
+ * @param {number} input_offset
+ */
+export function v3_negate_array(result: number[] | Float32Array, result_offset: number, input: number[] | Float32Array, input_offset: number): void;
+//# sourceMappingURL=v3_negate_array.d.ts.map

package/src/core/geom/3d/v3_negate_array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v3_negate_array.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/3d/v3_negate_array.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wCALW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,gBACrB,MAAM,QAUhB"}

package/src/core/geom/3d/v3_negate_array.js

@@ -0,0 +1,16 @@
+/**
+ *
+ * @param {number[]|Float32Array} result
+ * @param {number} result_offset
+ * @param {number[]|Float32Array} input
+ * @param {number} input_offset
+ */
+export function v3_negate_array(result, result_offset, input, input_offset) {
+    const x = input[input_offset];
+    const y = input[input_offset + 1];
+    const z = input[input_offset + 2];
+
+    result[result_offset] = -x;
+    result[result_offset + 1] = -y;
+    result[result_offset + 2] = -z;
+}

package/src/core/geom/Quaternion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Quaternion.d.ts","sourceRoot":"","sources":["../../../../src/core/geom/Quaternion.js"],"names":[],"mappings":";AAsBA;IA+2CI;;;;OAIG;IACH,kCAFa,UAAU,CAQtB;IAED;;;;;;OAMG;IACH,0BALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,UAAU,CAQtB;IAED;;;;;;OAMG;IACH,6BALW,UAAU,QACV,UAAU,MACV,UAAU,aACV,MAAM,QAkBhB;IAj6CD;;;;;;;OAOG;IACH,gBANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,EA+BhB;IA1BG;;;OAGG;IACH,GAFU,MAAM,CAEN;IACV;;;OAGG;IACH,GAFU,MAAM,CAEN;IACV;;;OAGG;IACH,GAFU,MAAM,CAEN;IACV;;;OAGG;IACH,GAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,oBAFU,OAAO,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEnD;IAqBjC,mBAEC;IAlBD,gBAEC;IAkBD,mBAEC;IAlBD,gBAEC;IAkBD,mBAEC;IAlBD,gBAEC;IAkBD,mBAEC;IAlBD,gBAEC;IA+BD;;;;;;;;OAQG;IACH,kBAPW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAiDhB;IAED;;;;;OAKG;IACH,uBAJW,OAAO,QACP,OAAO,QAMjB;IAED;;;;OAIG;IACH,WAHW,UAAU,GACT,MAAM,CAQjB;IAED;;;OAGG;IACH,mBAFW,UAAU,QAKpB;IAED;;OAEG;IACH,eAqBC;IAED;;;;OAIG;IACH,eAHW,UAAU,GACT,MAAM,CAoBjB;IAED;;;;OAIG;IACH,oBAHW,OAAO,SACP,MAAM,QAIhB;IAED;;;;;;OAMG;IACH,mBALW,MAAM,MACN,MAAM,MACN,MAAM,SACN,MAAM,QAwBhB;IAED;;;;;OAKG;IACH,2BAJW,OAAO,SACP,UAAU,SACV,UAAU,QA+BpB;IAED;;;;OAIG;IACH,wBAHW,OAAO,GACL,MAAM,CAYlB;IAED;;;;OAIG;IACH,kBAHW,OAAO,GACL,MAAM,CAkBlB;IAED,kBAWC;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACL,UAAU,CASrB;IAED;;OAEG;IACH,gBAFW,UAAU,QAIpB;IAED;;;;OAIG;IACH,2BAHW,UAAU,UACV,UAAU,QAcpB;IAED;;;;;;;;;;;OAWG;IACH,yBAVW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACL,UAAU,CAYrB;IAED;;;OAGG;IACH,UAFY,MAAM,CASjB;IAED;;;;OAIG;IACH,qBAHW,UAAU,aACV,MAAM,QAIhB;IAED;;;;;OAKG;IACH,eAJW,OAAO,UACP,OAAO,OACP,OAAO,QAUjB;IAED;;;OAGG;IACH,wBAFsB,MAAM,QAM3B;IAED;;;;;;;OAOG;IACH,kBANW,MAAM,KACN,MAAM,KACN,MAAM,mBAEJ,UAAU,CAmCtB;IAED;;;;OAIG;IACH,yBAFW,OAAO,QA4BjB;IAED;;;OAGG;IACH,yBAFW,OAAO,QA2BjB;IAED;;;OAGG;IACH,yBAFW,OAAO,QA0BjB;IAED;;;;;;OAMG;IACH,mBAJW,MAAM,KACN,MAAM,KACN,MAAM,QAIhB;IAED;;;;;;;;OAQG;IACH,sBAJW,MAAM,KACN,MAAM,KACN,MAAM,QAqBhB;IAED;;;;;;;;OAQG;IACH,sBAJW,MAAM,KACN,MAAM,KACN,MAAM,QAqBhB;IAED;;;;;;;;OAQG;IACH,sBAJW,MAAM,KACN,MAAM,KACN,MAAM,QAqBhB;IAED;;;;;;;;OAQG;IACH,sBAJW,MAAM,KACN,MAAM,KACN,MAAM,QAqBhB;IAED;;;;;;;;OAQG;IACH,sBAJW,MAAM,KACN,MAAM,KACN,MAAM,QAqBhB;IAED;;;;;;;;OAQG;IACH,sBAJW,MAAM,KACN,MAAM,KACN,MAAM,QAqBhB;IAED;;;;OAIG;IACH,yBAHW,OAAO,MACP,OAAO,QA+CjB;IAED;;;;;OAKG;IACH,sBAHW,OAAO,MACP,OAAO,QAiEjB;IAED;;;OAGG;IACH,wCASC;IAED;;;;;;;;;;;;;;OAcG;IACH,6BAXW,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,GACJ,UAAU,CA4EtB;IAED;;;;OAIG;IACH,YAHW,UAAU,KACV,MAAM,QAMhB;IAED;;;;;OAKG;IACH,uBAJW,UAAU,UACV,UAAU,KACV,MAAM,QAgBhB;IAED;;;;;OAKG;IACH,uBAJW,UAAU,MACV,UAAU,KACV,MAAM,QAiDhB;IAGD;;;;OAIG;IACH,aAHW,UAAU,KACV,MAAM,QAIhB;IAED;;;OAGG;IACH,iCAIC;IAED;;;;OAIG;IACH,YAHW,UAAU,GACR,UAAU,CAItB;IAED;;;OAGG;IACH,SAFa,UAAU,CAQtB;IAED;;;;;;;OAOG;IACH,OANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,UAAU,CA+BtB;IAED;;;OAGG;IACH,aAFa,UAAU,CAItB;IAED;;;;;MAOC;IAED,yBAEC;IAED;;;OAGG;IACH,2CAKC;IAED;;;OAGG;IACH,6CAOC;IAED;;;OAGG;IACH,kDAKC;IAED;;;OAGG;IACH,oDAOC;IAED;;;;OAIG;IACH,wBAFW,MAAM,QAIhB;IAED;;;;OAIG;IACH,kBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,qBAHW,MAAM,EAAE,WACR,MAAM,QAShB;IAED;;;;OAIG;IACH,oBAHW,MAAM,EAAE,WACR,MAAM,QAOhB;IAED,oBAEC;IAED;;;;OAIG;IACH,cAHW,UAAU,GACR,OAAO,CAQnB;IAED;;;OAGG;IACH,QAFa,MAAM,CAQlB;IAED;;;;;OAKG;IACH,qBAJW,UAAU,cACV,MAAM,GACL,OAAO,CAIlB;IAED;;;;;;;;;OASG;IACH,uBAKC;IAED;;;;OAIG;IACH,sBAHsB,MAAM,GAChB,UAAU,CAkBrB;IAED,mBAEC;IAwDL,mBAjKe,MAAM,EAAE,WACR,MAAM,UAgKS;IAC9B,iBApJe,MAAM,EAAE,WACR,MAAM,UAmJO;IA71CxB;;OAEG;IACH,sDAOC;CAg1CJ;;kBAOS,UAAU;;mBA/7CD,4BAA4B;oBAW3B,cAAc"}
+{"version":3,"file":"Quaternion.d.ts","sourceRoot":"","sources":["../../../../src/core/geom/Quaternion.js"],"names":[],"mappings":"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"}

package/src/core/geom/Quaternion.js

@@ -13,9 +13,9 @@ import { v4_length } from "./vec4/v4_length.js";
 import Vector3 from "./Vector3.js";
 
 
-const forward = new Vector3();
-const up = new Vector3();
-const right = new Vector3();
+const scratch_v3_a = new Vector3();
+const scratch_v3_b = new Vector3();
+const scratch_v3_c = new Vector3();
 
 const sin = Math.sin;
 const cos = Math.cos;
@@ -116,12 +116,12 @@ class Quaternion {
      * @param {number} uz up vector
      */
     _lookRotation(fx, fy, fz, ux, uy, uz) {
-        forward.set(fx, fy, fz);
-        forward.normalize();
+        scratch_v3_a.set(fx, fy, fz);
+        scratch_v3_a.normalize();
 
-        right._crossVectors(ux, uy, uz, forward.x, forward.y, forward.z);
+        scratch_v3_c._crossVectors(ux, uy, uz, scratch_v3_a.x, scratch_v3_a.y, scratch_v3_a.z);
 
-        if (right.lengthSq() === 0) {
+        if (scratch_v3_c.lengthSq() === 0) {
             // up and forward are parallel
 
             /*
@@ -130,32 +130,32 @@ class Quaternion {
              */
 
             if (Math.abs(uz) === 1) {
-                forward.x += 0.001;
+                scratch_v3_a.x += 0.001;
             } else {
-                forward.z += 0.001;
+                scratch_v3_a.z += 0.001;
             }
 
-            forward.normalize();
-            right._crossVectors(ux, uy, uz, forward.x, forward.y, forward.z);
+            scratch_v3_a.normalize();
+            scratch_v3_c._crossVectors(ux, uy, uz, scratch_v3_a.x, scratch_v3_a.y, scratch_v3_a.z);
 
         }
 
-        right.normalize();
+        scratch_v3_c.normalize();
 
-        up.crossVectors(forward, right);
+        scratch_v3_b.crossVectors(scratch_v3_a, scratch_v3_c);
 
         // construct partial transform matrix
-        const m00 = right.x;
-        const m10 = right.y;
-        const m20 = right.z;
+        const m00 = scratch_v3_c.x;
+        const m10 = scratch_v3_c.y;
+        const m20 = scratch_v3_c.z;
 
-        const m01 = up.x;
-        const m11 = up.y;
-        const m21 = up.z;
+        const m01 = scratch_v3_b.x;
+        const m11 = scratch_v3_b.y;
+        const m21 = scratch_v3_b.z;
 
-        const m02 = forward.x;
-        const m12 = forward.y;
-        const m22 = forward.z;
+        const m02 = scratch_v3_a.x;
+        const m12 = scratch_v3_a.y;
+        const m22 = scratch_v3_a.z;
 
         this.__setFromRotationMatrix(
             m00, m01, m02,
@@ -189,7 +189,7 @@ class Quaternion {
     }
 
     /**
-     *
+     * Makes this quaternion into an inverse of the other
      * @param {Quaternion} other
      */
     copyInverse(other) {
@@ -209,7 +209,7 @@ class Quaternion {
         const length_sqr = x * x + y * y + z * z + w * w;
 
         if (length_sqr === 0) {
-            this.set(0, 0, 0, 0);
+            this.set(0, 0, 0, 1);
             return;
         }
 
@@ -265,6 +265,11 @@ class Quaternion {
      * @param {number} angle
      */
     _fromAxisAngle(ax, ay, az, angle) {
+        assert.isNumber(ax, 'ax');
+        assert.isNumber(ay, 'ay');
+        assert.isNumber(az, 'az');
+        assert.isNumber(angle, 'angle');
+
         const halfAngle = angle * 0.5;
 
         const sinA2 = sin(halfAngle);
@@ -303,7 +308,7 @@ class Quaternion {
         // perform projection of rotation onto axis
         const d = v3_dot(x, y, z, axis.x, axis.y, axis.z);
 
-        const mag2 = (axis.x * axis.x + axis.y * axis.y + axis.z * axis.z);
+        const mag2 = axis.x * axis.x + axis.y * axis.y + axis.z * axis.z;
 
         const m = d / mag2;
 
@@ -818,58 +823,6 @@ class Quaternion {
         this.set(_x, _y, _z, _w);
     }
 
-    /**
-     * Based on blog post: http://lolengine.net/blog/2013/09/18/beautiful-maths-quaternion-from-vectors
-     * @param {Vector3} from
-     * @param {Vector3} to
-     */
-    fromNonUnitVectors(from, to) {
-        //quat quat::fromtwovectors(vec3 u, vec3 v)
-        // {
-        //     vec3 w = cross(u, v);
-        //     quat q = quat(dot(u, v), w.x, w.y, w.z);
-        //     q.w += length(q);
-        //     return normalize(q);
-        // }
-
-        const ax = from.x;
-        const ay = from.y;
-        const az = from.z;
-
-        const bx = to.x;
-        const by = to.y;
-        const bz = to.z;
-
-        //compute cross product
-        const crossX = ay * bz - az * by;
-        const crossY = az * bx - ax * bz;
-        const crossZ = ax * by - ay * bx;
-
-        const uv_dot = v3_dot(ax, ay, az, bx, by, bz);
-
-
-        const qX = crossX;
-        const qY = crossY;
-        const qZ = crossZ;
-        const qW = uv_dot;
-
-        const p0 = qX * qX + qY * qY + qZ * qZ;
-
-        const l0 = Math.sqrt(p0 + qW * qW);
-
-        const qW_1 = qW + l0;
-
-        //normalize result
-        const l1 = 1 / Math.sqrt(p0 + qW_1 * qW_1);
-
-        const x = qX * l1;
-        const y = qY * l1;
-        const z = qZ * l1;
-        const w = qW * l1;
-
-        this.set(x, y, z, w);
-    }
-
     /**
      * NOTE: Vectors need to be normalized
      * Based on blog post: http://lolengine.net/blog/2013/09/18/beautiful-maths-quaternion-from-vectors

package/src/core/geom/Vector3.d.ts

@@ -112,6 +112,10 @@ export default class Vector3 implements Vector3Like {
 
     writeToArray(array: number[] | ArrayLike<number>, offset?: number): void
 
+    toArray(array: number[] | ArrayLike<number>, offset?: number): void
+
+    fromArray(array: number[] | ArrayLike<number>, offset?: number): void
+
     asArray(): number[]
 
     static distance(a: Vector3Like, b: Vector3Like): number

package/src/core/geom/Vector3.js

@@ -505,10 +505,10 @@ class Vector3 {
 
         // calculate quat * vector
 
-        var ix = qw * x + qy * z - qz * y;
-        var iy = qw * y + qz * x - qx * z;
-        var iz = qw * z + qx * y - qy * x;
-        var iw = -qx * x - qy * y - qz * z;
+        const ix = qw * x + qy * z - qz * y;
+        const iy = qw * y + qz * x - qx * z;
+        const iz = qw * z + qx * y - qy * x;
+        const iw = -qx * x - qy * y - qz * z;
 
         // calculate result * inverse quat
 

package/src/core/geom/vec3/v3_cross_array.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Cross product
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number[]|Float32Array} a
+ * @param {number} a_offset
+ * @param {number[]|Float32Array} b
+ * @param {number} b_offset
+ */
+export function v3_cross_array(output: number[] | Float32Array, output_offset: number, a: number[] | Float32Array, a_offset: number, b: number[] | Float32Array, b_offset: number): void;
+//# sourceMappingURL=v3_cross_array.d.ts.map

package/src/core/geom/vec3/v3_cross_array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v3_cross_array.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_cross_array.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,uCAPW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,YACrB,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,YACrB,MAAM,QAuBhB"}

package/src/core/geom/vec3/v3_cross_array.js

@@ -0,0 +1,31 @@
+/**
+ * Cross product
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number[]|Float32Array} a
+ * @param {number} a_offset
+ * @param {number[]|Float32Array} b
+ * @param {number} b_offset
+ */
+export function v3_cross_array(
+    output, output_offset,
+    a, a_offset,
+    b, b_offset,
+) {
+
+    const ax = a[a_offset];
+    const ay = a[a_offset + 1];
+    const az = a[a_offset + 2];
+
+    const bx = b[b_offset];
+    const by = b[b_offset + 1];
+    const bz = b[b_offset + 2];
+
+    const x = ay * bz - az * by;
+    const y = az * bx - ax * bz;
+    const z = ax * by - ay * bx;
+
+    output[output_offset] = x;
+    output[output_offset + 1] = y;
+    output[output_offset + 2] = z;
+}

package/src/core/geom/vec3/v3_displace_in_direction.js

@@ -16,7 +16,7 @@ export function v3_displace_in_direction(
     origin_x, source_y, source_z,
     direction_x, direction_y, direction_z
 ) {
-    
+
     if (distance === 0) {
         result.set(origin_x, source_y, source_z);
         return true;
@@ -43,4 +43,5 @@ export function v3_displace_in_direction(
     result.set(x, y, z);
 
     return true;
-}
+}
+

package/src/core/geom/vec3/v3_displace_in_direction_array.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Direction vector must be normalized
+ * @param {number[]|Float32Array} result
+ * @param {number} result_offset
+ * @param {number[]|Float32Array} origin
+ * @param {number} origin_offset
+ * @param {number[]|Float32Array} direction Must be normalized
+ * @param {number} direction_offset
+ * @param {number} distance
+ */
+export function v3_displace_in_direction_array(result: number[] | Float32Array, result_offset: number, origin: number[] | Float32Array, origin_offset: number, direction: number[] | Float32Array, direction_offset: number, distance: number): void;
+//# sourceMappingURL=v3_displace_in_direction_array.d.ts.map

package/src/core/geom/vec3/v3_displace_in_direction_array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v3_displace_in_direction_array.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_displace_in_direction_array.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,uDARW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,aACN,MAAM,EAAE,GAAC,YAAY,oBACrB,MAAM,YACN,MAAM,QAahB"}

package/src/core/geom/vec3/v3_displace_in_direction_array.js

@@ -0,0 +1,22 @@
+/**
+ * Direction vector must be normalized
+ * @param {number[]|Float32Array} result
+ * @param {number} result_offset
+ * @param {number[]|Float32Array} origin
+ * @param {number} origin_offset
+ * @param {number[]|Float32Array} direction Must be normalized
+ * @param {number} direction_offset
+ * @param {number} distance
+ */
+export function v3_displace_in_direction_array(
+    result, result_offset,
+    origin, origin_offset,
+    direction, direction_offset,
+    distance
+) {
+
+    result[result_offset] = origin[origin_offset] + direction[direction_offset + 0] * distance;
+    result[result_offset + 1] = origin[origin_offset + 1] + direction[direction_offset + 1] * distance;
+    result[result_offset + 2] = origin[origin_offset + 2] + direction[direction_offset + 2] * distance;
+
+}

package/src/core/geom/vec3/v3_dot_array_array.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_dot_array_array.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_dot_array_array.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,sCANW,MAAM,EAAE,GAAC,YAAY,YACrB,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,YACrB,MAAM,GACJ,MAAM,CAalB"}
+{"version":3,"file":"v3_dot_array_array.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_dot_array_array.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,sCANW,MAAM,EAAE,GAAC,YAAY,YACrB,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,YACrB,MAAM,GACJ,MAAM,CAgBlB"}

package/src/core/geom/vec3/v3_dot_array_array.js

@@ -6,7 +6,10 @@
  * @param {number} b_offset
  * @returns {number}
  */
-export function v3_dot_array_array(a, a_offset, b, b_offset) {
+export function v3_dot_array_array(
+    a, a_offset,
+    b, b_offset
+) {
 
     const a_x = a[a_offset];
     const a_y = a[a_offset + 1];

package/src/core/geom/vec3/v3_normalize_array.d.ts

@@ -1,9 +1,9 @@
 /**
  *
- * @param {number[]|Float32Array} input
- * @param {number} input_offset
  * @param {number[]|Float32Array} output
  * @param {number} output_offset
+ * @param {number[]|Float32Array} input
+ * @param {number} input_offset
  */
-export function v3_normalize_array(input: number[] | Float32Array, input_offset: number, output: number[] | Float32Array, output_offset: number): void;
+export function v3_normalize_array(output: number[] | Float32Array, output_offset: number, input: number[] | Float32Array, input_offset: number): void;
 //# sourceMappingURL=v3_normalize_array.d.ts.map

package/src/core/geom/vec3/v3_normalize_array.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_normalize_array.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_normalize_array.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,0CALW,MAAM,EAAE,GAAC,YAAY,gBACrB,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,QAqBhB"}
+{"version":3,"file":"v3_normalize_array.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_normalize_array.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,2CALW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,gBACrB,MAAM,QAqBhB"}

package/src/core/geom/vec3/v3_normalize_array.js

@@ -2,14 +2,14 @@ import { v3_length } from "./v3_length.js";
 
 /**
  *
- * @param {number[]|Float32Array} input
- * @param {number} input_offset
  * @param {number[]|Float32Array} output
  * @param {number} output_offset
+ * @param {number[]|Float32Array} input
+ * @param {number} input_offset
  */
 export function v3_normalize_array(
+    output, output_offset,
     input, input_offset,
-    output, output_offset
 ) {
 
 

package/src/core/math/copysign.d.ts

@@ -2,7 +2,7 @@
  * Returns a value with the magnitude of x and the sign of y.
  * NOTE: a port of c++ method from tgmath.h
  * @param {number} x
- * @param {number} y
+ * @param {number} y take sign from this value
  * @returns {number}
  */
 export function copysign(x: number, y: number): number;

package/src/core/math/copysign.js

@@ -2,7 +2,7 @@
  * Returns a value with the magnitude of x and the sign of y.
  * NOTE: a port of c++ method from tgmath.h
  * @param {number} x
- * @param {number} y
+ * @param {number} y take sign from this value
  * @returns {number}
  */
 export function copysign(x, y) {

package/src/core/math/epsilonEquals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"epsilonEquals.d.ts","sourceRoot":"","sources":["../../../../src/core/math/epsilonEquals.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,iCALW,MAAM,KACN,MAAM,aACN,MAAM,GACJ,OAAO,CASnB"}
+{"version":3,"file":"epsilonEquals.d.ts","sourceRoot":"","sources":["../../../../src/core/math/epsilonEquals.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,iCALW,MAAM,KACN,MAAM,cACN,MAAM,GACJ,OAAO,CASnB"}

package/src/core/math/epsilonEquals.js

@@ -1,13 +1,14 @@
 import { assert } from "../assert.js";
+import { EPSILON } from "./EPSILON.js";
 
 /**
  * Comparison of two numbers with a given tolerance
  * @param {number} a
  * @param {number} b
- * @param {number} tolerance
+ * @param {number} [tolerance]
  * @returns {boolean}
  */
-export function epsilonEquals(a, b, tolerance) {
+export function epsilonEquals(a, b, tolerance = EPSILON) {
     assert.isNumber(a, 'a');
     assert.isNumber(b, 'b');
     assert.isNumber(tolerance, 'tolerance');

package/src/core/math/linalg/README.md

@@ -1 +1 @@
-Linear Argebra package
+# Linear Algebra package

package/src/core/math/random/randomGaussian.spec.js

@@ -1,4 +1,4 @@
-import { makeSequenceLoop } from "../makeSequenceLoop.js";
+import { makeSequenceLoop } from "../../function/makeSequenceLoop.js";
 import { randomGaussian } from "./randomGaussian.js";
 
 test("sample is average of rolls", () => {

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

@@ -4,7 +4,7 @@
  * @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 existing from first value)
+ * @param {number} m0 first tangent (tangent exiting from first value)
  * @param {number} m1 second tangent (tangent entering into second value)
  * @return {number}
  */

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

@@ -4,7 +4,7 @@
  * @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 existing from first value)
+ * @param {number} m0 first tangent (tangent exiting from first value)
  * @param {number} m1 second tangent (tangent entering into second value)
  * @return {number}
  */

package/src/core/process/delay.d.ts

@@ -1,2 +1,7 @@
-export function delay(timeout_ms: any): Promise<any>;
+/**
+ *
+ * @param {number} timeout_ms in milliseconds
+ * @return {Promise<unknown>}
+ */
+export function delay(timeout_ms: number): Promise<unknown>;
 //# sourceMappingURL=delay.d.ts.map