@woosh/meep-engine 2.46.25 → 2.46.27

package/package.json

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

package/src/core/bvh2/binary/2/BinaryUint32BVH.js

@@ -119,10 +119,7 @@ function build_morton(data, address, matrix) {
 
 }
 
-const scratch_box_0 = [];
-const scratch_box_1 = [];
-const scratch_box_2 = [];
-
+const scratch_box_0 = new Float32Array(18);
 const stack = [];
 
 export class BinaryUint32BVH {
@@ -294,16 +291,16 @@ export class BinaryUint32BVH {
      */
     __compute_bounds_area_of_3_boxes(a, b, c) {
         this.readBounds(a, scratch_box_0, 0);
-        this.readBounds(b, scratch_box_1, 0);
-        this.readBounds(c, scratch_box_2, 0);
+        this.readBounds(b, scratch_box_0, 6);
+        this.readBounds(c, scratch_box_0, 12);
 
-        const x0 = min3(scratch_box_0[0], scratch_box_1[0], scratch_box_2[0]);
-        const y0 = min3(scratch_box_0[1], scratch_box_1[1], scratch_box_2[1]);
-        const z0 = min3(scratch_box_0[2], scratch_box_1[2], scratch_box_2[2]);
+        const x0 = min3(scratch_box_0[0], scratch_box_0[6], scratch_box_0[12]);
+        const y0 = min3(scratch_box_0[1], scratch_box_0[7], scratch_box_0[13]);
+        const z0 = min3(scratch_box_0[2], scratch_box_0[8], scratch_box_0[14]);
 
-        const x1 = max3(scratch_box_0[3], scratch_box_1[3], scratch_box_2[3]);
-        const y1 = max3(scratch_box_0[4], scratch_box_1[4], scratch_box_2[4]);
-        const z1 = max3(scratch_box_0[5], scratch_box_1[5], scratch_box_2[5]);
+        const x1 = max3(scratch_box_0[3], scratch_box_0[9], scratch_box_0[15]);
+        const y1 = max3(scratch_box_0[4], scratch_box_0[10], scratch_box_0[16]);
+        const z1 = max3(scratch_box_0[5], scratch_box_0[11], scratch_box_0[17]);
 
         return aabb3_compute_half_surface_area(x0, y0, z0, x1, y1, z1);
     }

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

@@ -0,0 +1,60 @@
+import { assert } from "../../assert.js";
+
+/**
+ * A convenience class to work with BVH leaf nodes
+ */
+export class EBBVHLeafProxy {
+    /**
+     *
+     * @type {ExplicitBinaryBoundingVolumeHierarchy|null}
+     */
+    #tree = null;
+
+    /**
+     *
+     * @type {number}
+     */
+    #node_id = -1;
+
+    /**
+     * @readonly
+     * @type {number[]}
+     */
+    bounds = new Float32Array(6);
+
+    get is_linked(){
+        return this.#node_id !== -1;
+    }
+
+    /**
+     *
+     * @param {ExplicitBinaryBoundingVolumeHierarchy} tree
+     * @param {number} data Must be a uint32
+     */
+    link(tree, data) {
+        assert.defined(tree, 'tree');
+        assert.isNonNegativeInteger(data, 'data');
+
+        this.#tree = tree;
+
+        const node_id = tree.allocate_node();
+
+        this.#node_id = node_id;
+
+        tree.node_set_aabb(node_id, this.bounds);
+        tree.node_set_user_data(node_id, data);
+        tree.insert_leaf(node_id);
+    }
+
+    unlink() {
+        this.#tree.remove_leaf(this.#node_id);
+        this.#tree.release_node(this.#node_id);
+
+        this.#node_id = -1;
+        this.#tree = null;
+    }
+
+    write_bounds() {
+        this.#tree.node_move_aabb(this.#node_id, this.bounds);
+    }
+}

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

@@ -267,6 +267,7 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
      */
     node_set_user_data(id, value) {
         assert.isNonNegativeInteger(id, 'id');
+        assert.isNonNegativeInteger(value, 'value');
 
         this.__data_uint32[ELEMENT_WORD_COUNT * id + COLUMN_USER_DATA] = value;
     }

package/src/core/collection/HashMap.js

@@ -11,8 +11,9 @@ class MapEntry {
      *
      * @param {K} key
      * @param {V} value
+     * @param {number} hash
      */
-    constructor(key, value) {
+    constructor(key, value, hash) {
         /**
          *
          * @type {K}
@@ -23,6 +24,12 @@ class MapEntry {
          * @type {V}
          */
         this.value = value;
+
+        /**
+         *
+         * @type {number}
+         */
+        this.hash = hash;
     }
 }
 
@@ -219,7 +226,11 @@ export class HashMap {
 
                 const entryKey = entry.key;
 
-                if (entryKey === key || this.keyEqualityFunction(entryKey, key)) {
+
+                if (
+                    entry.hash === raw_hash
+                    && (entryKey === key || this.keyEqualityFunction(entryKey, key))
+                ) {
 
                     // found record with matching key, replace the value
 
@@ -234,7 +245,7 @@ export class HashMap {
 
         }
 
-        bucket.push(new MapEntry(key, value));
+        bucket.push(new MapEntry(key, value,raw_hash));
 
         const old_size = this.size;
         const new_size = old_size + 1;
@@ -269,8 +280,10 @@ export class HashMap {
 
                 const entryKey = entry.key;
 
-                if (entryKey === key || this.keyEqualityFunction(entryKey, key)) {
-
+                if (
+                    entry.hash === raw_hash
+                    && (entryKey === key || this.keyEqualityFunction(entryKey, key))
+                ) {
                     return entry.value;
 
                 }
@@ -432,6 +445,9 @@ export class HashMap {
 
                 //check hash
                 const raw_hash = this.keyHashFunction(entry.key);
+
+                entry.hash = raw_hash;
+
                 const actual_bucket_index = this.__compute_bucket_index(raw_hash);
 
 

package/src/core/events/signal/Signal.js

@@ -147,7 +147,7 @@ export class Signal {
      * @param {*} [context]
      */
     addOne(h, context) {
-        assert.equal(typeof h, "function", "Handler is not a function");
+        assert.isFunction( h,  "handler");
 
         const handler = new SignalHandler(h, context);
 
@@ -195,8 +195,8 @@ export class Signal {
      * Remove all handlers
      */
     removeAll() {
-        const signalHandlers = this.handlers;
-        signalHandlers.splice(0, signalHandlers.length);
+        const handlers = this.handlers;
+        handlers.splice(0, handlers.length);
     }
 
     /**

package/src/core/geom/3d/cone/computeConeBoundingBox.js

@@ -4,7 +4,7 @@ import { v3_angle_between } from "../../v3_angle_between.js";
 
 /**
  * NOTE: used stackoverflow answer as a basis for circle part: https://stackoverflow.com/questions/2592011/bounding-boxes-for-circle-and-arcs-in-3d
- * @param {AABB3} result
+ * @param {number[]|ArrayLike<number>|Float32Array} result
  * @param {number} originX
  * @param {number} originY
  * @param {number} originZ
@@ -41,14 +41,11 @@ export function computeConeBoundingBox(result, originX, originY, originZ, direct
     const cz1 = centerZ + rZ;
 
     //combine bounds of the origin and base of the cone
-    const x0 = min2(originX, cx0);
-    const y0 = min2(originY, cy0);
-    const z0 = min2(originZ, cz0);
+    result[0] = min2(originX, cx0);
+    result[1] = min2(originY, cy0);
+    result[2] = min2(originZ, cz0);
 
-    const x1 = max2(originX, cx1);
-    const y1 = max2(originY, cy1);
-    const z1 = max2(originZ, cz1);
-
-    //write result
-    result.setBounds(x0, y0, z0, x1, y1, z1);
+    result[3] = max2(originX, cx1);
+    result[4] = max2(originY, cy1);
+    result[5] = max2(originZ, cz1);
 }

package/src/core/geom/3d/ray/ray3_array_apply_matrix4.js

@@ -1,18 +1,20 @@
 /**
  *
  * @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[]|ArrayLike<number>|Float32Array} m4 4x4 matrix
  * @returns {boolean} false if matrix transformation is impossible, such as when scale of the matrix is 0
  */
-export function ray3_array_apply_matrix4(output, input, m4) {
-    const origin_x = input[0];
-    const origin_y = input[1];
-    const origin_z = input[2];
+export function ray3_array_apply_matrix4(output, output_offset, input, input_offset, m4) {
+    const origin_x = input[input_offset + 0];
+    const origin_y = input[input_offset + 1];
+    const origin_z = input[input_offset + 2];
 
-    const direction_x = input[3];
-    const direction_y = input[4];
-    const direction_z = input[5];
+    const direction_x = input[input_offset + 3];
+    const direction_y = input[input_offset + 4];
+    const direction_z = input[input_offset + 5];
 
     // transform ray to local space (inlined for speed)
     const det = m4[3] * origin_x + m4[7] * origin_y + m4[11] * origin_z + m4[15];
@@ -44,13 +46,13 @@ export function ray3_array_apply_matrix4(output, input, m4) {
     const out_direction_normalized_y = out_direction_y * out_direction_magnitude_inverse;
     const out_direction_normalized_z = out_direction_z * out_direction_magnitude_inverse;
 
-    output[0] = out_origin_x;
-    output[1] = out_origin_y;
-    output[2] = out_origin_z;
+    output[output_offset + 0] = out_origin_x;
+    output[output_offset + 1] = out_origin_y;
+    output[output_offset + 2] = out_origin_z;
 
-    output[3] = out_direction_normalized_x;
-    output[4] = out_direction_normalized_y;
-    output[5] = out_direction_normalized_z;
+    output[output_offset + 3] = out_direction_normalized_x;
+    output[output_offset + 4] = out_direction_normalized_y;
+    output[output_offset + 5] = out_direction_normalized_z;
 
     return true;
 }

package/src/engine/graphics/ecs/mesh-v2/ShadedGeometry.js

@@ -6,6 +6,7 @@ import { mat4 } from "gl-matrix";
 import { ray3_array_apply_matrix4 } from "../../../../core/geom/3d/ray/ray3_array_apply_matrix4.js";
 import { GeometrySpatialQueryAccelerator } from "../../geometry/buffered/query/GeometrySpatialQueryAccelerator.js";
 import { assert } from "../../../../core/assert.js";
+import { EBBVHLeafProxy } from "../../../../core/bvh2/bvh3/EBBVHLeafProxy.js";
 
 /**
  * @readonly
@@ -55,26 +56,7 @@ export class ShadedGeometry {
          */
         this.depth_material = null;
 
-        /**
-         *
-         * @type {number}
-         * @private
-         */
-        this.__bvh_leaf_id = -1;
-
-        /**
-         *
-         * @type {ExplicitBinaryBoundingVolumeHierarchy|null}
-         * @private
-         */
-        this.__bvh_tree = null;
-
-        /**
-         * @readonly
-         * @type {number[]|Float32Array}
-         * @private
-         */
-        this.__bvh_aabb = new Float32Array(6);
+        this.__bvh_leaf = new EBBVHLeafProxy();
 
         /**
          * Transient, assigned in the system
@@ -240,7 +222,7 @@ export class ShadedGeometry {
      * @param {AABB3} destination
      */
     getBoundingBox(destination) {
-        const aabb = this.__bvh_aabb;
+        const aabb = this.__bvh_leaf.bounds;
 
         destination.readFromArray(aabb);
     }
@@ -280,7 +262,7 @@ export class ShadedGeometry {
     updateTransform() {
         this.update_bounds();
 
-        this.__bvh_tree.node_move_aabb(this.__bvh_leaf_id, this.__bvh_aabb);
+        this.__bvh_leaf.write_bounds();
     }
 
     update_bounds() {
@@ -317,7 +299,7 @@ export class ShadedGeometry {
         scratch_aabb3_array[4] = y1;
         scratch_aabb3_array[5] = z1;
 
-        aabb3_matrix4_project(this.__bvh_aabb, scratch_aabb3_array, this.transform);
+        aabb3_matrix4_project(this.__bvh_leaf.bounds, scratch_aabb3_array, this.transform);
     }
 
     /**
@@ -333,7 +315,7 @@ export class ShadedGeometry {
         mat4.invert(scratch_m4, transform_matrix4);
 
         // transform ray to local space
-        if (!ray3_array_apply_matrix4(scratch_ray_0, ray, scratch_m4)) {
+        if (!ray3_array_apply_matrix4(scratch_ray_0,0, ray,0, scratch_m4)) {
             // invalid transform matrix
             return false;
         }

package/src/engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.js

@@ -289,25 +289,13 @@ export class ShadedGeometrySystem extends System {
 
         sg.update_bounds();
 
-        t.position.onChanged.add(sg.updateTransform, sg);
-        t.rotation.onChanged.add(sg.updateTransform, sg);
-        t.scale.onChanged.add(sg.updateTransform, sg);
+        t.subscribeAllChanges(sg.updateTransform, sg);
 
         // remember entity for lookups
         sg.__entity = entity;
 
         // insert BVH entry
-        const bvh = this.__bvh_binary;
-
-        const bvh_node_id = bvh.allocate_node();
-
-        bvh.node_set_aabb(bvh_node_id, sg.__bvh_aabb);
-        bvh.node_set_user_data(bvh_node_id, entity);
-        bvh.insert_leaf(bvh_node_id);
-
-        sg.__bvh_tree = bvh;
-        sg.__bvh_leaf_id = bvh_node_id;
-
+        sg.__bvh_leaf.link(this.__bvh_binary, entity);
 
         // update usage count
         const geometry_id = sg.geometry.id;
@@ -324,19 +312,10 @@ export class ShadedGeometrySystem extends System {
      * @param {number} entity
      */
     unlink(sg, t, entity) {
-        t.position.onChanged.remove(sg.updateTransform, sg);
-        t.rotation.onChanged.remove(sg.updateTransform, sg);
-        t.scale.onChanged.remove(sg.updateTransform, sg);
+        t.unsubscribeAllChanges(sg.updateTransform, sg);
 
         // disconnect BVH
-        const node_id = sg.__bvh_leaf_id;
-
-        this.__bvh_binary.remove_leaf(node_id);
-        this.__bvh_binary.release_node(node_id);
-
-        // reset BVH references
-        sg.__bvh_leaf_id = -1;
-        sg.__bvh_tree = null;
+        sg.__bvh_leaf.unlink();
 
         const geometry_id = sg.geometry.id;
         const count_existing = this.__geometry_usage_counters.get(geometry_id);

package/src/engine/graphics/ecs/mesh-v2/aggregate/SGMeshSystem.js

@@ -162,15 +162,11 @@ export class SGMeshSystem extends System {
 
         entity_node.build(ecd);
 
-        transform.position.onChanged.add(copy_transform);
-        transform.rotation.onChanged.add(copy_transform);
-        transform.scale.onChanged.add(copy_transform);
+        transform.subscribeAllChanges(copy_transform);
 
         entity_node.on.destroyed.addOne(() => {
 
-            transform.position.onChanged.remove(copy_transform);
-            transform.rotation.onChanged.remove(copy_transform);
-            transform.scale.onChanged.remove(copy_transform);
+            transform.unsubscribeAllChanges(copy_transform);
 
         });
 

package/src/engine/graphics/geometry/bvh/buffered/BVHGeometryRaycaster.js

@@ -194,7 +194,7 @@ export class BVHGeometryRaycaster {
             directionX, directionY, directionZ
         );
 
-        ray3_array_apply_matrix4(ray_tmp, ray_tmp, m4_tmp);
+        ray3_array_apply_matrix4(ray_tmp, 0,ray_tmp,0, m4_tmp);
 
         const _originX = ray_tmp[0];
         const _originY = ray_tmp[1];

package/src/engine/graphics/particles/particular/engine/parameter/ParameterLookupTable.d.ts

@@ -11,5 +11,5 @@ export class ParameterLookupTable {
 
     write(value: number[], positions: number[]): void
 
-    static from(itemSize: number, value: number[], positions: number[]): ParameterLookupTable
+    static from(itemSize: number, value: number[], positions?: number[]): ParameterLookupTable
 }

package/src/engine/graphics/particles/particular/engine/parameter/ParameterLookupTable.js

@@ -6,6 +6,7 @@ import { ParameterLookupTableFlags } from "./ParameterLookupTableFlags.js";
 import { ParameterLookupTableSerializationAdapter } from "../emitter/serde/ParameterLookupTableSerializationAdapter.js";
 import { computeHashIntegerArray } from "../../../../../../core/collection/array/computeHashIntegerArray.js";
 import { computeHashFloatArray } from "../../../../../../core/math/hash/computeHashFloatArray.js";
+import { isArrayEqualStrict } from "../../../../../../core/collection/array/isArrayEqualStrict.js";
 
 
 export class ParameterLookupTable {
@@ -211,7 +212,7 @@ export class ParameterLookupTable {
 
         if (positions === undefined) {
 
-            console.warn('positions are undefined, assuming uniform distribution');
+            //console.warn('positions are undefined, assuming uniform distribution');
             this.computeUniformPositions();
 
         } else {
@@ -309,52 +310,18 @@ export class ParameterLookupTable {
      * @returns {boolean}
      */
     equals(other) {
-        if (this.itemSize !== other.itemSize) {
-            return false;
-        }
-
-        const thisData = this.data;
-        const otherData = other.data;
-
-        const thisDataLength = thisData.length;
-        const otherDataLength = otherData.length;
-
-        if (thisDataLength !== otherDataLength) {
-            return false;
+        if(this === other){
+            // identity shortcut
+            return true;
         }
 
-        const thisPositions = this.positions;
-        const otherPositions = other.positions;
-
-        const thisPositionsLength = thisPositions.length;
-        const otherPositionsLength = otherPositions.length;
-
-        if (thisPositionsLength !== otherPositionsLength) {
+        if (this.itemSize !== other.itemSize) {
             return false;
         }
 
-        let i;
-
-        for (i = 0; i < thisPositionsLength; i++) {
-            const pA = thisPositions[i];
-            const pB = otherPositions[i];
-
-            if (pA !== pB) {
-                return false;
-            }
-        }
-
-        for (i = 0; i < thisDataLength; i++) {
-            const dA = thisData[i];
-            const dB = otherData[i];
-
-            if (dA !== dB) {
-                return false;
-            }
-        }
-
-        //equal
-        return true;
+        return isArrayEqualStrict(this.data, other.data)
+            && isArrayEqualStrict(this.positions, other.positions)
+            ;
     }
 
     validate() {
@@ -408,7 +375,7 @@ export class ParameterLookupTable {
     static from(itemSize, values, positions) {
         const r = new ParameterLookupTable(itemSize);
 
-        r.write(values, positions)
+        r.write(values, positions);
 
         return r;
     }