@woosh/meep-engine 2.33.23 → 2.33.27

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,6 +517,7 @@ 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);
@@ -567,10 +578,11 @@ export class LightManager {
 
 
                     // at this point we have a fully constructed cluster, we can query lights within the cluster
-                    const match_count = queryBVH_Frustum(
+                    const match_count = query_bvh_frustum_from_texture(
                         scratch_light_nodes,
                         0,
                         bvh,
+                        light_source_data,
                         scratch_frustum_planes,
                         scratch_corners
                     );
@@ -626,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++;
                     }
@@ -732,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;
@@ -782,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');
@@ -836,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/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 );
+        }
+       `;

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

@@ -0,0 +1,51 @@
+export const FP_SHADER_CHUNK_DECODE_PARS = `
+        // don't rely on three.js light number define to ensure that point light calculations are available
+        #if NUM_POINT_LIGHTS < 1
+            struct PointLight {
+                vec3 position;
+                vec3 color;
+                float distance;
+                float decay;
+            };
+        #endif
+        
+        // directLight is an out parameter as having it as a return value caused compiler errors on some devices
+        void fp_getPointDirectLightIrradiance( const in PointLight pointLight, out IncidentLight directLight, vec3 viewPosition ) {
+        
+            // TODO consider moving light position transformation to view-space over to CPU
+            vec3 lVector = (viewMatrix*vec4(pointLight.position,1.0)).xyz + viewPosition;
+            
+            directLight.direction = normalize( lVector );
+            
+            float lightDistance = length( lVector );
+            
+            directLight.color = pointLight.color;
+            directLight.color *= getDistanceAttenuation( lightDistance, pointLight.distance, pointLight.decay );
+            directLight.visible = ( directLight.color != vec3( 0.0 ) );
+        }
+        
+        float convert_depth_to_linear(in float d){
+            float d_n = 2.0*d - 1.0;
+        
+            float f = fp_f_camera_far;
+            float n = fp_f_camera_near;
+        
+            float fn = f*n;
+            
+            float z_diff = f - n;
+            
+            float denominator = (f + n - d_n * z_diff );
+        
+            float z_view = (2.0*fn) / denominator;
+        
+            return (z_view - n) / z_diff;
+        }
+        
+        ivec2 address_to_data_texture_coordinates(uint address){
+            // Lookup texture has 128 width
+            uint lookup_index_x = address % 128u;
+            uint lookup_index_y = address >> 7;
+            
+            return ivec2(int(lookup_index_x),int(lookup_index_y));
+        }
+    `;

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

@@ -0,0 +1,25 @@
+export const FP_SHADER_CHUNK_PREAMBLE = `precision mediump usampler3D;
+    precision mediump usampler2D;
+    
+    uniform usampler3D fp_t_light_tiles;
+    
+    uniform usampler2D fp_t_light_lookup;
+    uniform sampler2D fp_t_light_data;
+    
+    uniform vec3 fp_v3_light_cluster_resolution;
+    
+    uniform float fp_f_camera_near;
+    uniform float fp_f_camera_far;
+    
+    #define gl_FragDepthEXT gl_FragDepth
+    #define texture2D texture
+    #define textureCube texture
+    #define texture2DProj textureProj
+    #define texture2DLodEXT textureLod
+    #define texture2DProjLodEXT textureProjLod
+    #define textureCubeLodEXT textureLod
+    #define texture2DGradEXT textureGrad
+    #define texture2DProjGradEXT textureProjGrad
+    #define textureCubeGradEXT textureGrad
+    
+    uniform vec2 fp_resolution;`;

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

@@ -36,7 +36,7 @@ const f_shader = `
     
     uniform sampler2D t_heatmap_lookup;
     
-    uniform vec2 resolution;
+    uniform vec2 fp_resolution;
     
     uniform mat4 projectionMatrix;
     
@@ -79,7 +79,7 @@ const f_shader = `
     
     void main(){
     
-            vec3 clip_v = vec3(gl_FragCoord.xy / resolution, convert_depth_to_linear( gl_FragCoord.z));
+            vec3 clip_v = vec3(gl_FragCoord.xy / fp_resolution, convert_depth_to_linear( gl_FragCoord.z));
        
             ivec3 v3_cluster_resolution = textureSize(fp_t_light_tiles, 0);
             ivec3 v3_cluster_position = ivec3( ( 1.0 - clip_v.x) * float(v3_cluster_resolution.x), clip_v.y*float(v3_cluster_resolution.y), (clip_v.z)*float(v3_cluster_resolution.z) );
@@ -119,7 +119,7 @@ export class FPlusDebugMaterial extends ShaderMaterial {
                     type: 'f',
                     value: 0
                 },
-                resolution: {
+                fp_resolution: {
                     type: 'v2',
                     value: new Vector2()
                 },

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

@@ -29,7 +29,7 @@ export class ForwardPlusThreeMaterial extends ShaderMaterial {
                     type: 'f',
                     value: 0
                 },
-                resolution: {
+                fp_resolution: {
                     type: 'v2',
                     value: new Vector2()
                 }