@woosh/meep-engine 2.108.4 → 2.109.0

package/build/meep.module.js

@@ -555,7 +555,7 @@ assert.isArray = function (value, name = 'value') {
 
 /**
  * @template T
- * @param {ArrayLike<T>|T[]} value
+ * @param {ArrayLike<T>|T[]|Uint32Array|Float32Array} value
  * @param {string} name
  */
 assert.isArrayLike = function (value, name = 'value') {
@@ -3606,7 +3606,7 @@ let Quaternion$1 = class Quaternion {
     /**
      *
      * @param {Quaternion} other
-     * @param {number} max_delta
+     * @param {number} max_delta in radians
      */
     rotateTowards(other, max_delta) {
         Quaternion.rotateTowards(this, this, other, max_delta);
@@ -4985,6 +4985,19 @@ class Transform {
         return result;
     }
 
+    /**
+     *
+     * @param {number[]|Float32Array} mat
+     * @returns {Transform}
+     */
+    static fromMatrix(mat) {
+        const result = new Transform();
+
+        result.fromMatrix4(mat);
+
+        return result;
+    }
+
     /**
      * Multiply two transforms, result it written into this one
      * @param {Transform} a
@@ -4998,17 +5011,18 @@ class Transform {
 
     /**
      *
-     * @param {mat4|number[]|Float32Array} m
+     * @param {mat4|number[]|Float32Array} matrix
      */
-    fromMatrix4(m) {
+    fromMatrix4(matrix) {
+
         // we know we are changing the matrix, so we're going to need to disable the flag that sets matrix from position/rotation/scale changes
         const ad = this.getFlag(TransformFlags.AutomaticChangeDetection);
 
         this.clearFlag(TransformFlags.AutomaticChangeDetection);
 
-        this.matrix.set(m);
+        this.matrix.set(matrix);
 
-        decompose_matrix_4_array(m, this.position, this.rotation, this.scale);
+        decompose_matrix_4_array(matrix, this.position, this.rotation, this.scale);
 
         // restore value of the flag
         this.writeFlag(TransformFlags.AutomaticChangeDetection, ad);
@@ -69341,6 +69355,36 @@ function computeSystemName(system) {
     return system.constructor.name;
 }
 
+/**
+ *
+ * @param {Object3D} object
+ */
+function threeUpdateMatrix(object) {
+    object.updateMatrix();
+
+    const children = object.children;
+    for (let i = 0, childCount = children.length; i < childCount; i++) {
+        const child = children[i];
+
+        threeUpdateMatrix(child);
+    }
+}
+
+/**
+ *
+ * @param {Object3D} object3
+ */
+function threeUpdateTransform(object3) {
+
+    /**
+     signal that transformation matrix should be updated
+     @see https://threejs.org/docs/index.html#api/core/Object3D.matrixWorldNeedsUpdate
+     */
+    threeUpdateMatrix(object3);
+
+    object3.updateMatrixWorld(false);
+}
+
 /**
  *
  * @param {Camera} c
@@ -70087,50 +70131,43 @@ function set_camera_aspect_ratio(camera, width, height) {
 
 /**
  *
- * @param {Object3D} object
+ * @param {Camera} camera
  */
-function threeUpdateMatrix(object) {
-    object.updateMatrix();
+function update_camera_transform(camera) {
 
-    const children = object.children;
-    for (let i = 0, childCount = children.length; i < childCount; i++) {
-        const child = children[i];
+    const three_camera = camera.object;
 
-        threeUpdateMatrix(child);
+    if (three_camera === null) {
+        return;
     }
+
+    three_camera.updateProjectionMatrix();
+    threeUpdateTransform(three_camera);
 }
 
 /**
  *
- * @param {Object3D} object3
+ * @param {THREE.Camera} object
+ * @param {Quaternion} rotation
  */
-function threeUpdateTransform(object3) {
+function three_camera_set_transform_rotation(object, rotation) {
 
-    /**
-     signal that transformation matrix should be updated
-     @see https://threejs.org/docs/index.html#api/core/Object3D.matrixWorldNeedsUpdate
+    /*
+    NOTE: I'm not sure why, but three.js camera points in the opposite direction to normal objects
+    See: https://github.com/mrdoob/three.js/blob/412b99a7f26e117ea97f40eb53d010ab81aa3279/src/core/Object3D.js#L282
      */
-    threeUpdateMatrix(object3);
 
-    object3.updateMatrixWorld(false);
-}
-
-/**
- *
- * @param {Camera} camera
- */
-function update_camera_transform(camera) {
+    invertQuaternionOrientation(object.quaternion, rotation);
 
-    const three_camera = camera.object;
+    object.rotation.setFromQuaternion(object.quaternion);
 
-    if (three_camera === null) {
-        return;
-    }
+    // rotation.__setThreeEuler(camera.object.rotation); // seems unnecessary, based on Object3D.lookAt implementation
+    // camera.object.quaternion.set(rotation.x, rotation.y, rotation.z, rotation.w);
+
+    object.updateProjectionMatrix();
+    threeUpdateTransform(object);
+}
 
-    three_camera.updateProjectionMatrix();
-    threeUpdateTransform(three_camera);
-}
-
 class CameraSystem extends System {
     /**
      *
@@ -70219,19 +70256,7 @@ class CameraSystem extends System {
         function synchronizeRotation() {
             const rotation = transform.rotation;
 
-            /*
-            NOTE: I'm not sure why, but three.js camera points in the opposite direction to normal objects
-            See: https://github.com/mrdoob/three.js/blob/412b99a7f26e117ea97f40eb53d010ab81aa3279/src/core/Object3D.js#L282
-             */
-
-            invertQuaternionOrientation(camera.object.quaternion, rotation);
-
-            camera.object.rotation.setFromQuaternion(camera.object.quaternion);
-
-            // rotation.__setThreeEuler(camera.object.rotation); // seems unnecessary, based on Object3D.lookAt implementation
-            // camera.object.quaternion.set(rotation.x, rotation.y, rotation.z, rotation.w);
-
-            update_camera_transform(camera);
+            three_camera_set_transform_rotation(camera.object, rotation);
         }
 
         function rebuild() {

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.108.4",
+  "version": "2.109.0",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/assert.d.ts

@@ -79,10 +79,10 @@ export namespace assert {
     export function isArray<T>(value: T[], name?: string): void;
     /**
      * @template T
-     * @param {ArrayLike<T>|T[]} value
+     * @param {ArrayLike<T>|T[]|Uint32Array|Float32Array} value
      * @param {string} name
      */
-    export function isArrayLike<T>(value: ArrayLike<T> | T[], name?: string): void;
+    export function isArrayLike<T>(value: Uint32Array | Float32Array | ArrayLike<T> | T[], name?: string): void;
     /**
      *
      * @param {*} value

package/src/core/assert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../../src/core/assert.js"],"names":[],"mappings":"AA+BA,6CAIC;;IAsJD;;;;;OAKG;IACH,kEAQC;;;;;;;;;;;;;;;IAmBD;;;;;;OAMG;IACH,uGAGC;IAGD;;;;OAIG;IACH,0DAMC;IAED;;;;OAIG;IACH,0DAMC;IAED;;;;OAIG;IACH,2DAMC;IAED;;;;OAIG;IACH,4DAMC;IAED;;;;OAIG;IACH,0DAMC;IAED;;;;OAIG;IACH,2DAMC;IAED;;;;OAIG;IACH,sEAMC;IAED;;;;OAIG;IACH,4DAKC;IAED;;;;OAIG;IACH,+EAKC;IAGD;;;;OAIG;IACH,yDAMC;IAED;;;;OAIG;IACH,wDAIC;IAED;;;;OAIG;IACH,yDAMC;IAED;;;;OAIG;IACH,2DAIC;IAED;;;;OAIG;IACH,mEAIC;IAED;;;;;OAKG;IACH,2EAgBC;;AA/ZD,wDAEC;AAED,6CAEC;AAfD,qDAOC;AAUD;;;;;GAKG;AACH,kCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAIhB;AAQD;;;;;GAKG;AACH,gCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AAyBD;;;;;GAKG;AACH,uCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AA5CD;;;;;GAKG;AACH,6BAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AAyBD;;;;;GAKG;AACH,oCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AAKD;;;;;GAKG;AACH,0CAHW,MAAM,cACN,MAAM,QAehB;AAED;;;;;GAKG;AACH,iEAFW,MAAM,QAIhB;AAED;;;;;GAKG;AACH,mEAFW,MAAM,QAIhB;AAED;;;;;GAKG;AACH,+IAFW,MAAM,QAMhB"}
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../../src/core/assert.js"],"names":[],"mappings":"AA+BA,6CAIC;;IAsJD;;;;;OAKG;IACH,kEAQC;;;;;;;;;;;;;;;IAmBD;;;;;;OAMG;IACH,uGAGC;IAGD;;;;OAIG;IACH,0DAMC;IAED;;;;OAIG;IACH,0DAMC;IAED;;;;OAIG;IACH,2DAMC;IAED;;;;OAIG;IACH,4DAMC;IAED;;;;OAIG;IACH,0DAMC;IAED;;;;OAIG;IACH,2DAMC;IAED;;;;OAIG;IACH,sEAMC;IAED;;;;OAIG;IACH,4DAKC;IAED;;;;OAIG;IACH,4GAKC;IAGD;;;;OAIG;IACH,yDAMC;IAED;;;;OAIG;IACH,wDAIC;IAED;;;;OAIG;IACH,yDAMC;IAED;;;;OAIG;IACH,2DAIC;IAED;;;;OAIG;IACH,mEAIC;IAED;;;;;OAKG;IACH,2EAgBC;;AA/ZD,wDAEC;AAED,6CAEC;AAfD,qDAOC;AAUD;;;;;GAKG;AACH,kCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAIhB;AAQD;;;;;GAKG;AACH,gCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AAyBD;;;;;GAKG;AACH,uCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AA5CD;;;;;GAKG;AACH,6BAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AAyBD;;;;;GAKG;AACH,oCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AAKD;;;;;GAKG;AACH,0CAHW,MAAM,cACN,MAAM,QAehB;AAED;;;;;GAKG;AACH,iEAFW,MAAM,QAIhB;AAED;;;;;GAKG;AACH,mEAFW,MAAM,QAIhB;AAED;;;;;GAKG;AACH,+IAFW,MAAM,QAMhB"}

package/src/core/assert.js

@@ -334,7 +334,7 @@ assert.isArray = function (value, name = 'value') {
 
 /**
  * @template T
- * @param {ArrayLike<T>|T[]} value
+ * @param {ArrayLike<T>|T[]|Uint32Array|Float32Array} value
  * @param {string} name
  */
 assert.isArrayLike = function (value, name = 'value') {

package/src/core/binary/align_4.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=align_4.spec.d.ts.map

package/src/core/binary/align_4.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"align_4.spec.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/align_4.spec.js"],"names":[],"mappings":""}

package/src/core/binary/align_4.spec.js

@@ -0,0 +1,20 @@
+import { align_4 } from "./align_4.js";
+
+test("basics", () => {
+
+    expect(align_4(0)).toBe(0);
+    expect(align_4(1)).toBe(4);
+    expect(align_4(3)).toBe(4);
+    expect(align_4(4)).toBe(4);
+
+    expect(align_4(5)).toBe(8);
+    expect(align_4(6)).toBe(8);
+    expect(align_4(7)).toBe(8);
+    expect(align_4(8)).toBe(8);
+
+    expect(align_4(9)).toBe(12);
+    expect(align_4(10)).toBe(12);
+    expect(align_4(11)).toBe(12);
+    expect(align_4(12)).toBe(12);
+
+});

package/src/core/binary/{de_interleave_bits_by_2.d.ts → de_interleave_2_bits.d.ts}

@@ -4,4 +4,4 @@
  * @returns {number} Odd bits end up in lower 16 bits, even bits end up in top part
  */
 export function de_interleave_2_bits(interleaved: number): number;
-//# sourceMappingURL=de_interleave_bits_by_2.d.ts.map
+//# sourceMappingURL=de_interleave_2_bits.d.ts.map

package/src/core/binary/de_interleave_2_bits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"de_interleave_2_bits.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/de_interleave_2_bits.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,kDAHW,MAAM,GACJ,MAAM,CAWlB"}

package/src/core/binary/de_interleave_2_bits.spec.js

@@ -1,4 +1,4 @@
-import { de_interleave_2_bits } from "./de_interleave_bits_by_2.js";
+import { de_interleave_2_bits } from "./de_interleave_2_bits.js";
 
 test("deinterleave 0", () => {
 

package/src/core/binary/hex2dec.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=hex2dec.spec.d.ts.map

package/src/core/binary/hex2dec.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hex2dec.spec.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/hex2dec.spec.js"],"names":[],"mappings":""}

package/src/core/binary/hex2dec.spec.js

@@ -0,0 +1,22 @@
+import { hex2dec } from "./hex2dec.js";
+
+test("basics", () => {
+
+    expect(hex2dec("0")).toBe(0)
+    expect(hex2dec("1")).toBe(1)
+    expect(hex2dec("2")).toBe(2)
+    expect(hex2dec("3")).toBe(3)
+    expect(hex2dec("4")).toBe(4)
+    expect(hex2dec("5")).toBe(5)
+    expect(hex2dec("6")).toBe(6)
+    expect(hex2dec("7")).toBe(7)
+    expect(hex2dec("8")).toBe(8)
+    expect(hex2dec("9")).toBe(9)
+    expect(hex2dec("A")).toBe(0xA)
+    expect(hex2dec("B")).toBe(0xB)
+    expect(hex2dec("C")).toBe(0xC)
+    expect(hex2dec("D")).toBe(0xD)
+    expect(hex2dec("E")).toBe(0xE)
+    expect(hex2dec("F")).toBe(0xF)
+
+});

package/src/core/binary/split_by_2.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=split_by_2.spec.d.ts.map

package/src/core/binary/split_by_2.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split_by_2.spec.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/split_by_2.spec.js"],"names":[],"mappings":""}

package/src/core/binary/split_by_2.spec.js

@@ -0,0 +1,22 @@
+import { int32_to_binary_string } from "./int32_to_binary_string.js";
+import { split_by_2 } from "./split_by_2.js";
+
+test("zero", () => {
+
+    expect(split_by_2(0)).toEqual(0);
+
+});
+
+test("max value", () => {
+
+    expect(
+        int32_to_binary_string(split_by_2(0xFFFFFFFF))
+    ).toEqual("01010101 01010101 01010101 01010101");
+
+});
+
+test("max 16bit value", () => {
+    expect(
+        int32_to_binary_string(split_by_2(0b1111111111111111))
+    ).toEqual("01010101 01010101 01010101 01010101");
+});

package/src/core/bvh2/bvh3/ebvh_build_for_geometry_morton.d.ts

@@ -4,6 +4,9 @@
  * @param {BVH} bvh
  * @param {number[]|Float32Array} index_array
  * @param {number[]|Float32Array} position_array
+ * @param {Uint32Array} [morton_codes]
+ * @param {AABB3} [bounds]
  */
-export function ebvh_build_for_geometry_morton(bvh: BVH, index_array: number[] | Float32Array, position_array: number[] | Float32Array): void;
+export function ebvh_build_for_geometry_morton(bvh: BVH, index_array: number[] | Float32Array, position_array: number[] | Float32Array, morton_codes?: Uint32Array, bounds?: AABB3): void;
+import { AABB3 } from "../../geom/3d/aabb/AABB3.js";
 //# sourceMappingURL=ebvh_build_for_geometry_morton.d.ts.map

package/src/core/bvh2/bvh3/ebvh_build_for_geometry_morton.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ebvh_build_for_geometry_morton.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_build_for_geometry_morton.js"],"names":[],"mappings":"AAWA;;;;;;GAMG;AACH,sEAHW,MAAM,EAAE,GAAC,YAAY,kBACrB,MAAM,EAAE,GAAC,YAAY,QAoF/B"}
+{"version":3,"file":"ebvh_build_for_geometry_morton.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_build_for_geometry_morton.js"],"names":[],"mappings":"AAWA;;;;;;;;GAQG;AACH,sEALW,MAAM,EAAE,GAAC,YAAY,kBACrB,MAAM,EAAE,GAAC,YAAY,iBACrB,WAAW,WACX,KAAK,QA2Ff;sBA1GqB,6BAA6B"}

package/src/core/bvh2/bvh3/ebvh_build_for_geometry_morton.js

@@ -15,8 +15,16 @@ import { ebvh_build_hierarchy } from "./ebvh_build_hierarchy.js";
  * @param {BVH} bvh
  * @param {number[]|Float32Array} index_array
  * @param {number[]|Float32Array} position_array
+ * @param {Uint32Array} [morton_codes]
+ * @param {AABB3} [bounds]
  */
-export function ebvh_build_for_geometry_morton(bvh, index_array, position_array) {
+export function ebvh_build_for_geometry_morton(
+    bvh,
+    index_array,
+    position_array,
+    morton_codes = new Uint32Array(index_array.length / 3),
+    bounds = new AABB3()
+) {
     assert.defined(bvh, 'bvh');
 
     assert.defined(index_array, 'index_array');
@@ -25,16 +33,19 @@ export function ebvh_build_for_geometry_morton(bvh, index_array, position_array)
     assert.defined(position_array, 'position_array');
     assert.isArrayLike(position_array, 'position_array');
 
+    assert.isArrayLike(morton_codes, 'morton_codes');
+
     // clear out existing BVH
     bvh.release_all();
 
-    const aabb3 = new AABB3();
-
     // get bounds for the entire geometry
-    aabb3_from_v3_array(aabb3, position_array, position_array.length);
+    aabb3_from_v3_array(bounds, position_array, position_array.length);
 
     // allocate nodes
     const tri_count = index_array.length / 3;
+
+    assert.greaterThanOrEqual(morton_codes.length, tri_count);
+
     const node_leaf_count = tri_count;
     const node_bin_count = max2(0, node_leaf_count - 1);
 
@@ -59,9 +70,7 @@ export function ebvh_build_for_geometry_morton(bvh, index_array, position_array)
         sorted_triangle_order[i] = i;
     }
 
-    const morton_codes = new Uint32Array(tri_count);
-
-    build_triangle_morton_codes(morton_codes, tri_count, index_array, position_array, aabb3.x0, aabb3.y0, aabb3.z0, aabb3.x1, aabb3.y1, aabb3.z1);
+    build_triangle_morton_codes(morton_codes, tri_count, index_array, position_array, bounds.x0, bounds.y0, bounds.z0, bounds.x1, bounds.y1, bounds.z1);
 
     // sort leaves by morton codes
     array_quick_sort_by_lookup(sorted_triangle_order, morton_codes, 0, tri_count - 1);

package/src/core/bvh2/bvh3/ebvh_build_hierarchy.js

@@ -35,8 +35,8 @@ export function ebvh_build_hierarchy(
         let cursor = 0;
 
         while (cursor + 1 < unprocessed_node_count) {
-            const child_1 = unprocessed_nodes[cursor++];
             const child_2 = unprocessed_nodes[cursor++];
+            const child_1 = unprocessed_nodes[cursor++];
 
             const parent = node_pool[used_index++];
 

package/src/core/bvh2/bvh3/query/bvh_query_user_data_ray.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bvh_query_user_data_ray.d.ts","sourceRoot":"","sources":["../../../../../../src/core/bvh2/bvh3/query/bvh_query_user_data_ray.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;GAaG;AACH,wDAXW,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,GACJ,MAAM,CAwElB"}
+{"version":3,"file":"bvh_query_user_data_ray.d.ts","sourceRoot":"","sources":["../../../../../../src/core/bvh2/bvh3/query/bvh_query_user_data_ray.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;GAaG;AACH,wDAXW,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,GACJ,MAAM,CA6ElB"}

package/src/core/bvh2/bvh3/query/bvh_query_user_data_ray.js

@@ -29,14 +29,19 @@ export function bvh_query_user_data_ray(
         return 0;
     }
 
+    /**
+     * Move stack pointer to local variable scope to avoid de-referencing inside the loop
+     * @type {number}
+     */
+    let pointer = stack.pointer;
 
     /**
      *
      * @type {number}
      */
-    const stack_top = stack.pointer++;
+    const stack_top = pointer;
 
-    stack[stack_top] = root;
+    stack[pointer++] = root;
 
     let result_cursor = result_offset;
 
@@ -47,13 +52,13 @@ export function bvh_query_user_data_ray(
     const uint32 = bvh.__data_uint32;
 
     do {
-        stack.pointer--;
+        --pointer;
 
         /**
          *
          * @type {number}
          */
-        const node = stack[stack.pointer];
+        const node = stack[pointer];
 
         const address = node * ELEMENT_WORD_COUNT;
 
@@ -77,15 +82,15 @@ export function bvh_query_user_data_ray(
             // this is not a leaf node, push children onto traversal stack
             const child_2 = uint32[address + COLUMN_CHILD_2];
 
-            stack[stack.pointer++] = child_2;
-            stack[stack.pointer++] = child_1;
+            stack[pointer++] = child_2;
+            stack[pointer++] = child_1;
 
         } else {
             // leaf node
 
             result[result_cursor++] = uint32[address + COLUMN_USER_DATA];
         }
-    } while (stack.pointer > stack_top);
+    } while (pointer > stack_top);
 
     return result_cursor - result_offset;
 }

package/src/core/geom/2d/circle/circle_circumference.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @param {number} radius
+ * @returns {number}
+ */
+export function circle_circumference(radius: number): number;
+//# sourceMappingURL=circle_circumference.d.ts.map

package/src/core/geom/2d/circle/circle_circumference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circle_circumference.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/circle/circle_circumference.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,6CAHW,MAAM,GACJ,MAAM,CAMlB"}

package/src/core/geom/2d/circle/circle_circumference.js

@@ -0,0 +1,12 @@
+import { assert } from "../../../assert.js";
+
+/**
+ *
+ * @param {number} radius
+ * @returns {number}
+ */
+export function circle_circumference(radius) {
+    assert.isNumber(radius, 'radius');
+
+    return 2 * Math.PI * radius;
+}

package/src/core/geom/2d/compute_polygon_area_2d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compute_polygon_area_2d.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/2d/compute_polygon_area_2d.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,gDAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,eAClC,MAAM,GACJ,MAAM,CA2BlB"}
+{"version":3,"file":"compute_polygon_area_2d.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/2d/compute_polygon_area_2d.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,gDAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,eAClC,MAAM,GACJ,MAAM,CA6BlB"}

package/src/core/geom/2d/compute_polygon_area_2d.js

@@ -8,11 +8,13 @@ export function compute_polygon_area_2d(points, point_count) {
     let sum = 0;
 
     for (let i = 0; i < point_count - 1; i++) {
-        const x0 = points[(i) * 2];
-        const y0 = points[(i) * 2 + 1];
+        const i2 = i * 2;
 
-        const x1 = points[(i + 1) * 2];
-        const y1 = points[(i + 1) * 2 + 1];
+        const x0 = points[i2];
+        const y0 = points[i2 + 1];
+
+        const x1 = points[i2 + 2];
+        const y1 = points[i2 + 3];
 
         sum += x0 * y1 - y0 * x1;
     }

package/src/core/geom/2d/lt-grid/LooseTightGrid.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../assert.js";
-import { de_interleave_2_bits } from "../../../binary/de_interleave_bits_by_2.js";
+import { de_interleave_2_bits } from "../../../binary/de_interleave_2_bits.js";
 import { split_by_2 } from "../../../binary/split_by_2.js";
 import { UINT32_MAX } from "../../../binary/UINT32_MAX.js";
 import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";

package/src/core/geom/2d/triangle2d_get_barycentric.d.ts

@@ -8,8 +8,8 @@
  * @param {number} by
  * @param {number} cx
  * @param {number} cy
- * @param {number} px
- * @param {number} py
+ * @param {number} px reference point X
+ * @param {number} py reference point Y
  */
 export function triangle2d_get_barycentric(output: number[], output_offset: number, ax: number, ay: number, bx: number, by: number, cx: number, cy: number, px: number, py: number): void;
 //# sourceMappingURL=triangle2d_get_barycentric.d.ts.map

package/src/core/geom/2d/triangle2d_get_barycentric.js

@@ -10,8 +10,8 @@ import { v2_dot } from "../vec2/v2_dot.js";
  * @param {number} by
  * @param {number} cx
  * @param {number} cy
- * @param {number} px
- * @param {number} py
+ * @param {number} px reference point X
+ * @param {number} py reference point Y
  */
 export function triangle2d_get_barycentric(
     output, output_offset,

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

@@ -0,0 +1,19 @@
+/**
+ * 3D ray
+ */
+export class Ray3 {
+    origin: Vector3;
+    direction: Vector3;
+    /**
+     *
+     * @param {number[]|mat4|Float32Array} m4
+     */
+    applyMatrix4(m4: number[] | mat4 | Float32Array): void;
+    /**
+     *
+     * @param {Ray3} other
+     */
+    copy(other: Ray3): void;
+}
+import Vector3 from "../Vector3.js";
+//# sourceMappingURL=Ray3.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Ray3.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/3d/Ray3.js"],"names":[],"mappings":"AAEA;;GAEG;AACH;IACI,gBAAsB;IACtB,mBAAyB;IAEzB;;;OAGG;IACH,iBAFW,MAAM,EAAE,UAAM,YAAY,QAKpC;IAED;;;OAGG;IACH,YAFW,IAAI,QAKd;CACJ;oBA1BmB,eAAe"}

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

@@ -0,0 +1,27 @@
+import Vector3 from "../Vector3.js";
+
+/**
+ * 3D ray
+ */
+export class Ray3 {
+    origin = new Vector3()
+    direction = new Vector3()
+
+    /**
+     *
+     * @param {number[]|mat4|Float32Array} m4
+     */
+    applyMatrix4(m4) {
+        this.origin.applyMatrix4(m4);
+        this.direction.applyDirectionMatrix4(m4);
+    }
+
+    /**
+     *
+     * @param {Ray3} other
+     */
+    copy(other) {
+        this.origin.copy(other.origin);
+        this.direction.copy(other.direction);
+    }
+}

package/src/core/geom/3d/ray/ray3_shift_origin_along_direction.d.ts

@@ -0,0 +1,10 @@
+/**
+ *
+ * @param {number[]|ArrayLike<number>|Float32Array} output 6 component vector, [origin_x, origin_y, origin_z, direction_x, direction_y, direction_z]
+ * @param {number} output_offset
+ * @param {number[]|ArrayLike<number>|Float32Array} input 6 component vector, [origin_x, origin_y, origin_z, direction_x, direction_y, direction_z]
+ * @param {number} input_offset
+ * @param {number} distance
+ */
+export function ray3_shift_origin_along_direction(output: number[] | ArrayLike<number> | Float32Array, output_offset: number, input: number[] | ArrayLike<number> | Float32Array, input_offset: number, distance: number): void;
+//# sourceMappingURL=ray3_shift_origin_along_direction.d.ts.map

package/src/core/geom/3d/ray/ray3_shift_origin_along_direction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ray3_shift_origin_along_direction.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/ray/ray3_shift_origin_along_direction.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,0DANW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,iBACvC,MAAM,SACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,gBACvC,MAAM,YACN,MAAM,QAyBhB"}