rayzee 5.6.0 → 5.6.1

package/package.json

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

package/src/Passes/AIUpscaler.js

@@ -104,6 +104,7 @@ export class AIUpscaler extends EventDispatcher {
 		this._worker = null;
 		this._currentModelUrl = null;
 		this._tileId = 0;
+		this._pendingWorkerHandlers = new Set();
 
 		// Alpha channel cache (bilinear-upscaled from source, applied per tile)
 		this._upscaledAlpha = null;
@@ -315,6 +316,7 @@ export class AIUpscaler extends EventDispatcher {
 
 			this._capturedSource = null;
 			this._upscaledAlpha = null;
+			this._backupCanvas = null;
 
 			// Only clean up if abort() hasn't already done it
 			if ( this.state.isUpscaling ) {
@@ -334,6 +336,7 @@ export class AIUpscaler extends EventDispatcher {
 		if ( ! this.state.isUpscaling ) return;
 
 		this.state.abortController?.abort();
+		this._cleanupPendingWorkerHandlers();
 
 		// Restore input visibility and canvas state
 		this.input.style.opacity = '1';
@@ -610,6 +613,7 @@ export class AIUpscaler extends EventDispatcher {
 
 				if ( e.data.id !== id ) return;
 				this._worker.removeEventListener( 'message', handler );
+				this._pendingWorkerHandlers.delete( handler );
 
 				if ( e.data.type === 'inferred' ) {
 
@@ -623,6 +627,7 @@ export class AIUpscaler extends EventDispatcher {
 
 			};
 
+			this._pendingWorkerHandlers.add( handler );
 			this._worker.addEventListener( 'message', handler );
 			this._worker.postMessage(
 				{ type: 'infer', tileData, width, height, id },
@@ -858,9 +863,26 @@ export class AIUpscaler extends EventDispatcher {
 
 	// ─── Disposal ─────────────────────────────────────────────────────────────
 
+	_cleanupPendingWorkerHandlers() {
+
+		if ( this._worker ) {
+
+			for ( const handler of this._pendingWorkerHandlers ) {
+
+				this._worker.removeEventListener( 'message', handler );
+
+			}
+
+		}
+
+		this._pendingWorkerHandlers.clear();
+
+	}
+
 	async dispose() {
 
 		this.abort();
+		this._cleanupPendingWorkerHandlers();
 
 		if ( this._worker ) {
 

package/src/Passes/OIDNDenoiser.js

@@ -87,6 +87,7 @@ export class OIDNDenoiser extends EventDispatcher {
 		// renderer.getArrayBufferAsync because the source is a raw GPUBuffer,
 		// not a Three.js BufferAttribute.
 		this._alphaReadbackBuffer = null;
+		this._alphaReadbackMapped = false;
 
 		// Cached alpha channel from the input color buffer (OIDN discards alpha)
 		this._cachedAlpha = null;
@@ -108,6 +109,9 @@ export class OIDNDenoiser extends EventDispatcher {
 			abortController: null
 		};
 
+		// Track in-flight tile staging buffers so they can be destroyed on abort
+		this._pendingStagingBuffers = new Set();
+
 		this.currentTZAUrl = null;
 		this.unet = null;
 
@@ -514,7 +518,22 @@ export class OIDNDenoiser extends EventDispatcher {
 		this._gpuInputBuffers.albedo?.destroy();
 		this._gpuInputBuffers.normal?.destroy();
 		this._gpuInputPadBuffer?.destroy();
+
+		// Unmap before destroying if a mapAsync resolved but unmap hasn't been called yet.
+		// If mapAsync is still pending, destroy() will reject it — _cacheInputAlpha's
+		// catch handler covers that case.
+		if ( this._alphaReadbackMapped && this._alphaReadbackBuffer ) {
+
+			try {
+
+				this._alphaReadbackBuffer.unmap();
+
+			} catch { /* already unmapped or destroyed */ }
+
+		}
+
 		this._alphaReadbackBuffer?.destroy();
+		this._alphaReadbackMapped = false;
 		this._gpuInputBuffers = { color: null, albedo: null, normal: null };
 		this._gpuInputPadBuffer = null;
 		this._gpuInputPaddedRowBytes = 0;
@@ -550,7 +569,19 @@ export class OIDNDenoiser extends EventDispatcher {
 		enc.copyBufferToBuffer( this._gpuInputBuffers.color, 0, staging, 0, byteSize );
 		device.queue.submit( [ enc.finish() ] );
 
-		await staging.mapAsync( GPUMapMode.READ );
+		this._alphaReadbackMapped = true;
+		try {
+
+			await staging.mapAsync( GPUMapMode.READ );
+
+		} catch {
+
+			// Buffer was destroyed while mapAsync was pending (resize or dispose)
+			this._alphaReadbackMapped = false;
+			return;
+
+		}
+
 		const f32 = new Float32Array( staging.getMappedRange() );
 
 		// Extract alpha channel as uint8 (pre-multiplied is not needed — alpha is 0 or 1)
@@ -563,6 +594,7 @@ export class OIDNDenoiser extends EventDispatcher {
 		}
 
 		staging.unmap();
+		this._alphaReadbackMapped = false;
 
 		this._cachedAlpha = alpha;
 		this._cachedAlphaWidth = width;
@@ -653,6 +685,8 @@ export class OIDNDenoiser extends EventDispatcher {
 						usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
 					} );
 
+					this._pendingStagingBuffers.add( staging );
+
 					// Copy each tile row from its position in the full output buffer
 					const enc = device.createCommandEncoder();
 
@@ -710,8 +744,15 @@ export class OIDNDenoiser extends EventDispatcher {
 
 						staging.unmap();
 						staging.destroy();
+						this._pendingStagingBuffers.delete( staging );
 						this.ctx.putImageData( tileImageData, tile.x, tile.y );
 
+					} ).catch( () => {
+
+						// mapAsync rejected (abort or GPU lost) — destroy the buffer
+						staging.destroy();
+						this._pendingStagingBuffers.delete( staging );
+
 					} );
 
 				}
@@ -745,44 +786,50 @@ export class OIDNDenoiser extends EventDispatcher {
 			usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
 		} );
 
-		// Queue a copy from the oidn output buffer (STORAGE|COPY_SRC) to staging
-		const encoder = device.createCommandEncoder( { label: 'oidn-readback' } );
-		encoder.copyBufferToBuffer( gpuBuffer, 0, stagingBuffer, 0, byteSize );
-		device.queue.submit( [ encoder.finish() ] );
+		try {
+
+			// Queue a copy from the oidn output buffer (STORAGE|COPY_SRC) to staging
+			const encoder = device.createCommandEncoder( { label: 'oidn-readback' } );
+			encoder.copyBufferToBuffer( gpuBuffer, 0, stagingBuffer, 0, byteSize );
+			device.queue.submit( [ encoder.finish() ] );
+
+			await stagingBuffer.mapAsync( GPUMapMode.READ );
+			const float32 = new Float32Array( stagingBuffer.getMappedRange() );
+
+			const imageData = new ImageData( width, height );
+			const exposure = this.getExposure();
+			const saturation = this.getSaturation();
+			const tmFn = TONE_MAP_FNS.get( this.getToneMapping() ) || TONE_MAP_FNS.get( ACESFilmicToneMapping );
+			const alpha = this._cachedAlpha;
 
-		await stagingBuffer.mapAsync( GPUMapMode.READ );
-		const float32 = new Float32Array( stagingBuffer.getMappedRange() );
+			for ( let i = 0, len = float32.length; i < len; i += 4 ) {
 
-		const imageData = new ImageData( width, height );
-		const exposure = this.getExposure();
-		const saturation = this.getSaturation();
-		const tmFn = TONE_MAP_FNS.get( this.getToneMapping() ) || TONE_MAP_FNS.get( ACESFilmicToneMapping );
-		const alpha = this._cachedAlpha;
+				// Exposure + saturation (pre-tonemap, matching Display)
+				let er = float32[ i ] * exposure, eg = float32[ i + 1 ] * exposure, eb = float32[ i + 2 ] * exposure;
+				if ( saturation !== 1.0 ) {
 
-		for ( let i = 0, len = float32.length; i < len; i += 4 ) {
+					_tmOut[ 0 ] = er; _tmOut[ 1 ] = eg; _tmOut[ 2 ] = eb;
+					applySaturation( _tmOut, saturation );
+					er = _tmOut[ 0 ]; eg = _tmOut[ 1 ]; eb = _tmOut[ 2 ];
 
-			// Exposure + saturation (pre-tonemap, matching Display)
-			let er = float32[ i ] * exposure, eg = float32[ i + 1 ] * exposure, eb = float32[ i + 2 ] * exposure;
-			if ( saturation !== 1.0 ) {
+				}
 
-				_tmOut[ 0 ] = er; _tmOut[ 1 ] = eg; _tmOut[ 2 ] = eb;
-				applySaturation( _tmOut, saturation );
-				er = _tmOut[ 0 ]; eg = _tmOut[ 1 ]; eb = _tmOut[ 2 ];
+				tmFn( er, eg, eb, 1.0, _tmOut );
+				imageData.data[ i ] = _tmOut[ 0 ] ** SRGB_GAMMA * 255 | 0;
+				imageData.data[ i + 1 ] = _tmOut[ 1 ] ** SRGB_GAMMA * 255 | 0;
+				imageData.data[ i + 2 ] = _tmOut[ 2 ] ** SRGB_GAMMA * 255 | 0;
+				imageData.data[ i + 3 ] = alpha ? alpha[ i >> 2 ] : 255;
 
 			}
 
-			tmFn( er, eg, eb, 1.0, _tmOut );
-			imageData.data[ i ] = _tmOut[ 0 ] ** SRGB_GAMMA * 255 | 0;
-			imageData.data[ i + 1 ] = _tmOut[ 1 ] ** SRGB_GAMMA * 255 | 0;
-			imageData.data[ i + 2 ] = _tmOut[ 2 ] ** SRGB_GAMMA * 255 | 0;
-			imageData.data[ i + 3 ] = alpha ? alpha[ i >> 2 ] : 255;
+			stagingBuffer.unmap();
+			this.ctx.putImageData( imageData, 0, 0 );
 
-		}
+		} finally {
 
-		stagingBuffer.unmap();
-		stagingBuffer.destroy();
+			stagingBuffer.destroy();
 
-		this.ctx.putImageData( imageData, 0, 0 );
+		}
 
 	}
 
@@ -793,6 +840,9 @@ export class OIDNDenoiser extends EventDispatcher {
 		// Signal abort to current operation
 		this.state.abortController?.abort();
 
+		// Destroy any in-flight tile staging buffers that mapAsync won't resolve
+		this._destroyPendingStagingBuffers();
+
 		// Restore input visibility
 		this.input.style.opacity = '1';
 
@@ -896,11 +946,26 @@ export class OIDNDenoiser extends EventDispatcher {
 
 	}
 
+	_destroyPendingStagingBuffers() {
+
+		for ( const buf of this._pendingStagingBuffers ) {
+
+			buf.destroy();
+
+		}
+
+		this._pendingStagingBuffers.clear();
+
+	}
+
 	dispose() {
 
 		// Abort any ongoing operations
 		this.abort();
 
+		// Destroy any remaining staging buffers
+		this._destroyPendingStagingBuffers();
+
 		// Dispose resources
 		this.unet?.dispose();
 		this._destroyGPUInputBuffers();

package/src/Pipeline/RenderPipeline.js

@@ -120,6 +120,9 @@ export class RenderPipeline {
 
 			}
 
+			// Prune stale stats entry for removed stage
+			this.stats.timings.delete( stage.name );
+
 			return true;
 
 		}

package/src/Stages/ASVGF.js

@@ -832,6 +832,24 @@ export class ASVGF extends RenderStage {
 		this._heatmapComputeNode?.dispose();
 		this._heatmapStorageTex?.dispose();
 		this.heatmapTarget?.dispose();
+
+		// Dispose input TextureNode objects
+		this._colorTexNode?.dispose();
+		this._normalDepthTexNode?.dispose();
+		this._motionTexNode?.dispose();
+		this._readTemporalTexNode?.dispose();
+		this._readPrevNDTexNode?.dispose();
+		this._gradientReadTexNode?.dispose();
+
+		// Dispose heatmap TextureNode objects
+		this._heatmapRawColorTexNode?.dispose();
+		this._heatmapColorTexNode?.dispose();
+		this._heatmapTemporalTexNode?.dispose();
+		this._heatmapNDTexNode?.dispose();
+		this._heatmapMotionTexNode?.dispose();
+		this._heatmapGradientTexNode?.dispose();
+
+		// dispose() also removes the DOM node
 		this.heatmapHelper?.dispose();
 
 	}

package/src/Stages/AdaptiveSampling.js

@@ -483,6 +483,7 @@ export class AdaptiveSampling extends RenderStage {
 		this._heatmapStorageTex?.dispose();
 		this._outputStorageTex?.dispose();
 		this.heatmapTarget?.dispose();
+		this._varianceTexNode?.dispose();
 		this.helper?.dispose();
 
 		this._computeNode = null;
@@ -490,6 +491,7 @@ export class AdaptiveSampling extends RenderStage {
 		this._heatmapStorageTex = null;
 		this._outputStorageTex = null;
 		this.heatmapTarget = null;
+		this._varianceTexNode = null;
 		this.helper = null;
 
 	}

package/src/Stages/AutoExposure.js

@@ -698,6 +698,8 @@ export class AutoExposure extends RenderStage {
 		this._reductionStorageTex?.dispose();
 		this._reductionReadTarget?.dispose();
 		this._readbackBuffer?.dispose();
+		this._inputTexNode?.dispose();
+		this._reductionReadTexNode?.dispose();
 
 	}
 

package/src/Stages/BilateralFilter.js

@@ -321,6 +321,8 @@ export class BilateralFilter extends RenderStage {
 		this._computeNodeB?.dispose();
 		this._storageTexA?.dispose();
 		this._storageTexB?.dispose();
+		this._readTexNode?.dispose();
+		this._normalDepthTexNode?.dispose();
 
 	}
 

package/src/Stages/Display.js

@@ -110,6 +110,7 @@ export class Display extends RenderStage {
 
 	dispose() {
 
+		this._displayTexNode?.dispose();
 		this.displayMaterial?.dispose();
 		// QuadMesh extends Mesh — no dispose method; material already disposed.
 		this.displayQuad = null;

package/src/Stages/EdgeFilter.js

@@ -275,6 +275,7 @@ export class EdgeFilter extends RenderStage {
 		this._computeNode?.dispose();
 		this._outputStorageTex?.dispose();
 		this.outputTarget?.dispose();
+		this._inputTexNode?.dispose();
 
 	}
 

package/src/Stages/MotionVector.js

@@ -547,6 +547,7 @@ export class MotionVector extends RenderStage {
 		this._worldSpaceStorageTex?.dispose();
 		this.screenSpaceTarget?.dispose();
 		this.worldSpaceTarget?.dispose();
+		this._normalDepthTexNode?.dispose();
 
 	}
 

package/src/Stages/SSRC.js

@@ -194,6 +194,12 @@ export class SSRC extends RenderStage {
 		this._prevNDTexA.dispose();
 		this._prevNDTexB.dispose();
 		this._outputTex.dispose();
+		this._colorTexNode?.dispose();
+		this._ndTexNode?.dispose();
+		this._motionTexNode?.dispose();
+		this._readCacheTexNode?.dispose();
+		this._readPrevNDTexNode?.dispose();
+		this._readPass1CacheTexNode?.dispose();
 
 	}
 

package/src/Stages/Variance.js

@@ -371,6 +371,9 @@ export class Variance extends RenderStage {
 		this._computeNodeB?.dispose();
 		this._storageTexA?.dispose();
 		this._storageTexB?.dispose();
+		this._colorTexNode?.dispose();
+		this._readTexNodeA?.dispose();
+		this._readTexNodeB?.dispose();
 
 	}
 

package/src/managers/DenoisingManager.js

@@ -54,6 +54,17 @@ export class DenoisingManager extends EventDispatcher {
 		this._lastRenderWidth = 0;
 		this._lastRenderHeight = 0;
 
+		// Track the current completion-chain listener so it can be removed on re-trigger
+		this._pendingStartUpscaler = null;
+
+		// Bound event forwarding handlers (stored for removal on re-setup / dispose)
+		this._denoiserStartHandler = null;
+		this._denoiserEndHandler = null;
+		this._upscalerResChangedHandler = null;
+		this._upscalerStartHandler = null;
+		this._upscalerProgressHandler = null;
+		this._upscalerEndHandler = null;
+
 	}
 
 	_createDenoiserCanvas( mainCanvas ) {
@@ -146,11 +157,13 @@ export class DenoisingManager extends EventDispatcher {
 
 		this.denoiser.enabled = DEFAULT_STATE.enableOIDN;
 
-		// Forward lifecycle events
-		this.denoiser.addEventListener( 'start', () =>
-			this.dispatchEvent( { type: EngineEvents.DENOISING_START } ) );
-		this.denoiser.addEventListener( 'end', () =>
-			this.dispatchEvent( { type: EngineEvents.DENOISING_END } ) );
+		// Forward lifecycle events (store refs for removal on re-setup / dispose)
+		this._denoiserStartHandler = () =>
+			this.dispatchEvent( { type: EngineEvents.DENOISING_START } );
+		this._denoiserEndHandler = () =>
+			this.dispatchEvent( { type: EngineEvents.DENOISING_END } );
+		this.denoiser.addEventListener( 'start', this._denoiserStartHandler );
+		this.denoiser.addEventListener( 'end', this._denoiserEndHandler );
 
 	}
 
@@ -189,15 +202,19 @@ export class DenoisingManager extends EventDispatcher {
 
 		this.upscaler.enabled = DEFAULT_STATE.enableUpscaler || false;
 
-		// Forward lifecycle events
-		this.upscaler.addEventListener( 'resolution_changed', ( e ) =>
-			this.dispatchEvent( { type: 'resolution_changed', width: e.width, height: e.height } ) );
-		this.upscaler.addEventListener( 'start', () =>
-			this.dispatchEvent( { type: EngineEvents.UPSCALING_START } ) );
-		this.upscaler.addEventListener( 'progress', ( e ) =>
-			this.dispatchEvent( { type: EngineEvents.UPSCALING_PROGRESS, progress: e.progress } ) );
-		this.upscaler.addEventListener( 'end', () =>
-			this.dispatchEvent( { type: EngineEvents.UPSCALING_END } ) );
+		// Forward lifecycle events (store refs for removal on re-setup / dispose)
+		this._upscalerResChangedHandler = ( e ) =>
+			this.dispatchEvent( { type: 'resolution_changed', width: e.width, height: e.height } );
+		this._upscalerStartHandler = () =>
+			this.dispatchEvent( { type: EngineEvents.UPSCALING_START } );
+		this._upscalerProgressHandler = ( e ) =>
+			this.dispatchEvent( { type: EngineEvents.UPSCALING_PROGRESS, progress: e.progress } );
+		this._upscalerEndHandler = () =>
+			this.dispatchEvent( { type: EngineEvents.UPSCALING_END } );
+		this.upscaler.addEventListener( 'resolution_changed', this._upscalerResChangedHandler );
+		this.upscaler.addEventListener( 'start', this._upscalerStartHandler );
+		this.upscaler.addEventListener( 'progress', this._upscalerProgressHandler );
+		this.upscaler.addEventListener( 'end', this._upscalerEndHandler );
 
 	}
 
@@ -353,8 +370,23 @@ export class DenoisingManager extends EventDispatcher {
 	 * @param {Function}         params.isStillComplete   - () => boolean, guard for async race
 	 * @param {import('../Pipeline/PipelineContext.js').PipelineContext} params.context
 	 */
+	_cleanupCompletionListener() {
+
+		if ( this._pendingStartUpscaler && this.denoiser ) {
+
+			this.denoiser.removeEventListener( 'end', this._pendingStartUpscaler );
+
+		}
+
+		this._pendingStartUpscaler = null;
+
+	}
+
 	onRenderComplete( { isStillComplete, context } ) {
 
+		// Remove any stale completion-chain listener from a previous render cycle
+		this._cleanupCompletionListener();
+
 		// Show post-process canvas if any post-process is enabled
 		if ( ( this.denoiser?.enabled || this.upscaler?.enabled ) && this.denoiserCanvas ) {
 
@@ -365,6 +397,8 @@ export class DenoisingManager extends EventDispatcher {
 		// Chain: denoise first (if enabled), then upscale (if enabled)
 		const startUpscaler = () => {
 
+			this._pendingStartUpscaler = null;
+
 			if ( ! isStillComplete() ) return;
 
 			if ( this.upscaler?.enabled ) {
@@ -377,6 +411,7 @@ export class DenoisingManager extends EventDispatcher {
 
 		if ( this.denoiser?.enabled ) {
 
+			this._pendingStartUpscaler = startUpscaler;
 			this.denoiser.addEventListener( 'end', startUpscaler, { once: true } );
 			this.denoiser.start();
 
@@ -401,6 +436,9 @@ export class DenoisingManager extends EventDispatcher {
 	 */
 	abort( mainCanvas ) {
 
+		// Remove stale completion-chain listener before aborting
+		this._cleanupCompletionListener();
+
 		if ( mainCanvas ) mainCanvas.style.opacity = '1';
 
 		if ( this.upscaler ) this.upscaler.abort();
@@ -416,8 +454,13 @@ export class DenoisingManager extends EventDispatcher {
 
 	dispose() {
 
+		// Remove pending completion-chain listener
+		this._cleanupCompletionListener();
+
 		if ( this.denoiser ) {
 
+			if ( this._denoiserStartHandler ) this.denoiser.removeEventListener( 'start', this._denoiserStartHandler );
+			if ( this._denoiserEndHandler ) this.denoiser.removeEventListener( 'end', this._denoiserEndHandler );
 			this.denoiser.dispose();
 			this.denoiser = null;
 
@@ -425,11 +468,22 @@ export class DenoisingManager extends EventDispatcher {
 
 		if ( this.upscaler ) {
 
+			if ( this._upscalerResChangedHandler ) this.upscaler.removeEventListener( 'resolution_changed', this._upscalerResChangedHandler );
+			if ( this._upscalerStartHandler ) this.upscaler.removeEventListener( 'start', this._upscalerStartHandler );
+			if ( this._upscalerProgressHandler ) this.upscaler.removeEventListener( 'progress', this._upscalerProgressHandler );
+			if ( this._upscalerEndHandler ) this.upscaler.removeEventListener( 'end', this._upscalerEndHandler );
 			this.upscaler.dispose();
 			this.upscaler = null;
 
 		}
 
+		this._denoiserStartHandler = null;
+		this._denoiserEndHandler = null;
+		this._upscalerResChangedHandler = null;
+		this._upscalerStartHandler = null;
+		this._upscalerProgressHandler = null;
+		this._upscalerEndHandler = null;
+
 		if ( this.denoiserCanvas?.parentNode ) {
 
 			this.denoiserCanvas.parentNode.removeChild( this.denoiserCanvas );