@woosh/meep-engine 2.46.31 → 2.46.33

package/build/meep.module.js

@@ -658,7 +658,7 @@ 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);
 
@@ -706,8 +706,8 @@ class Signal {
      * Remove all handlers
      */
     removeAll() {
-        const signalHandlers = this.handlers;
-        signalHandlers.splice(0, signalHandlers.length);
+        const handlers = this.handlers;
+        handlers.splice(0, handlers.length);
     }
 
     /**
@@ -49812,7 +49812,7 @@ function arraySwapElements(array, index0, index1) {
     array[index1] = t;
 }
 
-const stack$9 = [];
+const stack$8 = [];
 
 /**
  * @template T
@@ -49833,14 +49833,14 @@ function arrayQuickSort(data, score_function, score_function_context, start, end
     let stackPointer = 2;
     let i, j;
 
-    stack$9[0] = start;
-    stack$9[1] = end;
+    stack$8[0] = start;
+    stack$8[1] = end;
 
     while (stackPointer > 0) {
         stackPointer -= 2;
 
-        const right = stack$9[stackPointer + 1];
-        const left = stack$9[stackPointer];
+        const right = stack$8[stackPointer + 1];
+        const left = stack$8[stackPointer];
 
         i = left;
         j = right;
@@ -49873,12 +49873,12 @@ function arrayQuickSort(data, score_function, score_function_context, start, end
 
         /* recursion */
         if (left < j) {
-            stack$9[stackPointer++] = left;
-            stack$9[stackPointer++] = j;
+            stack$8[stackPointer++] = left;
+            stack$8[stackPointer++] = j;
         }
         if (i < right) {
-            stack$9[stackPointer++] = i;
-            stack$9[stackPointer++] = right;
+            stack$8[stackPointer++] = i;
+            stack$8[stackPointer++] = right;
         }
     }
 }
@@ -49900,14 +49900,14 @@ function array_quick_sort_by_comparator(data, compare_function, compare_function
     let stackPointer = 2;
     let i, j;
 
-    stack$9[0] = start;
-    stack$9[1] = end;
+    stack$8[0] = start;
+    stack$8[1] = end;
 
     while (stackPointer > 0) {
         stackPointer -= 2;
 
-        const right = stack$9[stackPointer + 1];
-        const left = stack$9[stackPointer];
+        const right = stack$8[stackPointer + 1];
+        const left = stack$8[stackPointer];
 
         i = left;
         j = right;
@@ -49943,12 +49943,12 @@ function array_quick_sort_by_comparator(data, compare_function, compare_function
 
         /* recursion */
         if (left < j) {
-            stack$9[stackPointer++] = left;
-            stack$9[stackPointer++] = j;
+            stack$8[stackPointer++] = left;
+            stack$8[stackPointer++] = j;
         }
         if (i < right) {
-            stack$9[stackPointer++] = i;
-            stack$9[stackPointer++] = right;
+            stack$8[stackPointer++] = i;
+            stack$8[stackPointer++] = right;
         }
     }
 }
@@ -50493,7 +50493,7 @@ function aabb3_intersects_frustum_array(x0, y0, z0, x1, y1, z1, frustum) {
  * NOTE: {@link result} and {@link aabb} must be different objects
  * @param {ArrayLike<number>|number[]|Float32Array} result
  * @param {ArrayLike<number>|number[]|Float32Array} aabb
- * @param {number[]} matrix 4x4 matrix
+ * @param {ArrayLike<number>|number[]|Float32Array} matrix 4x4 matrix
  */
 function aabb3_matrix4_project(result, aabb, matrix) {
     assert.notEqual(result, aabb, 'input and output must not be the same for algorithm to work correctly');
@@ -51780,8 +51780,8 @@ class BVHVisitor {
     }
 }
 
-const stack$8 = [];
-let stackPointer$4 = 0;
+const stack$7 = [];
+let stackPointer$3 = 0;
 
 /**
  *
@@ -51791,13 +51791,13 @@ let stackPointer$4 = 0;
 function traverseBinaryNodeUsingVisitor(node, visitor) {
     let n;
 
-    const stackOffset = stackPointer$4;
+    const stackOffset = stackPointer$3;
 
-    stack$8[stackPointer$4++] = node;
+    stack$7[stackPointer$3++] = node;
 
-    while (stackPointer$4-- > stackOffset) {
+    while (stackPointer$3-- > stackOffset) {
 
-        n = stack$8[stackPointer$4];
+        n = stack$7[stackPointer$3];
 
         if (n.isBinaryNode) {
             const traverseDeeper = visitor.visitBinary(n);
@@ -51808,7 +51808,7 @@ function traverseBinaryNodeUsingVisitor(node, visitor) {
 
                     // has a LEFT child
 
-                    stack$8[stackPointer$4++] = n.left;
+                    stack$7[stackPointer$3++] = n.left;
 
                 }
 
@@ -51816,7 +51816,7 @@ function traverseBinaryNodeUsingVisitor(node, visitor) {
 
                     // has a RIGHT child
 
-                    stack$8[stackPointer$4++] = n.right;
+                    stack$7[stackPointer$3++] = n.right;
 
                 }
 
@@ -51828,7 +51828,7 @@ function traverseBinaryNodeUsingVisitor(node, visitor) {
     }
 
     //drop the stack frame
-    stackPointer$4 = stackOffset;
+    stackPointer$3 = stackOffset;
 }
 
 /**
@@ -51936,12 +51936,12 @@ function aabb3_combined_surface_area(a, b) {
  *
  * @type {number}
  */
-let stackPointer$3 = 0;
+let stackPointer$2 = 0;
 /**
  *
  * @type {Node[]}
  */
-const stack$7 = [];
+const stack$6 = [];
 
 class BinaryNode extends Node {
     constructor() {
@@ -51989,30 +51989,30 @@ class BinaryNode extends Node {
     traversePreOrderUsingStack(visitor, thisArg) {
         let visitCount = 0;
 
-        const stackOffset = stackPointer$3;
+        const stackOffset = stackPointer$2;
 
-        stack$7[stackPointer$3++] = this;
+        stack$6[stackPointer$2++] = this;
         let n;
-        while (stackPointer$3-- > stackOffset) {
+        while (stackPointer$2-- > stackOffset) {
 
             visitCount++;
 
-            n = stack$7[stackPointer$3];
+            n = stack$6[stackPointer$2];
 
             const traverseDeeper = visitor.call(thisArg, n);
 
             if (traverseDeeper !== false && n.isBinaryNode) {
                 if (n.right !== null) {
-                    stack$7[stackPointer$3++] = n.right;
+                    stack$6[stackPointer$2++] = n.right;
                 }
                 if (n.left !== null) {
-                    stack$7[stackPointer$3++] = n.left;
+                    stack$6[stackPointer$2++] = n.left;
                 }
             }
         }
 
         // drop stack frame
-        stackPointer$3 = stackOffset;
+        stackPointer$2 = stackOffset;
 
         return visitCount;
     }
@@ -52025,33 +52025,33 @@ class BinaryNode extends Node {
     traverseLeavesPreOrderUsingStack(visitor, thisArg) {
         let visitCount = 0;
 
-        const stackOffset = stackPointer$3;
+        const stackOffset = stackPointer$2;
 
-        stack$7[stackPointer$3++] = this;
+        stack$6[stackPointer$2++] = this;
 
         let n;
 
-        while (stackPointer$3-- > stackOffset) {
+        while (stackPointer$2-- > stackOffset) {
 
             visitCount++;
 
-            n = stack$7[stackPointer$3];
+            n = stack$6[stackPointer$2];
 
             if (n.isLeafNode) {
                 visitor.call(thisArg, n);
             } else {
                 //a binary node
                 if (n.right !== null) {
-                    stack$7[stackPointer$3++] = n.right;
+                    stack$6[stackPointer$2++] = n.right;
                 }
                 if (n.left !== null) {
-                    stack$7[stackPointer$3++] = n.left;
+                    stack$6[stackPointer$2++] = n.left;
                 }
             }
         }
 
         // drop stack frame
-        stackPointer$3 = stackOffset;
+        stackPointer$2 = stackOffset;
 
         return visitCount;
     }
@@ -52620,15 +52620,15 @@ class BinaryNode extends Node {
      * @returns {number} number of objects added to the result
      */
     requestLeafIntersectionsAABB3(result, x0, y0, z0, x1, y1, z1) {
-        const startOffset = stackPointer$3;
+        const startOffset = stackPointer$2;
 
-        stack$7[stackPointer$3++] = this;
+        stack$6[stackPointer$2++] = this;
 
         let count = 0;
 
-        while (stackPointer$3 > startOffset) {
-            stackPointer$3--;
-            const node = stack$7[stackPointer$3];
+        while (stackPointer$2 > startOffset) {
+            stackPointer$2--;
+            const node = stack$6[stackPointer$2];
 
             if (!aabb3_intersect_aabb3(
                 x0, y0, z0, x1, y1, z1,
@@ -52645,12 +52645,12 @@ class BinaryNode extends Node {
             } else {
                 const left = node.left;
                 if (left !== null) {
-                    stack$7[stackPointer$3++] = left;
+                    stack$6[stackPointer$2++] = left;
                 }
 
                 const right = node.right;
                 if (right !== null) {
-                    stack$7[stackPointer$3++] = right;
+                    stack$6[stackPointer$2++] = right;
                 }
             }
         }
@@ -56115,16 +56115,16 @@ class IndexedBinaryBVH {
      */
     traversePreOrderStack(visitor, startIndex) {
 
-        const stackOffset = stackPointer$2;
+        const stackOffset = stackPointer$1;
 
-        stack$6[stackPointer$2++] = startIndex;
+        stack$5[stackPointer$1++] = startIndex;
 
         const nodeThreshold = this.binaryNodeCount * 6;
         const endAddress = this.boxCount * 6;
 
-        while (stackPointer$2-- > stackOffset) {
+        while (stackPointer$1-- > stackOffset) {
 
-            const index = stack$6[stackPointer$2];
+            const index = stack$5[stackPointer$1];
 
             const address = index * 6;
 
@@ -56140,7 +56140,7 @@ class IndexedBinaryBVH {
                 //right
                 if (rightAddress < endAddress) {
                     if (rightAddress < nodeThreshold) {
-                        stack$6[stackPointer$2++] = rightIndex;
+                        stack$5[stackPointer$1++] = rightIndex;
                     } else {
                         visitor.visit(rightAddress, NodeType.LEAF);
                     }
@@ -56149,7 +56149,7 @@ class IndexedBinaryBVH {
                 //left
                 if (leftAddress < endAddress) {
                     if (leftAddress < nodeThreshold) {
-                        stack$6[stackPointer$2++] = leftIndex;
+                        stack$5[stackPointer$1++] = leftIndex;
                     } else {
                         visitor.visit(leftAddress, NodeType.LEAF);
                     }
@@ -56158,7 +56158,7 @@ class IndexedBinaryBVH {
         }
 
         //drop stack
-        stackPointer$2 = stackOffset;
+        stackPointer$1 = stackOffset;
     }
 
     /**
@@ -56325,8 +56325,8 @@ function binaryNodeRefit(array, binaryNode, childNode0, childNode1) {
 }
 
 
-const stack$6 = [];
-let stackPointer$2 = 0;
+const stack$5 = [];
+let stackPointer$1 = 0;
 
 const rayLeafIntersectionVisitor = new RayLeafIntersectionVisitor();
 
@@ -56614,18 +56614,20 @@ function rayTriangleIntersection(result, rayOrigin, rayDirection, a, b, c) {
 /**
  *
  * @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
  */
-function ray3_array_apply_matrix4(output, input, m4) {
-    const origin_x = input[0];
-    const origin_y = input[1];
-    const origin_z = input[2];
+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];
@@ -56657,13 +56659,13 @@ 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;
 }
@@ -56881,7 +56883,7 @@ 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];
@@ -60528,8 +60530,9 @@ class MapEntry {
      *
      * @param {K} key
      * @param {V} value
+     * @param {number} hash
      */
-    constructor(key, value) {
+    constructor(key, value, hash) {
         /**
          *
          * @type {K}
@@ -60540,6 +60543,12 @@ class MapEntry {
          * @type {V}
          */
         this.value = value;
+
+        /**
+         *
+         * @type {number}
+         */
+        this.hash = hash;
     }
 }
 
@@ -60736,7 +60745,11 @@ 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
 
@@ -60751,7 +60764,7 @@ 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;
@@ -60786,8 +60799,10 @@ 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;
 
                 }
@@ -60949,6 +60964,9 @@ 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);
 
 
@@ -69970,6 +69988,70 @@ class GeometrySpatialQueryAccelerator {
  */
 GeometrySpatialQueryAccelerator.INSTANCE = new GeometrySpatialQueryAccelerator();
 
+/**
+ * A convenience class to work with BVH leaf nodes
+ */
+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() {
+        if (this.#tree === null) {
+            // nothing to write to
+            return;
+        }
+
+        this.#tree.node_move_aabb(this.#node_id, this.bounds);
+    }
+}
+
 /**
  * @readonly
  * @type {Float32Array}
@@ -70018,26 +70100,7 @@ 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
@@ -70203,7 +70266,7 @@ class ShadedGeometry {
      * @param {AABB3} destination
      */
     getBoundingBox(destination) {
-        const aabb = this.__bvh_aabb;
+        const aabb = this.__bvh_leaf.bounds;
 
         destination.readFromArray(aabb);
     }
@@ -70243,7 +70306,7 @@ 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() {
@@ -70280,7 +70343,7 @@ 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);
     }
 
     /**
@@ -70296,7 +70359,7 @@ class ShadedGeometry {
         invert(scratch_m4, transform_matrix4);
 
         // transform ray to local space
-        if (!ray3_array_apply_matrix4(scratch_ray_0$1, ray, scratch_m4)) {
+        if (!ray3_array_apply_matrix4(scratch_ray_0$1,0, ray,0, scratch_m4)) {
             // invalid transform matrix
             return false;
         }
@@ -76253,15 +76316,11 @@ 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);
 
         });
 
@@ -78827,6 +78886,7 @@ 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;
     }
@@ -80540,25 +80600,13 @@ 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;
@@ -80575,19 +80623,10 @@ 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);
@@ -87565,8 +87604,8 @@ function compare_three_objects(a, b) {
  *
  * @type {(BinaryNode|LeafNode)[]}
  */
-const stack$5 = [];
-let stackPointer$1 = 0;
+const stack$4 = [];
+let stackPointer = 0;
 
 /**
  * @template T
@@ -87578,22 +87617,22 @@ function queryBinaryNode_CollectData(destination, destinationOffset, root) {
     let n;
     let i = 0;
 
-    const stackOffset = stackPointer$1;
+    const stackOffset = stackPointer;
 
-    stack$5[stackPointer$1++] = root;
+    stack$4[stackPointer++] = root;
 
-    while (stackPointer$1-- > stackOffset) {
+    while (stackPointer-- > stackOffset) {
 
-        n = stack$5[stackPointer$1];
+        n = stack$4[stackPointer];
 
         if (n.isBinaryNode) {
 
             if (n.right !== null) {
-                stack$5[stackPointer$1++] = n.right;
+                stack$4[stackPointer++] = n.right;
             }
 
             if (n.left !== null) {
-                stack$5[stackPointer$1++] = n.left;
+                stack$4[stackPointer++] = n.left;
             }
 
         } else {
@@ -87606,7 +87645,7 @@ function queryBinaryNode_CollectData(destination, destinationOffset, root) {
     }
 
     //drop the stack frame
-    stackPointer$1 = stackOffset;
+    stackPointer = stackOffset;
 
     return i;
 }
@@ -87615,7 +87654,7 @@ function queryBinaryNode_CollectData(destination, destinationOffset, root) {
  *
  * @type {(BinaryNode|LeafNode)[]}
  */
-const stack$4 = [];
+const stack$3 = [];
 
 
 /**
@@ -87635,13 +87674,13 @@ function queryBinaryNode_FrustumIntersections_Data(destination, destination_offs
     let offset = destination_offset;
     let stackPointer = 1;
 
-    stack$4[0] = root;
+    stack$3[0] = root;
 
     while (stackPointer > 0) {
 
         stackPointer--;
 
-        n = stack$4[stackPointer];
+        n = stack$3[stackPointer];
 
         const intersection_degree = aabb3_intersects_frustum_degree(
             n.x0, n.y0, n.z0,
@@ -87662,13 +87701,13 @@ function queryBinaryNode_FrustumIntersections_Data(destination, destination_offs
                 const right = n.right;
 
                 if (right !== null) {
-                    stack$4[stackPointer++] = right;
+                    stack$3[stackPointer++] = right;
                 }
 
                 const left = n.left;
 
                 if (left !== null) {
-                    stack$4[stackPointer++] = left;
+                    stack$3[stackPointer++] = left;
                 }
 
             } else {
@@ -88630,7 +88669,7 @@ const MetricsCategory = {
     System: "system"
 };
 
-const stack$3 = [];
+const stack$2 = [];
 
 class ThreeBypassRenderer {
     constructor() {
@@ -88707,13 +88746,13 @@ class ThreeBypassRenderer {
             const object3D = input[i];
 
             if (input_filter(object3D)) {
-                stack$3[stack_top++] = object3D;
+                stack$2[stack_top++] = object3D;
             }
 
         }
 
         while (stack_top > 0) {
-            const object3D = stack$3[--stack_top];
+            const object3D = stack$2[--stack_top];
 
             if (
                 object_filter(object3D)
@@ -88752,7 +88791,7 @@ class ThreeBypassRenderer {
             for (i = 0; i < child_count; i++) {
                 const child = children[i];
 
-                stack$3[stack_top++] = child;
+                stack$2[stack_top++] = child;
             }
         }
 
@@ -99902,6 +99941,9 @@ class ActionBehavior extends Behavior {
     }
 }
 
+/**
+ * Abstract class
+ */
 class CompositeBehavior extends Behavior {
     constructor() {
         super();
@@ -99919,12 +99961,25 @@ class CompositeBehavior extends Behavior {
      * @param {Behavior} child
      */
     addChild(child) {
-        assert.defined(child);
-        assert.ok(child.isBehavior, 'child is not a Behavior');
+        assert.defined(child, 'child');
+        assert.notNull(child, 'child');
+        assert.equal(child.isBehavior, true, 'child is not a Behavior');
 
         this.__children.push(child);
     }
 
+    /**
+     *
+     * @param {Behavior[]} many
+     */
+    addChildren(many) {
+        const n = many.length;
+        for (let i = 0; i < n; i++) {
+            const e = many[i];
+            r.addChild(e);
+        }
+    }
+
     /**
      * NOTE: do not modify obtained value
      * @return {Behavior[]}
@@ -99962,6 +100017,10 @@ class CompositeBehavior extends Behavior {
  */
 CompositeBehavior.prototype.isCompositeBehavior = true;
 
+/**
+ * Executes all contained behaviors one after another in a sequence, next behaviour in the sequence will not be started until the previous one signal success
+ * If any of the contained behaviours fail - the whole sequence fails
+ */
 class SequenceBehavior extends CompositeBehavior {
     constructor() {
         super();
@@ -100065,7 +100124,7 @@ class SequenceBehavior extends CompositeBehavior {
     static from(list) {
         const r = new SequenceBehavior();
 
-        list.forEach(b => r.addChild(b));
+        r.addChildren(list);
 
         return r;
     }
@@ -115166,7 +115225,9 @@ var FrustumProjector = {
     projectInWorldSpace
 };
 
-class PointLightData {
+class LightRenderMetadata {
+
+
     /**
      *
      * @param {AbstractLight} light
@@ -115184,12 +115245,12 @@ class PointLightData {
          */
         this.address = 0;
 
-        this.bvh_leaf_main = new LeafNode(this, 0, 0, 0, 0, 0, 0);
+        this.bvh_leaf = new EBBVHLeafProxy();
     }
 
     /**
      *
-     * @param {PointLightData} other
+     * @param {LightRenderMetadata} other
      * @returns {number}
      */
     compare(other) {
@@ -115197,17 +115258,20 @@ class PointLightData {
     }
 
     update() {
+        const leaf = this.bvh_leaf;
 
-        const leaf = this.bvh_leaf_main;
+        this.light.getAABB(leaf.bounds);
 
-        this.light.getAABB(leaf);
-
-        if (leaf.parentNode !== null) {
-            leaf.parentNode.bubbleRefit();
-        }
+        leaf.write_bounds();
     }
 
-    link() {
+    /**
+     *
+     * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
+     */
+    link(bvh) {
+        this.bvh_leaf.link(bvh, this.light.id);
+
         this.update();
 
         this.light.onDimensionChanged(this.update, this);
@@ -115218,488 +115282,10 @@ class PointLightData {
         this.light.offDimensionChanged(this.update, this);
 
         // disconnect from bvh
-        this.bvh_leaf_main.disconnect();
-    }
-}
-
-const _lut_array_buffer = new ArrayBuffer(84);
-/**
- * Mapping from 3 plane bitfield, corresponding to intersection point of the planes
- * @type {number[]}
- */
-const triplanar_corner_mapping = new Uint8Array(_lut_array_buffer, 0, 43);
-
-triplanar_corner_mapping[0b010101] = 0;
-triplanar_corner_mapping[0b100101] = 1;
-triplanar_corner_mapping[0b011001] = 2;
-triplanar_corner_mapping[0b101001] = 3;
-triplanar_corner_mapping[0b010110] = 4;
-triplanar_corner_mapping[0b100110] = 5;
-triplanar_corner_mapping[0b011010] = 6;
-triplanar_corner_mapping[0b101010] = 7;
-/**
- * Mapping from 2 plane bitfield to 2 corner bitfield, corresponding to corner indices of intersecting planes
- * @type {number[]}
- */
-const biplanar_edge_mapping = new Uint8Array(_lut_array_buffer, 43, 41);
-
-biplanar_edge_mapping[0b000101] = 0 | (1 << 3);
-biplanar_edge_mapping[0b000110] = 4 | (5 << 3);
-
-biplanar_edge_mapping[0b001001] = 2 | (3 << 3);
-biplanar_edge_mapping[0b001010] = 6 | (7 << 3);
-
-biplanar_edge_mapping[0b010100] = 0 | (4 << 3);
-biplanar_edge_mapping[0b011000] = 2 | (6 << 3);
-
-biplanar_edge_mapping[0b100100] = 1 | (5 << 3);
-biplanar_edge_mapping[0b101000] = 3 | (7 << 3);
-
-biplanar_edge_mapping[0b010001] = 0 | (2 << 3);
-biplanar_edge_mapping[0b010010] = 4 | (6 << 3);
-
-biplanar_edge_mapping[0b100001] = 1 | (3 << 3);
-biplanar_edge_mapping[0b100010] = 5 | (7 << 3);
-
-/**
- * Computes shortest distance between a line segment(defined by 2 points) and a point
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @param {number} px
- * @param {number} py
- * @param {number} pz
- */
-function line3_computeSegmentPointDistance_sqr(x0, y0, z0, x1, y1, z1, px, py, pz) {
-    // get line delta
-    const line_delta_x = x1 - x0;
-    const line_delta_y = y1 - y0;
-    const line_delta_z = z1 - z0;
-
-    // find closest point
-    const sp0_x = px - x0;
-    const sp0_y = py - y0;
-    const sp0_z = pz - z0;
-
-    //
-    const d2 = line_delta_x * line_delta_x + line_delta_y * line_delta_y + line_delta_z * line_delta_z;
-
-    const d3 = line_delta_x * sp0_x + line_delta_y * sp0_y + line_delta_z * sp0_z;
-
-    const t = clamp01(d3 / d2);
-
-    // compute point on the line
-    const lp_x = line_delta_x * t + x0;
-    const lp_y = line_delta_y * t + y0;
-    const lp_z = line_delta_z * t + z0;
-
-    // compute distance from the point in question to the point on the line
-    return v3_distance_sqr(px, py, pz, lp_x, lp_y, lp_z);
-}
-
-/**
- *
- * @param {number} radius
- * @param {number} light_x
- * @param {number} light_y
- * @param {number} light_z
- * @param {number} outside_plane_count
- * @param {number} outside_plane_bitfield
- * @param {number[]} points
- * @return {boolean}
- */
-function detailed_sphere_frustum_intersection_test(
-    radius, light_x, light_y, light_z,
-    outside_plane_count, outside_plane_bitfield,
-    points
-) {
-
-    const radius_sqr = radius * radius;
-
-    if (outside_plane_count === 3) {
-        // nearest point in a corner, find the corner
-        const point_index = triplanar_corner_mapping[outside_plane_bitfield];
-
-        const point_address = point_index * 3;
-
-        const point_x = points[point_address];
-        const point_y = points[point_address + 1];
-        const point_z = points[point_address + 2];
-
-        const distance_to_light_sqr = v3_distance_sqr(
-            point_x, point_y, point_z,
-            light_x, light_y, light_z
-        );
-
-        // query_bvh_frustum_from_objects.checks_sphere_frustum_corner++;
-
-        // return distance_to_light_sqr <= radius_sqr;
-
-        if (distance_to_light_sqr > radius_sqr) {
-
-            // query_bvh_frustum_from_objects.rejection_sphere_count++;
-            return false;
-        }
-
-    } else if (outside_plane_count === 2) {
-        // nearest point is on an edge of two plane intersection
-        const edge_bitfield = biplanar_edge_mapping[outside_plane_bitfield];
-
-        // get 2 corners from edge bitfield
-        const corner_index_0 = edge_bitfield & 0b111;
-        const corner_address_0 = corner_index_0 * 3;
-
-        const corner_index_1 = (edge_bitfield >> 3) & 0b111;
-        const corner_address_1 = corner_index_1 * 3;
-
-        const point_0_x = points[corner_address_0];
-        const point_0_y = points[corner_address_0 + 1];
-        const point_0_z = points[corner_address_0 + 2];
-
-        const point_1_x = points[corner_address_1];
-        const point_1_y = points[corner_address_1 + 1];
-        const point_1_z = points[corner_address_1 + 2];
-
-        const distance_to_frustum_sqr = line3_computeSegmentPointDistance_sqr(
-            point_0_x, point_0_y, point_0_z,
-            point_1_x, point_1_y, point_1_z,
-            light_x, light_y, light_z
-        );
-
-        // query_bvh_frustum_from_objects.checks_sphere_frustum_edge++;
-
-        // return distance_to_frustum_sqr <= radius_sqr;
-
-        if (distance_to_frustum_sqr > radius_sqr) {
-
-            // query_bvh_frustum_from_objects.rejection_sphere_count++;
-            return false;
-        }
+        this.bvh_leaf.unlink();
     }
-
-    return true;
 }
 
-/**
- *
- * @param {number} light_x
- * @param {number} light_y
- * @param {number} light_z
- * @param {number} radius
- * @param {number[]} points
- * @param {number[]|Float32Array|Float64Array} planes
- * @returns {boolean}
- */
-function point_light_inside_volume(
-    light_x, light_y, light_z, radius,
-    points, planes
-) {
-    let j = 0;
-    let outside_plane_count = 0;
-    let outside_plane_bitfield = 0;
-
-    // validate if the sphere intersects the plane-bound space
-
-    // query_bvh_frustum_from_objects.checks_sphere++;
-
-    for (; j < 6; j++) {
-
-        const plane_address = j * 4;
-
-        const plane_normal_x = planes[plane_address];
-        const plane_normal_y = planes[plane_address + 1];
-        const plane_normal_z = planes[plane_address + 2];
-        const plane_constant = planes[plane_address + 3];
-
-        /*
-         compute distance from the center of the sphere to the plane
-         NOTE: inlined computation of distance from point to plane
-         */
-        const distance = (plane_normal_x * light_x + plane_normal_y * light_y + plane_normal_z * light_z) + plane_constant;
-
-        // query_bvh_frustum_from_objects.checks_sphere_plane++;
-
-        if (distance < 0) {
-            // center of the sphere is below the plane
-
-            if (distance >= -radius) {
-
-                // sphere intersects the plane
-
-                outside_plane_count++;
-
-                const plane_bit_mask = 1 << j;
-
-                outside_plane_bitfield |= plane_bit_mask;
-            } else {
-                // sphere is entirely below the plane
-
-                // query_bvh_frustum_from_objects.rejection_sphere_count++;
-
-                return false;
-            }
-        }
-
-    }
-
-    if (outside_plane_count < 2) {
-        return true;
-    } else {
-        return detailed_sphere_frustum_intersection_test(
-            radius, light_x, light_y, light_z,
-            outside_plane_count, outside_plane_bitfield,
-            points
-        );
-    }
-}
-
-const V1 = new Vector3$1();
-const V2 = new Vector3$1();
-
-/**
- * 2,0,or -2; 2: above, -2 : below, 0 : intersects plane
- * NOTE: used an article by Bart Wronski https://bartwronski.com/2017/04/13/cull-that-cone/
- * @param {number} plane_normal_x
- * @param {number} plane_normal_y
- * @param {number} plane_normal_z
- * @param {number} plane_constant
- * @param {number} originX
- * @param {number} originY
- * @param {number} originZ
- * @param {number} directionX
- * @param {number} directionY
- * @param {number} directionZ
- * @param {number} angle
- * @param {number} length
- * @returns {number}
- */
-function computeConePlaneSide(
-    plane_normal_x, plane_normal_y, plane_normal_z,
-    plane_constant,
-    originX, originY, originZ,
-    directionX, directionY, directionZ,
-    angle,
-    length
-) {
-
-    /*
-    ORIGINAL HLSL:
-    bool TestConeVsPlane(in float3 origin, in float3 forward, in float size, in float angle, in float4 testPlane)
-    {
-        const float3 V1 = cross(testPlane.xyz, forward);
-        const float3 V2 = cross(V1, forward);
-
-        const float3 capRimPoint =  origin +
-                                    size * cos(angle) * forward +
-                                    size * sin(angle) * V2;
-
-        return dot(float4(capRimPoint, 1.0f), testPlane) >= 0.0f || dot(float4(origin, 1.0f), testPlane) >= 0.0f;
-    }
-     */
-
-    V1._crossVectors(plane_normal_x, plane_normal_y, plane_normal_z, directionX, directionY, directionZ);
-    V2._crossVectors(V1.x, V1.y, V1.z, directionX, directionY, directionZ);
-
-    const scaled_cos = length * Math.cos(angle);
-    const scaled_sin = length * Math.sin(angle);
-
-    // compute cap rim point (closest point to the plane on the wide side of the cone)
-    V1.set(
-        originX + scaled_cos * directionX + scaled_sin * V2.x,
-        originY + scaled_cos * directionY + scaled_sin * V2.y,
-        originZ + scaled_cos * directionZ + scaled_sin * V2.z
-    );
-
-    const rim_point_side = v4_dot(
-        V1.x, V1.y, V1.z, 1,
-        plane_normal_x, plane_normal_y, plane_normal_z, plane_constant
-    );
-
-    const origin_point_side = v4_dot(
-        originX, originY, originZ, 1,
-        plane_normal_x, plane_normal_y, plane_normal_z, plane_constant
-    );
-
-    let result = 0;
-
-    if (rim_point_side >= 0) {
-        result += 1;
-    } else {
-        result -= 1;
-    }
-
-    if (origin_point_side >= 0) {
-        result += 1;
-    } else {
-        result -= 1;
-    }
-
-    return result;
-}
-
-/**
- *
- * @param {SpotLight} light
- * @param {number[]} points
- * @param {number[]|Float32Array|Float64Array} planes
- * @returns {boolean}
- */
-function spot_light_inside_volume(light, points, planes) {
-    for (let j = 0; j < 6; j++) {
-
-        const plane_address = j * 4;
-
-        const plane_normal_x = planes[plane_address];
-        const plane_normal_y = planes[plane_address + 1];
-        const plane_normal_z = planes[plane_address + 2];
-        const plane_constant = planes[plane_address + 3];
-
-        const side = computeConePlaneSide(
-            plane_normal_x, plane_normal_y, plane_normal_z, plane_constant,
-            light.position.x, light.position.y, light.position.z,
-            light.direction.x, light.direction.y, light.direction.z,
-            light.angle.getValue(), light.distance.getValue()
-        );
-
-        if (side < 0) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-/**
- *
- * @type {(BinaryNode|LeafNode)[]}
- */
-const stack$2 = [];
-
-let stackPointer = 0;
-
-/**
- * Most of the data is in flat continuous array for cache coherence
- * @param {PointLightData[]} destination
- * @param {number} destination_offset
- * @param {BinaryNode<PointLightData>} root
- * @param {number[]|Float32Array|Float64Array} planes
- * @param {number[]|Float32Array|Float64Array} points
- * @returns {number} number of items added to the destination, non-negative integer
- */
-function query_bvh_frustum_from_objects(
-    destination,
-    destination_offset,
-    root, planes, points
-) {
-    let i = 0;
-    let j = 0;
-    // read out points
-    const stackOffset = stackPointer;
-
-    stack$2[stackPointer] = root;
-
-    stackPointer++;
-
-    stack_loop:while (stackPointer-- > stackOffset) {
-
-        // query_bvh_frustum_from_objects.iteration_count++;
-
-        const n = stack$2[stackPointer];
-
-        if (n.isBinaryNode === true) {
-
-            for (j = 0; j < 6; j++) {
-
-                const plane_address = j * 4;
-
-                const plane_normal_x = planes[plane_address];
-                const plane_normal_y = planes[plane_address + 1];
-                const plane_normal_z = planes[plane_address + 2];
-                const plane_constant = planes[plane_address + 3];
-
-                const distanceAbovePlane = aabb3_computeDistanceAbovePlane_max(
-                    plane_normal_x, plane_normal_y, plane_normal_z, plane_constant,
-                    n.x0, n.y0, n.z0,
-                    n.x1, n.y1, n.z1
-                );
-
-                if (distanceAbovePlane < 0) {
-                    // node is below the plane
-
-                    // query_bvh_frustum_from_objects.rejection_count++;
-
-                    continue stack_loop;
-                }
-            }
-
-
-            if (n.right !== null) {
-                stack$2[stackPointer] = n.right;
-                stackPointer++;
-            }
-
-            if (n.left !== null) {
-                stack$2[stackPointer] = n.left;
-                stackPointer++;
-            }
-
-        } else {
-
-            // leaf node
-
-            /**
-             *
-             * @type {PointLightData}
-             */
-            const light_data = n.object;
-
-            const light = light_data.light;
-
-            if (light.isPointLight) {
-
-                const light_position = light.position;
-
-                const light_x = light_position.x;
-                const light_y = light_position.y;
-                const light_z = light_position.z;
-
-                const radius = light.radius.getValue();
-
-                if (!point_light_inside_volume(light_x, light_y, light_z, radius, points, planes)) {
-                    continue;
-                }
-            } else if (light.isSpotLight) {
-                if (!spot_light_inside_volume(light, points, planes)) {
-                    continue;
-                }
-            }
-
-            destination[destination_offset + i] = light_data;
-
-            i++;
-        }
-
-    }
-
-    //drop the stack frame
-    stackPointer = stackOffset;
-
-    return i;
-}
-
-query_bvh_frustum_from_objects.iteration_count = 0;
-query_bvh_frustum_from_objects.rejection_count = 0;
-query_bvh_frustum_from_objects.rejection_sphere_count = 0;
-query_bvh_frustum_from_objects.plane_tests = 0;
-query_bvh_frustum_from_objects.plane_tests_early_exits = 0;
-query_bvh_frustum_from_objects.checks_sphere = 0;
-query_bvh_frustum_from_objects.checks_sphere_plane = 0;
-query_bvh_frustum_from_objects.checks_sphere_frustum_corner = 0;
-query_bvh_frustum_from_objects.checks_sphere_frustum_edge = 0;
-
 /**
  *
  * @param {number[]} result
@@ -116420,10 +116006,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$1 = [];
 
 class BinaryUint32BVH {
@@ -116595,16 +116178,16 @@ 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);
     }
@@ -118872,7 +118455,6 @@ class CachingTextureAtlas extends AbstractTextureAtlas {
     /**
      *
      * @param {AbstractTextureAtlas} atlas
-     * @param {number} cache_size
      */
     constructor({
                     atlas
@@ -119187,7 +118769,7 @@ class AbstractLight {
 
     /**
      *
-     * @param {AABB3} result
+     * @param {number[]|ArrayLike<number>|Float32Array} result
      * @returns {void}
      */
     getAABB(result) {
@@ -119312,7 +118894,6 @@ function aabb3_matrix4_project_by_corners(result, aabb_corners, projection_matri
 }
 
 const corners = [];
-const aabb_array = new Float32Array(6);
 
 class Decal extends AbstractLight {
     constructor() {
@@ -119344,7 +118925,7 @@ class Decal extends AbstractLight {
 
     /**
      *
-     * @param {number[]} m
+     * @param {number[]|Float32Array|ArrayLike<number>} m
      */
     setTransform(m) {
         copy(this.transform, m);
@@ -119395,9 +118976,7 @@ class Decal extends AbstractLight {
     getAABB(result) {
         aabb3_build_corners(corners, 0, -0.5, -0.5, -0.5, 0.5, 0.5, 0.5);
 
-        aabb3_matrix4_project_by_corners(aabb_array, corners, this.transform);
-
-        result.readFromArray(aabb_array, 0);
+        aabb3_matrix4_project_by_corners(result, corners, this.transform);
     }
 
     toArray(destination, address) {
@@ -119553,16 +119132,6 @@ function v3_distance(x0, y0, z0, x1, y1, z1) {
     return Math.sqrt(v3_distance_sqr(x0, y0, z0, x1, y1, z1));
 }
 
-/**
- *
- * @param {{id:number}} a
- * @param {{id:number}} b
- * @returns {number}
- */
-function compareObjectsByNumericId(a,b){
-    return a.id - b.id;
-}
-
 /**
  * TODO compute slices to minimize world-space volume difference between clusters
  * @param {number[]} input_frustum_corners corners of input frustum
@@ -119716,6 +119285,240 @@ function read_cluster_frustum_corners(output, i_z_0, tr_xy_1, i_y_0, tr_x_1, i_x
     read_frustum_corner(cluster_frustum_points, frustum_point_index_111, output, 21);
 }
 
+const _lut_array_buffer = new ArrayBuffer(84);
+/**
+ * Mapping from 3 plane bitfield, corresponding to intersection point of the planes
+ * @type {number[]}
+ */
+const triplanar_corner_mapping = new Uint8Array(_lut_array_buffer, 0, 43);
+
+triplanar_corner_mapping[0b010101] = 0;
+triplanar_corner_mapping[0b100101] = 1;
+triplanar_corner_mapping[0b011001] = 2;
+triplanar_corner_mapping[0b101001] = 3;
+triplanar_corner_mapping[0b010110] = 4;
+triplanar_corner_mapping[0b100110] = 5;
+triplanar_corner_mapping[0b011010] = 6;
+triplanar_corner_mapping[0b101010] = 7;
+/**
+ * Mapping from 2 plane bitfield to 2 corner bitfield, corresponding to corner indices of intersecting planes
+ * @type {number[]}
+ */
+const biplanar_edge_mapping = new Uint8Array(_lut_array_buffer, 43, 41);
+
+biplanar_edge_mapping[0b000101] = 0 | (1 << 3);
+biplanar_edge_mapping[0b000110] = 4 | (5 << 3);
+
+biplanar_edge_mapping[0b001001] = 2 | (3 << 3);
+biplanar_edge_mapping[0b001010] = 6 | (7 << 3);
+
+biplanar_edge_mapping[0b010100] = 0 | (4 << 3);
+biplanar_edge_mapping[0b011000] = 2 | (6 << 3);
+
+biplanar_edge_mapping[0b100100] = 1 | (5 << 3);
+biplanar_edge_mapping[0b101000] = 3 | (7 << 3);
+
+biplanar_edge_mapping[0b010001] = 0 | (2 << 3);
+biplanar_edge_mapping[0b010010] = 4 | (6 << 3);
+
+biplanar_edge_mapping[0b100001] = 1 | (3 << 3);
+biplanar_edge_mapping[0b100010] = 5 | (7 << 3);
+
+/**
+ * Computes shortest distance between a line segment(defined by 2 points) and a point
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} px
+ * @param {number} py
+ * @param {number} pz
+ */
+function line3_computeSegmentPointDistance_sqr(x0, y0, z0, x1, y1, z1, px, py, pz) {
+    // get line delta
+    const line_delta_x = x1 - x0;
+    const line_delta_y = y1 - y0;
+    const line_delta_z = z1 - z0;
+
+    // find closest point
+    const sp0_x = px - x0;
+    const sp0_y = py - y0;
+    const sp0_z = pz - z0;
+
+    //
+    const d2 = line_delta_x * line_delta_x + line_delta_y * line_delta_y + line_delta_z * line_delta_z;
+
+    const d3 = line_delta_x * sp0_x + line_delta_y * sp0_y + line_delta_z * sp0_z;
+
+    const t = clamp01(d3 / d2);
+
+    // compute point on the line
+    const lp_x = line_delta_x * t + x0;
+    const lp_y = line_delta_y * t + y0;
+    const lp_z = line_delta_z * t + z0;
+
+    // compute distance from the point in question to the point on the line
+    return v3_distance_sqr(px, py, pz, lp_x, lp_y, lp_z);
+}
+
+/**
+ *
+ * @param {number} radius
+ * @param {number} light_x
+ * @param {number} light_y
+ * @param {number} light_z
+ * @param {number} outside_plane_count
+ * @param {number} outside_plane_bitfield
+ * @param {number[]} points
+ * @return {boolean}
+ */
+function detailed_sphere_frustum_intersection_test(
+    radius, light_x, light_y, light_z,
+    outside_plane_count, outside_plane_bitfield,
+    points
+) {
+
+    const radius_sqr = radius * radius;
+
+    if (outside_plane_count === 3) {
+        // nearest point in a corner, find the corner
+        const point_index = triplanar_corner_mapping[outside_plane_bitfield];
+
+        const point_address = point_index * 3;
+
+        const point_x = points[point_address];
+        const point_y = points[point_address + 1];
+        const point_z = points[point_address + 2];
+
+        const distance_to_light_sqr = v3_distance_sqr(
+            point_x, point_y, point_z,
+            light_x, light_y, light_z
+        );
+
+        // query_bvh_frustum_from_objects.checks_sphere_frustum_corner++;
+
+        // return distance_to_light_sqr <= radius_sqr;
+
+        if (distance_to_light_sqr > radius_sqr) {
+
+            // query_bvh_frustum_from_objects.rejection_sphere_count++;
+            return false;
+        }
+
+    } else if (outside_plane_count === 2) {
+        // nearest point is on an edge of two plane intersection
+        const edge_bitfield = biplanar_edge_mapping[outside_plane_bitfield];
+
+        // get 2 corners from edge bitfield
+        const corner_index_0 = edge_bitfield & 0b111;
+        const corner_address_0 = corner_index_0 * 3;
+
+        const corner_index_1 = (edge_bitfield >> 3) & 0b111;
+        const corner_address_1 = corner_index_1 * 3;
+
+        const point_0_x = points[corner_address_0];
+        const point_0_y = points[corner_address_0 + 1];
+        const point_0_z = points[corner_address_0 + 2];
+
+        const point_1_x = points[corner_address_1];
+        const point_1_y = points[corner_address_1 + 1];
+        const point_1_z = points[corner_address_1 + 2];
+
+        const distance_to_frustum_sqr = line3_computeSegmentPointDistance_sqr(
+            point_0_x, point_0_y, point_0_z,
+            point_1_x, point_1_y, point_1_z,
+            light_x, light_y, light_z
+        );
+
+        // query_bvh_frustum_from_objects.checks_sphere_frustum_edge++;
+
+        // return distance_to_frustum_sqr <= radius_sqr;
+
+        if (distance_to_frustum_sqr > radius_sqr) {
+
+            // query_bvh_frustum_from_objects.rejection_sphere_count++;
+            return false;
+        }
+    }
+
+    return true;
+}
+
+/**
+ *
+ * @param {number} light_x
+ * @param {number} light_y
+ * @param {number} light_z
+ * @param {number} radius
+ * @param {number[]|Float32Array} points
+ * @param {number[]|Float32Array|Float64Array} planes
+ * @returns {boolean}
+ */
+function point_light_inside_volume(
+    light_x, light_y, light_z, radius,
+    points, planes
+) {
+    let j = 0;
+    let outside_plane_count = 0;
+    let outside_plane_bitfield = 0;
+
+    // validate if the sphere intersects the plane-bound space
+
+    // query_bvh_frustum_from_objects.checks_sphere++;
+
+    for (; j < 6; j++) {
+
+        const plane_address = j * 4;
+
+        const plane_normal_x = planes[plane_address];
+        const plane_normal_y = planes[plane_address + 1];
+        const plane_normal_z = planes[plane_address + 2];
+        const plane_constant = planes[plane_address + 3];
+
+        /*
+         compute distance from the center of the sphere to the plane
+         NOTE: inlined computation of distance from point to plane
+         */
+        const distance = (plane_normal_x * light_x + plane_normal_y * light_y + plane_normal_z * light_z) + plane_constant;
+
+        // query_bvh_frustum_from_objects.checks_sphere_plane++;
+
+        if (distance < 0) {
+            // center of the sphere is below the plane
+
+            if (distance >= -radius) {
+
+                // sphere intersects the plane
+
+                outside_plane_count++;
+
+                const plane_bit_mask = 1 << j;
+
+                outside_plane_bitfield |= plane_bit_mask;
+            } else {
+                // sphere is entirely below the plane
+
+                // query_bvh_frustum_from_objects.rejection_sphere_count++;
+
+                return false;
+            }
+        }
+
+    }
+
+    if (outside_plane_count < 2) {
+        return true;
+    } else {
+        return detailed_sphere_frustum_intersection_test(
+            radius, light_x, light_y, light_z,
+            outside_plane_count, outside_plane_bitfield,
+            points
+        );
+    }
+}
+
 /**
  *
  * @type {number[]}
@@ -120074,7 +119877,7 @@ function encode_light_descriptor(address, light) {
 
 /**
  *
- * @param {IncrementalDeltaSet<PointLightData>} data_set
+ * @param {IncrementalDeltaSet<LightRenderMetadata>} data_set
  * @param {BinaryUint32BVH} bvh
  */
 function build_light_data_bvh(data_set, bvh) {
@@ -120088,18 +119891,18 @@ function build_light_data_bvh(data_set, bvh) {
 
         /**
          *
-         * @type {PointLightData}
+         * @type {LightRenderMetadata}
          */
         const datum = elements[i];
 
-        const bb = datum.bvh_leaf_main;
+        const bb = datum.bvh_leaf.bounds;
 
         const payload = encode_light_descriptor(datum.address, datum.light);
 
         bvh.setLeafData(
             i, payload,
-            bb.x0, bb.y0, bb.z0,
-            bb.x1, bb.y1, bb.z1
+            bb[0], bb[1], bb[2],
+            bb[3], bb[4], bb[5],
         );
     }
 
@@ -120109,22 +119912,32 @@ function build_light_data_bvh(data_set, bvh) {
     bvh.build();
 }
 
+/**
+ *
+ * @param {LightRenderMetadata} a
+ * @param {LightRenderMetadata} b
+ * @returns {number}
+ */
+function compareLRMByLightId(a, b) {
+    return b.light.id - a.light.id;
+}
+
 class LightManager {
 
-    constructor() {
+    /**
+     * @readonly
+     * @type {ExplicitBinaryBoundingVolumeHierarchy}
+     */
+    #light_data_bvh = new ExplicitBinaryBoundingVolumeHierarchy();
 
-        /**
-         * @type {BinaryNode<PointLightData>}
-         * @private
-         */
-        this.__light_data_bvh = new BinaryNode();
+    /**
+     * Mapping from a light/decal object ID internal metadata
+     * @type {Map<number,LightRenderMetadata>}
+     */
+    #metadata_map = new Map();
 
-        /**
-         *
-         * @type {Map<AbstractLight, PointLightData>}
-         * @private
-         */
-        this.__light_data_map = new Map();
+
+    constructor() {
 
         /**
          * Number of cluster slices along each dimension
@@ -120227,22 +120040,22 @@ class LightManager {
 
         /**
          *
-         * @type {IncrementalDeltaSet<PointLightData>}
+         * @type {IncrementalDeltaSet<LightRenderMetadata>}
          * @readonly
          * @private
          */
-        this.__visible_lights = new IncrementalDeltaSet(compareObjectsByNumericId);
+        this.__visible_lights = new IncrementalDeltaSet(compareLRMByLightId);
         /**
          *
-         * @type {IncrementalDeltaSet<PointLightData>}
+         * @type {IncrementalDeltaSet<LightRenderMetadata>}
          * @readonly
          * @private
          */
-        this.__visible_decals = new IncrementalDeltaSet(compareObjectsByNumericId);
+        this.__visible_decals = new IncrementalDeltaSet(compareLRMByLightId);
 
         /**
          *
-         * @type {PointLightData[]}
+         * @type {LightRenderMetadata[]}
          * @private
          */
         this.__sorted_visible_lights = [];
@@ -120479,7 +120292,7 @@ class LightManager {
 
     /**
      *
-     * @param {PointLightData} data
+     * @param {LightRenderMetadata} data
      * @private
      */
     __handle_visible_decal_added(data) {
@@ -120511,7 +120324,7 @@ class LightManager {
 
     /**
      *
-     * @param {PointLightData} data
+     * @param {LightRenderMetadata} data
      * @private
      */
     __handle_visible_decal_removed(data) {
@@ -120548,7 +120361,7 @@ class LightManager {
 
     /**
      *
-     * @param {PointLightData} data
+     * @param {LightRenderMetadata} data
      * @private
      */
     __handle_visible_light_added(data) {
@@ -120561,7 +120374,7 @@ class LightManager {
 
     /**
      *
-     * @param {PointLightData} data
+     * @param {LightRenderMetadata} data
      * @private
      */
     __handle_visible_light_removed(data) {
@@ -120573,7 +120386,7 @@ class LightManager {
 
     /**
      *
-     * @param {PointLightData} light
+     * @param {LightRenderMetadata} light
      * @returns {number}
      * @protected
      */
@@ -120591,7 +120404,7 @@ class LightManager {
 
     /**
      * DEBUG method
-     * @param {PointLightData} lights
+     * @param {LightRenderMetadata} lights
      * @param {number} count
      * @returns {number} lower = better sorting score
      * @private
@@ -120688,7 +120501,7 @@ class LightManager {
 
         /**
          *
-         * @type {IncrementalDeltaSet<PointLightData>}
+         * @type {IncrementalDeltaSet<LightRenderMetadata>}
          */
         const visible_lights = this.__visible_lights;
 
@@ -120702,20 +120515,54 @@ class LightManager {
 
         read_frustum_planes_to_array(this.__view_frustum.planes, scratch_frustum_planes);
 
-        const match_count = query_bvh_frustum_from_objects(nodes, 0, this.__light_data_bvh, scratch_frustum_planes, this.__view_frustum_points);
+        /*
+        Search is done in 2 phases:
+        1) broad phase using bounding boxes
+        2) granular phase where we use object-specific shape to check against frustum
+         */
+
+        const broad_match_count = bvh_query_user_data_overlaps_frustum(nodes, 0, this.#light_data_bvh, scratch_frustum_planes);
+
+        for (let i = 0; i < broad_match_count; i++) {
 
-        for (let i = 0; i < match_count; i++) {
+            const light_id = nodes[i];
 
             /**
              *
-             * @type {PointLightData}
+             * @type {LightRenderMetadata}
              */
-            const light_data = nodes[i];
+            const light_data = this.#metadata_map.get(light_id);
+
+            /**
+             *
+             * @type {PointLight|Decal}
+             */
+            const light = light_data.light;
+
+            if (light.isDecal === true) {
+
 
-            if (light_data.light instanceof Decal) {
                 // decals go into a separate bucket
                 visible_decals.push(light_data);
-            } else {
+
+            } else if (light.isPointLight === true) {
+                // perform granular check
+
+                const light_position = light.position;
+
+                const light_x = light_position.x;
+                const light_y = light_position.y;
+                const light_z = light_position.z;
+
+                const radius = light.radius.getValue();
+
+                if (!point_light_inside_volume(light_x, light_y, light_z, radius, this.__view_frustum_points, scratch_frustum_planes)) {
+                    // outside of view frustum
+                    continue;
+                }
+
+
+                // register as visible
                 visible_lights.push(light_data);
             }
 
@@ -120730,7 +120577,7 @@ class LightManager {
 
         /**
          *
-         * @type {PointLightData[]}
+         * @type {LightRenderMetadata[]}
          */
         const visible_lights = this.__sorted_visible_lights;
 
@@ -121074,17 +120921,17 @@ class LightManager {
      * @param {number} z
      */
     setTileMapResolution(x, y, z) {
-        assert.isNumber(x,'x');
-        assert.isNonNegativeInteger(x,'x');
-        assert.isFiniteNumber(x,'x');
+        assert.isNumber(x, 'x');
+        assert.isNonNegativeInteger(x, 'x');
+        assert.isFiniteNumber(x, 'x');
 
-        assert.isNumber(y,'y');
-        assert.isNonNegativeInteger(y,'y');
-        assert.isFiniteNumber(y,'y');
+        assert.isNumber(y, 'y');
+        assert.isNonNegativeInteger(y, 'y');
+        assert.isFiniteNumber(y, 'y');
 
-        assert.isNumber(z,'z');
-        assert.isNonNegativeInteger(z,'z');
-        assert.isFiniteNumber(z,'z');
+        assert.isNumber(z, 'z');
+        assert.isNonNegativeInteger(z, 'z');
+        assert.isFiniteNumber(z, 'z');
 
         const r = this.__tiles_resolution;
 
@@ -121118,13 +120965,11 @@ class LightManager {
      * @param {AbstractLight} light
      */
     addLight(light) {
-        const lightData = new PointLightData(light);
-
-        lightData.link();
+        const lightData = new LightRenderMetadata(light);
 
-        this.__light_data_bvh.insertNode(lightData.bvh_leaf_main);
+        lightData.link(this.#light_data_bvh);
 
-        this.__light_data_map.set(light, lightData);
+        this.#metadata_map.set(light.id, lightData);
     }
 
     /**
@@ -121134,7 +120979,9 @@ class LightManager {
      */
     removeLight(light) {
 
-        const data = this.__light_data_map.get(light);
+        const light_id = light.id;
+
+        const data = this.#metadata_map.get(light_id);
 
         if (data === undefined) {
             return false;
@@ -121142,7 +120989,7 @@ class LightManager {
 
         data.unlink();
 
-        this.__light_data_map.delete(light);
+        this.#metadata_map.delete(light_id);
 
         return true;
     }
@@ -121771,6 +121618,7 @@ class ForwardPlusRenderingPlugin extends EnginePlugin {
     getLightManager() {
         return this.__light_manager;
     }
+
 }
 
 /**
@@ -122408,10 +122256,6 @@ class PointLight extends AbstractLight {
         this.position.writeToArray(result, 0);
     }
 
-    /**
-     *
-     * @param {AABB3} result
-     */
     getAABB(result) {
         const r = this.radius.getValue();
         const p = this.position;
@@ -122420,15 +122264,13 @@ class PointLight extends AbstractLight {
         const center_y = p.y;
         const center_z = p.z;
 
-        result.setBounds(
-            center_x - r,
-            center_y - r,
-            center_z - r,
+        result[0] = center_x - r;
+            result[1] =     center_y - r;
+            result[2] =  center_z - r;
 
-            center_x + r,
-            center_y + r,
-            center_z + r
-        );
+            result[3] =  center_x + r;
+            result[4] =  center_y + r;
+            result[5] =  center_z + r;
     }
 
     onDimensionChanged(listener, context) {
@@ -124889,6 +124731,12 @@ function browserInfo() {
         return cached;
     }
 
+    const navigator = globalThis.navigator;
+
+    if(navigator === undefined){
+        throw new Error('Not a browser, globalThis.navigator is undefined');
+    }
+
     let ua = navigator.userAgent, tem,
         M = ua.match(/(opera|chrome|safari|firefox|msie|trident(?=\/))\/?\s*(\d+)/i) || [];
 
@@ -125112,7 +124960,7 @@ function setListenerPositionNOOP(listener, position) {
 
 let setListenerPosition = setListenerPositionNOOP;
 
-if (navigator !== undefined) {
+if (globalThis.navigator !== undefined) {
     const info = browserInfo();
     if (info.name === "Chrome") {
         if (info.version >= 64) {
@@ -125164,7 +125012,7 @@ function setListenerOrientation2(listener, forward, up) {
 
 let setListenerOrientation = noop;
 
-if (navigator !== undefined) {
+if (globalThis.navigator !== undefined) {
     const info = browserInfo();
     if (info.name === "Chrome") {
         setListenerOrientation = setListenerOrientation1;
@@ -125924,6 +125772,9 @@ const ParallelBehaviorPolicy = {
     RequireAll: 1
 };
 
+/**
+ * Executes all contained behaviors in parallel
+ */
 class ParallelBehavior extends CompositeBehavior {
     /**
      *
@@ -125933,6 +125784,9 @@ class ParallelBehavior extends CompositeBehavior {
     constructor(successPolicy, failurePolicy) {
         super();
 
+        assert.enum(successPolicy, ParallelBehaviorPolicy, 'successPolicy');
+        assert.enum(failurePolicy, ParallelBehaviorPolicy, 'failurePolicy');
+
         /**
          * @private
          * @type {ParallelBehaviorPolicy}
@@ -125946,6 +125800,7 @@ class ParallelBehavior extends CompositeBehavior {
         this.failurePolicy = failurePolicy;
 
         /**
+         * @readonly
          * @private
          * @type {BitSet}
          */
@@ -125973,10 +125828,11 @@ class ParallelBehavior extends CompositeBehavior {
 
     /**
      *
-     * @param {ParallelBehaviorPolicy|number} v
+     * @param {ParallelBehaviorPolicy|number} policy
      */
-    setSuccessPolicy(v) {
-        this.successPolicy = v;
+    setSuccessPolicy(policy) {
+        assert.enum(policy, ParallelBehaviorPolicy, 'policy');
+        this.successPolicy = policy;
     }
 
     /**
@@ -125989,10 +125845,11 @@ class ParallelBehavior extends CompositeBehavior {
 
     /**
      *
-     * @param {ParallelBehaviorPolicy|number} v
+     * @param {ParallelBehaviorPolicy|number} policy
      */
-    setFailurePolicy(v) {
-        this.failurePolicy = v;
+    setFailurePolicy(policy) {
+        assert.enum(policy, ParallelBehaviorPolicy, 'policy');
+        this.failurePolicy = policy;
     }
 
     /**
@@ -126126,14 +125983,16 @@ class ParallelBehavior extends CompositeBehavior {
     /**
      *
      * @param {Behavior[]} elements
-     * @param {ParallelBehaviorPolicy} success
-     * @param {ParallelBehaviorPolicy} failure
+     * @param {ParallelBehaviorPolicy} success how should successful completion be determined?
+     * @param {ParallelBehaviorPolicy} failure how should failing completion be determined
      * @returns {ParallelBehavior}
      */
     static from(elements, success = ParallelBehaviorPolicy.RequireAll, failure = ParallelBehaviorPolicy.RequireOne) {
+        assert.isArray(elements, 'elements');
+
         const r = new ParallelBehavior(success, failure);
 
-        elements.forEach(e => r.addChild(e));
+        r.addChildren(elements);
 
         return r;
     }