rayzee 7.15.1 → 7.16.0

package/package.json

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

package/src/PathTracerApp.js

@@ -775,11 +775,7 @@ export class PathTracerApp extends EventDispatcher {
 			this.reset();
 			this.cameraManager.currentCameraIndex = 0;
 			this.dispatchEvent( eventPayload );
-			this.dispatchEvent( {
-				type: 'CamerasUpdated',
-				cameras: this.cameraManager.cameras,
-				cameraNames: this.cameraManager.getCameraNames()
-			} );
+			this._dispatchCamerasUpdated();
 
 		} finally {
 
@@ -838,6 +834,10 @@ export class PathTracerApp extends EventDispatcher {
 		this.stages.pathTracer._meshRefs = this.stages.pathTracer._collectMeshRefs( this.meshScene );
 		this.stages.pathTracer.setMeshVisibilityData( this.stages.pathTracer._meshRefs );
 
+		// Drop authored-hidden meshes' triangles from the emissive-NEE structure
+		// (runs before setupMaterial so the kernels compile against the final buffer)
+		this._refreshEmissiveForVisibility();
+
 		timer.end( 'GPU data transfer' );
 
 		// Compile shaders
@@ -882,7 +882,10 @@ export class PathTracerApp extends EventDispatcher {
 		// Runs before applyAll()/SceneRebuild so the uniform and UI both pick up the new value.
 		if ( ! this._emissiveSamplingUserSet ) {
 
-			const hasEmissive = ( this._sdf?.emissiveTriangleCount ?? 0 ) > 0;
+			// Keyed on the canonical (unfiltered) emissive set — emissiveTriangleCount
+			// reflects only the visible subset, and hidden emitters can be shown later.
+			const hasEmissive = ( this._sdf?.emissiveTriangleBuilder?.emissiveTriangles?.length
+				?? this._sdf?.emissiveTriangleCount ?? 0 ) > 0;
 			this.settings.set( 'enableEmissiveTriangleSampling', hasEmissive, { reset: false } );
 
 		}
@@ -1086,6 +1089,57 @@ export class PathTracerApp extends EventDispatcher {
 
 	}
 
+	// ═══════════════════════════════════════════════════════════════
+	// Dynamic cameras (add / remove)
+	// ═══════════════════════════════════════════════════════════════
+
+	/** The index of the currently active camera (0 = built-in default). */
+	get currentCameraIndex() {
+
+		return this.cameraManager?.currentCameraIndex ?? 0;
+
+	}
+
+	/**
+	 * Snapshot the current view as a new named camera and switch to it.
+	 * @param {Object} [opts]
+	 * @param {string} [opts.name] - Display name (auto-generated otherwise).
+	 * @returns {number} The index of the newly added camera.
+	 */
+	addCamera( { name } = {} ) {
+
+		const index = this.cameraManager.addCameraFromView( name );
+		this.cameraManager.switchCamera( index );
+		this._dispatchCamerasUpdated();
+		return index;
+
+	}
+
+	/**
+	 * Remove a user-added camera by index. Built-in and model-embedded cameras
+	 * are protected. Falls back to the default camera if the active one is removed.
+	 * @param {number} index
+	 * @returns {boolean} true if a camera was removed.
+	 */
+	removeCamera( index ) {
+
+		const removed = this.cameraManager.removeCamera( index );
+		if ( removed ) this._dispatchCamerasUpdated();
+		return removed;
+
+	}
+
+	/** Notify consumers that the camera list changed (names / count). */
+	_dispatchCamerasUpdated() {
+
+		this.dispatchEvent( {
+			type: 'CamerasUpdated',
+			cameras: this.cameraManager.cameras,
+			cameraNames: this.cameraManager.getCameraNames(),
+		} );
+
+	}
+
 	// ═══════════════════════════════════════════════════════════════
 	// BVH Refit (Animation)
 	// ═══════════════════════════════════════════════════════════════
@@ -1504,27 +1558,60 @@ export class PathTracerApp extends EventDispatcher {
 
 		this.stages.pathTracer?.materialData.updateMaterialProperty( materialIndex, property, value );
 
+		// Keep the emissive-NEE structure in sync unconditionally (not gated on the
+		// sampling toggle) so edits made while NEE is off aren't lost on re-enable.
 		const emissiveAffectingProps = [ 'emissive', 'emissiveIntensity' ];
-		if ( emissiveAffectingProps.includes( property )
-			&& this.stages.pathTracer?.enableEmissiveTriangleSampling?.value ) {
+		if ( emissiveAffectingProps.includes( property ) && this._sdf ) {
 
-			const result = this._sdf.updateMaterialEmissive( materialIndex, property, value );
-			if ( result ) {
+			this._uploadEmissivePayload( this._sdf.updateMaterialEmissive( materialIndex, property, value ) );
 
-				this.stages.pathTracer.setEmissiveTriangleData(
-					result.rawData, result.emissiveCount, result.totalPower, result.bitTrailMap,
-				);
-				if ( result.lightBVHNodeData ) {
+		}
 
-					this.stages.pathTracer.setLightBVHData( result.lightBVHNodeData, result.lightBVHNodeCount );
+		this.reset();
 
-				}
+	}
 
-			}
+	/**
+	 * Upload a rebuilt emissive-NEE payload (sorted emissive data + Light BVH +
+	 * bit-trail map) to the path tracer stage. No-op for a null payload.
+	 * @param {object|null} payload
+	 * @private
+	 */
+	_uploadEmissivePayload( payload ) {
+
+		if ( ! payload || ! this.stages.pathTracer ) return;
+
+		this.stages.pathTracer.setEmissiveTriangleData(
+			payload.rawData, payload.emissiveCount, payload.totalPower, payload.bitTrailMap,
+		);
+		if ( payload.lightBVHNodeData ) {
+
+			this.stages.pathTracer.setLightBVHData( payload.lightBVHNodeData, payload.lightBVHNodeCount );
 
 		}
 
-		this.reset();
+	}
+
+	/**
+	 * Re-derive the emissive-NEE sampled set from current per-mesh world-visibility
+	 * (InstanceTable is the source of truth — patched by the stage's visibility API).
+	 * Hidden meshes' triangles are dropped from the Light BVH so they stop casting
+	 * NEE light; the shadow ray can't do it (a hidden mesh no longer self-occludes).
+	 * @private
+	 */
+	_refreshEmissiveForVisibility() {
+
+		const entries = this._sdf?.instanceTable?.entries;
+		if ( ! entries ) return;
+
+		const hidden = new Set();
+		for ( const entry of entries ) {
+
+			if ( entry && entry.visible === false ) hidden.add( entry.meshIndex );
+
+		}
+
+		this._uploadEmissivePayload( this._sdf.rebuildEmissiveForVisibility( hidden ) );
 
 	}
 
@@ -1542,11 +1629,13 @@ export class PathTracerApp extends EventDispatcher {
 	}
 
 	/**
-	 * @returns {boolean} True if the current scene contains emissive geometry.
+	 * @returns {boolean} True if the current scene contains emissive geometry
+	 * (regardless of per-mesh visibility).
 	 */
 	hasEmissiveGeometry() {
 
-		return ( this._sdf?.emissiveTriangleCount ?? 0 ) > 0;
+		return ( this._sdf?.emissiveTriangleBuilder?.emissiveTriangles?.length
+			?? this._sdf?.emissiveTriangleCount ?? 0 ) > 0;
 
 	}
 
@@ -1559,6 +1648,7 @@ export class PathTracerApp extends EventDispatcher {
 	setMeshVisibility( meshIndex, visible ) {
 
 		this.stages.pathTracer?.updateMeshVisibility( meshIndex, visible );
+		this._refreshEmissiveForVisibility();
 		this.reset();
 
 	}
@@ -1570,6 +1660,7 @@ export class PathTracerApp extends EventDispatcher {
 	updateAllMeshVisibility() {
 
 		this.stages.pathTracer?.updateAllMeshVisibility();
+		this._refreshEmissiveForVisibility();
 		this.reset();
 
 	}
@@ -1830,6 +1921,8 @@ export class PathTracerApp extends EventDispatcher {
 			onResize: () => this.onResize(),
 			onReset: () => this.reset(),
 			getSettings: ( k ) => this.settings.get( k ),
+			// Per-camera DOF restore — silent + reset:false so switchCamera's own onReset() is the single reset.
+			applySettings: ( updates ) => this.settings.setMany( updates, { silent: true, reset: false } ),
 		} );
 
 		// Auto-focus context — CameraManager stores it, reads it each frame

package/src/Processor/EmissiveTriangleBuilder.js

@@ -26,6 +26,10 @@ export class EmissiveTriangleBuilder {
 		// triangleIndex, -1 for non-emissive. Lets the GPU re-walk the descent pdf for MIS.
 		this.emissiveBitTrailMap = null;
 		this._totalTriangleCount = 0;
+		// Mesh indices whose emissive triangles are excluded from the sampled set
+		// (per-mesh visibility). Canonical `emissiveTriangles` is never filtered —
+		// the GPU-facing arrays are rebuilt from the visible subset in buildLightBVH().
+		this._hiddenMeshes = new Set();
 
 	}
 
@@ -45,11 +49,13 @@ export class EmissiveTriangleBuilder {
 
 		const FLOATS_PER_TRIANGLE = TRIANGLE_DATA_LAYOUT.FLOATS_PER_TRIANGLE;
 		const MATERIAL_INDEX_OFFSET = TRIANGLE_DATA_LAYOUT.UV_C_MAT_OFFSET + 2; // materialIndex within vec4
+		const MESH_INDEX_OFFSET = TRIANGLE_DATA_LAYOUT.UV_C_MAT_OFFSET + 3; // meshIndex within vec4
 
 		for ( let i = 0; i < triangleCount; i ++ ) {
 
 			const baseOffset = i * FLOATS_PER_TRIANGLE;
 			const materialIndex = Math.floor( triangleData[ baseOffset + MATERIAL_INDEX_OFFSET ] );
+			const meshIndex = Math.floor( triangleData[ baseOffset + MESH_INDEX_OFFSET ] );
 
 			// Get material
 			const material = materials[ materialIndex ];
@@ -111,6 +117,7 @@ export class EmissiveTriangleBuilder {
 				this.emissiveTriangles.push( {
 					triangleIndex: i,
 					materialIndex: materialIndex,
+					meshIndex: meshIndex,
 					power: power,
 					area: area,
 					emissive: { r: emissive.r, g: emissive.g, b: emissive.b },
@@ -443,40 +450,81 @@ export class EmissiveTriangleBuilder {
 		// If not emissive before and not now, nothing to do
 		if ( ! isNowEmissive ) return false;
 
-		// Fast path: just update power + CDF for affected entries.
+		// Fast path: update the canonical entries only. Derived arrays, CDF and
+		// totals are rebuilt by the buildLightBVH() call that always follows.
 		// Rec.709 luma — must match the build path + shader MIS weighting.
 		const luma = 0.2126 * emissive.r + 0.7152 * emissive.g + 0.0722 * emissive.b;
 
-		this.totalEmissivePower = 0;
-		for ( let i = 0; i < this.emissiveCount; i ++ ) {
+		for ( const tri of this.emissiveTriangles ) {
 
-			const tri = this.emissiveTriangles[ i ];
 			if ( tri.materialIndex === materialIndex ) {
 
 				tri.power = luma * emissiveIntensity * tri.area;
 				tri.emissive = { r: emissive.r, g: emissive.g, b: emissive.b };
 				tri.emissiveIntensity = emissiveIntensity;
-				this.emissivePowerArray[ i ] = tri.power;
 
 			}
 
-			this.totalEmissivePower += this.emissiveTriangles[ i ].power;
-
 		}
 
-		this._buildCDF();
 		return true;
 
 	}
 
 	/**
-	 * Build a Light BVH over the current emissive triangles.
-	 * Reorders emissiveTriangleData so that leaf node start/count indices are valid.
+	 * Set the meshes whose emissive triangles must be excluded from sampling
+	 * (per-mesh visibility). Indices that don't own emissive triangles are
+	 * ignored so non-emissive visibility toggles are no-ops.
+	 * @param {Set<number>|Iterable<number>} hiddenMeshIndices
+	 * @returns {boolean} true if the effective hidden set changed (caller should rebuild)
+	 */
+	setHiddenMeshes( hiddenMeshIndices ) {
+
+		const emissiveMeshes = new Set();
+		for ( const tri of this.emissiveTriangles ) emissiveMeshes.add( tri.meshIndex );
+
+		const next = new Set();
+		for ( const m of hiddenMeshIndices ) if ( emissiveMeshes.has( m ) ) next.add( m );
+
+		const prev = this._hiddenMeshes;
+		let changed = next.size !== prev.size;
+		if ( ! changed ) {
+
+			for ( const m of next ) {
+
+				if ( ! prev.has( m ) ) {
+
+					changed = true;
+					break;
+
+				}
+
+			}
+
+		}
+
+		this._hiddenMeshes = next;
+		return changed;
+
+	}
+
+	/**
+	 * Build a Light BVH over the VISIBLE emissive triangles (canonical set minus
+	 * hidden meshes). Authoritative for the GPU-facing emissiveCount /
+	 * totalEmissivePower / sorted raw data / bit-trail map.
 	 * @returns {number} nodeCount
 	 */
 	buildLightBVH() {
 
-		if ( this.emissiveCount === 0 ) {
+		const active = this._hiddenMeshes.size === 0
+			? this.emissiveTriangles
+			: this.emissiveTriangles.filter( t => ! this._hiddenMeshes.has( t.meshIndex ) );
+
+		this.emissiveCount = active.length;
+		this.totalEmissivePower = 0;
+		for ( const tri of active ) this.totalEmissivePower += tri.power;
+
+		if ( active.length === 0 ) {
 
 			// Dummy single leaf node (whole-sphere cone)
 			this.lightBVHNodeData = new Float32Array( 16 );
@@ -485,23 +533,27 @@ export class EmissiveTriangleBuilder {
 			this.lightBVHNodeData[ 15 ] = - 1.0; // cosThetaO = whole sphere
 			this.lightBVHNodeCount = 1;
 			this.emissiveBitTrailMap = new Float32Array( Math.max( this._totalTriangleCount, 1 ) ).fill( - 1 );
+			this.emissiveIndicesArray = new Int32Array( 0 );
+			this.emissivePowerArray = new Float32Array( 0 );
+			this._buildCDF();
+			this.emissiveTriangleData = new Float32Array( 8 ); // 2 dummy vec4s
 			return 1;
 
 		}
 
 		const builder = new LightBVHBuilder();
-		const { nodeData, nodeCount, sortedPerm, bitTrails } = builder.build( this.emissiveTriangles );
+		const { nodeData, nodeCount, sortedPerm, bitTrails } = builder.build( active );
 		this.lightBVHNodeData = nodeData;
 		this.lightBVHNodeCount = nodeCount;
 
 		// Rebuild emissive raw data in sorted leaf order so node start/count refs are valid
-		this._rebuildSortedEmissiveData( sortedPerm );
+		this._rebuildSortedEmissiveData( sortedPerm, active );
 
-		// Build the per-triangle bit-trail map (indexed by absolute triangleIndex; -1 = non-emissive)
+		// Build the per-triangle bit-trail map (indexed by absolute triangleIndex; -1 = non-emissive/hidden)
 		this.emissiveBitTrailMap = new Float32Array( Math.max( this._totalTriangleCount, 1 ) ).fill( - 1 );
 		for ( let i = 0; i < sortedPerm.length; i ++ ) {
 
-			const triIndex = this.emissiveTriangles[ sortedPerm[ i ] ].triangleIndex;
+			const triIndex = active[ sortedPerm[ i ] ].triangleIndex;
 			this.emissiveBitTrailMap[ triIndex ] = bitTrails[ i ];
 
 		}
@@ -512,10 +564,11 @@ export class EmissiveTriangleBuilder {
 
 	/**
 	 * Rebuild emissive arrays and raw GPU data in the sorted leaf order given by sortedPerm.
-	 * @param {Int32Array} sortedPerm - sortedPerm[i] = original emissiveTriangles index for position i
+	 * @param {Int32Array} sortedPerm - sortedPerm[i] = index into `tris` for position i
+	 * @param {Array} tris - The (visible) triangle set the Light BVH was built over
 	 * @private
 	 */
-	_rebuildSortedEmissiveData( sortedPerm ) {
+	_rebuildSortedEmissiveData( sortedPerm, tris ) {
 
 		const n = sortedPerm.length;
 
@@ -526,8 +579,8 @@ export class EmissiveTriangleBuilder {
 		for ( let i = 0; i < n; i ++ ) {
 
 			const origIdx = sortedPerm[ i ];
-			this.emissiveIndicesArray[ i ] = this.emissiveTriangles[ origIdx ].triangleIndex;
-			this.emissivePowerArray[ i ] = this.emissiveTriangles[ origIdx ].power;
+			this.emissiveIndicesArray[ i ] = tris[ origIdx ].triangleIndex;
+			this.emissivePowerArray[ i ] = tris[ origIdx ].power;
 
 		}
 
@@ -540,7 +593,7 @@ export class EmissiveTriangleBuilder {
 		for ( let i = 0; i < n; i ++ ) {
 
 			const origIdx = sortedPerm[ i ];
-			const tri = this.emissiveTriangles[ origIdx ];
+			const tri = tris[ origIdx ];
 			const offset = i * 8;
 
 			// vec4[0]: triangleIndex, power, cdf, selectionPdf
@@ -579,6 +632,7 @@ export class EmissiveTriangleBuilder {
 		// triangleIndex, -1 for non-emissive. Lets the GPU re-walk the descent pdf for MIS.
 		this.emissiveBitTrailMap = null;
 		this._totalTriangleCount = 0;
+		this._hiddenMeshes = new Set();
 
 	}
 

package/src/Processor/SceneProcessor.js

@@ -979,6 +979,9 @@ export class SceneProcessor {
 		this.emissiveTriangleData = this.emissiveTriangleBuilder.emissiveTriangleData || this.emissiveTriangleData;
 		// Per-triangle bit-trail map for the bounce-hit MIS re-walk
 		this.emissiveBitTrailMap = this.emissiveTriangleBuilder.emissiveBitTrailMap;
+		// buildLightBVH is authoritative for the sampled (visible-subset) count/power
+		this.emissiveTriangleCount = this.emissiveTriangleBuilder.emissiveCount;
+		this.emissiveTotalPower = this.emissiveTriangleBuilder.totalEmissivePower;
 
 	}
 
@@ -1581,8 +1584,35 @@ export class SceneProcessor {
 
 		if ( ! changed ) return null;
 
-		// Rebuild the Light BVH + sorted emissive data + bit-trail map so the stochastic descent and
-		// the bounce-hit MIS re-walk stay consistent after powers / the emissive set change.
+		return this._collectEmissivePayload();
+
+	}
+
+	/**
+	 * Re-derive the sampled emissive set from per-mesh visibility.
+	 * @param {Set<number>|Iterable<number>} hiddenMeshIndices - meshIndex values that are world-hidden
+	 * @param {boolean} force - rebuild even if the effective hidden set is unchanged
+	 * @returns {object|null} GPU upload payload, or null when nothing changed
+	 */
+	rebuildEmissiveForVisibility( hiddenMeshIndices, force = false ) {
+
+		if ( ! this.emissiveTriangleBuilder ) return null;
+
+		const changed = this.emissiveTriangleBuilder.setHiddenMeshes( hiddenMeshIndices );
+		if ( ! changed && ! force ) return null;
+
+		return this._collectEmissivePayload();
+
+	}
+
+	/**
+	 * Rebuild the Light BVH + sorted emissive data + bit-trail map (over the visible
+	 * subset) so the stochastic descent and the bounce-hit MIS re-walk stay consistent,
+	 * then sync the processor fields and return the GPU upload payload.
+	 * @private
+	 */
+	_collectEmissivePayload() {
+
 		this.emissiveTriangleBuilder.buildLightBVH();
 		this.lightBVHNodeData = this.emissiveTriangleBuilder.lightBVHNodeData;
 		this.lightBVHNodeCount = this.emissiveTriangleBuilder.lightBVHNodeCount;
@@ -1592,9 +1622,9 @@ export class SceneProcessor {
 		this.emissiveTotalPower = this.emissiveTriangleBuilder.totalEmissivePower;
 
 		return {
-			rawData: this.emissiveTriangleBuilder.emissiveTriangleData,
-			emissiveCount: this.emissiveTriangleBuilder.emissiveCount,
-			totalPower: this.emissiveTriangleBuilder.totalEmissivePower,
+			rawData: this.emissiveTriangleData,
+			emissiveCount: this.emissiveTriangleCount,
+			totalPower: this.emissiveTotalPower,
 			bitTrailMap: this.emissiveBitTrailMap,
 			lightBVHNodeData: this.lightBVHNodeData,
 			lightBVHNodeCount: this.lightBVHNodeCount,

package/src/RenderSettings.js

@@ -252,8 +252,9 @@ export class RenderSettings extends EventDispatcher {
 	 * @param {Object} updates - Key/value pairs
 	 * @param {Object} [options]
 	 * @param {boolean} [options.silent] - Suppress settingChanged events
+	 * @param {boolean} [options.reset]  - Override the routes' default reset behavior
 	 */
-	setMany( updates, { silent } = {} ) {
+	setMany( updates, { silent, reset } = {} ) {
 
 		let needsReset = false;
 
@@ -279,7 +280,8 @@ export class RenderSettings extends EventDispatcher {
 
 		}
 
-		if ( needsReset ) this._resetCallback?.();
+		const shouldReset = reset !== undefined ? reset : needsReset;
+		if ( shouldReset ) this._resetCallback?.();
 
 	}
 

package/src/Stages/PathTracer.js

@@ -199,6 +199,17 @@ export class PathTracer extends PathTracerStage {
 		// Kernels not built yet (first frame / mid-resize) — skip until ready.
 		if ( ! this.isReady || ! this._wavefrontReady ) return;
 
+		// The packed light buffer was grow-reallocated at runtime (emissive set grew) —
+		// the compiled kernels still bind the old attribute, so rebuild before rendering.
+		if ( this._lightBufferRealloc ) {
+
+			if ( this._kernelManager ) this._kernelManager.dispose();
+			this._wavefrontReady = false;
+			this._buildWavefrontKernels();
+			if ( ! this._wavefrontReady ) return;
+
+		}
+
 		if ( this.isComplete || this.frameCount >= this.completionThreshold || this._isConvergedComplete() ) {
 
 			if ( ! this.isComplete ) this.isComplete = true;
@@ -685,6 +696,9 @@ export class PathTracer extends PathTracerStage {
 		const texNodes = this.shaderBuilder.getSceneTextureNodes();
 		if ( ! texNodes ) return;
 
+		// A fresh build binds the current lightStorageAttr — any pending realloc is covered.
+		this._lightBufferRealloc = false;
+
 		const w = this.storageTextures.renderWidth;
 		const h = this.storageTextures.renderHeight;
 		const maxRays = w * h;

package/src/Stages/PathTracerStage.js

@@ -197,6 +197,9 @@ export class PathTracerStage extends RenderStage {
 		// 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();
+		// Set when _rebuildLightBuffer had to grow-reallocate the attribute: compiled
+		// kernels still bind the old one and must be rebuilt to see the new data.
+		this._lightBufferRealloc = false;
 
 		// Cached CPU-side data — rebuilt into the packed buffer whenever any source changes.
 		this._lbvhDataCache = null;
@@ -1279,6 +1282,12 @@ export class PathTracerStage extends RenderStage {
 	 * 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).
+	 *
+	 * The compiled wavefront kernels bind the attribute that existed at kernel-build
+	 * time and NEVER pick up a `lightStorageNode.value` reassignment — so runtime
+	 * updates MUST write in-place into the bound attribute (+ needsUpdate). Only
+	 * grow-reallocate when the data outgrows capacity, and flag it so the kernels
+	 * get rebuilt against the new attribute.
 	 * @private
 	 */
 	_rebuildLightBuffer() {
@@ -1294,14 +1303,33 @@ export class PathTracerStage extends RenderStage {
 
 		// Ensure at least a minimal non-empty buffer so GPU allocation remains valid.
 		const totalLen = Math.max( lbvhLen + emisLen + trailPadded, 4 );
-		const combined = new Float32Array( totalLen );
-		if ( lbvh ) combined.set( lbvh, 0 );
-		if ( emis ) combined.set( emis, lbvhLen );
-		if ( trail ) combined.set( trail, lbvhLen + emisLen );
-
-		this.lightStorageAttr = new StorageInstancedBufferAttribute( combined, 4 );
-		this.lightStorageNode.value = this.lightStorageAttr;
-		this.lightStorageNode.bufferCount = combined.length / 4;
+
+		if ( this.lightStorageAttr && totalLen <= this.lightStorageAttr.array.length ) {
+
+			// In-place update of the bound attribute. Stale floats past the new data
+			// are unreachable — all reads are gated by the count/offset uniforms.
+			const arr = this.lightStorageAttr.array;
+			if ( lbvh ) arr.set( lbvh, 0 );
+			if ( emis ) arr.set( emis, lbvhLen );
+			if ( trail ) arr.set( trail, lbvhLen + emisLen );
+			this.lightStorageAttr.needsUpdate = true;
+
+		} else {
+
+			const combined = new Float32Array( totalLen );
+			if ( lbvh ) combined.set( lbvh, 0 );
+			if ( emis ) combined.set( emis, lbvhLen );
+			if ( trail ) combined.set( trail, lbvhLen + emisLen );
+
+			this.lightStorageAttr = new StorageInstancedBufferAttribute( combined, 4 );
+			this.lightStorageNode.value = this.lightStorageAttr;
+			this.lightStorageNode.bufferCount = combined.length / 4;
+
+			// Already-compiled kernels still bind the old attribute — request a rebuild.
+			// (During scene load this is a no-op: setupMaterial rebuilds kernels anyway.)
+			this._lightBufferRealloc = true;
+
+		}
 
 		// Offset (in vec4 elements) where emissive data starts.
 		this.emissiveVec4Offset.value = ( this.lightBVHNodeCount.value || 0 ) * LBVH_STRIDE;

package/src/TSL/EmissiveSampling.js

@@ -96,7 +96,9 @@ export const sphericalTriangleSolidAngle = Fn( ( [ v0, v1, v2, p ] ) => {
 
 } );
 
-// Heuristic: use spherical sampling when triangle is close/large (Blender Cycles approach)
+// Heuristic: use spherical sampling when triangle is close/large (Blender Cycles approach).
+// Shared by the samplers AND the MIS pdf re-walks (EmissiveSampling + LightBVHSampling) —
+// both sides MUST take the same branch or MIS partition-of-unity breaks.
 export const useSphericalSampling = Fn( ( [ v0, v1, v2, hitPoint ] ) => {
 
 	const e0 = v1.sub( v0 );
@@ -114,7 +116,14 @@ export const useSphericalSampling = Fn( ( [ v0, v1, v2, hitPoint ] ) => {
 		const d = dot( triNormal, hitPoint.sub( v0 ) );
 		// planeDist² = d² / |triNormal|²
 		const planeDistSq = d.mul( d ).div( triNormalLenSq );
-		result.assign( longestEdgeSq.greaterThan( planeDistSq ) );
+
+		// Sliver guard: Arvo spherical-triangle sampling is numerically unstable on
+		// high-aspect slivers (NaN/garbage → colored fireflies). |triNormal|² = (2A)²
+		// and 2A = longestEdge·height, so longestEdgeSq²/triNormalLenSq = (edge/height)².
+		// Require aspect < 8 (64 = 8²), else fall back to stable area sampling.
+		const notSliver = longestEdgeSq.mul( longestEdgeSq ).lessThan( triNormalLenSq.mul( 64.0 ) );
+
+		result.assign( longestEdgeSq.greaterThan( planeDistSq ).and( notSliver ) );
 
 	} );