rayzee 9.3.3 → 9.4.1

package/package.json

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

package/src/EngineIssues.js

@@ -32,6 +32,7 @@ export const ISSUE_CODES = Object.freeze( {
 	STORAGE_CACHE_MISMATCH: 'storage.cache_mismatch',
 	DENOISER_UNAVAILABLE: 'denoiser.unavailable',
 	OUTPUT_SOURCE_FALLBACK: 'output.source_fallback',
+	OUTPUT_TONEMAP_FALLBACK: 'output.tonemap_fallback',
 	LIGHT_PLACEHOLDER_SKIPPED: 'light.placeholder_skipped',
 } );
 

package/src/PathTracerApp.js

@@ -24,7 +24,7 @@ import { TextureReadback } from './Processor/TextureReadback.js';
 import { createLogger, fmt } from './utils/Logger.js';
 import { InteractionManager } from './managers/InteractionManager.js';
 import { EngineEvents, LEGACY_EVENT_NAMES } from './EngineEvents.js';
-import { IssueLog, ISSUE_CODES } from './EngineIssues.js';
+import { IssueLog, ISSUE_CODES, EngineIssueError } from './EngineIssues.js';
 import { getAssetConfig, isAssetConfigured } from './AssetConfig.js';
 import { StorageManager } from './Storage/StorageManager.js';
 import { acquireSharedStorage } from './Storage/openStorage.js';
@@ -2903,7 +2903,7 @@ export class PathTracerApp extends EventDispatcher {
 				headless: this._headless,
 				strict: this._issues.strict,
 				deterministic: this.isDeterministic,
-				lockstep: !! stage?.lockstepReadbacks,
+				lockstep: !! stage?.accumulationLockstep,
 			},
 			render: stage ? {
 				width: stage.width,
@@ -2998,8 +2998,9 @@ export class PathTracerApp extends EventDispatcher {
 	 *   viewport is showing — denoised when a denoiser has run, without bloom — instead of the raw
 	 *   accumulation
 	 * @returns {Promise<{data: Float32Array|Uint8ClampedArray, width: number, height: number, colorSpace: string,
-	 *   source: string}>} `source` is what was read: `'accumulation'`, or the denoiser that published
-	 *   it (`'oidn'`, `'asvgf'`, `'nrd'`, `'edgeFiltering'`, `'bilateralFiltering'`)
+	 *   source: string, toneMappedOn?: 'gpu'|'cpu'}>} `source` is what was read: `'accumulation'`, or the
+	 *   denoiser that published it (`'oidn'`, `'asvgf'`, `'nrd'`, `'edgeFiltering'`, `'bilateralFiltering'`).
+	 *   `toneMappedOn` is set for `'srgb'` only.
 	 */
 	async renderToBuffer( { colorSpace = 'srgb', preserveAlpha = false, source = 'accumulation' } = {} ) {
 
@@ -3029,11 +3030,11 @@ export class PathTracerApp extends EventDispatcher {
 				preserveAlpha,
 			};
 
-			const data = await this._toneMapOnGPU( shown?.texture ?? null, target, width, height, tone )
-				?? toneMapToRGBA8( shown
-					? await this._readTexture( shown.texture, width, height )
-					: await this.renderer.readRenderTargetPixelsAsync( target, 0, 0, width, height, 0 ), tone );
-			return { data, width, height, colorSpace, source: shown?.source ?? 'accumulation' };
+			const gpu = await this._toneMapOnGPU( shown?.texture ?? null, target, width, height, tone );
+			const data = gpu ?? toneMapToRGBA8( shown
+				? await this._readTexture( shown.texture, width, height )
+				: await this.renderer.readRenderTargetPixelsAsync( target, 0, 0, width, height, 0 ), tone );
+			return { data, width, height, colorSpace, source: shown?.source ?? 'accumulation', toneMappedOn: gpu ? 'gpu' : 'cpu' };
 
 		}
 
@@ -3065,13 +3066,13 @@ export class PathTracerApp extends EventDispatcher {
 	async _toneMapOnGPU( shown, accumulation, width, height, tone ) {
 
 		const backend = this.renderer?.backend;
-		if ( ! backend?.device ) return null;
+		if ( ! backend?.device ) return this._toneMapFallback( 'the renderer has no WebGPU device' );
 
 		try {
 
 			const texture = shown ? this._readbackPass().draw( shown, width, height ).texture : accumulation.textures[ 0 ];
 			const gpuTexture = backend.get( texture ).texture;
-			if ( ! gpuTexture ) return null;
+			if ( ! gpuTexture ) return this._toneMapFallback( 'the picture has no GPU texture yet' );
 
 			this._readbackToneMapper ??= new PackedToneMapper( backend.device, 'rayzee:readback-tonemap', { input: 'texture' } );
 			this._readbackToneMapper.ensureSize( width, height );
@@ -3079,8 +3080,8 @@ export class PathTracerApp extends EventDispatcher {
 
 		} catch ( error ) {
 
-			log.warn( `renderToBuffer: tone mapping on the GPU failed, doing it on the CPU: ${error?.message ?? error}` );
-			return null;
+			if ( error instanceof EngineIssueError ) throw error;
+			return this._toneMapFallback( 'the GPU pass threw', error );
 
 		} finally {
 
@@ -3091,6 +3092,17 @@ export class PathTracerApp extends EventDispatcher {
 
 	}
 
+	/** A warning, so strict keeps going: the CPU bytes match within a level, only slower. @private */
+	_toneMapFallback( reason, error = null ) {
+
+		const cause = error ? String( error?.message ?? error ) : null;
+		const message = `renderToBuffer: tone mapped on the CPU — ${reason}${cause ? `: ${cause}` : ''}`;
+		log.warn( message );
+		this._issues.warn( ISSUE_CODES.OUTPUT_TONEMAP_FALLBACK, message, { reason, cause } );
+		return null;
+
+	}
+
 	/**
 	 * Enables WebGPU timestamp queries so {@link PathTracerApp#getGPUTimings} reports real
 	 * GPU time. Off by default because the queries themselves cost time. No-ops when the

package/src/Processor/TextureCreator.js

@@ -15,6 +15,13 @@ const log = createLogger( 'textures' );
 // Below this a pack is cheaper than starting a worker for it.
 const WORKER_PACK_BYTES = 8 * 2 ** 20;
 
+// Main-thread work allowed between yields while streaming layers to a worker.
+const STREAM_YIELD_MS = 16;
+
+const SHARED_PACK_WORKERS = 4;
+// Below about one 8K source a bucket packs fast enough alone, and extra workers only compete with the BVH build.
+const SHARED_PACK_MIN_PIXELS = 8192 * 8192;
+
 // Buckets pack concurrently; this keeps their workers within the cores, beside the BVH pool's.
 const packSlots = { busy: 0, waiting: [] };
 
@@ -835,6 +842,9 @@ export class TextureCreator {
 				case 'worker-direct':
 					result = await this.processWithWorkerDirect( normalized );
 					break;
+				case 'worker-streaming':
+					result = await this.processInWorkerStreaming( normalized );
+					break;
 				case 'main-batch':
 					result = await this.processOnMainThreadBatch( normalized, strategy.batchSize );
 					break;
@@ -892,10 +902,7 @@ export class TextureCreator {
 
 		if ( this.capabilities.workers && estimatedMemory > MEMORY_CONSTANTS.MAX_TEXTURE_MEMORY ) {
 
-			// Very large texture set: stream on the main thread (GC-yielding, builds the
-			// full array correctly). The former 'worker-chunked' path combined its chunks
-			// by returning only the first, silently dropping the rest — removed.
-			return { method: 'main-streaming' };
+			return { method: 'worker-streaming' };
 
 		} else if ( this.capabilities.workers && totalPixels > 2097152 ) {
 
@@ -931,14 +938,24 @@ export class TextureCreator {
 		}
 
 		this.activeWorkers ++;
-
-		const worker = new TexturesWorker();
+		let slots = 1;
+		let worker = null;
 
 		try {
 
 			// Prepare textures for worker with direct transfer
 			const texturesData = await this.prepareTexturesForWorkerDirect( textures );
 
+			const extra = this._sharedPackSlots( texturesData );
+			if ( extra > 0 ) {
+
+				slots += extra;
+				this.activeWorkers += extra;
+				return this.createDataArrayTextureFromResult( await this._packAcrossWorkers( texturesData, slots ) );
+
+			}
+
+			worker = new TexturesWorker();
 			const result = await new Promise( ( resolve, reject ) => {
 
 				worker.onmessage = ( e ) => {
@@ -983,6 +1000,153 @@ export class TextureCreator {
 
 			return this.createDataArrayTextureFromResult( result );
 
+		} finally {
+
+			worker?.terminate();
+			this.activeWorkers -= slots;
+
+		}
+
+	}
+
+	/** Extra worker slots a bucket may take now, beyond its own. */
+	_sharedPackSlots( texturesData ) {
+
+		if ( typeof SharedArrayBuffer === 'undefined' || ! globalThis.crossOriginIsolated ) return 0;
+		if ( texturesData.reduce( ( sum, t ) => sum + t.width * t.height, 0 ) < SHARED_PACK_MIN_PIXELS ) return 0;
+		const free = this.maxConcurrentWorkers - this.activeWorkers;
+		return Math.max( 0, Math.min( texturesData.length, SHARED_PACK_WORKERS, free + 1 ) - 1 );
+
+	}
+
+	/**
+	 * The worker's direct path split across `count` workers, each drawing its layers straight into
+	 * one shared array. Large sources dominate (their downscale), so they are dealt out first.
+	 */
+	async _packAcrossWorkers( texturesData, count ) {
+
+		const { maxWidth: width, maxHeight: height } = this.calculateOptimalDimensions( texturesData.map( image => ( { image } ) ) );
+		const depth = texturesData.length;
+		const shared = new SharedArrayBuffer( width * height * depth * 4 );
+
+		const parts = Array.from( { length: count }, () => ( { cost: 0, layers: [], transfer: [] } ) );
+		const order = texturesData.map( ( _, index ) => index );
+		const cost = index => texturesData[ index ].width * texturesData[ index ].height;
+		order.sort( ( a, b ) => cost( b ) - cost( a ) );
+
+		for ( const index of order ) {
+
+			const part = parts.reduce( ( least, p ) => ( p.cost < least.cost ? p : least ) );
+			const texture = texturesData[ index ];
+			part.layers.push( { index, texture } );
+			part.cost += cost( index );
+			if ( texture.data instanceof ArrayBuffer ) part.transfer.push( texture.data );
+			else if ( texture.bitmap ) part.transfer.push( texture.bitmap );
+
+		}
+
+		const workers = [];
+
+		try {
+
+			await Promise.all( parts.filter( part => part.layers.length ).map( part => new Promise( ( resolve, reject ) => {
+
+				const worker = createWorker( TexturesWorker );
+				workers.push( worker );
+				worker.onmessage = ( { data } ) => ( data.error ? reject( new Error( data.error ) ) : resolve() );
+				worker.onerror = ( event ) => reject( new Error( event.message || 'texture worker failed' ) );
+				worker.postMessage( { shared, width, height, layers: part.layers, maxTextureSize: this.maxTextureSize }, part.transfer );
+
+			} ) ) );
+
+		} finally {
+
+			for ( const worker of workers ) worker.terminate();
+
+		}
+
+		return { data: shared, width, height, depth };
+
+	}
+
+	/**
+	 * `processOnMainThreadStreaming` with the draw and read moved to a worker: each layer is
+	 * resized here exactly as there, so the array is byte-for-byte the same.
+	 */
+	async processInWorkerStreaming( textures ) {
+
+		const validTextures = textures.filter( tex => tex?.image );
+		if ( validTextures.length === 0 ) return this.createFallbackTexture();
+
+		const { maxWidth, maxHeight } = this.calculateOptimalDimensions( validTextures );
+		const depth = validTextures.length;
+
+		while ( this.activeWorkers >= this.maxConcurrentWorkers ) {
+
+			await new Promise( resolve => setTimeout( resolve, 10 ) );
+
+		}
+
+		this.activeWorkers ++;
+		const worker = createWorker( TexturesWorker );
+
+		try {
+
+			let acked = 0;
+			let wake = null;
+			let settle;
+			const finished = new Promise( ( resolve, reject ) => settle = { resolve, reject } );
+			finished.catch( () => {} );
+
+			worker.onmessage = ( { data } ) => {
+
+				if ( data.error ) settle.reject( new Error( data.error ) );
+				else if ( data.stream === 'ack' ) acked ++;
+				else settle.resolve( data );
+				wake?.();
+
+			};
+
+			worker.onerror = ( event ) => {
+
+				settle.reject( new Error( event.message || 'texture worker failed' ) );
+				wake?.();
+
+			};
+
+			worker.postMessage( { stream: 'begin', width: maxWidth, height: maxHeight, depth } );
+			let lastYield = performance.now();
+
+			for ( let i = 0; i < depth; i ++ ) {
+
+				while ( i - acked >= MEMORY_CONSTANTS.STREAM_BATCH_SIZE ) {
+
+					await Promise.race( [ new Promise( resolve => wake = resolve ), finished ] );
+					lastYield = performance.now();
+
+				}
+
+				const texture = validTextures[ i ];
+				const bitmap = await createImageBitmap( texture.image, {
+					resizeWidth: maxWidth,
+					resizeHeight: maxHeight,
+					resizeQuality: 'high',
+					imageOrientation: texture.flipY !== false ? 'flipY' : 'none',
+				} );
+				worker.postMessage( { stream: 'layer', index: i, bitmap }, [ bitmap ] );
+
+				if ( performance.now() - lastYield > STREAM_YIELD_MS ) {
+
+					await new Promise( resolve => setTimeout( resolve, 0 ) );
+					lastYield = performance.now();
+
+				}
+
+			}
+
+			worker.postMessage( { stream: 'end' } );
+			return this.createDataArrayTextureFromResult( await finished );
+
 		} finally {
 
 			worker.terminate();

package/src/Processor/Workers/TexturesWorker.js

@@ -2,15 +2,112 @@ let canvas, ctx;
 
 // Memory limits and chunking configuration
 const MEMORY_LIMITS = {
-	MAX_BYTES_PER_TEXTURE: 256 * 1024 * 1024, // 256MB per texture array
 	MAX_TEXTURE_DIMENSION: 8192, // Hardware ceiling (WebGPU maxTextureDimension2D guaranteed min); the per-scene maxTextureSize setting is the actual knob
 	CHUNK_SIZE: 8, // Optimized: Process textures in chunks of 8 for better memory locality
 	ADAPTIVE_CHUNK_SIZE: true, // Enable adaptive chunk sizing based on texture dimensions
 	MEMORY_SAFETY_FACTOR: 0.8 // Use only 80% of estimated available memory
 };
 
+let stream = null;
+
+function handleStream( msg ) {
+
+	if ( msg.stream === 'begin' ) {
+
+		const { width, height, depth } = msg;
+		const target = new OffscreenCanvas( width, height );
+		const context = target.getContext( '2d', { willReadFrequently: true, alpha: true, desynchronized: true } );
+		stream = { width, height, depth, context, data: new Uint8Array( width * height * depth * 4 ) };
+		return;
+
+	}
+
+	const { width, height, depth, context, data } = stream;
+
+	if ( msg.stream === 'layer' ) {
+
+		context.clearRect( 0, 0, width, height );
+		context.drawImage( msg.bitmap, 0, 0 );
+		msg.bitmap.close();
+		data.set( context.getImageData( 0, 0, width, height ).data, width * height * 4 * msg.index );
+		self.postMessage( { stream: 'ack', index: msg.index } );
+		return;
+
+	}
+
+	stream = null;
+	self.postMessage( { data: data.buffer, width, height, depth }, [ data.buffer ] );
+
+}
+
+async function processIntoShared( { shared, width, height, layers } ) {
+
+	if ( canvas.width !== width || canvas.height !== height ) {
+
+		canvas.width = width;
+		canvas.height = height;
+
+	}
+
+	ctx.imageSmoothingEnabled = true;
+	ctx.imageSmoothingQuality = 'high';
+
+	const data = new Uint8Array( shared );
+	const bytes = width * height * 4;
+
+	for ( const { index, texture } of layers ) {
+
+		try {
+
+			await processSingleTextureOptimized( texture, data, index * bytes, width, height );
+
+		} catch ( error ) {
+
+			console.warn( `Failed to process texture ${index}:`, error );
+			data.fill( 0, index * bytes, ( index + 1 ) * bytes );
+
+		}
+
+	}
+
+}
+
 self.onmessage = async function ( e ) {
 
+	if ( e.data.shared ) {
+
+		try {
+
+			if ( ! canvas ) initializeWorker( e.data.maxTextureSize );
+			await processIntoShared( e.data );
+			self.postMessage( { done: true } );
+
+		} catch ( error ) {
+
+			self.postMessage( { error: error.message } );
+
+		}
+
+		return;
+
+	}
+
+	if ( e.data.stream ) {
+
+		try {
+
+			handleStream( e.data );
+
+		} catch ( error ) {
+
+			self.postMessage( { error: error.message } );
+
+		}
+
+		return;
+
+	}
+
 	const { textures, maxTextureSize, method = 'direct-transfer' } = e.data;
 
 	try {
@@ -51,17 +148,6 @@ function initializeWorker( maxTextureSize ) {
 
 async function processTextures( textures, maxTextureSize, method ) {
 
-	// Check if we need to use chunked processing
-	const dimensions = calculateOptimalDimensions( textures, maxTextureSize );
-	const estimatedBytes = dimensions.maxWidth * dimensions.maxHeight * textures.length * 4;
-
-	if ( estimatedBytes > MEMORY_LIMITS.MAX_BYTES_PER_TEXTURE ) {
-
-		console.log( `Large texture array detected (${( estimatedBytes / 1024 / 1024 ).toFixed( 2 )}MB), using chunked processing` );
-		return await processTexturesInChunks( textures, maxTextureSize, method );
-
-	}
-
 	switch ( method ) {
 
 		case 'direct-transfer':

package/src/Stages/PathTracer.js

@@ -118,6 +118,7 @@ export class PathTracer extends PathTracerStage {
 		// so when one lands cannot change the image. { due, read, apply } while one is in flight.
 		this._lockstep = false;
 		this._lockstepRead = null;
+		this._accumulationLockstep = false;
 
 		// Tier-2: last settled active-pixel count (maxRays − frozen), sizes next frame's bounce-0 grid.
 		// 0 until a settled readback lands (and on reset/camera-move/resize) → grid stays full-size until then.
@@ -240,8 +241,8 @@ 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.
+		// The packed light buffer was grow-reallocated at runtime (emissive set grew) or a light list grew —
+		// the compiled kernels still bind the old one, so rebuild before rendering.
 		if ( this._lightBufferRealloc ) {
 
 			if ( this._kernelManager ) this._kernelManager.dispose();
@@ -320,6 +321,7 @@ export class PathTracer extends PathTracerStage {
 		this.frame.value = frameValue;
 		this.seedFrame.value = this._seedTick ++;
 		this.tracedFrames ++;
+		if ( ! this._lockstep ) this._accumulationLockstep = false;
 
 		this._setWfDispatch();
 
@@ -661,6 +663,8 @@ export class PathTracer extends PathTracerStage {
 		this._convergedFraction = state.convergedFraction ?? 0;
 		this._convergedGeometryFraction = state.convergedGeometryFraction ?? 0;
 		this.isComplete = false;
+		// The survivor curve is not in a checkpoint, so a continuation is not the lockstep render.
+		this._accumulationLockstep = false;
 
 	}
 
@@ -711,6 +715,13 @@ export class PathTracer extends PathTracerStage {
 
 	}
 
+	/** Whether the current image was traced in lockstep from a reset made in it; with no sample yet, the setting. */
+	get accumulationLockstep() {
+
+		return this.frameCount > 0 ? this._accumulationLockstep : this._lockstep;
+
+	}
+
 	/**
 	 * While a lockstep readback is due and has not landed, render() traces nothing: await this
 	 * before the next frame. Null otherwise.

package/src/Stages/PathTracerStage.js

@@ -10,7 +10,7 @@ import { RenderStage, StageExecutionMode } from '../Pipeline/RenderStage.js';
 import { CameraOptimizer } from '../Processor/CameraOptimizer.js';
 import { createPerformanceMonitor, calculateAccumulationAlpha, updateCompletionThreshold } from '../Processor/utils.js';
 import { StorageTexturePool } from '../Processor/StorageTexturePool.js';
-import { UniformManager } from '../managers/UniformManager.js';
+import { UniformManager, LIGHT_FLOATS, lightListCapacity } from '../managers/UniformManager.js';
 import { MaterialDataManager } from '../managers/MaterialDataManager.js';
 import { EnvironmentManager } from '../managers/EnvironmentManager.js';
 import { ShaderBuilder } from '../Processor/ShaderBuilder.js';
@@ -218,8 +218,8 @@ 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.
+		// Set when _rebuildLightBuffer had to grow-reallocate the attribute, or a light list grew
+		// (_writeLightList): 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.
@@ -492,53 +492,36 @@ export class PathTracerStage extends RenderStage {
 	 */
 	_updateLightBufferNodes() {
 
-		// Directional lights (12 floats per light — 8 light fields + gobo {index, signed intensity, scale, pad})
-		if ( this.directionalLightsData && this.directionalLightsData.length > 0 ) {
+		this._writeLightList( 'directional', this.directionalLightsData, this.numDirectionalLights );
+		this._writeLightList( 'area', this.areaLightsData, this.numAreaLights );
+		this._writeLightList( 'point', this.pointLightsData, this.numPointLights );
+		this._writeLightList( 'spot', this.spotLightsData, this.numSpotLights );
 
-			this.directionalLightsBufferNode.array = Array.from( this.directionalLightsData );
-			this.numDirectionalLights.value = Math.floor( this.directionalLightsData.length / 12 );
-
-		} else {
-
-			this.numDirectionalLights.value = 0;
-
-		}
-
-		// Area lights (16 floats per light — 13 base + normalize/spread/shape)
-		if ( this.areaLightsData && this.areaLightsData.length > 0 ) {
-
-			this.areaLightsBufferNode.array = Array.from( this.areaLightsData );
-			this.numAreaLights.value = Math.floor( this.areaLightsData.length / 16 );
-
-		} else {
-
-			this.numAreaLights.value = 0;
-
-		}
+	}
 
-		// Point lights (9 floats per light)
-		if ( this.pointLightsData && this.pointLightsData.length > 0 ) {
+	/**
+	 * In place, because the shader bakes the list's length: sized per scene it compiled a program per
+	 * light count, and three.js uploads only what fits the length it was built with, so a light added
+	 * after a build was dropped. A list grows only past its capacity, and that rebuilds the kernels.
+	 * @private
+	 */
+	_writeLightList( type, data, count ) {
 
-			this.pointLightsBufferNode.array = Array.from( this.pointLightsData );
-			this.numPointLights.value = Math.floor( this.pointLightsData.length / 9 );
+		const floats = LIGHT_FLOATS[ type ];
+		const node = this[ `${type}LightsBufferNode` ];
+		const lights = data ? Math.floor( data.length / floats ) : 0;
+		const used = lights * floats;
 
-		} else {
+		if ( used > node.array.length ) {
 
-			this.numPointLights.value = 0;
+			node.array = new Float32Array( lightListCapacity( type, lights ) * floats );
+			this._lightBufferRealloc = true;
 
 		}
 
-		// Spot lights (20 floats per light — 14 light fields + gobo {idx, signed intensity} + IES {idx, intensity} + 2 reserved)
-		if ( this.spotLightsData && this.spotLightsData.length > 0 ) {
-
-			this.spotLightsBufferNode.array = Array.from( this.spotLightsData );
-			this.numSpotLights.value = Math.floor( this.spotLightsData.length / 20 );
-
-		} else {
-
-			this.numSpotLights.value = 0;
-
-		}
+		if ( used > 0 ) node.array.set( data.subarray( 0, used ) );
+		node.array.fill( 0, used );
+		count.value = lights;
 
 	}
 
@@ -565,6 +548,7 @@ export class PathTracerStage extends RenderStage {
 
 		// Only deterministic mode and lockstep readbacks rewind the seed axis; see _pinSeedToFrame.
 		if ( this._pinSeedToFrame || this._lockstep ) this._seedTick = 0;
+		this._accumulationLockstep = !! this._lockstep;
 
 	}
 
@@ -1288,6 +1272,7 @@ export class PathTracerStage extends RenderStage {
 
 			this.createStorageTextures( width, height );
 			this.frameCount = 0;
+			this._accumulationLockstep = false;
 
 		}