rayzee 5.4.0 → 5.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rayzee",
-  "version": "5.4.0",
+  "version": "5.4.1",
   "type": "module",
   "description": "Real-time WebGPU path tracing engine built on Three.js",
   "main": "dist/rayzee.umd.js",

package/src/PathTracerApp.js

@@ -639,8 +639,7 @@ export class PathTracerApp extends EventDispatcher {
 
 		if ( ! this._sdf.uploadToPathTracer( this.stages.pathTracer, this.lightManager, this.meshScene, environmentTexture ) ) return false;
 
-		// Build per-mesh visibility buffer (must happen before setupMaterial so the
-		// shader graph captures the storage node during compilation)
+		// Patch per-mesh visibility into the TLAS leaves we just uploaded
 		this.stages.pathTracer._meshRefs = this.stages.pathTracer._collectMeshRefs( this.meshScene );
 		this.stages.pathTracer.setMeshVisibilityData( this.stages.pathTracer._meshRefs );
 

package/src/Processor/AssetLoader.js

@@ -472,20 +472,28 @@ export class AssetLoader extends EventDispatcher {
 			const loader = await this.createGLTFLoader();
 			loader.manager = manager;
 
-			return await new Promise( ( resolve, reject ) => {
+			try {
 
-				loader.parse( gltfContent, '',
-					gltf => {
+				return await new Promise( ( resolve, reject ) => {
 
-						if ( this.targetModel ) disposeObjectFromMemory( this.targetModel );
-						this.targetModel = gltf.scene;
-						this.onModelLoad( this.targetModel ).then( () => resolve( gltf ) );
+					loader.parse( gltfContent, '',
+						gltf => {
 
-					},
-					error => reject( error )
-				);
+							if ( this.targetModel ) disposeObjectFromMemory( this.targetModel );
+							this.targetModel = gltf.scene;
+							this.onModelLoad( this.targetModel ).then( () => resolve( gltf ) );
 
-			} );
+						},
+						error => reject( error )
+					);
+
+				} );
+
+			} finally {
+
+				this._disposeGLTFLoader( loader );
+
+			}
 
 		} else {
 
@@ -697,11 +705,10 @@ export class AssetLoader extends EventDispatcher {
 
 	}
 
-	// Model loading methods
+	// Returns a fresh loader each call — DRACOLoader/KTX2Loader hold persistent
+	// worker pools. Callers must invoke _disposeGLTFLoader() to terminate them.
 	async createGLTFLoader() {
 
-		if ( this.loaderCache.gltf ) return this.loaderCache.gltf;
-
 		const dracoLoader = new DRACOLoader();
 		dracoLoader.setDecoderConfig( { type: 'js' } );
 		dracoLoader.setDecoderPath( 'https://www.gstatic.com/draco/v1/decoders/' );
@@ -726,18 +733,23 @@ export class AssetLoader extends EventDispatcher {
 
 		}
 
-		this.loaderCache.ktx2 = ktx2Loader;
-
 		const loader = new GLTFLoader();
 		loader.setDRACOLoader( dracoLoader );
 		loader.setKTX2Loader( ktx2Loader );
 		loader.setMeshoptDecoder( MeshoptDecoder );
 
-		this.loaderCache.gltf = loader;
 		return loader;
 
 	}
 
+	_disposeGLTFLoader( loader ) {
+
+		if ( ! loader ) return;
+		loader.dracoLoader?.dispose();
+		loader.ktx2Loader?.dispose();
+
+	}
+
 	async loadExampleModels( index, modelFiles ) {
 
 		if ( ! modelFiles || ! modelFiles[ index ] ) {
@@ -753,9 +765,10 @@ export class AssetLoader extends EventDispatcher {
 
 	async loadModel( modelUrl ) {
 
+		const loader = await this.createGLTFLoader();
+
 		try {
 
-			const loader = await this.createGLTFLoader();
 			updateLoading( { status: "Loading Model...", progress: 2 } );
 			const data = await loader.loadAsync( modelUrl );
 			updateLoading( { status: "Processing Data...", progress: 10 } );
@@ -774,15 +787,20 @@ export class AssetLoader extends EventDispatcher {
 			this.dispatchEvent( { type: 'error', message: error.message, filename: modelUrl } );
 			throw error;
 
+		} finally {
+
+			this._disposeGLTFLoader( loader );
+
 		}
 
 	}
 
 	async loadGLBFromArrayBuffer( arrayBuffer, filename = 'model.glb' ) {
 
+		const loader = await this.createGLTFLoader();
+
 		try {
 
-			const loader = await this.createGLTFLoader();
 			updateLoading( { isLoading: true, status: "Processing GLB Data...", progress: 5 } );
 			await new Promise( r => setTimeout( r, 0 ) );
 
@@ -804,6 +822,10 @@ export class AssetLoader extends EventDispatcher {
 			this.dispatchEvent( { type: 'error', message: error.message, filename } );
 			throw error;
 
+		} finally {
+
+			this._disposeGLTFLoader( loader );
+
 		}
 
 	}

package/src/Processor/EquirectHDRInfo.js

@@ -220,53 +220,62 @@ export class EquirectHDRInfo {
 
 		const { floatData, width, height } = extractFloatData( hdr );
 
-		// Reuse worker across calls; create on first use
-		if ( ! this._worker ) {
+		// Fresh worker per call — terminated in finally to avoid ~30 MB residency.
+		try {
 
-			try {
+			this._worker = new Worker( CDF_WORKER_URL, { type: 'module' } );
 
-				this._worker = new Worker( CDF_WORKER_URL, { type: 'module' } );
+		} catch ( e ) {
 
-			} catch ( e ) {
+			if ( e.name !== 'SecurityError' ) throw e;
+			this._worker = await fetchAsWorker( CDF_WORKER_URL );
 
-				if ( e.name !== 'SecurityError' ) throw e;
-				this._worker = await fetchAsWorker( CDF_WORKER_URL );
+		}
 
-			}
+		try {
 
-		}
+			const result = await new Promise( ( resolve, reject ) => {
 
-		const result = await new Promise( ( resolve, reject ) => {
+				this._worker.onmessage = ( e ) => {
 
-			this._worker.onmessage = ( e ) => {
+					if ( e.data.error ) {
 
-				if ( e.data.error ) {
+						reject( new Error( e.data.error ) );
 
-					reject( new Error( e.data.error ) );
+					} else {
 
-				} else {
+						resolve( e.data );
 
-					resolve( e.data );
+					}
 
-				}
+				};
 
-			};
+				this._worker.onerror = reject;
 
-			this._worker.onerror = reject;
+				// Transfer floatData to worker (zero-copy)
+				this._worker.postMessage(
+					{ floatData, width, height },
+					[ floatData.buffer ]
+				);
 
-			// Transfer floatData to worker (zero-copy)
-			this._worker.postMessage(
-				{ floatData, width, height },
-				[ floatData.buffer ]
-			);
+			} );
 
-		} );
+			this.marginalData = result.marginalData;
+			this.conditionalData = result.conditionalData;
+			this.totalSum = result.totalSum;
+			this.width = result.width;
+			this.height = result.height;
 
-		this.marginalData = result.marginalData;
-		this.conditionalData = result.conditionalData;
-		this.totalSum = result.totalSum;
-		this.width = result.width;
-		this.height = result.height;
+		} finally {
+
+			if ( this._worker ) {
+
+				this._worker.terminate();
+				this._worker = null;
+
+			}
+
+		}
 
 	}
 

package/src/Processor/InstanceTable.js

@@ -57,10 +57,26 @@ export class InstanceTable {
 			worldAABB: null, // Computed from triangle data
 			originalToBvhMap,
 			bvhData,
+			visible: true, // Per-mesh visibility (baked into TLAS leaf slot [2])
+			tlasLeafIndex: - 1, // Set by TLASBuilder.flatten() — enables in-place visibility patching
 		};
 
 	}
 
+	/**
+	 * Set per-mesh visibility flag. Does NOT update the GPU buffer —
+	 * caller must patch combinedBvhData[tlasLeafIndex*16 + 2] and mark bvh attr dirty.
+	 *
+	 * @param {number} meshIndex
+	 * @param {boolean} visible
+	 */
+	setVisibility( meshIndex, visible ) {
+
+		const entry = this.entries[ meshIndex ];
+		if ( entry ) entry.visible = visible;
+
+	}
+
 	/**
 	 * Compute world-space AABBs for all entries from their BLAS root node data.
 	 * O(1) per mesh for inner roots; falls back to triangle scan for leaf roots (rare).

package/src/Processor/SceneProcessor.js

@@ -476,48 +476,36 @@ export class SceneProcessor {
 
 			const validEntries = this.instanceTable.entries.filter( e => e !== null );
 
-			if ( validEntries.length === 1 ) {
-
-				// Single mesh — use BLAS directly as flat BVH (no TLAS wrapper).
-				// Avoids per-ray TLAS overhead and the extra branch in traversal.
-				const entry = validEntries[ 0 ];
-				this.bvhData = entry.bvhData;
-				this.instanceTable.assignOffsets( 0 ); // BLAS at offset 0
-				this._buildGlobalOriginalToBvhMap();
-				entry.originalToBvhMap = null;
-				entry.bvhData = null;
-
-			} else {
-
-				// Multi-mesh — build TLAS over mesh AABBs
-				this.instanceTable.computeAABBs( this.triangleData );
-				const { root: tlasRoot, nodeCount: tlasNodeCount } = this.tlasBuilder.build( validEntries );
+			// Always build a TLAS — even for a single mesh — so the BLAS-pointer leaf
+			// carries packed per-mesh visibility in its slot [2]. The 1-node TLAS
+			// overhead (one extra leaf fetch per ray) is negligible and eliminates
+			// a dedicated visibility storage buffer binding.
+			this.instanceTable.computeAABBs( this.triangleData );
+			const { root: tlasRoot, nodeCount: tlasNodeCount } = this.tlasBuilder.build( validEntries );
 
-				this.instanceTable.assignOffsets( tlasNodeCount );
-				const totalNodes = this.instanceTable.totalNodeCount;
+			this.instanceTable.assignOffsets( tlasNodeCount );
+			const totalNodes = this.instanceTable.totalNodeCount;
 
-				const tlasData = this.tlasBuilder.flatten( tlasRoot, validEntries );
+			const tlasData = this.tlasBuilder.flatten( tlasRoot, validEntries );
 
-				// Assemble combined buffer: [TLAS][BLAS_0][BLAS_1]...[BLAS_M]
-				this.bvhData = new Float32Array( totalNodes * 16 );
-				this.bvhData.set( tlasData );
+			// Assemble combined buffer: [TLAS][BLAS_0][BLAS_1]...[BLAS_M]
+			this.bvhData = new Float32Array( totalNodes * 16 );
+			this.bvhData.set( tlasData );
 
-				for ( const entry of validEntries ) {
+			for ( const entry of validEntries ) {
 
-					const destOffset = entry.blasOffset * 16;
-					this.bvhData.set( entry.bvhData, destOffset );
-					this._offsetBLASInPlace( destOffset, entry.bvhData.length / 16, entry.blasOffset, entry.triOffset );
+				const destOffset = entry.blasOffset * 16;
+				this.bvhData.set( entry.bvhData, destOffset );
+				this._offsetBLASInPlace( destOffset, entry.bvhData.length / 16, entry.blasOffset, entry.triOffset );
 
-				}
-
-				this._buildGlobalOriginalToBvhMap();
+			}
 
-				for ( const entry of validEntries ) {
+			this._buildGlobalOriginalToBvhMap();
 
-					entry.originalToBvhMap = null;
-					entry.bvhData = null;
+			for ( const entry of validEntries ) {
 
-				}
+				entry.originalToBvhMap = null;
+				entry.bvhData = null;
 
 			}
 
@@ -1384,6 +1372,7 @@ export class SceneProcessor {
 		}
 
 		pathTracer.setBVHData( this.bvhData );
+		pathTracer.setInstanceTable( this.instanceTable );
 
 		if ( this.materialData ) {
 

package/src/Processor/ShaderBuilder.js

@@ -16,7 +16,6 @@ import { Fn, texture, vec2, float, int, uniform, If,
 import { TextureNode } from 'three/webgpu';
 import { LinearFilter, DataArrayTexture } from 'three';
 import { pathTracerMain } from '../TSL/PathTracer.js';
-import { setMeshVisibilityBuffer } from '../TSL/BVHTraversal.js';
 import { setShadowAlbedoMaps, setAlphaShadowsUniform } from '../TSL/LightsDirect.js';
 import { BuildTimer } from './BuildTimer.js';
 
@@ -234,11 +233,9 @@ export class ShaderBuilder {
 		const triStorage = stage.triangleStorageNode;
 		const bvhStorage = stage.bvhStorageNode;
 		const matStorage = stage.materialData.materialStorageNode;
-		const emissiveTriStorage = stage.emissiveTriangleStorageNode;
-		const lightBVHStorage = stage.lightBVHStorageNode;
-
-		// Set per-mesh visibility buffer (module-level in BVHTraversal.js, read during graph construction)
-		setMeshVisibilityBuffer( stage.meshVisibilityStorageNode );
+		// Packed light buffer — [lightBVH | emissive triangles]. One node fed to both
+		// TSL params; emissive reads offset by stage.emissiveVec4Offset.
+		const lightBufferStorage = stage.lightStorageNode;
 
 		// Set alpha-shadow uniform (module-level in LightsDirect.js, read at runtime)
 		setAlphaShadowsUniform( stage.uniforms.get( 'enableAlphaShadows' ) );
@@ -249,9 +246,9 @@ export class ShaderBuilder {
 		const adaptiveSamplingTex = new TextureNode();
 		this.adaptiveSamplingTexNode = adaptiveSamplingTex;
 
-		// Environment importance sampling CDF (storage buffers)
-		const marginalCDFStorage = stage.environment.envMarginalStorageNode;
-		const conditionalCDFStorage = stage.environment.envConditionalStorageNode;
+		// Environment importance sampling CDF — packed storage buffer
+		// Layout: [marginal (envResolution.y floats) | conditional (envResolution.x * envResolution.y floats)]
+		const envCDFStorage = stage.environment.envCDFStorageNode;
 
 		// Previous-frame texture nodes — initialized from readTarget textures
 		const readTextures = storageTextures.getReadTextures();
@@ -285,8 +282,8 @@ export class ShaderBuilder {
 		setShadowAlbedoMaps( albedoMapsTex );
 
 		const result = {
-			triStorage, bvhStorage, matStorage, emissiveTriStorage, lightBVHStorage,
-			envTex, adaptiveSamplingTex, marginalCDFStorage, conditionalCDFStorage,
+			triStorage, bvhStorage, matStorage, lightBufferStorage,
+			envTex, adaptiveSamplingTex, envCDFStorage,
 			albedoMapsTex, normalMapsTex, bumpMapsTex,
 			metalnessMapsTex, roughnessMapsTex, emissiveMapsTex, displacementMapsTex,
 		};
@@ -304,8 +301,8 @@ export class ShaderBuilder {
 		writeColorTex, writeNDTex, writeAlbedoTex ) {
 
 		const {
-			triStorage, bvhStorage, matStorage, emissiveTriStorage, lightBVHStorage,
-			envTex, adaptiveSamplingTex, marginalCDFStorage, conditionalCDFStorage,
+			triStorage, bvhStorage, matStorage, lightBufferStorage,
+			envTex, adaptiveSamplingTex, envCDFStorage,
 			albedoMapsTex, normalMapsTex, bumpMapsTex,
 			metalnessMapsTex, roughnessMapsTex, emissiveMapsTex, displacementMapsTex,
 		} = textureNodes;
@@ -366,8 +363,7 @@ export class ShaderBuilder {
 					envTexture: envTex,
 					environmentIntensity: stage.environmentIntensity,
 					envMatrix: stage.environmentMatrix,
-					envMarginalWeights: marginalCDFStorage,
-					envConditionalWeights: conditionalCDFStorage,
+					envCDFBuffer: envCDFStorage,
 					envTotalSum: stage.envTotalSum,
 					envResolution: stage.envResolution,
 					enableEnvironmentLight: stage.enableEnvironment,
@@ -381,11 +377,12 @@ export class ShaderBuilder {
 					globalIlluminationIntensity: stage.globalIlluminationIntensity,
 					totalTriangleCount: stage.totalTriangleCount,
 					enableEmissiveTriangleSampling: stage.enableEmissiveTriangleSampling,
-					emissiveTriangleBuffer: emissiveTriStorage,
+					emissiveTriangleBuffer: lightBufferStorage,
 					emissiveTriangleCount: stage.emissiveTriangleCount,
 					emissiveTotalPower: stage.emissiveTotalPower,
 					emissiveBoost: stage.emissiveBoost,
-					lightBVHBuffer: lightBVHStorage,
+					emissiveVec4Offset: stage.emissiveVec4Offset,
+					lightBVHBuffer: lightBufferStorage,
 					lightBVHNodeCount: stage.lightBVHNodeCount,
 					debugVisScale: stage.debugVisScale,
 					enableAccumulation: stage.enableAccumulation,

package/src/Processor/TLASBuilder.js

@@ -199,10 +199,13 @@ export class TLASBuilder {
 	/**
 	 * Flatten TLAS tree into Float32Array.
 	 * Inner nodes: same format as BVH.
-	 * Leaf nodes: [blasRootNodeIndex, 0, 0, -2] (BLAS-pointer marker).
+	 * Leaf nodes: [blasRootNodeIndex, meshIndex, visibility, -2] (BLAS-pointer marker).
+	 *
+	 * Side effect: records each entry's flat leaf index on `entry.tlasLeafIndex` so that
+	 * visibility can later be patched in place (combinedBvhData[tlasLeafIndex*16 + 2]).
 	 *
 	 * @param {TLASNode} root
-	 * @param {Array<{blasOffset: number}>} entries - Instance table entries with assigned blasOffsets
+	 * @param {Array<{blasOffset: number, visible: boolean, tlasLeafIndex: number}>} entries
 	 * @returns {Float32Array}
 	 */
 	flatten( root, entries ) {
@@ -268,10 +271,12 @@ export class TLASBuilder {
 				// Leaf node — BLAS pointer
 				const entry = entries[ n.entryIndex ];
 				data[ o ] = entry.blasOffset; // Absolute node index of BLAS root in combined buffer
-				data[ o + 1 ] = n.entryIndex; // meshIndex for per-mesh visibility check
-				// data[o+2] = 0
+				data[ o + 1 ] = n.entryIndex; // meshIndex (kept for debug/ID — traversal uses slot [2])
+				data[ o + 2 ] = entry.visible === false ? 0.0 : 1.0; // Per-mesh visibility (packed — frees a binding)
 				data[ o + 3 ] = BVH_LEAF_MARKERS.BLAS_POINTER_LEAF; // -2 marker
 
+				entry.tlasLeafIndex = i;
+
 			}
 
 		}

package/src/Stages/PathTracer.js

@@ -180,17 +180,20 @@ export class PathTracer extends RenderStage {
 		// Blue noise
 		this.blueNoiseTexture = null;
 
-		// Emissive triangles (storage buffer) — initialized with dummy data so TSL compilation never sees null
-		this.emissiveTriangleStorageAttr = new StorageInstancedBufferAttribute( new Float32Array( 4 ), 4 );
-		this.emissiveTriangleStorageNode = storage( this.emissiveTriangleStorageAttr, 'vec4', 1 ).toReadOnly();
+		// Packed light buffer — [lightBVH nodes (4 vec4s each) | emissive triangles (2 vec4s each)]
+		// emissiveVec4Offset uniform tracks the vec4-count offset where emissive data starts.
+		// Initialized with dummy data so TSL compilation never sees null.
+		this.lightStorageAttr = new StorageInstancedBufferAttribute( new Float32Array( 16 ), 4 );
+		this.lightStorageNode = storage( this.lightStorageAttr, 'vec4', 1 ).toReadOnly();
 
-		// Light BVH storage buffer — initialized with dummy data
-		this.lightBVHStorageAttr = new StorageInstancedBufferAttribute( new Float32Array( 16 ), 4 );
-		this.lightBVHStorageNode = storage( this.lightBVHStorageAttr, 'vec4', 1 ).toReadOnly();
+		// Cached CPU-side data — rebuilt into the packed buffer whenever either source changes.
+		this._lbvhDataCache = null;
+		this._emissiveDataCache = null;
 
-		// Per-mesh visibility (storage buffer for TLAS BLAS-pointer skip)
-		this.meshVisibilityStorageAttr = new StorageInstancedBufferAttribute( new Float32Array( [ 1, 0, 0, 0 ] ), 4 );
-		this.meshVisibilityStorageNode = storage( this.meshVisibilityStorageAttr, 'vec4', 1 ).toReadOnly();
+		// Per-mesh visibility is packed into the TLAS BLAS-pointer leaf's slot [2]
+		// (see TLASBuilder.flatten + BVHTraversal.js). The InstanceTable holds the
+		// tlasLeafIndex for each mesh so we can patch visibility in place.
+		this._instanceTable = null;
 
 		// Adaptive sampling
 		this.adaptiveSamplingTexture = null;
@@ -454,6 +457,7 @@ export class PathTracer extends RenderStage {
 		// Set data references
 		this.setTriangleData( this.sdfs.triangleData, this.sdfs.triangleCount );
 		this.setBVHData( this.sdfs.bvhData );
+		this.setInstanceTable( this.sdfs.instanceTable );
 		this.materialData.setMaterialData( this.sdfs.materialData );
 
 		// Update triangle count
@@ -768,61 +772,78 @@ export class PathTracer extends RenderStage {
 	}
 
 	/**
-	 * Build per-mesh visibility storage buffer from mesh world-visibility.
-	 * Each mesh gets one float (1.0 = visible, 0.0 = hidden).
-	 * Padded to vec4 alignment for GPU storage buffer compatibility.
-	 * @param {Array} meshes - Array of Three.js mesh objects
+	 * Bind the InstanceTable used to locate each mesh's TLAS leaf for in-place
+	 * visibility patching. Called by SceneProcessor during upload.
+	 * @param {import('../Processor/InstanceTable.js').InstanceTable} instanceTable
 	 */
-	setMeshVisibilityData( meshes ) {
+	setInstanceTable( instanceTable ) {
+
+		this._instanceTable = instanceTable;
+
+	}
 
-		if ( ! meshes || meshes.length === 0 ) return;
+	/**
+	 * Initialize packed visibility for each mesh from current world-visibility.
+	 * Patches the TLAS leaf slots in the combined BVH buffer that was just uploaded.
+	 * @param {Array} meshes - Array of Three.js mesh objects, ordered by meshIndex
+	 */
+	setMeshVisibilityData( meshes ) {
 
-		const meshCount = meshes.length;
-		// One vec4 per mesh — visibility stored in .x (simple indexing on GPU)
-		const data = new Float32Array( meshCount * 4 );
+		if ( ! meshes || meshes.length === 0 || ! this._instanceTable ) return;
 
-		for ( let i = 0; i < meshCount; i ++ ) {
+		for ( let i = 0; i < meshes.length; i ++ ) {
 
-			data[ i * 4 ] = this._isWorldVisible( meshes[ i ] ) ? 1.0 : 0.0;
+			this._patchTLASLeafVisibility( i, this._isWorldVisible( meshes[ i ] ) );
 
 		}
 
-		this.meshVisibilityStorageAttr = new StorageInstancedBufferAttribute( data, 4 );
-		this.meshVisibilityStorageNode.value = this.meshVisibilityStorageAttr;
-		this.meshVisibilityStorageNode.bufferCount = meshCount;
+		if ( this.bvhStorageAttr ) this.bvhStorageAttr.needsUpdate = true;
 
 	}
 
 	/**
-	 * Update visibility for a single mesh in the GPU buffer (no rebuild).
+	 * Update visibility for a single mesh by patching its TLAS leaf slot [2].
 	 * @param {number} meshIndex
 	 * @param {boolean} visible
 	 */
 	updateMeshVisibility( meshIndex, visible ) {
 
-		if ( ! this.meshVisibilityStorageAttr ) return;
-
-		this.meshVisibilityStorageAttr.array[ meshIndex * 4 ] = visible ? 1.0 : 0.0;
-		this.meshVisibilityStorageAttr.needsUpdate = true;
+		if ( ! this._patchTLASLeafVisibility( meshIndex, visible ) ) return;
+		if ( this.bvhStorageAttr ) this.bvhStorageAttr.needsUpdate = true;
 
 	}
 
 	/**
-	 * Recompute world-visibility for all meshes and update the GPU buffer.
+	 * Recompute world-visibility for all meshes and patch TLAS leaves in place.
 	 * Call this when group visibility changes at runtime.
 	 */
 	updateAllMeshVisibility() {
 
-		if ( ! this._meshRefs || ! this.meshVisibilityStorageAttr ) return;
+		if ( ! this._meshRefs || ! this._instanceTable ) return;
 
-		const data = this.meshVisibilityStorageAttr.array;
 		for ( let i = 0; i < this._meshRefs.length; i ++ ) {
 
-			data[ i * 4 ] = this._isWorldVisible( this._meshRefs[ i ] ) ? 1.0 : 0.0;
+			this._patchTLASLeafVisibility( i, this._isWorldVisible( this._meshRefs[ i ] ) );
 
 		}
 
-		this.meshVisibilityStorageAttr.needsUpdate = true;
+		if ( this.bvhStorageAttr ) this.bvhStorageAttr.needsUpdate = true;
+
+	}
+
+	/**
+	 * Patch a single TLAS leaf's visibility flag in the combined BVH buffer.
+	 * Returns true if the patch was applied.
+	 * @private
+	 */
+	_patchTLASLeafVisibility( meshIndex, visible ) {
+
+		const entry = this._instanceTable?.entries?.[ meshIndex ];
+		if ( ! entry || entry.tlasLeafIndex < 0 || ! this.bvhStorageAttr ) return false;
+
+		entry.visible = visible;
+		this.bvhStorageAttr.array[ entry.tlasLeafIndex * 16 + 2 ] = visible ? 1.0 : 0.0;
+		return true;
 
 	}
 
@@ -1493,18 +1514,43 @@ export class PathTracer extends RenderStage {
 
 	}
 
-	setEmissiveTriangleData( emissiveData, count, totalPower = 0 ) {
+	/**
+	 * Rebuild the packed light buffer from cached lightBVH + emissive data.
+	 * Layout: [ lightBVH (LBVH_STRIDE vec4s per node) | emissive (EMISSIVE_STRIDE vec4s per entry) ].
+	 * Also updates `emissiveVec4Offset` uniform (in vec4 elements).
+	 * @private
+	 */
+	_rebuildLightBuffer() {
 
-		if ( ! emissiveData ) return;
+		const LBVH_STRIDE = 4; // vec4s per LBVH node — must match LightBVHSampling.js
+		const lbvh = this._lbvhDataCache;
+		const emis = this._emissiveDataCache;
+		const lbvhLen = lbvh ? lbvh.length : 0;
+		const emisLen = emis ? emis.length : 0;
 
-		const vec4Count = emissiveData.length / 4;
+		// Ensure at least a minimal non-empty buffer so GPU allocation remains valid.
+		const totalLen = Math.max( lbvhLen + emisLen, 4 );
+		const combined = new Float32Array( totalLen );
+		if ( lbvh ) combined.set( lbvh, 0 );
+		if ( emis ) combined.set( emis, lbvhLen );
 
-		this.emissiveTriangleStorageAttr = new StorageInstancedBufferAttribute( emissiveData, 4 );
-		this.emissiveTriangleStorageNode.value = this.emissiveTriangleStorageAttr;
-		this.emissiveTriangleStorageNode.bufferCount = vec4Count;
+		this.lightStorageAttr = new StorageInstancedBufferAttribute( combined, 4 );
+		this.lightStorageNode.value = this.lightStorageAttr;
+		this.lightStorageNode.bufferCount = combined.length / 4;
+
+		// Offset (in vec4 elements) where emissive data starts.
+		this.emissiveVec4Offset.value = ( this.lightBVHNodeCount.value || 0 ) * LBVH_STRIDE;
+
+	}
+
+	setEmissiveTriangleData( emissiveData, count, totalPower = 0 ) {
+
+		if ( ! emissiveData ) return;
 
+		this._emissiveDataCache = emissiveData;
 		this.emissiveTriangleCount.value = count;
 		this.emissiveTotalPower.value = totalPower;
+		this._rebuildLightBuffer();
 		console.log( `PathTracer: ${count} emissive triangles, totalPower=${totalPower.toFixed( 4 )} (storage buffer)` );
 
 	}
@@ -1513,11 +1559,9 @@ export class PathTracer extends RenderStage {
 
 		if ( ! nodeData ) return;
 
-		const vec4Count = nodeData.length / 4;
-		this.lightBVHStorageAttr = new StorageInstancedBufferAttribute( nodeData, 4 );
-		this.lightBVHStorageNode.value = this.lightBVHStorageAttr;
-		this.lightBVHStorageNode.bufferCount = vec4Count;
+		this._lbvhDataCache = nodeData;
 		this.lightBVHNodeCount.value = nodeCount;
+		this._rebuildLightBuffer();
 		console.log( `PathTracer: Light BVH ${nodeCount} nodes` );
 
 	}