@woosh/meep-engine 3.55.0 → 3.57.0

package/src/core/binary/BitSet.js

@@ -659,7 +659,7 @@ export class BitSet {
         if (distance > 0) {
             this.shift_right(distance, start_index, end_index);
         } else {
-            this.shift_right(-distance, start_index, end_index);
+            this.shift_left(-distance, start_index, end_index);
         }
     }
 

package/src/core/binary/FLOAT16_MAX.d.ts

@@ -0,0 +1,2 @@
+export const FLOAT16_MAX: 65504;
+//# sourceMappingURL=FLOAT16_MAX.d.ts.map

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

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

package/src/core/binary/FLOAT16_MAX.js

@@ -0,0 +1 @@
+export const FLOAT16_MAX = 65504;

package/src/core/binary/base58/base58_encode.js

@@ -39,7 +39,7 @@ export function base58_encode(
     const size = ((pend - pbegin) * 138 / 100 + 1) >>> 0; /// log(256) / log(58), rounded up.
 
     // use scratch if possible to avoid allocation
-    const b58 = (size <= scratch.length) ? scratch : new Uint8Array(size);
+    const b58 = (size <= scratch.length) ? scratch.fill(0, 0, size) : new Uint8Array(size);
 
     // Process the bytes.
     while (pbegin !== pend) {
@@ -80,7 +80,7 @@ export function base58_encode(
 
     if (b58 === scratch) {
         // clear out scratch
-        scratch.fill(0);
+        scratch.fill(0, 0, size);
     }
 
     return str;

package/src/core/binary/type/TypeBuilder.js

@@ -73,7 +73,7 @@ function buildConstructorFunction(structure) {
     lines.dedent();
     lines.add('}');
 
-    buildTypePrototype(type, lines);
+    buildTypePrototype(structure, lines);
 
     lines.add('return ' + structure.name + ';');
 

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

@@ -916,7 +916,7 @@ export class BVH {
         const iC = uint32[iA * ELEMENT_WORD_COUNT + COLUMN_CHILD_2];
 
         assert.notEqual(iA, iB, 'child1 equal to parent');
-        assert.notEqual(iA, iB, 'child2 equal to parent');
+        assert.notEqual(iA, iC, 'child2 equal to parent');
 
         assert.greaterThanOrEqual(iB, 0);
         assert.lessThan(iB, this.node_capacity);

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

@@ -1 +1 @@
-{"version":3,"file":"ebvh_optimize_treelet.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_optimize_treelet.js"],"names":[],"mappings":"AAgRA;;;;;;;GAOG;AACH,uDAHW,MAAM,iBACN,MAAM,QA6JhB"}
+{"version":3,"file":"ebvh_optimize_treelet.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_optimize_treelet.js"],"names":[],"mappings":"AAgRA;;;;;;;GAOG;AACH,uDAHW,MAAM,iBACN,MAAM,QAiKhB"}

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

@@ -333,7 +333,7 @@ export function ebvh_optimize_treelet(
                 1 + Math.max(bvh.node_get_height(child_1), bvh.node_get_height(child_2))
             );
 
-            if (bvh.node_get_height(node) >= min_height) {
+            if (node === root || bvh.node_get_height(node) >= min_height) {
                 // only form treelets when moving up
                 optimize_at_node(bvh, node, treelet_size);
             }
@@ -357,7 +357,11 @@ export function ebvh_optimize_treelet(
             came_from_node = node;
 
             node = parent;
-        } else if (came_from_type === CAME_FROM_TYPE_CHILD_2) {
+        } else if (came_from_type === CAME_FROM_TYPE_CHILD_2) {
+            if (node === root) {
+                // traversed all the way back up
+                break;
+            }
             // finishing traversal of this branch
             came_from_node = node;
             const parent = bvh.node_get_parent(node);
@@ -432,5 +436,5 @@ export function ebvh_optimize_treelet(
     }
 
     // optimize last collected treelet
-    optimize_at_node(bvh, root, treelet_size);
+
 }

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

@@ -1 +1 @@
-{"version":3,"file":"ebvh_update_hierarchy_bounds.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_update_hierarchy_bounds.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,8DAHW,MAAM,GACJ,IAAI,CAuIhB"}
+{"version":3,"file":"ebvh_update_hierarchy_bounds.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_update_hierarchy_bounds.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,8DAHW,MAAM,GACJ,IAAI,CA2IhB"}

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

@@ -71,7 +71,11 @@ export function ebvh_update_hierarchy_bounds(bvh, root = bvh.root) {
             came_from_node = node;
 
             node = parent;
-        } else if (came_from_type === CAME_FROM_TYPE_CHILD_2) {
+        } else if (came_from_type === CAME_FROM_TYPE_CHILD_2) {
+            if (node === root) {
+                // traversed all the way back up
+                break;
+            }
             // finishing traversal of this branch
             came_from_node = node;
             const parent = bvh.node_get_parent(node);

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

@@ -1 +1 @@
-{"version":3,"file":"compute_tight_near_far_clipping_planes.d.ts","sourceRoot":"","sources":["../../../../../../src/core/bvh2/bvh3/query/compute_tight_near_far_clipping_planes.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;GAiBG;AACH,+DATW,MAAM,EAAE,iBACR,MAAM,cACN,MAAM,qBAEN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,GACrC,OAAO,CA2NnB"}
+{"version":3,"file":"compute_tight_near_far_clipping_planes.d.ts","sourceRoot":"","sources":["../../../../../../src/core/bvh2/bvh3/query/compute_tight_near_far_clipping_planes.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;GAiBG;AACH,+DATW,MAAM,EAAE,iBACR,MAAM,cACN,MAAM,qBAEN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,GACrC,OAAO,CAuKnB"}

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

@@ -1,246 +1,195 @@
-import { assert } from "../../../assert.js";
-import { array_copy } from "../../../collection/array/array_copy.js";
-import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
-import { v3_distance_above_plane } from "../../../geom/vec3/v3_distance_above_plane.js";
-import { NULL_NODE } from "../BVH.js";
-
-const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
-
-const scratch_aabb = [];
-
-const scratch_frustum = new Float32Array(24);
-
-/**
- * Tightens the relaxed planes of a frustum against the contents of a BVH: each relaxed
- * plane is moved to the tightest position that still contains every leaf AABB surviving
- * the fixed planes.
- *
- * Both input and output planes use the engine's inward `dot(normal, p) + offset >= 0`
- * convention (see {@link v3_distance_above_plane}); fixed planes are copied through
- * unchanged.
- *
- * @param {number[]} result
- * @param {number} result_offset
- * @param {number} plane_mask if bit is set to 0, that plane is not allowed to move
- * @param {BVH} bvh
- * @param {number[]|ArrayLike<number>|Float32Array} frustum
- * @returns {boolean} true iff every relaxed plane was tightened against geometry. False
- * when the BVH is empty or when no leaf intersects the fixed planes — a relaxed plane
- * would otherwise carry its infinite sentinel. If false is returned - result is not written
- */
-export function compute_tight_near_far_clipping_planes(
-    result,
-    result_offset,
-    plane_mask,
-    bvh,
-    frustum
-) {
-    assert.isNonNegativeInteger(result_offset, 'result_offset');
-    assert.isNonNegativeInteger(plane_mask, 'plane_mask');
-
-    const relaxed_mask = plane_mask & 0b111111;
-
-    // initialize result
-    array_copy(frustum, 0, scratch_frustum, 0, 24);
-
-    // Relaxed planes start infinitely tight ("no geometry seen yet") and are pushed out by
-    // leaves. In the dot+offset convention the tight containing offset is the running
-    // maximum of -dot(normal, nearest_corner), so the sentinel is -Infinity.
-    for (let i = 0; i < 6; i++) {
-        if (((relaxed_mask >> i) & 1) === 1) {
-            scratch_frustum[i * 4 + 3] = -Infinity;
-        }
-    }
-
-    const root = bvh.root;
-
-    if (root === NULL_NODE) {
-        return false;
-    }
-
-    /**
-     *
-     * @type {number}
-     */
-    const stack_top = stack.pointer++;
-
-    stack[stack_top] = root;
-
-    // relaxed planes that have been tightened against at least one leaf
-    let updated_mask = 0;
-
-    // 0 is the nearest point along the normal and 1 is the furthest
-    let x0,
-        y0,
-        z0,
-        x1,
-        y1,
-        z1;
-
-    node_loop: while (stack.pointer > stack_top) {
-        stack.pointer--;
-
-        /**
-         *
-         * @type {number}
-         */
-        const node = stack[stack.pointer];
-
-        bvh.node_get_aabb(node, scratch_aabb);
-
-        const _x0 = scratch_aabb[0];
-        const _y0 = scratch_aabb[1];
-        const _z0 = scratch_aabb[2];
-        const _x1 = scratch_aabb[3];
-        const _y1 = scratch_aabb[4];
-        const _z1 = scratch_aabb[5];
-
-        // bitset of relaxed planes affected by this node
-        // lets us discard intermediate nodes that would not affect any planes
-        let collision_mask = 0;
-
-        for (let plane_index = 0; plane_index < 6; plane_index++) {
-
-
-            const plane_address = plane_index * 4;
-
-            //read out plane
-            const plane_normal_x = scratch_frustum[plane_address];
-            const plane_normal_y = scratch_frustum[plane_address + 1];
-            const plane_normal_z = scratch_frustum[plane_address + 2];
-            const plane_offset = scratch_frustum[plane_address + 3];
-
-
-            // construct nearest and farthest corners along the plane normal
-            if (plane_normal_x > 0) {
-                x0 = _x0;
-                x1 = _x1;
-            } else {
-                x0 = _x1;
-                x1 = _x0;
-            }
-
-            if (plane_normal_y > 0) {
-                y0 = _y0;
-                y1 = _y1;
-            } else {
-                y0 = _y1;
-                y1 = _y0;
-            }
-
-            if (plane_normal_z > 0) {
-                z0 = _z0;
-                z1 = _z1;
-            } else {
-                z0 = _z1;
-                z1 = _z0;
-            }
-
-            if (((relaxed_mask >> plane_index) & 1) === 1) {
-                // relaxed plane: this node can push it out iff the node's nearest corner
-                // lies outside the current plane
-                const distance_above_plane = v3_distance_above_plane(
-                    x0, y0, z0,
-                    plane_normal_x, plane_normal_y, plane_normal_z, plane_offset
-                );
-
-                if (distance_above_plane < 0) {
-                    collision_mask |= (1 << plane_index);
-                }
-
-            } else {
-
-                // fixed plane
-                const distance_above_plane = v3_distance_above_plane(
-                    x1, y1, z1,
-                    plane_normal_x, plane_normal_y, plane_normal_z, plane_offset
-                );
-
-                if (distance_above_plane < 0) {
-                    // below plane, reject this branch
-                    continue node_loop;
-                }
-
-            }
-        }
-
-
-        const node_is_leaf = bvh.node_is_leaf(node);
-
-        if (!node_is_leaf) {
-
-            if (collision_mask === 0) {
-                // does not affect any planes, skip
-                continue;
-            }
-
-            // inside
-            // read in-order
-            const child1 = bvh.node_get_child1(node);
-            const child2 = bvh.node_get_child2(node);
-
-            // write to stack in reverse order, so that the first child ends up being visited first
-            stack[stack.pointer++] = child2;
-            stack[stack.pointer++] = child1;
-
-        } else {
-
-            // leaf node
-
-            // expand planes
-            for (let i = 0; i < 6; i++) {
-                if (((collision_mask >> i) & 1) === 1) {
-
-                    const plane_address = i * 4;
-
-                    //read out plane
-                    const plane_normal_x = scratch_frustum[plane_address];
-                    const plane_normal_y = scratch_frustum[plane_address + 1];
-                    const plane_normal_z = scratch_frustum[plane_address + 2];
-
-                    // get the nearest corner along the plane normal
-                    if (plane_normal_x > 0) {
-                        x0 = _x0;
-                    } else {
-                        x0 = _x1;
-                    }
-
-                    if (plane_normal_y > 0) {
-                        y0 = _y0;
-                    } else {
-                        y0 = _y1;
-                    }
-
-                    if (plane_normal_z > 0) {
-                        z0 = _z0;
-                    } else {
-                        z0 = _z1;
-                    }
-
-                    // move the plane out to contain this leaf: offset = -dot(n, nearest
-                    // corner) puts the corner exactly on the plane (dot + offset == 0).
-                    // Only ever reached when the corner is outside the current plane
-                    // (collision_mask gate), so the offset grows monotonically.
-                    scratch_frustum[plane_address + 3] = -v3_distance_above_plane(
-                        x0, y0, z0,
-                        plane_normal_x, plane_normal_y, plane_normal_z, 0
-                    );
-
-                    updated_mask |= (1 << i);
-
-                }
-            }
-
-        }
-    }
-
-    if ((updated_mask & relaxed_mask) !== relaxed_mask) {
-        // some relaxed plane was never constrained by geometry (nothing intersects the
-        // fixed planes) — it still carries the -Infinity sentinel and must not leak out
-        return false;
-    }
-
-    array_copy(scratch_frustum, 0, result, result_offset, 24);
-
-    return true;
-}
+import { assert } from "../../../assert.js";
+import { array_copy } from "../../../collection/array/array_copy.js";
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
+import { aabb3_compute_distance_above_plane_max } from "../../../geom/3d/aabb/aabb3_compute_distance_above_plane_max.js";
+import { aabb3_compute_distance_above_plane_min } from "../../../geom/3d/aabb/aabb3_compute_distance_above_plane_min.js";
+import { NULL_NODE } from "../BVH.js";
+
+const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
+
+const scratch_aabb = [];
+
+const scratch_frustum = new Float32Array(24);
+
+/**
+ * Tightens the relaxed planes of a frustum against the contents of a BVH: each relaxed
+ * plane is moved to the tightest position that still contains every leaf AABB surviving
+ * the fixed planes.
+ *
+ * Both input and output planes use the engine's inward `dot(normal, p) + offset >= 0`
+ * convention (see {@link v3_distance_above_plane}); fixed planes are copied through
+ * unchanged.
+ *
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {number} plane_mask if bit is set to 0, that plane is not allowed to move
+ * @param {BVH} bvh
+ * @param {number[]|ArrayLike<number>|Float32Array} frustum
+ * @returns {boolean} true iff every relaxed plane was tightened against geometry. False
+ * when the BVH is empty or when no leaf intersects the fixed planes — a relaxed plane
+ * would otherwise carry its infinite sentinel. If false is returned - result is not written
+ */
+export function compute_tight_near_far_clipping_planes(
+    result,
+    result_offset,
+    plane_mask,
+    bvh,
+    frustum
+) {
+    assert.isNonNegativeInteger(result_offset, 'result_offset');
+    assert.isNonNegativeInteger(plane_mask, 'plane_mask');
+
+    const relaxed_mask = plane_mask & 0b111111;
+
+    // initialize result
+    array_copy(frustum, 0, scratch_frustum, 0, 24);
+
+    // Relaxed planes start infinitely tight ("no geometry seen yet") and are pushed out by
+    // leaves. In the dot+offset convention the tight containing offset is the running
+    // maximum of -dot(normal, nearest_corner), so the sentinel is -Infinity.
+    for (let i = 0; i < 6; i++) {
+        if (((relaxed_mask >> i) & 1) === 1) {
+            scratch_frustum[i * 4 + 3] = -Infinity;
+        }
+    }
+
+    const root = bvh.root;
+
+    if (root === NULL_NODE) {
+        return false;
+    }
+
+    /**
+     *
+     * @type {number}
+     */
+    const stack_top = stack.pointer++;
+
+    stack[stack_top] = root;
+
+    // relaxed planes that have been tightened against at least one leaf
+    let updated_mask = 0;
+
+    node_loop: while (stack.pointer > stack_top) {
+        stack.pointer--;
+
+        /**
+         *
+         * @type {number}
+         */
+        const node = stack[stack.pointer];
+
+        bvh.node_get_aabb(node, scratch_aabb);
+
+        const _x0 = scratch_aabb[0];
+        const _y0 = scratch_aabb[1];
+        const _z0 = scratch_aabb[2];
+        const _x1 = scratch_aabb[3];
+        const _y1 = scratch_aabb[4];
+        const _z1 = scratch_aabb[5];
+
+        // bitset of relaxed planes affected by this node
+        // lets us discard intermediate nodes that would not affect any planes
+        let collision_mask = 0;
+
+        for (let plane_index = 0; plane_index < 6; plane_index++) {
+            const plane_address = plane_index * 4;
+
+            //read out plane
+            const plane_normal_x = scratch_frustum[plane_address];
+            const plane_normal_y = scratch_frustum[plane_address + 1];
+            const plane_normal_z = scratch_frustum[plane_address + 2];
+            const plane_offset = scratch_frustum[plane_address + 3];
+
+            if (((relaxed_mask >> plane_index) & 1) === 1) {
+                // relaxed plane: this node can push it out iff the node's nearest corner
+                // lies outside the current plane
+                const distance_above_plane = aabb3_compute_distance_above_plane_min(
+                    plane_normal_x, plane_normal_y, plane_normal_z, plane_offset,
+                    _x0, _y0, _z0,
+                    _x1, _y1, _z1
+                );
+
+                if (distance_above_plane < 0) {
+                    collision_mask |= (1 << plane_index);
+                }
+
+            } else {
+
+                // fixed plane
+                const distance_above_plane = aabb3_compute_distance_above_plane_max(
+                    plane_normal_x, plane_normal_y, plane_normal_z, plane_offset,
+                    _x0, _y0, _z0,
+                    _x1, _y1, _z1
+                );
+
+                if (distance_above_plane < 0) {
+                    // below plane, reject this branch
+                    continue node_loop;
+                }
+
+            }
+        }
+
+
+        const node_is_leaf = bvh.node_is_leaf(node);
+
+        if (!node_is_leaf) {
+
+            if (collision_mask === 0) {
+                // does not affect any planes, skip
+                continue;
+            }
+
+            // inside
+            // read in-order
+            const child1 = bvh.node_get_child1(node);
+            const child2 = bvh.node_get_child2(node);
+
+            // write to stack in reverse order, so that the first child ends up being visited first
+            stack[stack.pointer++] = child2;
+            stack[stack.pointer++] = child1;
+
+        } else {
+
+            // leaf node
+
+            // expand planes
+            for (let i = 0; i < 6; i++) {
+                if (((collision_mask >> i) & 1) === 1) {
+
+                    const plane_address = i * 4;
+
+                    //read out plane
+                    const plane_normal_x = scratch_frustum[plane_address];
+                    const plane_normal_y = scratch_frustum[plane_address + 1];
+                    const plane_normal_z = scratch_frustum[plane_address + 2];
+
+                    // move the plane out to contain this leaf: offset = -dot(n, nearest
+                    // corner) puts the corner exactly on the plane (dot + offset == 0).
+                    // Only ever reached when the corner is outside the current plane
+                    // (collision_mask gate), so the offset grows monotonically.
+                    scratch_frustum[plane_address + 3] = -aabb3_compute_distance_above_plane_min(
+                        plane_normal_x, plane_normal_y, plane_normal_z, 0,
+                        _x0, _y0, _z0,
+                        _x1, _y1, _z1
+                    );
+
+                    updated_mask |= (1 << i);
+
+                }
+            }
+
+        }
+    }
+
+    if ((updated_mask & relaxed_mask) !== relaxed_mask) {
+        // some relaxed plane was never constrained by geometry (nothing intersects the
+        // fixed planes) — it still carries the -Infinity sentinel and must not leak out
+        return false;
+    }
+
+    array_copy(scratch_frustum, 0, result, result_offset, 24);
+
+    return true;
+}

package/src/core/collection/CuckooFilter.js

@@ -32,7 +32,7 @@ function computeBitsPerTagForFPP(fpp) {
  * @returns {number}
  */
 function computeBucketsNeeded(max_keys, bucket_size) {
-    return ceilPowerOfTwo(max_keys / bucket_size);
+    return ceilPowerOfTwo(Math.ceil(max_keys / bucket_size));
 }
 
 

package/src/core/collection/array/isArrayEqual.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isArrayEqual.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/isArrayEqual.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,6DAFY,OAAO,CAkDlB"}
+{"version":3,"file":"isArrayEqual.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/isArrayEqual.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,6DAFY,OAAO,CAwBlB"}