@woosh/meep-engine 2.33.23 → 2.33.24

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/plugin/ForwardPlusRenderingPlugin.js

@@ -40,7 +40,7 @@ export class ForwardPlusRenderingPlugin extends EnginePlugin {
     async startup() {
         const lm = this.__light_manager;
 
-        lm.setTileMapResolution(24, 14, 8);
+        lm.setTileMapResolution(16, 8, 10);
 
         const graphics = this.engine.graphics;
 

package/engine/graphics/render/forward_plus/plugin/ptototypeFPPlugin.js

@@ -59,7 +59,6 @@ import { BehaviorComponent } from "../../../../intelligence/behavior/ecs/Behavio
 import { Light } from "../../../ecs/light/Light.js";
 import { LightType } from "../../../ecs/light/LightType.js";
 import { parseColor } from "../../../../../core/color/ColorUtils.js";
-import { randomFloatBetween } from "../../../../../core/math/MathUtils.js";
 import Renderable from "../../../../ecs/components/Renderable.js";
 import { makeHelperSphereGeometry } from "../../../../../editor/process/symbolic/makeHelperSphereGeometry.js";
 import GUIElement from "../../../../ecs/gui/GUIElement.js";
@@ -75,8 +74,8 @@ import { TextureAssetLoader } from "../../../../asset/loaders/texture/TextureAss
 import { GameAssetType } from "../../../../asset/GameAssetType.js";
 import { GLTFAssetLoader } from "../../../../asset/loaders/GLTFAssetLoader.js";
 import { ImageRGBADataLoader } from "../../../../asset/loaders/image/ImageRGBADataLoader.js";
-import { MicronRenderPlugin } from "../../../micron/plugin/MicronRenderPlugin.js";
 import { buildCubeURLs } from "../../../texture/cubemap/buildCubeURLs.js";
+import { randomFloatBetween } from "../../../../../core/math/random/randomFloatBetween.js";
 
 const engineHarness = new EngineHarness();
 
@@ -152,7 +151,7 @@ function makeConfig(engine) {
 
     // Plugins
     config.addPlugin(ForwardPlusRenderingPlugin);
-    config.addPlugin(MicronRenderPlugin);
+    // config.addPlugin(MicronRenderPlugin);
 
     // Knowledge
 
@@ -286,7 +285,7 @@ function setup_scene_0(engine, ecd) {
             "y": 1,
             "z": -0.3141130871587056
         },
-        "pitch": -0.47999999999999965,
+        "pitch": 0.47999999999999965,
         "yaw": 4.279999999999975,
         "roll": 0,
         "distance": 28,
@@ -586,7 +585,7 @@ function main(engine) {
         // pitch: -0.5,
         // yaw: 2.2,
         // distance: 3
-        pitch: 0.9,
+        pitch: -0.9,
         yaw: 3.1,
         distance: 20,
         enableLights: false
@@ -609,6 +608,7 @@ function main(engine) {
     lm.setTileMapResolution(24, 14, 14);
 
     console.log(lm);
+    window.lm = lm;
 
     const v = new View();
     const clusterWidget = buildLightClusterWidget(lm, engine.graphics.camera);