@woosh/meep-engine 2.46.26 → 2.46.28

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.46.26",
+  "version": "2.46.28",
   "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;
     }

package/src/engine/graphics/render/forward_plus/LightManager.js

@@ -1,5 +1,4 @@
-import { BinaryNode } from "../../../../core/bvh2/BinaryNode.js";
-import { PointLightData } from "./PointLightData.js";
+import { LightRenderMetadata } from "./LightRenderMetadata.js";
 import {
     ClampToEdgeWrapping,
     DataTexture,
@@ -14,7 +13,6 @@ import {
     UnsignedShortType
 } from "three";
 import Vector3 from "../../../../core/geom/Vector3.js";
-import { query_bvh_frustum_from_objects } from "./query/query_bvh_frustum_from_objects.js";
 import { IncrementalDeltaSet } from "../visibility/IncrementalDeltaSet.js";
 import { computeFrustumCorners } from "./computeFrustumCorners.js";
 import { read_plane_pair } from "./cluster/read_plane_pair.js";
@@ -42,10 +40,19 @@ import { array_copy } from "../../../../core/collection/array/copyArray.js";
 import { arrayQuickSort } from "../../../../core/collection/array/arrayQuickSort.js";
 import { frustum_from_camera } from "../../ecs/camera/frustum_from_camera.js";
 import { arraySwapElements } from "../../../../core/collection/array/arraySwapElements.js";
-import { compareObjectsByNumericId } from "../../../../core/model/object/compareObjectsByNumericId.js";
 import { slice_frustum_linear_to_points } from "../../../../core/geom/3d/frustum/slice_frustum_linear_to_points.js";
 import { read_cluster_frustum_corners } from "../../../../core/geom/3d/frustum/read_cluster_frustum_corners.js";
 import { assign_cluster, LOOKUP_CACHE, scratch_corners, scratch_frustum_planes } from "./assign_cluster.js";
+import {
+    ExplicitBinaryBoundingVolumeHierarchy
+} from "../../../../core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.js";
+import {
+    bvh_query_user_data_overlaps_frustum
+} from "../../../../core/bvh2/bvh3/query/bvh_query_user_data_overlaps_frustum.js";
+import { point_light_inside_volume } from "./query/point_light_inside_volume.js";
+import { bvh_query_leaves_ray } from "../../../../core/bvh2/bvh3/query/bvh_query_leaves_ray.js";
+import { ray3_array_apply_matrix4 } from "../../../../core/geom/3d/ray/ray3_array_apply_matrix4.js";
+import { aabb3_intersects_ray } from "../../../../core/bvh2/aabb3/aabb3_intersects_ray.js";
 
 
 /**
@@ -82,7 +89,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) {
@@ -96,18 +103,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],
         );
     }
 
@@ -117,22 +124,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;
+}
+
 export 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
@@ -235,22 +252,22 @@ export 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 = [];
@@ -487,7 +504,7 @@ export class LightManager {
 
     /**
      *
-     * @param {PointLightData} data
+     * @param {LightRenderMetadata} data
      * @private
      */
     __handle_visible_decal_added(data) {
@@ -519,7 +536,7 @@ export class LightManager {
 
     /**
      *
-     * @param {PointLightData} data
+     * @param {LightRenderMetadata} data
      * @private
      */
     __handle_visible_decal_removed(data) {
@@ -556,7 +573,7 @@ export class LightManager {
 
     /**
      *
-     * @param {PointLightData} data
+     * @param {LightRenderMetadata} data
      * @private
      */
     __handle_visible_light_added(data) {
@@ -569,7 +586,7 @@ export class LightManager {
 
     /**
      *
-     * @param {PointLightData} data
+     * @param {LightRenderMetadata} data
      * @private
      */
     __handle_visible_light_removed(data) {
@@ -581,7 +598,7 @@ export class LightManager {
 
     /**
      *
-     * @param {PointLightData} light
+     * @param {LightRenderMetadata} light
      * @returns {number}
      * @protected
      */
@@ -599,7 +616,7 @@ export class LightManager {
 
     /**
      * DEBUG method
-     * @param {PointLightData} lights
+     * @param {LightRenderMetadata} lights
      * @param {number} count
      * @returns {number} lower = better sorting score
      * @private
@@ -696,7 +713,7 @@ export class LightManager {
 
         /**
          *
-         * @type {IncrementalDeltaSet<PointLightData>}
+         * @type {IncrementalDeltaSet<LightRenderMetadata>}
          */
         const visible_lights = this.__visible_lights;
 
@@ -710,20 +727,54 @@ export 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);
             }
 
@@ -738,7 +789,7 @@ export class LightManager {
 
         /**
          *
-         * @type {PointLightData[]}
+         * @type {LightRenderMetadata[]}
          */
         const visible_lights = this.__sorted_visible_lights;
 
@@ -1082,17 +1133,17 @@ export 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;
 
@@ -1126,13 +1177,11 @@ export 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);
     }
 
     /**
@@ -1142,7 +1191,9 @@ export 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;
@@ -1150,8 +1201,65 @@ export class LightManager {
 
         data.unlink();
 
-        this.__light_data_map.delete(light);
+        this.#metadata_map.delete(light_id);
 
         return true;
     }
+
+    /**
+     *
+     * @param {Decal[]} result
+     * @param {number} result_offset
+     * @param {number[]} query
+     * @param {number} query_offset
+     * @returns {number} number of elements added to the result
+     */
+    query_decals_by_ray(result, result_offset, query, query_offset) {
+
+        const leaves = [];
+        const local_ray = new Float32Array(6);
+
+        const hit_count = bvh_query_leaves_ray(this.#light_data_bvh, leaves, 0,
+            query[query_offset], query[query_offset + 1], query[query_offset + 2],
+            query[query_offset + 3], query[query_offset + 4], query[query_offset + 5]
+        );
+
+        let result_count = 0;
+
+        for (let i = 0; i < hit_count; i++) {
+            const node = leaves[i];
+            const light_id = this.#light_data_bvh.node_get_user_data(node);
+
+            const metadata = this.#metadata_map.get(light_id);
+
+            /**
+             *
+             * @type {Decal}
+             */
+            const prop = metadata.light;
+
+            if (prop.isDecal !== true) {
+                // wrong prop type
+                continue;
+            }
+
+            // transform ray into decal's local space
+            ray3_array_apply_matrix4(local_ray, 0, query, query_offset, prop.transform_inverse);
+
+            if (aabb3_intersects_ray(
+                -0.5, -0.5, -0.5,
+                0.5, 0.5, 0.5,
+
+                local_ray[0], local_ray[1], local_ray[2],
+                local_ray[3], local_ray[4], local_ray[5],
+            )) {
+                result[result_offset + result_count] = prop;
+
+                result_count++;
+            }
+
+        }
+
+        return result_count;
+    }
 }

package/src/engine/graphics/render/forward_plus/{PointLightData.js → LightRenderMetadata.js}

@@ -1,6 +1,8 @@
-import { LeafNode } from "../../../../core/bvh2/LeafNode.js";
+import { EBBVHLeafProxy } from "../../../../core/bvh2/bvh3/EBBVHLeafProxy.js";
+
+export class LightRenderMetadata {
+
 
-export class PointLightData {
     /**
      *
      * @param {AbstractLight} light
@@ -18,12 +20,12 @@ export 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) {
@@ -31,17 +33,22 @@ export 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();
+        if (leaf.is_linked) {
+            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);
@@ -52,6 +59,6 @@ export class PointLightData {
         this.light.offDimensionChanged(this.update, this);
 
         // disconnect from bvh
-        this.bvh_leaf_main.disconnect();
+        this.bvh_leaf.unlink();
     }
 }

package/src/engine/graphics/render/forward_plus/cluster/compute_light_data_hash.js

@@ -1,6 +1,6 @@
 /**
  *
- * @param {PointLightData[]} nodes
+ * @param {LightRenderMetadata[]} nodes
  * @param {number} count
  */
 export function compute_light_data_hash(nodes, count) {

package/src/engine/graphics/render/forward_plus/model/AbstractLight.js

@@ -40,7 +40,7 @@ export class AbstractLight {
 
     /**
      *
-     * @param {AABB3} result
+     * @param {number[]|ArrayLike<number>|Float32Array} result
      * @returns {void}
      */
     getAABB(result) {

package/src/engine/graphics/render/forward_plus/model/Decal.js

@@ -6,7 +6,6 @@ import { mat4 } from "gl-matrix";
 import Signal from "../../../../../core/events/signal/Signal.js";
 
 const corners = [];
-const aabb_array = new Float32Array(6);
 
 export class Decal extends AbstractLight {
     constructor() {
@@ -89,9 +88,7 @@ export 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) {

package/src/engine/graphics/render/forward_plus/model/PointLight.js

@@ -36,10 +36,6 @@ export class PointLight extends AbstractLight {
         this.position.writeToArray(result, 0);
     }
 
-    /**
-     *
-     * @param {AABB3} result
-     */
     getAABB(result) {
         const r = this.radius.getValue();
         const p = this.position;
@@ -48,15 +44,13 @@ export 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) {

package/src/engine/graphics/render/forward_plus/model/SpotLight.js

@@ -65,10 +65,6 @@ export class SpotLight extends AbstractLight {
         result[2] = p.z + d.z * m;
     }
 
-    /**
-     *
-     * @param {AABB3} result
-     */
     getAABB(result) {
         const position = this.position;
         const direction = this.direction;

package/src/engine/graphics/render/forward_plus/plugin/ForwardPlusRenderingPlugin.d.ts

@@ -1,5 +1,8 @@
 import {EnginePlugin} from "../../../../plugin/EnginePlugin";
+import {Decal} from "../../../ecs/decal/v2/Decal";
 
 export class ForwardPlusRenderingPlugin extends EnginePlugin {
     setClusterResolution(x: number, y: number, z: number): void
+
+    queryDecalsByRay(result: Decal[], result_offset: number, query: ArrayLike<number>, query_offset?: number): number
 }

package/src/engine/graphics/render/forward_plus/plugin/ForwardPlusRenderingPlugin.js

@@ -88,4 +88,16 @@ export class ForwardPlusRenderingPlugin extends EnginePlugin {
     getLightManager() {
         return this.__light_manager;
     }
+
+    /**
+     *
+     * @param {Decal[]} result
+     * @param {number} result_offset
+     * @param {number[]} query
+     * @param {number} query_offset
+     * @returns {number} number of elements added to the result
+     */
+    queryDecalsByRay(result, result_offset, query, query_offset=0){
+return        this.__light_manager.query_decals_by_ray(result,result_offset, query,query_offset);
+    }
 }

package/src/engine/graphics/render/forward_plus/prototype/prototypeLightManager.js

@@ -1559,11 +1559,12 @@ function draw_camera_view_planes() {
 }
 
 // prepare_scene_2();
-prepare_scene_decal_0();
+// prepare_scene_decal_0();
 // prepare_scene_decal_1();
 // prepare_scene_decal_2();
 // prepare_scene_9();
-// prepare_scene_0();
+// prepare_scene_0(); // stress test
+prepare_scene_4(); // sponza
 animate();
 
 // draw_camera_view_planes();

package/src/engine/graphics/render/forward_plus/query/point_light_inside_volume.js

@@ -6,7 +6,7 @@ import { detailed_sphere_frustum_intersection_test } from "./detailed_sphere_fru
  * @param {number} light_y
  * @param {number} light_z
  * @param {number} radius
- * @param {number[]} points
+ * @param {number[]|Float32Array} points
  * @param {number[]|Float32Array|Float64Array} planes
  * @returns {boolean}
  */

package/src/engine/graphics/render/forward_plus/query/query_bvh_frustum_from_objects.js

@@ -14,9 +14,9 @@ let stackPointer = 0;
 
 /**
  * Most of the data is in flat continuous array for cache coherence
- * @param {PointLightData[]} destination
+ * @param {LightRenderMetadata[]} destination
  * @param {number} destination_offset
- * @param {BinaryNode<PointLightData>} root
+ * @param {BinaryNode<LightRenderMetadata>} root
  * @param {number[]|Float32Array|Float64Array} planes
  * @param {number[]|Float32Array|Float64Array} points
  * @returns {number} number of items added to the destination, non-negative integer
@@ -84,7 +84,7 @@ export function query_bvh_frustum_from_objects(
 
             /**
              *
-             * @type {PointLightData}
+             * @type {LightRenderMetadata}
              */
             const light_data = n.object;
 

package/src/engine/graphics/sh3/path_tracer/PathTracedMesh.js

@@ -69,7 +69,7 @@ export class PathTracedMesh {
     hit(out, ray, min_distance, max_distance) {
         //transform ray
         const m4 = this.__transform_inverse;
-        ray3_array_apply_matrix4(local_ray, ray, m4);
+        ray3_array_apply_matrix4(local_ray,0, ray,0, m4);
 
         const scale_d = this.__local_scale_inverse;
 

package/src/engine/graphics/texture/atlas/CachingTextureAtlas.js

@@ -29,7 +29,6 @@ export class CachingTextureAtlas extends AbstractTextureAtlas {
     /**
      *
      * @param {AbstractTextureAtlas} atlas
-     * @param {number} cache_size
      */
     constructor({
                     atlas

package/src/engine/intelligence/behavior/util/BranchBehavior.js

@@ -5,6 +5,11 @@ import { BehaviorStatus } from "../BehaviorStatus.js";
 
 const DEFAULT = new SucceedingBehavior();
 
+/**
+ * Utility behavior that works just like an IF/ELSE statement
+ * If you are not sure if this is the right behavior for your use-case, consider using a selector behavior instead,
+ * as selector is a more commonly applicable behavior type
+ */
 export class BranchBehavior extends Behavior {
     #successBranch = DEFAULT
     #failureBranch = DEFAULT

package/src/engine/plugin/EnginePluginManager.d.ts

@@ -6,4 +6,6 @@ interface Type<T> extends Function {
 
 export class EnginePluginManager {
     acquire<T>(klass: Type<T>): Promise<Reference<T>>
+
+    getPlugin<T>(klass: Type<T>): T | undefined
 }

package/src/engine/intelligence/behavior/util/SelectorBehavior.js

@@ -1,83 +0,0 @@
-import { CompositeBehavior } from "../composite/CompositeBehavior.js";
-import { BehaviorStatus } from "../BehaviorStatus.js";
-
-export class SelectorBehavior extends CompositeBehavior {
-    constructor() {
-        super();
-
-        this.__index = 0;
-    }
-
-    /**
-     *
-     * @param {Behavior[]} children
-     * @return {SelectorBehavior}
-     */
-    static from(children) {
-        const r = new SelectorBehavior();
-
-        r.__children = children.slice();
-
-        return r;
-    }
-
-    tick(timeDelta) {
-        const children = this.__children;
-        const child_count = children.length;
-
-        if (child_count === 0) {
-            // arbitrarily decide success
-            return BehaviorStatus.Succeeded;
-        }
-
-        for (; ;) {
-            const child = children[this.__index];
-
-            const s = child.tick(timeDelta);
-
-            //if child succeeds or keeps running, do the same
-            if (s !== BehaviorStatus.Failed) {
-                return s;
-            }
-
-
-            //continue search for fallback behavior until the last child
-            this.__index++;
-
-            if (this.__index >= child_count) {
-                return BehaviorStatus.Failed;
-            }
-
-            //initialize new child
-            const next = children[this.__index];
-
-            child.finalize();
-            next.initialize(this.context);
-        }
-
-        //we should never reach this point
-        return BehaviorStatus.Invalid;
-    }
-
-    finalize() {
-        super.finalize();
-
-        if (this.__children.length > 0) {
-            const b = this.__children[this.__index];
-
-            b.finalize();
-        }
-    }
-
-
-    initialize(context) {
-        super.initialize(context);
-
-        this.__index = 0;
-
-        if (this.__children.length > 0) {
-            this.__children[0].initialize(context);
-        }
-    }
-
-}