@woosh/meep-engine 2.33.21 → 2.33.25

package/engine/graphics/render/buffer/slot/parameter/ProgramValueSlotParameter.js

@@ -1,6 +1,7 @@
-import { computeHashFloat, computeHashIntegerArray } from "../../../../../../core/math/MathUtils.js";
 import { ProgramValueSlotParameterType } from "./ProgramValueSlotParameterType.js";
 import { computeStringHash } from "../../../../../../core/primitives/strings/computeStringHash.js";
+import { computeHashIntegerArray } from "../../../../../../core/collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../../../../../../core/math/hash/computeHashFloat.js";
 
 /**
  *

package/engine/graphics/render/buffer/slot/parameter/ProgramValueSlotParameterSet.js

@@ -1,4 +1,4 @@
-import { computeHashIntegerArray } from "../../../../../../core/math/MathUtils.js";
+import { computeHashIntegerArray } from "../../../../../../core/collection/array/computeHashIntegerArray.js";
 
 export class ProgramValueSlotParameterSet {
     constructor() {

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

@@ -3,7 +3,7 @@ import { PointLightData } from "./PointLightData.js";
 import { DataTexture, DataTexture3D, Frustum, NearestFilter, RGBIntegerFormat, UnsignedShortType } from "three";
 import { frustumFromCamera } from "../../ecs/camera/CameraSystem.js";
 import Vector3 from "../../../../core/geom/Vector3.js";
-import { queryBVH_Frustum } from "./queryBVH_Frustum.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 { arraySwapElements } from "../../../../core/collection/ArrayUtils.js";
@@ -18,69 +18,25 @@ import { NumericType } from "./data/NumericType.js";
 import { computeDataType } from "./data/computeDataType.js";
 import { computeThreeTextureTypeFromDataType } from "./data/computeThreeTextureTypeFromDataType.js";
 import { computeThreeTextureInternalFormatFromDataType } from "./data/computeThreeTextureInternalFormatFromDataType.js";
+import { testClusterEquality } from "./testClusterEquality.js";
+import { read_frustum_corner } from "./read_frustum_corner.js";
+import { BinaryUint32BVH } from "../../../../core/bvh2/binary/2/BinaryUint32BVH.js";
+import { query_bvh_frustum_from_texture } from "./query/query_bvh_frustum_from_texture.js";
+import { mat4 } from "gl-matrix";
+import { mortonEncode_magicbits } from "../../../../core/geom/3d/morton/mortonEncode_magicbits.js";
 
 const LOOKUP_CACHE_SIZE = 16384; // must be power of two
-/**
- * Cache used to identify duplicate cells. Helps reduce memory usage and just point to equivalent existing cells instead of allocating new ones.
- * @type {Uint16Array|Uint32Array}
- */
-const LOOKUP_CACHE = new Uint32Array(LOOKUP_CACHE_SIZE);
-
-/**
- *
- * @param {PointLightData[]} lights
- * @param {number} count
- * @param {number[]|Uint32Array|Uint16Array|Uint8Array|Uint8ClampedArray} light_lookup_texture_data
- * @param {number} address
- * @returns {boolean}
- */
-function testClusterEquality(lights, count, light_lookup_texture_data, address) {
-    for (let i = 0; i < count; i++) {
-
-        const actual_visible_index = light_lookup_texture_data[address + i];
-
-        const datum = scratch_light_nodes[i];
-
-        const expected_visible_index = datum.visible_index;
-
-        if (expected_visible_index !== actual_visible_index) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-/**
- *
- * @param {PointLightData} datum
- * @returns {number}
- */
-function get_light_visible_index(datum) {
-    return datum.visible_index;
-}
-
-/**
- *
- * @param {number[]|Float32Array|Float64Array} source
- * @param {number} source_index
- * @param {number[]|Float32Array|Float64Array} destination
- * @param {number} destination_offset
- */
-function read_frustum_corner(source, source_index, destination, destination_offset) {
-    const address = source_index * 3;
-
-    destination[destination_offset] = source[address];
-    destination[destination_offset + 1] = source[address + 1];
-    destination[destination_offset + 2] = source[address + 2];
-}
 
 /**
  * Using continuous buffer for related attributes to get better cache utilization
  * @type {ArrayBuffer}
  * @private
  */
-const _scratch_array_buffer = new ArrayBuffer((24 + 24) * 4);
+const _scratch_array_buffer = new ArrayBuffer(
+    24 * 4
+    + 24 * 4
+    + LOOKUP_CACHE_SIZE * 4
+);
 
 /**
  *
@@ -88,11 +44,6 @@ const _scratch_array_buffer = new ArrayBuffer((24 + 24) * 4);
  */
 const scratch_corners = new Float32Array(_scratch_array_buffer, 0, 24);
 
-/**
- *
- * @type {PointLightData[]}
- */
-const scratch_light_nodes = [];
 
 /**
  * Linear access data structure with parameters of each plane of the frustum
@@ -102,6 +53,18 @@ const scratch_light_nodes = [];
  */
 const scratch_frustum_planes = new Float32Array(_scratch_array_buffer, 24 * 4, 24);
 
+/**
+ * Cache used to identify duplicate cells. Helps reduce memory usage and just point to equivalent existing cells instead of allocating new ones.
+ * @type {Uint16Array|Uint32Array}
+ */
+const LOOKUP_CACHE = new Uint32Array(_scratch_array_buffer, (24 + 24) * 4, LOOKUP_CACHE_SIZE);
+
+/**
+ *
+ * @type {number[]}
+ */
+const scratch_light_nodes = [];
+
 export class LightManager {
 
     constructor() {
@@ -170,10 +133,10 @@ export class LightManager {
 
         /**
          *
-         * @type {BinaryNode}
+         * @type {BinaryUint32BVH}
          * @private
          */
-        this.__visible_bvh = new BinaryNode();
+        this.__visible_bvh = new BinaryUint32BVH();
 
         /**
          *
@@ -189,6 +152,13 @@ export class LightManager {
          */
         this.__view_frustum_points = new Float32Array(24);
 
+        /**
+         *
+         * @type {Float32Array|mat4|number[]}
+         * @private
+         */
+        this.__projection_matrix = new Float32Array(16);
+
 
         /**
          * Accelerated data structure with pre-computed plane normals for clusters in each dimensions. Order: X, Y, Z
@@ -313,6 +283,14 @@ export class LightManager {
         return this.__tiles_resolution;
     }
 
+    /**
+     *
+     * @private
+     */
+    __request_update_visible_bvh() {
+        this.__visible_bvh_needs_update = true;
+    }
+
     /**
      *
      * @param {PointLightData} data
@@ -320,6 +298,8 @@ export class LightManager {
      */
     __handle_visible_added(data) {
         this.__visible_bvh_needs_update = true;
+
+        data.light.onDimensionChanged(this.__request_update_visible_bvh, this);
     }
 
     /**
@@ -331,40 +311,70 @@ export class LightManager {
         this.__visible_bvh_needs_update = true;
 
         data.bvh_leaf_visible.disconnect();
+
+        data.light.offDimensionChanged(this.__request_update_visible_bvh, this);
+    }
+
+    /**
+     *
+     * @param {PointLightData} light
+     * @returns {number}
+     * @private
+     */
+    __sort_visible_light_score(light) {
+        const p = light.light.position;
+
+        // return v3_morton_encode_transformed(p.x, p.y, p.z, this.__projection_matrix);
+        return mortonEncode_magicbits(p.x, p.y, p.z);
+    }
+
+    /**
+     * Sort lights for better data locality
+     * @private
+     */
+    __sort_visible_light() {
+        this.__visible_lights.sort(this.__sort_visible_light_score, this);
     }
 
     __update_visible_bvh() {
         this.__visible_bvh_needs_update = false;
 
-        this.__visible_bvh.reset();
-
         const lights = this.__visible_lights.elements;
         const light_count = lights.length;
 
-        function inserter(i) {
+        // sort light for better search and query locality
+        this.__sort_visible_light();
+
+        const vbvh = this.__visible_bvh;
+
+        vbvh.setLeafCount(light_count);
+        vbvh.initialize_structure();
+
+        for (let i = 0; i < light_count; i++) {
+
             /**
              *
              * @type {PointLightData}
              */
             const datum = lights[i];
 
-            datum.bvh_leaf_visible.parentNode = null;
+            const bb = datum.bvh_leaf_main;
 
-            return datum.bvh_leaf_visible;
+            vbvh.setLeafData(
+                i, i,
+                bb.x0, bb.y0, bb.z0,
+                bb.x1, bb.y1, bb.z1
+            );
         }
 
-        this.__visible_bvh.insertManyBoxes2(inserter, light_count)
+        // vbvh.sort_morton(this.__projection_matrix);
+        // vbvh.sort_bubble_sah();
 
-    }
+        vbvh.build();
 
-    /**
-     *
-     * @returns {BinaryNode<PointLightData>}
-     */
-    getBVH() {
-        return this.__light_points_bvh;
     }
 
+
     /**
      *
      * @param {Camera} camera
@@ -388,13 +398,11 @@ export class LightManager {
 
         visible_lights.initializeUpdate();
 
-        let index_counter = 0;
-
         const nodes = [];
 
         read_frustum_planes_to_array(this.__view_frustum.planes, scratch_frustum_planes)
 
-        const match_count = queryBVH_Frustum(nodes, 0, this.__light_points_bvh, scratch_frustum_planes, this.__view_frustum_points);
+        const match_count = query_bvh_frustum_from_objects(nodes, 0, this.__light_points_bvh, scratch_frustum_planes, this.__view_frustum_points);
 
         for (let i = 0; i < match_count; i++) {
 
@@ -404,10 +412,6 @@ export class LightManager {
              */
             const light_data = nodes[i];
 
-            const index = index_counter++;
-
-            light_data.visible_index = index;
-
             visible_lights.push(light_data);
         }
 
@@ -433,7 +437,7 @@ export class LightManager {
 
         this.__light_data.update();
 
-        // update lookup precision
+        // update required lookup precision
         this.__lookup_data.precision = Math.max(0, Math.ceil(Math.log2(this.__light_data.size)));
 
         const tx_light = this.__light_data.getTexture();
@@ -448,7 +452,7 @@ export class LightManager {
             const datum = visible_lights[i];
 
 
-            const address = datum.visible_index * 8;
+            const address = i * 8;
 
             assert.lessThan(address, tx_light_data.length, "overflow")
 
@@ -490,6 +494,12 @@ export class LightManager {
         const cluster_planes_y_offset = tr_x_1 * 4;
         const cluster_planes_z_offset = cluster_planes_y_offset + tr_y_1 * 4;
 
+        /**
+         *
+         * @type {number[]|Uint8ClampedArray}
+         */
+        const light_source_data = this.__light_data.getTexture().image.data;
+
         const tile_slice_size = tr_x * tr_y;
 
         const light_cluster_texture = this.__cluster_texture;
@@ -507,7 +517,9 @@ export class LightManager {
 
         let lookup_address_offset = 0;
         let i_x_0, i_y_0, i_z_0;
+        let i;
 
+        // clear cache
         LOOKUP_CACHE.fill(0xFFFFFFFF);
 
         for (i_z_0 = 0; i_z_0 < tr_z; i_z_0++) {
@@ -529,7 +541,6 @@ export class LightManager {
                 read_plane_pair(cluster_planes, y_plane_index_offset_0, scratch_frustum_planes, 8);
 
                 for (i_x_0 = 0; i_x_0 < tr_x; i_x_0++) {
-                    const i_x_1 = i_x_0 + 1;
 
                     // construct x planes
 
@@ -551,6 +562,8 @@ export class LightManager {
                     const frustum_point_index_011 = i_z_1 * tr_xy_1 + i_y_1 * tr_x_1 + i_x_0;
                     read_frustum_corner(cluster_frustum_points, frustum_point_index_011, scratch_corners, 9);
 
+                    const i_x_1 = i_x_0 + 1;
+
                     const frustum_point_index_100 = i_z_0 * tr_xy_1 + i_y_0 * tr_x_1 + i_x_1;
                     read_frustum_corner(cluster_frustum_points, frustum_point_index_100, scratch_corners, 12);
 
@@ -565,7 +578,14 @@ export class LightManager {
 
 
                     // at this point we have a fully constructed cluster, we can query lights within the cluster
-                    const match_count = queryBVH_Frustum(scratch_light_nodes, 0, bvh, scratch_frustum_planes, scratch_corners);
+                    const match_count = query_bvh_frustum_from_texture(
+                        scratch_light_nodes,
+                        0,
+                        bvh,
+                        light_source_data,
+                        scratch_frustum_planes,
+                        scratch_corners
+                    );
 
                     const tile_index = (i_z_0 * tile_slice_size) + (i_y_0 * tr_x) + (tr_x - i_x_1);
 
@@ -618,15 +638,15 @@ export class LightManager {
                     // write address of the lookup table
                     tile_texture_data[tile_address] = lookup_address_offset;
 
-                    for (let i = 0; i < match_count; i++) {
+                    for (i = 0; i < match_count; i++) {
                         /**
                          *
-                         * @type {PointLightData}
+                         * @type {number[]}
                          */
-                        const light_data = scratch_light_nodes[i];
+                        const light_index = scratch_light_nodes[i];
 
                         // construct lookup table
-                        light_lookup_texture_data[lookup_address_offset] = light_data.visible_index * 2;
+                        light_lookup_texture_data[lookup_address_offset] = light_index * 2;
 
                         lookup_address_offset++;
                     }
@@ -724,6 +744,7 @@ export class LightManager {
         const y_plane_count = tr_y + 1;
         const z_plane_count = tr_z + 1;
 
+        // TODO compute slices to minimize world-space volume difference between clusters
         const z_slice_stride = x_plane_count * y_plane_count;
 
         const points_data = this.__cluster_frustum_points;
@@ -774,16 +795,20 @@ export class LightManager {
 
     /**
      * Build light tile texture
-     * @param {Camera} camera
+     * @param {Camera|THREE.PerspectiveCamera} camera
      */
     buildTiles(camera) {
         camera.updateProjectionMatrix();
+        camera.updateMatrix();
         camera.updateMatrixWorld(true);
 
         //update world inverse matrix
         camera.matrixWorldInverse.copy(camera.matrixWorld);
         camera.matrixWorldInverse.invert();
 
+        // this.__projection_matrix.set(camera.matrixWorldInverse.elements);
+        mat4.multiply(this.__projection_matrix, camera.projectionMatrix.elements, camera.matrixWorldInverse.elements);
+
         // console.time('__build_view_frustum');
         this.__build_view_frustum(camera);
         // console.timeEnd('__build_view_frustum');
@@ -828,12 +853,18 @@ export class LightManager {
         this.__cluster_texture_needs_rebuild = true;
         this.__update_cluster_texture();
 
+        const cluster_planes_size = ((x + 1) + (y + 1) + (z + 1)) * 4;
+        const cluster_frustum_points_size = (x + 1) * (y + 1) * (z + 1) * 3;
+
+        const buffer = new ArrayBuffer((cluster_planes_size + cluster_frustum_points_size) * 4);
+
         this.__cluster_planes = new Float32Array(
-            ((x + 1) + (y + 1) + (z + 1)) * 4
+            buffer, 0,
+            cluster_planes_size
         );
-
         this.__cluster_frustum_points = new Float32Array(
-            (x + 1) * (y + 1) * (z + 1) * 3
+            buffer, cluster_planes_size * 4,
+            cluster_frustum_points_size
         );
     }
 

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

@@ -1,6 +1,7 @@
 import Vector3 from "../../../../core/geom/Vector3.js";
 import { Color } from "../../../../core/color/Color.js";
 import Vector1 from "../../../../core/geom/Vector1.js";
+import { mortonEncode_magicbits } from "../../../../core/geom/3d/morton/mortonEncode_magicbits.js";
 
 export class PointLight {
     constructor() {
@@ -21,6 +22,14 @@ export class PointLight {
         this.intensity = new Vector1(1);
     }
 
+    /**
+     *
+     * @returns {number}
+     */
+    computeMortonCode() {
+        return mortonEncode_magicbits(this.position.x, this.position.y, this.position.z);
+    }
+
     /**
      *
      * @param {AABB3} result

package/engine/graphics/render/forward_plus/PointLightData.js

@@ -14,7 +14,7 @@ export class PointLightData {
         this.bvh_leaf_visible = new LeafNode(this, 0, 0, 0, 0, 0, 0);
 
         /**
-         *
+         * @deprecated
          * @type {number}
          */
         this.visible_index = 0;

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

@@ -2,6 +2,7 @@ import Vector3 from "../../../../core/geom/Vector3.js";
 import Vector1 from "../../../../core/geom/Vector1.js";
 import { Color } from "../../../../core/color/Color.js";
 import { computeConeBoundingBox } from "../../../../core/geom/3d/cone/computeConeBoundingBox.js";
+import { mortonEncode_magicbits } from "../../../../core/geom/3d/morton/mortonEncode_magicbits.js";
 
 export class SpotLight {
     constructor() {
@@ -48,6 +49,14 @@ export class SpotLight {
         this.penumbra = new Vector1(0.4);
     }
 
+    /**
+     *
+     * @returns {number}
+     */
+    computeMortonCode() {
+        return mortonEncode_magicbits(this.position.x, this.position.y, this.position.z);
+    }
+
     /**
      *
      * @param {AABB3} result

package/engine/graphics/render/forward_plus/cluster/compute_light_data_hash_0.js

@@ -1,6 +1,6 @@
 /**
  * Hash function using prime shift
- * @param {PointLightData[]} nodes
+ * @param {number[]} nodes
  * @param {number} count
  */
 export function compute_light_data_hash_0(nodes, count) {
@@ -10,7 +10,7 @@ export function compute_light_data_hash_0(nodes, count) {
     for (let i = 0; i < count; i++) {
         const datum = nodes[i];
 
-        hash = (hash * 31 + datum.visible_index);
+        hash = hash * 31 + datum;
     }
 
     return hash & 0x7fffffff;

package/engine/graphics/render/forward_plus/computeFrustumCorners.js

@@ -1,15 +1,5 @@
-import Vector3 from "../../../../core/geom/Vector3.js";
 import { plane_three_computeConvex3PlaneIntersection } from "../../../../core/geom/3d/plane/plane_computeConvex3PlaneIntersection.js";
 
-const v_000 = new Vector3();
-const v_001 = new Vector3();
-const v_010 = new Vector3();
-const v_011 = new Vector3();
-const v_100 = new Vector3();
-const v_101 = new Vector3();
-const v_110 = new Vector3();
-const v_111 = new Vector3();
-
 /**
  *
  * @param {Float32Array|number[]} result
@@ -18,68 +8,60 @@ const v_111 = new Vector3();
 export function computeFrustumCorners(result, planes) {
 
     const plane_x0 = planes[0];
-    const plane_x1 = planes[1];
-
     const plane_y0 = planes[2];
-    const plane_y1 = planes[3];
-
     const plane_z0 = planes[4];
-    const plane_z1 = planes[5];
 
-    plane_three_computeConvex3PlaneIntersection(v_000,
+    plane_three_computeConvex3PlaneIntersection(result, 0,
         plane_x0,
         plane_y0,
         plane_z0
     );
 
-    plane_three_computeConvex3PlaneIntersection(v_001,
+    const plane_z1 = planes[5];
+
+    plane_three_computeConvex3PlaneIntersection(result, 3,
         plane_x0,
         plane_y0,
         plane_z1
     );
 
-    plane_three_computeConvex3PlaneIntersection(v_010,
+    const plane_y1 = planes[3];
+
+    plane_three_computeConvex3PlaneIntersection(result, 6,
         plane_x0,
         plane_y1,
         plane_z0
     );
 
-    plane_three_computeConvex3PlaneIntersection(v_011,
+    plane_three_computeConvex3PlaneIntersection(result, 9,
         plane_x0,
         plane_y1,
         plane_z1
     );
 
-    plane_three_computeConvex3PlaneIntersection(v_100,
+    const plane_x1 = planes[1];
+
+    plane_three_computeConvex3PlaneIntersection(result, 12,
         plane_x1,
         plane_y0,
         plane_z0
     );
 
-    plane_three_computeConvex3PlaneIntersection(v_101,
+    plane_three_computeConvex3PlaneIntersection(result, 15,
         plane_x1,
         plane_y0,
         plane_z1
     );
 
-    plane_three_computeConvex3PlaneIntersection(v_110,
+    plane_three_computeConvex3PlaneIntersection(result, 18,
         plane_x1,
         plane_y1,
         plane_z0
     );
 
-    plane_three_computeConvex3PlaneIntersection(v_111,
+    plane_three_computeConvex3PlaneIntersection(result, 21,
         plane_x1,
         plane_y1,
         plane_z1
     );
-
-    v_000.writeToArray(result, 0);
-    v_001.writeToArray(result, 3);
-    v_010.writeToArray(result, 6);
-    v_011.writeToArray(result, 9);
-    v_100.writeToArray(result, 12);
-    v_101.writeToArray(result, 15);
-    v_110.writeToArray(result, 18);
-    v_111.writeToArray(result, 21);
 }

package/engine/graphics/render/forward_plus/materials/FP_INJECTION_POINT_ACCUMULATION.js

@@ -0,0 +1 @@
+export const FP_INJECTION_POINT_ACCUMULATION = '//@injection_point FORWARD_PLUS:accumulation';

package/engine/graphics/render/forward_plus/materials/FP_SHADER_CHUNK_ACCUMULATION.js

@@ -0,0 +1,32 @@
+export const FP_SHADER_CHUNK_ACCUMULATION = `
+        ivec3 v3_cluster_resolution = textureSize(fp_t_light_tiles, 0);
+        ivec3 v3_cluster_position = ivec3(  clip_v.x * float(v3_cluster_resolution.x), clip_v.y*float(v3_cluster_resolution.y),  (clip_v.z)*float(v3_cluster_resolution.z) );
+   
+        uvec3 cluster_metadata = texelFetch(fp_t_light_tiles, v3_cluster_position , 0).rgb;
+        
+        // read light data
+        for(uint i=0u; i < cluster_metadata.y; i++){
+            uint lookup_index = cluster_metadata.x + i;
+
+            uint light_address = texelFetch(fp_t_light_lookup, address_to_data_texture_coordinates(lookup_index), 0 ).r;
+
+            vec4 light_data_0 = texelFetch(fp_t_light_data, address_to_data_texture_coordinates(light_address), 0);
+            vec4 light_data_1 = texelFetch(fp_t_light_data, address_to_data_texture_coordinates(light_address+1u), 0);
+
+            vec3 light_position = light_data_0.xyz;
+            float light_radius = light_data_0.w;
+
+            vec3 light_color = light_data_1.xyz;
+            float light_intensity = light_data_1.w;
+
+            PointLight pointlight;
+
+            pointlight.position = light_position;
+            pointlight.distance = light_radius;
+            pointlight.color = light_color*light_intensity;
+            pointlight.decay = 1.0;
+
+            fp_getPointDirectLightIrradiance( pointlight, directLight, vViewPosition );
+            RE_Direct( directLight, geometry, material, reflectedLight );
+        }
+       `;