@woosh/meep-engine 2.46.25 → 2.46.27

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