@woosh/meep-engine 2.43.53 → 2.44.0

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

@@ -9,7 +9,7 @@ import {
     LinearMipMapLinearFilter,
     NearestFilter,
     RGBAFormat,
-    RGBIntegerFormat,
+    RGBAIntegerFormat,
     UnsignedByteType,
     UnsignedShortType
 } from "three";
@@ -31,7 +31,6 @@ 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";
@@ -44,9 +43,11 @@ import { v3_morton_encode_transformed } from "../../../../core/geom/3d/morton/v3
 import { v3_distance } from "../../../../core/geom/v3_distance.js";
 import { array_copy } from "../../../../core/collection/array/copyArray.js";
 import { arrayQuickSort } from "../../../../core/collection/array/arrayQuickSort.js";
-import { invokeObjectCompare } from "../../../../core/model/object/invokeObjectCompare.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";
 
 const LOOKUP_CACHE_SIZE = 1024; // must be power of two
 
@@ -120,6 +121,121 @@ function encode_light_descriptor(address, light) {
     return light_type | (address << 2);
 }
 
+function assign_cluster(
+    tile_texture_data_offset,
+    light_bvh,
+    lookup_address_offset,
+    light_lookup_texture_data,
+    tile_texture_data,
+    light_source_data
+) {
+
+    // at this point we have a fully constructed cluster, we can query lights within the cluster
+    const match_count = query_bvh_frustum_from_texture(
+        scratch_light_nodes,
+        0,
+        light_bvh,
+        light_source_data,
+        scratch_frustum_planes,
+        scratch_corners
+    );
+
+    // construct tile data
+
+    // write number of light entries
+    tile_texture_data[tile_texture_data_offset + 1] = match_count;
+
+    if (match_count === 0) {
+        // don't waste time on assignment, there are no lights in the cluster
+        return 0;
+    }
+
+    /*
+     We can sort lights by index to get higher cache utilization, but it turns out quite costly.
+     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];
+
+    if (existing_lookup_address !== 0xFFFFFFFF) {
+        // found a hash match, validate equality
+        const existing_lookup_entry_match = testClusterEquality(
+            scratch_light_nodes,
+            match_count,
+            light_lookup_texture_data,
+            existing_lookup_address
+        );
+
+        if (existing_lookup_entry_match) {
+            tile_texture_data[tile_texture_data_offset] = existing_lookup_address;
+
+            //hash_reuse_count++;
+
+            return 0;
+        }
+    } else {
+        // no hash entry exists, create one
+        LOOKUP_CACHE[cluster_data_hash] = lookup_address_offset;
+    }
+
+    // if we get to this point, that means no hash match was found, or equality check was failed
+
+    // write address of the lookup table
+    tile_texture_data[tile_texture_data_offset] = lookup_address_offset;
+
+    for (let i = 0; i < match_count; i++) {
+        /**
+         *
+         * @type {number}
+         */
+        const light_descriptor = scratch_light_nodes[i];
+
+        // construct lookup table
+        light_lookup_texture_data[lookup_address_offset + i] = light_descriptor;
+    }
+
+    return match_count;
+}
+
+/**
+ *
+ * @param {IncrementalDeltaSet<PointLightData>} data_set
+ * @param {BinaryUint32BVH} bvh
+ */
+function build_light_data_bvh(data_set, bvh) {
+    const elements = data_set.elements;
+    const element_count = data_set.size;
+
+    bvh.setLeafCount(element_count);
+    bvh.initialize_structure();
+
+    for (let i = 0; i < element_count; i++) {
+
+        /**
+         *
+         * @type {PointLightData}
+         */
+        const datum = elements[i];
+
+        const bb = datum.bvh_leaf_main;
+
+        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
+        );
+    }
+
+    // vbvh.sort_morton(this.__projection_matrix);
+    // vbvh.sort_bubble_sah();
+
+    bvh.build();
+}
+
 export class LightManager {
 
     constructor() {
@@ -128,14 +244,14 @@ export class LightManager {
          * @type {BinaryNode<PointLightData>}
          * @private
          */
-        this.__light_points_bvh = new BinaryNode();
+        this.__light_data_bvh = new BinaryNode();
 
         /**
          *
          * @type {Map<AbstractLight, PointLightData>}
          * @private
          */
-        this.__light_point_data = new Map();
+        this.__light_data_map = new Map();
 
         /**
          * Number of cluster slices along each dimension
@@ -146,8 +262,18 @@ export class LightManager {
 
         this.__cluster_texture_precision = 8;
         this.__cluster_texture_needs_rebuild = false;
+
+        /**
+         * Texel layout:
+         *  - R: offset into lookup texture for lights
+         *  - G: light count
+         *  - B: offset into lookup texture for decals
+         *  - A: decal count
+         * @type {DataTexture3D}
+         * @private
+         */
         this.__cluster_texture = new DataTexture3D(
-            new Uint16Array(3),
+            new Uint16Array(4),
             1,
             1,
             1,
@@ -160,8 +286,8 @@ export class LightManager {
         this.__cluster_texture.minFilter = NearestFilter;
 
         this.__cluster_texture.type = UnsignedShortType;
-        this.__cluster_texture.format = RGBIntegerFormat;
-        this.__cluster_texture.internalFormat = "RGB16UI";
+        this.__cluster_texture.format = RGBAIntegerFormat;
+        this.__cluster_texture.internalFormat = "RGBA16UI";
 
         /**
          *
@@ -232,7 +358,15 @@ export class LightManager {
          * @readonly
          * @private
          */
-        this.__visible_lights = new IncrementalDeltaSet(invokeObjectCompare);
+        this.__visible_lights = new IncrementalDeltaSet(compareObjectsByNumericId);
+        /**
+         *
+         * @type {IncrementalDeltaSet<PointLightData>}
+         * @readonly
+         * @private
+         */
+        this.__visible_decals = new IncrementalDeltaSet(compareObjectsByNumericId);
+
         /**
          *
          * @type {PointLightData[]}
@@ -245,7 +379,13 @@ export class LightManager {
          * @type {BinaryUint32BVH}
          * @private
          */
-        this.__visible_bvh = new BinaryUint32BVH();
+        this.__visible_bvh_lights = new BinaryUint32BVH();
+        /**
+         *
+         * @type {BinaryUint32BVH}
+         * @private
+         */
+        this.__visible_bvh_decals = new BinaryUint32BVH();
 
         /**
          *
@@ -285,8 +425,11 @@ export class LightManager {
 
         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);
+        this.__visible_lights.onAdded.add(this.__handle_visible_light_added, this);
+        this.__visible_lights.onRemoved.add(this.__handle_visible_light_removed, this);
+
+        this.__visible_decals.onAdded.add(this.__handle_visible_decal_added, this);
+        this.__visible_decals.onRemoved.add(this.__handle_visible_decal_removed, this);
 
         /**
          *
@@ -301,6 +444,8 @@ export class LightManager {
          * @private
          */
         this.__visible_bvh_needs_update = true;
+
+        window.light_manager = this; // DEBUG
     }
 
     /**
@@ -376,7 +521,7 @@ export class LightManager {
 
         const texture = this.__cluster_texture;
 
-        const channelCount = 3;
+        const channelCount = 4;
 
         texture.dispose();
 
@@ -464,29 +609,31 @@ export class LightManager {
      * @param {PointLightData} data
      * @private
      */
-    __handle_visible_added(data) {
+    __handle_visible_decal_added(data) {
         this.__light_data_needs_update = true;
 
+        /**
+         *
+         * @type {Decal}
+         */
         const light = data.light;
 
         light.onDimensionChanged(this.__handle_light_dimensions_change, this);
 
-        if (light instanceof Decal) {
-            const ref = this.__decal_patch_references.acquire(light.texture_diffuse);
+        const ref = this.__decal_patch_references.acquire(light.texture_diffuse);
 
-            const patch = ref.getValue();
-            const patch_uv = patch.uv;
+        const patch = ref.getValue();
+        const patch_uv = patch.uv;
 
-            patch_uv.position.onChanged.add(light.handleUvPositionChange, light);
-            patch_uv.size.onChanged.add(light.handleUvSizeChange, light);
+        patch_uv.position.onChanged.add(light.handleUvPositionChange, light);
+        patch_uv.size.onChanged.add(light.handleUvSizeChange, light);
 
-            light.uv[0] = patch_uv.position.x;
-            light.uv[1] = patch_uv.position.y;
-            light.uv[2] = patch_uv.size.x;
-            light.uv[3] = patch_uv.size.y;
+        light.uv[0] = patch_uv.position.x;
+        light.uv[1] = patch_uv.position.y;
+        light.uv[2] = patch_uv.size.x;
+        light.uv[3] = patch_uv.size.y;
 
-            this.__decal_references.set(light, ref);
-        }
+        this.__decal_references.set(light, ref);
     }
 
     /**
@@ -494,34 +641,61 @@ export class LightManager {
      * @param {PointLightData} data
      * @private
      */
-    __handle_visible_removed(data) {
+    __handle_visible_decal_removed(data) {
         this.__light_data_needs_update = true;
 
+        /**
+         *
+         * @type {Decal}
+         */
         const light = data.light;
+
         light.offDimensionChanged(this.__handle_light_dimensions_change, this);
 
-        if (light instanceof Decal) {
-            const ref = this.__decal_references.get(light);
+        const ref = this.__decal_references.get(light);
 
-            if (ref === undefined) {
-                // This can occur when decal changes while being in the visible list, messing with the IncrementalDeltaSet's compare order
-                console.warn(`Decal reference not found: ${light}, likely live decal changed`);
-                // TODO address this case properly
-                return;
-            }
+        if (ref === undefined) {
+            // This can occur when decal changes while being in the visible list, messing with the IncrementalDeltaSet's compare order
+            console.warn(`Decal reference not found: ${light}`);
+            return;
+        }
 
-            const patch = ref.getValue();
-            const patch_uv = patch.uv;
+        const patch = ref.getValue();
+        const patch_uv = patch.uv;
 
-            // unsubscribe
-            patch_uv.position.onChanged.remove(light.handleUvPositionChange, light);
-            patch_uv.size.onChanged.remove(light.handleUvSizeChange, light);
+        // unsubscribe
+        patch_uv.position.onChanged.remove(light.handleUvPositionChange, light);
+        patch_uv.size.onChanged.remove(light.handleUvSizeChange, light);
 
 
-            ref.release();
+        ref.release();
 
-            this.__decal_references.delete(light);
-        }
+        this.__decal_references.delete(light);
+    }
+
+    /**
+     *
+     * @param {PointLightData} data
+     * @private
+     */
+    __handle_visible_light_added(data) {
+        this.__light_data_needs_update = true;
+
+        const light = data.light;
+
+        light.onDimensionChanged(this.__handle_light_dimensions_change, this);
+    }
+
+    /**
+     *
+     * @param {PointLightData} data
+     * @private
+     */
+    __handle_visible_light_removed(data) {
+        this.__light_data_needs_update = true;
+
+        const light = data.light;
+        light.offDimensionChanged(this.__handle_light_dimensions_change, this);
     }
 
     /**
@@ -589,57 +763,38 @@ export class LightManager {
      */
     __sort_visible_light() {
         const sorted_lights = this.__sorted_visible_lights;
+
         const visible_light_set = this.__visible_lights;
         const visible_light_count = visible_light_set.size;
 
-        if (sorted_lights.length > visible_light_count) {
+        const visible_decal_set = this.__visible_decals;
+        const visible_decal_count = visible_decal_set.size;
+
+        const expected_sorted_size = visible_light_count + visible_decal_count;
+
+        if (expected_sorted_size > visible_light_count) {
             // crop array if it's too big
-            sorted_lights.splice(visible_light_count, sorted_lights.length - visible_light_count)
+            sorted_lights.splice(visible_light_count, expected_sorted_size - visible_light_count)
         }
 
         array_copy(visible_light_set.elements, 0, sorted_lights, 0, visible_light_count);
+        array_copy(visible_decal_set.elements, 0, sorted_lights, visible_light_count, visible_decal_count);
 
-        arrayQuickSort(sorted_lights, this.__sort_visible_light_score, this, 0, visible_light_count - 1);
+        arrayQuickSort(sorted_lights, this.__sort_visible_light_score, this, 0, expected_sorted_size - 1);
     }
 
     __update_visible_bvh() {
         this.__visible_bvh_needs_update = false;
 
-        const visibleLights = this.__visible_lights;
-
-        const lights = visibleLights.elements;
-        const light_count = visibleLights.size;
-
-
-        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];
-
-            const bb = datum.bvh_leaf_main;
-
-            const payload = encode_light_descriptor(datum.address, datum.light);
-
-            vbvh.setLeafData(
-                i, payload,
-                bb.x0, bb.y0, bb.z0,
-                bb.x1, bb.y1, bb.z1
-            );
-        }
-
-        // vbvh.sort_morton(this.__projection_matrix);
-        // vbvh.sort_bubble_sah();
-
-        vbvh.build();
+        build_light_data_bvh(
+            this.__visible_lights,
+            this.__visible_bvh_lights
+        );
 
+        build_light_data_bvh(
+            this.__visible_decals,
+            this.__visible_bvh_decals
+        );
     }
 
 
@@ -666,11 +821,15 @@ export class LightManager {
 
         visible_lights.initializeUpdate();
 
+        const visible_decals = this.__visible_decals;
+
+        visible_decals.initializeUpdate();
+
         const nodes = [];
 
         read_frustum_planes_to_array(this.__view_frustum.planes, scratch_frustum_planes)
 
-        const match_count = query_bvh_frustum_from_objects(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_data_bvh, scratch_frustum_planes, this.__view_frustum_points);
 
         for (let i = 0; i < match_count; i++) {
 
@@ -680,11 +839,18 @@ export class LightManager {
              */
             const light_data = nodes[i];
 
-            visible_lights.push(light_data);
+            if (light_data.light instanceof Decal) {
+                // decals go into a separate bucket
+                visible_decals.push(light_data);
+            } else {
+                visible_lights.push(light_data);
+            }
+
         }
 
         visible_lights.finalizeUpdate();
 
+        visible_decals.finalizeUpdate();
     }
 
     __write_light_data_texture() {
@@ -792,7 +958,8 @@ export class LightManager {
          */
         const cluster_planes = this.__cluster_planes;
 
-        const bvh = this.__visible_bvh;
+        const bvh_lights = this.__visible_bvh_lights;
+        const bvh_decals = this.__visible_bvh_decals;
 
 
         const cluster_planes_x_offset = 0;
@@ -817,12 +984,8 @@ export class LightManager {
 
         const cluster_frustum_points = this.__cluster_frustum_points;
 
-        let assignment_count = 0;
-        let hash_reuse_count = 0;
-
         let lookup_address_offset = 0;
         let i_x_0, i_y_0, i_z_0;
-        let i;
 
         // clear cache
         LOOKUP_CACHE.fill(0xFFFFFFFF);
@@ -830,7 +993,6 @@ export class LightManager {
         // 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
 
@@ -841,7 +1003,6 @@ export class LightManager {
             read_plane_pair(cluster_planes, z_plane_index_offset_0, scratch_frustum_planes, 16);
 
             for (i_y_0 = 0; i_y_0 < tr_y; i_y_0++) {
-                const i_y_1 = i_y_0 + 1;
 
                 // construct y planes
 
@@ -857,109 +1018,29 @@ export class LightManager {
 
                     read_plane_pair(cluster_planes, x_plane_index_offset_0, scratch_frustum_planes, 0);
 
-                    // construct addressed of individual corner points
-
-                    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 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_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_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_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);
-
-
-                    // at this point we have a fully constructed cluster, we can query lights within the cluster
-                    const match_count = query_bvh_frustum_from_texture(
-                        scratch_light_nodes,
-                        0,
-                        bvh,
-                        light_source_data,
-                        scratch_frustum_planes,
-                        scratch_corners
-                    );
+                    read_cluster_frustum_corners(scratch_corners, i_z_0, tr_xy_1, i_y_0, tr_x_1, i_x_0, cluster_frustum_points);
 
                     const tile_index = slice_offset + (i_y_0 * tr_x) + i_x_0;
 
-                    const tile_address = tile_index * 3;
-
-
-                    // construct tile data
-
-                    // write number of light entries
-                    tile_texture_data[tile_address + 1] = match_count;
-
-                    if (match_count === 0) {
-                        // don't waste time on assignment, there are no lights in the cluster
-                        continue;
-                    }
-
-                    /*
-                     We can sort lights by index to get higher cache utilization, but it turns out quite costly.
-                     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];
-
-                    if (existing_lookup_address !== 0xFFFFFFFF) {
-                        // found a hash match, validate equality
-                        const existing_lookup_entry_match = testClusterEquality(
-                            scratch_light_nodes,
-                            match_count,
-                            light_lookup_texture_data,
-                            existing_lookup_address
-                        );
-
-                        if (existing_lookup_entry_match) {
-                            tile_texture_data[tile_address] = existing_lookup_address;
-
-                            hash_reuse_count++;
+                    const tile_data_offset = tile_index * 4;
 
-                            continue;
-                        }
-                    } else {
-                        // no hash entry exists, create one
-                        LOOKUP_CACHE[cluster_data_hash] = lookup_address_offset;
-                    }
-
-                    // if we get to this point, that means no hash match was found, or equality check was failed
-
-                    // write address of the lookup table
-                    tile_texture_data[tile_address] = lookup_address_offset;
-
-                    for (i = 0; i < match_count; i++) {
-                        /**
-                         *
-                         * @type {number}
-                         */
-                        const light_descriptor = scratch_light_nodes[i];
-
-                        // construct lookup table
-                        light_lookup_texture_data[lookup_address_offset] = light_descriptor;
-
-                        lookup_address_offset++;
-                    }
+                    lookup_address_offset += assign_cluster(
+                        tile_data_offset,
+                        bvh_lights,
+                        lookup_address_offset,
+                        light_lookup_texture_data,
+                        tile_texture_data,
+                        light_source_data
+                    );
 
-                    assignment_count += match_count;
+                    lookup_address_offset += assign_cluster(
+                        tile_data_offset + 2,
+                        bvh_decals,
+                        lookup_address_offset,
+                        light_lookup_texture_data,
+                        tile_texture_data,
+                        light_source_data
+                    );
                 }
             }
         }
@@ -970,14 +1051,15 @@ export class LightManager {
         // Post-fact lookup texture resize, this frame will be wrong, but next one should be ok
         const current_lookup_size = this.__lookup_data.size;
 
-        const lookup_memory_resized = this.__ensure_lookup_size(assignment_count);
+        const lookup_memory_resized = this.__ensure_lookup_size(lookup_address_offset);
 
         const cluster_resized = this.__set_cluster_addressable_bit_range(Math.max(0, Math.log2(lookup_address_offset)));
 
         if (
-            (lookup_memory_resized && current_lookup_size < assignment_count)
+            (lookup_memory_resized && current_lookup_size < lookup_address_offset)
             || cluster_resized
         ) {
+            // overflow, we ended up trying to write more lights into some clusters than what they could contain
             this.__update_cluster_texture();
 
             // re-do assignment
@@ -1028,92 +1110,9 @@ export class LightManager {
         const tr_x = tiles_resolution.x;
 
         const view_frustum_points = this.__view_frustum_points;
-
-        // read out view frustum scratch_corners
-        const x_000 = view_frustum_points[0];
-        const y_000 = view_frustum_points[1];
-        const z_000 = view_frustum_points[2];
-
-        const x_001 = view_frustum_points[3];
-        const y_001 = view_frustum_points[4];
-        const z_001 = view_frustum_points[5];
-
-        const x_010 = view_frustum_points[6];
-        const y_010 = view_frustum_points[7];
-        const z_010 = view_frustum_points[8];
-
-        const x_011 = view_frustum_points[9];
-        const y_011 = view_frustum_points[10];
-        const z_011 = view_frustum_points[11];
-
-        const x_100 = view_frustum_points[12];
-        const y_100 = view_frustum_points[13];
-        const z_100 = view_frustum_points[14];
-
-        const x_101 = view_frustum_points[15];
-        const y_101 = view_frustum_points[16];
-        const z_101 = view_frustum_points[17];
-
-        const x_110 = view_frustum_points[18];
-        const y_110 = view_frustum_points[19];
-        const z_110 = view_frustum_points[20];
-
-        const x_111 = view_frustum_points[21];
-        const y_111 = view_frustum_points[22];
-        const z_111 = view_frustum_points[23];
-
-
-        const x_plane_count = tr_x + 1;
-        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;
 
-        for (let i_z = 0; i_z < z_plane_count; i_z++) {
-            const r_0 = i_z / (tr_z);
-            const r_1 = 1 - r_0;
-
-            const z_offset = i_z * z_slice_stride;
-
-            for (let i_y = 0; i_y < y_plane_count; i_y++) {
-
-                const v_0 = i_y / tr_y;
-                const v_1 = 1 - v_0;
-
-                const y_offset = z_offset + i_y * x_plane_count;
-
-                for (let i_x = 0; i_x < x_plane_count; i_x++) {
-                    const u_0 = i_x / tr_x;
-                    const u_1 = 1 - u_0;
-
-                    const m_000 = u_1 * v_1 * r_1;
-                    const m_001 = u_1 * v_1 * r_0;
-                    const m_010 = u_1 * v_0 * r_1;
-                    const m_011 = u_1 * v_0 * r_0;
-                    const m_100 = u_0 * v_1 * r_1;
-                    const m_101 = u_0 * v_1 * r_0;
-                    const m_110 = u_0 * v_0 * r_1;
-                    const m_111 = u_0 * v_0 * r_0;
-
-                    // interpolate view frustum scratch_corners
-                    const x = x_000 * m_000 + x_001 * m_001 + x_010 * m_010 + x_011 * m_011 + x_100 * m_100 + x_101 * m_101 + x_110 * m_110 + x_111 * m_111;
-                    const y = y_000 * m_000 + y_001 * m_001 + y_010 * m_010 + y_011 * m_011 + y_100 * m_100 + y_101 * m_101 + y_110 * m_110 + y_111 * m_111;
-                    const z = z_000 * m_000 + z_001 * m_001 + z_010 * m_010 + z_011 * m_011 + z_100 * m_100 + z_101 * m_101 + z_110 * m_110 + z_111 * m_111;
-
-                    // write out cluster corner position
-                    const index = y_offset + i_x
-                    const address = index * 3;
-
-                    points_data[address] = x;
-                    points_data[address + 1] = y;
-                    points_data[address + 2] = z;
-                }
-
-            }
-        }
+        slice_frustum_linear_to_points(view_frustum_points, tr_x, tr_y, tr_z, points_data);
     }
 
     /**
@@ -1175,6 +1174,7 @@ export class LightManager {
         this.__cluster_texture.dispose();
         this.__light_data.dispose();
         this.__lookup_data.dispose();
+        this.__decal_atlas_texture.dispose();
     }
 
     /**
@@ -1220,9 +1220,9 @@ export class LightManager {
 
         lightData.link();
 
-        this.__light_points_bvh.insertNode(lightData.bvh_leaf_main);
+        this.__light_data_bvh.insertNode(lightData.bvh_leaf_main);
 
-        this.__light_point_data.set(light, lightData);
+        this.__light_data_map.set(light, lightData);
     }
 
     /**
@@ -1232,7 +1232,7 @@ export class LightManager {
      */
     removeLight(light) {
 
-        const data = this.__light_point_data.get(light);
+        const data = this.__light_data_map.get(light);
 
         if (data === undefined) {
             return false;
@@ -1240,7 +1240,7 @@ export class LightManager {
 
         data.unlink();
 
-        this.__light_point_data.delete(light);
+        this.__light_data_map.delete(light);
 
         return true;
     }