@woosh/meep-engine 2.33.38 → 2.33.42

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

@@ -1,6 +1,18 @@
 import { BinaryNode } from "../../../../core/bvh2/BinaryNode.js";
 import { PointLightData } from "./PointLightData.js";
-import { DataTexture, DataTexture3D, Frustum, NearestFilter, RGBIntegerFormat, UnsignedShortType } from "three";
+import {
+    ClampToEdgeWrapping,
+    DataTexture,
+    DataTexture3D,
+    Frustum,
+    LinearFilter,
+    LinearMipMapLinearFilter,
+    NearestFilter,
+    RGBAFormat,
+    RGBIntegerFormat,
+    UnsignedByteType,
+    UnsignedShortType
+} from "three";
 import { frustumFromCamera } from "../../ecs/camera/CameraSystem.js";
 import Vector3 from "../../../../core/geom/Vector3.js";
 import { query_bvh_frustum_from_objects } from "./query/query_bvh_frustum_from_objects.js";
@@ -23,9 +35,15 @@ 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";
+import { TextureAtlas } from "../../texture/atlas/TextureAtlas.js";
+import { CachingTextureAtlas } from "../../texture/atlas/CachingTextureAtlas.js";
+import { writeSample2DDataToDataTexture } from "../../texture/sampler/writeSampler2DDataToDataTexture.js";
+import { Decal } from "./model/Decal.js";
+import { ReferencedTextureAtlas } from "../../texture/atlas/ReferencedTextureAtlas.js";
+import { v3_morton_encode_transformed } from "../../../../core/geom/3d/morton/v3_morton_encode_transformed.js";
+import { v3_distance } from "../../../../core/geom/v3_distance.js";
 
-const LOOKUP_CACHE_SIZE = 16384; // must be power of two
+const LOOKUP_CACHE_SIZE = 1024; // must be power of two
 
 /**
  * Using continuous buffer for related attributes to get better cache utilization
@@ -65,6 +83,38 @@ const LOOKUP_CACHE = new Uint32Array(_scratch_array_buffer, (24 + 24) * 4, LOOKU
  */
 const scratch_light_nodes = [];
 
+/**
+ * How many bits are used to encode light type
+ * @type {number}
+ */
+const LIGHT_ENCODING_TYPE_BIT_COUNT = 2;
+
+/**
+ *
+ * @param {AbstractLight|PointLight|Decal} light
+ * @returns {number}
+ */
+function encode_light_type(light) {
+    if (light.isPointLight === true) {
+        return 0;
+    } else if (light.isDecal === true) {
+        return 3;
+    } else {
+        throw new Error('Unsupported light type');
+    }
+}
+
+/**
+ *
+ * @param {number} index
+ * @param {AbstractLight} light
+ * @returns {number}
+ */
+function encode_light_descriptor(index, light) {
+    const light_type = encode_light_type(light);
+    return light_type | (index << 2);
+}
+
 export class LightManager {
 
     constructor() {
@@ -77,7 +127,7 @@ export class LightManager {
 
         /**
          *
-         * @type {Map<PointLight, PointLightData>}
+         * @type {Map<AbstractLight, PointLightData>}
          * @private
          */
         this.__light_point_data = new Map();
@@ -98,6 +148,7 @@ export class LightManager {
             1,
         );
 
+        this.__cluster_texture.flipY = false;
         this.__cluster_texture.generateMipmaps = false;
 
         this.__cluster_texture.magFilter = NearestFilter;
@@ -107,6 +158,12 @@ export class LightManager {
         this.__cluster_texture.format = RGBIntegerFormat;
         this.__cluster_texture.internalFormat = "RGB16UI";
 
+        /**
+         *
+         * @type {TextureBackedMemoryRegion}
+         * @readonly
+         * @private
+         */
         this.__lookup_data = new TextureBackedMemoryRegion();
         this.__lookup_data.type = NumericType.Uint;
         this.__lookup_data.channel_count = 1;
@@ -116,6 +173,7 @@ export class LightManager {
         /**
          *
          * @type {TextureBackedMemoryRegion}
+         * @readonly
          * @private
          */
         this.__light_data = new TextureBackedMemoryRegion();
@@ -124,9 +182,49 @@ export class LightManager {
         this.__light_data.channel_count = 4;
         this.__light_data.resize(8);
 
+        /**
+         * @type {DataTexture}
+         * @readonly
+         * @private
+         */
+        this.__decal_atlas_texture = new DataTexture(new Uint8Array(4), 1, 1, RGBAFormat);
+        this.__decal_atlas_texture.type = UnsignedByteType;
+        this.__decal_atlas_texture.flipY = false;
+        this.__decal_atlas_texture.wrapS = ClampToEdgeWrapping;
+        this.__decal_atlas_texture.wrapT = ClampToEdgeWrapping;
+        this.__decal_atlas_texture.minFilter = LinearMipMapLinearFilter;
+        this.__decal_atlas_texture.magFilter = LinearFilter;
+        this.__decal_atlas_texture.generateMipmaps = true;
+        this.__decal_atlas_texture.anisotropy = 4;
+
+        /**
+         *
+         * @type {CachingTextureAtlas}
+         * @readonly
+         * @private
+         */
+        this.__decal_atlas = new CachingTextureAtlas({
+            atlas: new TextureAtlas(16)
+        });
+
+        /**
+         *
+         * @type {ReferencedTextureAtlas}
+         * @private
+         */
+        this.__decal_patch_references = new ReferencedTextureAtlas(this.__decal_atlas);
+
+        /**
+         *
+         * @type {Map<Decal, Reference>}
+         * @private
+         */
+        this.__decal_references = new Map();
+
         /**
          *
          * @type {IncrementalDeltaSet<PointLightData>}
+         * @readonly
          * @private
          */
         this.__visible_lights = new IncrementalDeltaSet();
@@ -174,25 +272,43 @@ export class LightManager {
          */
         this.__cluster_frustum_points = new Float32Array(1);
 
-
         this.setTileMapResolution(32, 16, 16);
 
-
         this.__visible_lights.onAdded.add(this.__handle_visible_added, this);
         this.__visible_lights.onRemoved.add(this.__handle_visible_removed, this);
 
+        /**
+         *
+         * @type {boolean}
+         * @private
+         */
+        this.__light_data_needs_update = true;
+
+        /**
+         *
+         * @type {boolean}
+         * @private
+         */
         this.__visible_bvh_needs_update = true;
+
+        this.__decal_atlas.atlas.on.painted.add(this.__update_decal_atlas_texture, this);
+    }
+
+    __update_decal_atlas_texture() {
+        const sampler = this.__decal_atlas.atlas.sampler;
+
+        writeSample2DDataToDataTexture(sampler, this.__decal_atlas_texture);
     }
 
     /**
      * Sometimes light lookup table can get quite large, to make sure we can store these addresses in the cluster texture,
      * we may need to switch to a larger data type, such as Uint8->Uint16 or Uint16->Uint32
-     * @param {number} value How many bits should be addressable from the cluster content
+     * @param {number} bit_count How many bits should be addressable from the cluster content
      * @returns {boolean} true if texture was rebuilt (underlying type change), false otherwise
      * @private
      */
-    __set_cluster_addressable_bit_range(value) {
-        const rounded_value = Math.ceil(value);
+    __set_cluster_addressable_bit_range(bit_count) {
+        const rounded_value = Math.ceil(bit_count);
 
         this.__cluster_texture_precision = rounded_value;
         const dataType = computeDataType(NumericType.Uint, rounded_value);
@@ -272,13 +388,23 @@ export class LightManager {
     }
 
     /**
-     *
      * @returns {DataTexture3D}
      */
     getTextureClusters() {
         return this.__cluster_texture;
     }
 
+    /**
+     * @returns {DataTexture}
+     */
+    getDecalTexture() {
+        return this.__decal_atlas_texture;
+    }
+
+    /**
+     * NOTE: do not modify the value
+     * @returns {Readonly<Vector3>}
+     */
     getResolution() {
         return this.__tiles_resolution;
     }
@@ -297,9 +423,17 @@ export class LightManager {
      * @private
      */
     __handle_visible_added(data) {
-        this.__visible_bvh_needs_update = true;
+        this.__light_data_needs_update = true;
+
+        const light = data.light;
 
-        data.light.onDimensionChanged(this.__request_update_visible_bvh, this);
+        light.onDimensionChanged(this.__request_update_visible_bvh, this);
+
+        if (light instanceof Decal) {
+            const ref = this.__decal_patch_references.acquire(light.texture_diffuse);
+
+            this.__decal_references.set(light, ref);
+        }
     }
 
     /**
@@ -308,24 +442,77 @@ export class LightManager {
      * @private
      */
     __handle_visible_removed(data) {
-        this.__visible_bvh_needs_update = true;
+        this.__light_data_needs_update = true;
+
+        const light = data.light;
+        light.offDimensionChanged(this.__request_update_visible_bvh, this);
 
-        data.bvh_leaf_visible.disconnect();
+        if (light instanceof Decal) {
+            const ref = this.__decal_references.get(light);
 
-        data.light.offDimensionChanged(this.__request_update_visible_bvh, this);
+            ref.release();
+
+            this.__decal_references.delete(light);
+        }
     }
 
     /**
      *
      * @param {PointLightData} light
      * @returns {number}
-     * @private
+     * @protected
      */
     __sort_visible_light_score(light) {
-        const p = light.light.position;
+        const center = scratch_corners;
+
+        light.light.getCenter(center)
+
+        const x = center[0];
+        const y = center[1];
+        const z = center[2];
 
-        // return v3_morton_encode_transformed(p.x, p.y, p.z, this.__projection_matrix);
-        return mortonEncode_magicbits(p.x, p.y, p.z);
+        return v3_morton_encode_transformed(x, y, z, this.__projection_matrix);
+    }
+
+    /**
+     * DEBUG method
+     * @param {PointLightData} lights
+     * @param {number} count
+     * @returns {number} lower = better sorting score
+     * @private
+     */
+    __assess_sorting_score(lights, count) {
+
+        let r = 0;
+
+        const center_a = [];
+        const center_b = [];
+
+        for (let i = 0; i < count; i++) {
+            const a = lights[i];
+
+            const score_a = this.__sort_visible_light_score(a);
+            a.light.getCenter(center_a);
+
+            for (let j = i + 1; j < count; j++) {
+                const b = lights[j];
+
+                const score_b = this.__sort_visible_light_score(b);
+                b.light.getCenter(center_b);
+
+                //
+                const score_distance = Math.abs(score_a - score_b);
+                const position_distance = v3_distance(
+                    center_a[0], center_a[1], center_a[2],
+                    center_b[0], center_b[1], center_b[2],
+                );
+
+                r += score_distance / position_distance;
+            }
+        }
+
+
+        return r / (count * (count - 1) * 0.5);
     }
 
     /**
@@ -333,7 +520,10 @@ export class LightManager {
      * @private
      */
     __sort_visible_light() {
-        this.__visible_lights.sort(this.__sort_visible_light_score, this);
+        this.__visible_lights.sort(
+            this.__sort_visible_light_score,
+            this
+        );
     }
 
     __update_visible_bvh() {
@@ -342,8 +532,6 @@ export class LightManager {
         const lights = this.__visible_lights.elements;
         const light_count = lights.length;
 
-        // sort light for better search and query locality
-        this.__sort_visible_light();
 
         const vbvh = this.__visible_bvh;
 
@@ -360,8 +548,10 @@ export class LightManager {
 
             const bb = datum.bvh_leaf_main;
 
+            const payload = encode_light_descriptor(datum.address, datum.light);
+
             vbvh.setLeafData(
-                i, i,
+                i, payload,
                 bb.x0, bb.y0, bb.z0,
                 bb.x1, bb.y1, bb.z1
             );
@@ -417,9 +607,6 @@ export class LightManager {
 
         visible_lights.finalizeUpdate();
 
-        if (this.__visible_bvh_needs_update) {
-            this.__update_visible_bvh();
-        }
     }
 
     __write_light_data_texture() {
@@ -433,14 +620,33 @@ export class LightManager {
         // write light data into texture
         const visible_light_count = visible_lights.length;
 
-        this.__light_data.resize(visible_light_count * 2);
+        // compute amount of space required for the lights
+        let address = 0;
+        for (let i = 0; i < visible_light_count; i++) {
+            const datum = visible_lights[i];
+
+            /**
+             *
+             * @type {PointLight}
+             */
+            const light = datum.light;
+
+            address += light.ENCODED_SLOT_COUNT;
+        }
+
 
-        this.__light_data.update();
+        const light_data = this.__light_data;
+        light_data.resize(Math.ceil(address / 4));
+
+        light_data.update();
 
         // update required lookup precision
-        this.__lookup_data.precision = Math.max(0, Math.ceil(Math.log2(this.__light_data.size)));
+        this.__lookup_data.precision = Math.max(
+            0,
+            Math.ceil(Math.log2(light_data.size))
+        ) + LIGHT_ENCODING_TYPE_BIT_COUNT;
 
-        const tx_light = this.__light_data.getTexture();
+        const tx_light = light_data.getTexture();
 
         /**
          *
@@ -448,13 +654,12 @@ export class LightManager {
          */
         const tx_light_data = tx_light.image.data;
 
+        address = 0;
+
         for (let i = 0; i < visible_light_count; i++) {
             const datum = visible_lights[i];
 
-
-            const address = i * 8;
-
-            assert.lessThan(address, tx_light_data.length, "overflow")
+            assert.lessThan(address, tx_light_data.length, "overflow");
 
             /**
              *
@@ -462,10 +667,21 @@ export class LightManager {
              */
             const light = datum.light;
 
-            light.toArray(tx_light_data, address);
+            datum.address = address >> 2;
+
+            const written_slots = light.toArray(tx_light_data, address);
+
+            address += written_slots;
+
+            // align address to 4 slot boundary
+            if ((address & 3) !== 0) {
+                address = ((address >> 2) + 1) << 2;
+            }
         }
 
         tx_light.needsUpdate = true;
+
+        this.__visible_bvh_needs_update = true;
     }
 
     __assign_lights_to_clusters() {
@@ -522,11 +738,15 @@ export class LightManager {
         // clear cache
         LOOKUP_CACHE.fill(0xFFFFFFFF);
 
+        // console.log('Assignment Start');
+
         for (i_z_0 = 0; i_z_0 < tr_z; i_z_0++) {
             const i_z_1 = i_z_0 + 1;
 
             // construct z planes
 
+            const slice_offset = i_z_0 * tile_slice_size;
+
             const z_plane_index_offset_0 = cluster_planes_z_offset + i_z_0 * 4;
 
             read_plane_pair(cluster_planes, z_plane_index_offset_0, scratch_frustum_planes, 16);
@@ -553,25 +773,25 @@ export class LightManager {
                     const frustum_point_index_000 = i_z_0 * tr_xy_1 + i_y_0 * tr_x_1 + i_x_0;
                     read_frustum_corner(cluster_frustum_points, frustum_point_index_000, scratch_corners, 0);
 
-                    const frustum_point_index_001 = i_z_1 * tr_xy_1 + i_y_0 * tr_x_1 + i_x_0;
-                    read_frustum_corner(cluster_frustum_points, frustum_point_index_001, scratch_corners, 3);
+                    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);
 
                     const frustum_point_index_010 = i_z_0 * tr_xy_1 + i_y_1 * tr_x_1 + i_x_0;
                     read_frustum_corner(cluster_frustum_points, frustum_point_index_010, scratch_corners, 6);
 
-                    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_110 = i_z_0 * tr_xy_1 + i_y_1 * tr_x_1 + i_x_1;
+                    read_frustum_corner(cluster_frustum_points, frustum_point_index_110, scratch_corners, 18);
 
-                    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);
+                    const frustum_point_index_001 = i_z_1 * tr_xy_1 + i_y_0 * tr_x_1 + i_x_0;
+                    read_frustum_corner(cluster_frustum_points, frustum_point_index_001, scratch_corners, 3);
 
                     const frustum_point_index_101 = i_z_1 * tr_xy_1 + i_y_0 * tr_x_1 + i_x_1;
                     read_frustum_corner(cluster_frustum_points, frustum_point_index_101, scratch_corners, 15);
 
-                    const frustum_point_index_110 = i_z_0 * tr_xy_1 + i_y_1 * tr_x_1 + i_x_1;
-                    read_frustum_corner(cluster_frustum_points, frustum_point_index_110, scratch_corners, 18);
+                    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 frustum_point_index_111 = i_z_1 * tr_xy_1 + i_y_1 * tr_x_1 + i_x_1;
                     read_frustum_corner(cluster_frustum_points, frustum_point_index_111, scratch_corners, 21);
@@ -587,7 +807,7 @@ export class LightManager {
                         scratch_corners
                     );
 
-                    const tile_index = (i_z_0 * tile_slice_size) + (i_y_0 * tr_x) + (tr_x - i_x_1);
+                    const tile_index = slice_offset + (i_y_0 * tr_x) + i_x_0;
 
                     const tile_address = tile_index * 3;
 
@@ -607,7 +827,6 @@ export class LightManager {
                      Through experimentation, sorting was taking around 20% of the whole assignment time
                      while improving number of cache hits by around 40% (8000 without sorting -> 11000 with sorting)
                      */
-
                     const cluster_data_hash = compute_light_data_hash_0(scratch_light_nodes, match_count) & (LOOKUP_CACHE_SIZE - 1);
 
                     const existing_lookup_address = LOOKUP_CACHE[cluster_data_hash];
@@ -641,12 +860,12 @@ export class LightManager {
                     for (i = 0; i < match_count; i++) {
                         /**
                          *
-                         * @type {number[]}
+                         * @type {number}
                          */
-                        const light_index = scratch_light_nodes[i];
+                        const light_descriptor = scratch_light_nodes[i];
 
                         // construct lookup table
-                        light_lookup_texture_data[lookup_address_offset] = light_index * 2;
+                        light_lookup_texture_data[lookup_address_offset] = light_descriptor;
 
                         lookup_address_offset++;
                     }
@@ -818,11 +1037,22 @@ export class LightManager {
         this.__build_visible_light_list();
         // console.timeEnd('__build_visible_light_list');
 
+        // update decal atlas
+        this.__decal_atlas.atlas.update();
 
         // console.time('__write_light_data_texture');
-        this.__write_light_data_texture();
+        if (this.__light_data_needs_update) {
+            // sort light for better search and query locality
+            this.__sort_visible_light();
+
+            this.__write_light_data_texture();
+        }
         // console.timeEnd('__write_light_data_texture');
 
+        if (this.__visible_bvh_needs_update) {
+            this.__update_visible_bvh();
+        }
+
         this.__build_cluster_frustum_points();
         // console.time('__build_cluster_frustum_planes');
         this.__build_cluster_frustum_planes();
@@ -848,6 +1078,11 @@ export class LightManager {
     setTileMapResolution(x, y, z) {
         const r = this.__tiles_resolution;
 
+        if (x === r.x && y === r.y && z === r.z) {
+            // special case, no change
+            return;
+        }
+
         r.set(x, y, z);
 
         this.__cluster_texture_needs_rebuild = true;
@@ -868,6 +1103,10 @@ export class LightManager {
         );
     }
 
+    /**
+     *
+     * @param {AbstractLight} light
+     */
     addLight(light) {
         const lightData = new PointLightData(light);
 
@@ -878,6 +1117,11 @@ export class LightManager {
         this.__light_point_data.set(light, lightData);
     }
 
+    /**
+     *
+     * @param {AbstractLight} light
+     * @returns {boolean}
+     */
     removeLight(light) {
 
         const data = this.__light_point_data.get(light);

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

@@ -1,5 +1,5 @@
 import { LightManager } from "./LightManager.js";
-import { PointLight } from "./PointLight.js";
+import { PointLight } from "./model/PointLight.js";
 import { PerspectiveCamera } from "three";
 
 test('addLight does not throw', () => {

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

@@ -3,35 +3,33 @@ import { LeafNode } from "../../../../core/bvh2/LeafNode.js";
 export class PointLightData {
     /**
      *
-     * @param {PointLight|SpotLight} light
+     * @param {AbstractLight} light
      */
     constructor(light) {
+        /**
+         *
+         * @type {AbstractLight}
+         */
         this.light = light;
 
-
-        this.bvh_leaf_main = new LeafNode(this, 0, 0, 0, 0, 0, 0);
-
-        this.bvh_leaf_visible = new LeafNode(this, 0, 0, 0, 0, 0, 0);
-
         /**
-         * @deprecated
+         *
          * @type {number}
          */
-        this.visible_index = 0;
+        this.address = 0;
+
+        this.bvh_leaf_main = new LeafNode(this, 0, 0, 0, 0, 0, 0);
     }
 
     update() {
 
         const leaf = this.bvh_leaf_main;
-        const leaf_2 = this.bvh_leaf_visible;
 
         this.light.getAABB(leaf);
 
         if (leaf.parentNode !== null) {
             leaf.parentNode.bubbleRefit();
         }
-
-        leaf_2.resize(leaf.x0, leaf.y0, leaf.z0, leaf.x1, leaf.y1, leaf.z1);
     }
 
     link() {
@@ -46,7 +44,5 @@ export class PointLightData {
 
         // disconnect from bvh
         this.bvh_leaf_main.disconnect();
-
-        this.bvh_leaf_visible.disconnect();
     }
 }

package/engine/graphics/render/forward_plus/data/TextureBackedMemoryRegion.js

@@ -86,6 +86,10 @@ export class TextureBackedMemoryRegion {
         this.__data_type = DataType.Uint8;
     }
 
+    get concrete_type(){
+        return this.__data_type;
+    }
+
     /**
      *
      * @param {number} v
@@ -228,9 +232,14 @@ export class TextureBackedMemoryRegion {
      * @param {number} size
      */
     resize(size) {
+        assert.isNonNegativeInteger(size, 'size');
+
         this.size = size;
 
-        const target_height = max2(Math.ceil(size / DATA_TEXTURE_WIDTH), 1);
+        const target_height = max2(
+            Math.ceil(size / DATA_TEXTURE_WIDTH),
+            1
+        );
 
         const current_height = this.__texture.image.height;
 

package/engine/graphics/render/forward_plus/debug/LightClusterVolumeMaterial.js

@@ -41,7 +41,7 @@ const fragmentShader = /* glsl */`
 						return vec2( t0, t1 );
 					}
 					float sample1( vec3 p ) {
-						return float( texture( map, vec3( 1.0 - p.x, p.yz )).g );
+						return float( texture( map,  p ).g );
 					}
 					#define epsilon .0001
 					vec3 normal( vec3 coord ) {