rayzee 7.10.0 → 7.10.2

package/package.json

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

package/src/EngineDefaults.js

@@ -151,11 +151,6 @@ export const ENGINE_DEFAULTS = {
 	asvgfQualityPreset: 'medium',
 	showAsvgfHeatmap: false,
 
-	// SSRC settings
-	ssrcTemporalAlpha: 0.1,
-	ssrcSpatialRadius: 4,
-	ssrcSpatialWeight: 0.4,
-
 	// Auto-exposure settings
 	autoExposure: false,
 	autoExposureKeyValue: 0.18,

package/src/PathTracerApp.js

@@ -13,7 +13,6 @@ import { Variance } from './Stages/Variance.js';
 import { BilateralFilter } from './Stages/BilateralFilter.js';
 import { EdgeFilter } from './Stages/EdgeFilter.js';
 import { AutoExposure } from './Stages/AutoExposure.js';
-import { SSRC } from './Stages/SSRC.js';
 import { Compositor } from './Stages/Compositor.js';
 import { RenderPipeline } from './Pipeline/RenderPipeline.js';
 import { CompletionTracker } from './Pipeline/CompletionTracker.js';
@@ -927,6 +926,7 @@ export class PathTracerApp extends EventDispatcher {
 	async _finishRebuildNoReframe( eventPayload ) {
 
 		await this.loadSceneData(); // emits 'SceneRebuild'
+		this._recalibrateControlLimits(); // scene bounds changed — retune zoom limits + near/far (no camera move)
 		this.pipeline?.eventBus.emit( 'autoexposure:resetHistory' );
 		this.reset();
 		if ( eventPayload ) this.dispatchEvent( eventPayload );
@@ -1676,7 +1676,6 @@ export class PathTracerApp extends EventDispatcher {
 		this.pipeline.addStage( this.stages.pathTracer );
 		this.pipeline.addStage( this.stages.normalDepth );
 		this.pipeline.addStage( this.stages.motionVector );
-		this.pipeline.addStage( this.stages.ssrc );
 		this.pipeline.addStage( this.stages.asvgf );
 		this.pipeline.addStage( this.stages.variance );
 		this.pipeline.addStage( this.stages.bilateralFilter );
@@ -1892,7 +1891,6 @@ export class PathTracerApp extends EventDispatcher {
 		this.stages.motionVector = new MotionVector( this.renderer, this.cameraManager.camera, {
 			pathTracer: this.stages.pathTracer
 		} );
-		this.stages.ssrc = new SSRC( this.renderer, { enabled: false } );
 		this.stages.asvgf = new ASVGF( this.renderer, { enabled: false } );
 		this.stages.variance = new Variance( this.renderer, { enabled: false } );
 		this.stages.bilateralFilter = new BilateralFilter( this.renderer, { enabled: false } );
@@ -1920,7 +1918,6 @@ export class PathTracerApp extends EventDispatcher {
 				variance: this.stages.variance,
 				bilateralFilter: this.stages.bilateralFilter,
 				edgeFilter: this.stages.edgeFilter,
-				ssrc: this.stages.ssrc,
 				autoExposure: this.stages.autoExposure,
 				compositor: this.stages.compositor,
 			},
@@ -2023,6 +2020,63 @@ export class PathTracerApp extends EventDispatcher {
 
 	}
 
+	/**
+	 * Recompute OrbitControls zoom limits (+ default-camera near/far) from the CURRENT
+	 * model bounds without moving the camera or its target. Called after a dynamic
+	 * add/remove (the reframe-free path) so an enlarged scene stays reachable and
+	 * unclipped, and a shrunken one re-tightens. The replace-load (reframe) path owns
+	 * this via onModelLoad(). Bounds cover only the loaded model roots
+	 * (__rayzeeSceneObject) so the oversized, usually-hidden Ground plane can't inflate them.
+	 */
+	_recalibrateControlLimits() {
+
+		if ( ! this.meshScene || ! this.cameraManager ) return;
+
+		const bounds = new Box3();
+		const tmp = new Box3();
+		for ( const child of this.meshScene.children ) {
+
+			if ( ! child.userData?.__rayzeeSceneObject ) continue;
+			tmp.setFromObject( child );
+			if ( ! tmp.isEmpty() ) bounds.union( tmp );
+
+		}
+
+		if ( bounds.isEmpty() ) return;
+
+		const maxDim = Math.max(
+			bounds.max.x - bounds.min.x,
+			bounds.max.y - bounds.min.y,
+			bounds.max.z - bounds.min.z,
+		);
+		if ( ! Number.isFinite( maxDim ) || maxDim <= 0 ) return;
+
+		const { camera, controls } = this.cameraManager;
+
+		// Same framing distance onModelLoad() uses for the initial reframe.
+		const fov = camera.fov * ( Math.PI / 180 );
+		const cameraDistance = Math.abs( maxDim / Math.sin( fov / 2 ) / 2 );
+
+		// Keep the (grown/shrunken) scene inside the frustum. Only touch near/far when the
+		// default orbit camera is active — don't stomp an authored model camera's frustum.
+		if ( this.cameraManager.currentCameraIndex === 0 ) {
+
+			camera.near = maxDim / 100;
+			camera.far = maxDim * 100;
+			camera.updateProjectionMatrix();
+
+		}
+
+		// Reframe-free: never clamp past where the camera currently sits, so the rebuild
+		// can't yank it (e.g. when the scene shrinks after a removal).
+		const currentDist = camera.position.distanceTo( controls.target );
+		controls.minDistance = Math.min( maxDim / 1000, currentDist );
+		controls.maxDistance = Math.max( cameraDistance * 10, currentDist * 1.1 );
+
+		controls.update();
+
+	}
+
 	/**
 	 * Forwards events from a source EventDispatcher to this app instance.
 	 */

package/src/Processor/TextureCreator.js

@@ -366,6 +366,21 @@ class TextureCache {
 
 		if ( this.cache.has( key ) ) {
 
+			const texture = this.cache.get( key );
+
+			// A pool-backed texture disposed out-of-band (e.g. SceneProcessor._disposeBucketTextures
+			// on a scene rebuild) has returned its backing buffer to the SmartBufferPool — a later
+			// build may have already reused/overwritten it, so its pixels are now garbage. Never hand
+			// it back: drop the stale entry and force a fresh rebuild. (dispose() nulls userData.buffer.)
+			if ( texture?.userData && texture.userData.buffer === null ) {
+
+				this.cache.delete( key );
+				const stale = this.accessOrder.indexOf( key );
+				if ( stale > - 1 ) this.accessOrder.splice( stale, 1 );
+				return null;
+
+			}
+
 			// Move to end (most recently used)
 			const index = this.accessOrder.indexOf( key );
 			if ( index > - 1 ) {
@@ -379,7 +394,7 @@ class TextureCache {
 			// Return cached texture directly — clone() fails on large DataArrayTextures
 			// because Three.js's copy() calls JSON.stringify on the data array.
 			// Each map type stores its own reference so shared instances are safe.
-			return this.cache.get( key );
+			return texture;
 
 		}
 

package/src/Stages/Compositor.js

@@ -59,7 +59,6 @@ export class Compositor extends RenderStage {
 			|| context.getTexture( 'edgeFiltering:output' )
 			|| context.getTexture( 'bilateralFiltering:output' )
 			|| context.getTexture( 'asvgf:output' )
-			|| context.getTexture( 'ssrc:output' )
 			|| context.getTexture( 'pathtracer:color' );
 
 	}

package/src/TSL/Common.js

@@ -490,20 +490,3 @@ export const getShadowMaterial = Fn( ( [ materialIndex, materialBuffer ] ) => {
 	} );
 
 } );
-
-// ── Edge-stopping weight (normal + depth) ──────────────────────────────────
-// Used by ASVGF and SSRC for temporal/spatial reprojection edge-stopping.
-
-export const normalDepthWeight = /*@__PURE__*/ wgslFn( `
-	fn normalDepthWeight(
-		n1: vec3f, n2: vec3f,
-		d1: f32, d2: f32,
-		phiN: f32, phiD: f32
-	) -> f32 {
-
-		let normalW = pow( clamp( dot( n1, n2 ), 0.0, 1.0 ), phiN );
-		let depthW = exp( -abs( d1 - d2 ) / max( phiD, 0.001 ) );
-		return normalW * depthW;
-
-	}
-` );

package/src/managers/DenoisingManager.js

@@ -6,7 +6,7 @@ import { ENGINE_DEFAULTS as DEFAULT_STATE, ASVGF_QUALITY_PRESETS } from '../Engi
 
 /**
  * Orchestrates all denoising, post-processing, and AI upscaling:
- *   - Real-time denoiser strategy switching (ASVGF / SSRC / EdgeAware / None)
+ *   - Real-time denoiser strategy switching (ASVGF / EdgeAware / None)
  *   - OIDN (offline denoise on render completion)
  *   - AI Upscaler
  *   - Auto-exposure coordination
@@ -41,7 +41,7 @@ export class DenoisingManager extends EventDispatcher {
 		this.pipeline = pipeline;
 
 		// Stage references — only used internally for orchestration
-		this._stages = stages; // { pathTracer, asvgf, variance, bilateralFilter, edgeFilter, ssrc, autoExposure, compositor }
+		this._stages = stages; // { pathTracer, asvgf, variance, bilateralFilter, edgeFilter, autoExposure, compositor }
 
 		this._getExposure = getExposure;
 		this._getSaturation = getSaturation;
@@ -222,7 +222,7 @@ export class DenoisingManager extends EventDispatcher {
 
 	/**
 	 * Switches the real-time denoiser strategy.
-	 * @param {string} strategy   - 'none' | 'asvgf' | 'ssrc' | 'edgeaware'
+	 * @param {string} strategy   - 'none' | 'asvgf' | 'edgeaware'
 	 * @param {string} [asvgfPreset] - ASVGF quality preset when strategy is 'asvgf'
 	 */
 	setDenoiserStrategy( strategy, asvgfPreset ) {
@@ -234,7 +234,6 @@ export class DenoisingManager extends EventDispatcher {
 		if ( s.variance ) s.variance.enabled = false;
 		if ( s.bilateralFilter ) s.bilateralFilter.enabled = false;
 		if ( s.edgeFilter ) s.edgeFilter.setFilteringEnabled( false );
-		if ( s.ssrc ) s.ssrc.enabled = false;
 
 		this._clearDenoiserTextures();
 
@@ -248,10 +247,6 @@ export class DenoisingManager extends EventDispatcher {
 				this._applyASVGFPreset( asvgfPreset || 'medium' );
 				break;
 
-			case 'ssrc':
-				if ( s.ssrc ) s.ssrc.enabled = true;
-				break;
-
 			case 'edgeaware':
 				if ( s.edgeFilter ) s.edgeFilter.setFilteringEnabled( true );
 				break;
@@ -325,7 +320,7 @@ export class DenoisingManager extends EventDispatcher {
 	 * navigation and frees their textures. Call after any consumer toggle.
 	 *
 	 * MotionVector requires NormalDepth (reads pathtracer:normalDepth) and its
-	 * consumers (ASVGF, SSRC) are a subset of NormalDepth's, so NormalDepth is
+	 * consumers (ASVGF) are a subset of NormalDepth's, so NormalDepth is
 	 * always enabled whenever MotionVector is. Adaptive sampling / Variance / OIDN
 	 * do NOT read these signals, so they don't keep the G-buffer alive.
 	 */
@@ -335,9 +330,9 @@ export class DenoisingManager extends EventDispatcher {
 		const nd = s.normalDepth;
 		const mv = s.motionVector;
 
-		// motionVector:* consumed by ASVGF + SSRC
-		const motionNeeded = !! ( s.asvgf?.enabled || s.ssrc?.enabled );
-		// pathtracer:normalDepth consumed by ASVGF, SSRC, EdgeFilter, BilateralFilter
+		// motionVector:* consumed by ASVGF
+		const motionNeeded = !! ( s.asvgf?.enabled );
+		// pathtracer:normalDepth consumed by ASVGF, EdgeFilter, BilateralFilter
 		const normalNeeded = motionNeeded || !! ( s.edgeFilter?.enabled || s.bilateralFilter?.enabled );
 
 		if ( nd ) {
@@ -366,7 +361,7 @@ export class DenoisingManager extends EventDispatcher {
 		}
 
 		// PathTracer's aux MRT (normalDepth + albedo) is consumed by the real-time denoisers (ASVGF/
-		// BilateralFilter read albedo; ASVGF/SSRC/EdgeFilter read normalDepth) and by OIDN (reads the
+		// BilateralFilter read albedo; ASVGF/EdgeFilter read normalDepth) and by OIDN (reads the
 		// MRT read-targets directly). When none are active the wavefront skips those writes entirely.
 		s.pathTracer?.setAuxGBufferEnabled?.( normalNeeded || !! this.denoiser?.enabled );
 
@@ -374,7 +369,7 @@ export class DenoisingManager extends EventDispatcher {
 		// disabled (lazily re-created on the next dispatch after re-enable). Every strategy/denoiser
 		// toggle funnels through here after the enabled flags above are settled, so this is the one
 		// choke point. dispose() is idempotent, so re-running it for an already-released stage is a no-op.
-		for ( const stage of [ s.asvgf, s.variance, s.bilateralFilter, s.ssrc, s.edgeFilter, nd, mv ] ) {
+		for ( const stage of [ s.asvgf, s.variance, s.bilateralFilter, s.edgeFilter, nd, mv ] ) {
 
 			if ( stage && ! stage.enabled ) stage.releaseGPUMemory?.();
 
@@ -583,13 +578,6 @@ export class DenoisingManager extends EventDispatcher {
 
 	}
 
-	/** Updates SSRC stage parameters. */
-	setSSRCParams( params ) {
-
-		this._stages.ssrc?.updateParameters( params );
-
-	}
-
 	/** Updates edge-aware filtering parameters. */
 	setEdgeAwareParams( params ) {
 
@@ -667,7 +655,7 @@ export class DenoisingManager extends EventDispatcher {
 
 	/**
 	 * Switches strategy with automatic reset (convenience wrapper).
-	 * @param {'none'|'asvgf'|'ssrc'|'edgeaware'} strategy
+	 * @param {'none'|'asvgf'|'edgeaware'} strategy
 	 * @param {string} [asvgfPreset]
 	 */
 	setStrategy( strategy, asvgfPreset ) {
@@ -713,7 +701,7 @@ export class DenoisingManager extends EventDispatcher {
 		const keys = [
 			'asvgf:output', 'asvgf:demodulated', 'asvgf:gradient',
 			'variance:output', 'bilateralFiltering:output',
-			'edgeFiltering:output', 'ssrc:output',
+			'edgeFiltering:output',
 		];
 		keys.forEach( k => ctx.removeTexture( k ) );
 

package/src/Stages/SSRC.js

@@ -1,328 +0,0 @@
-// Screen-Space Radiance Cache (SSRC) Stage
-//
-// Two compute passes per frame:
-//   Pass 1 (Temporal): Reproject previous cache via motion vectors + EMA blend
-//   Pass 2 (Spatial):  8-tap neighbor reuse weighted by normal/depth similarity
-//
-// Execution: PER_CYCLE
-//
-// Events listened: pipeline:reset, camera:moved
-//
-// Textures published:  ssrc:output
-// Textures read:       pathtracer:color, pathtracer:normalDepth, motionVector:screenSpace
-
-import { uniform } from 'three/tsl';
-import { StorageTexture, TextureNode, RenderTarget } from 'three/webgpu';
-import { HalfFloatType, RGBAFormat, NearestFilter, LinearFilter, Box2, Vector2 } from 'three';
-import { RenderStage, StageExecutionMode } from '../Pipeline/RenderStage.js';
-import { buildTemporalPass, buildSpatialPass } from '../TSL/SSRC.js';
-import { MAX_STORAGE_TEXTURE_SIZE } from '../EngineDefaults.js';
-
-export class SSRC extends RenderStage {
-
-	constructor( renderer, options = {} ) {
-
-		super( 'SSRC', {
-			...options,
-			executionMode: StageExecutionMode.PER_CYCLE,
-		} );
-
-		this.renderer = renderer;
-
-		// ─── Uniforms ───
-		this.resW = uniform( 1 );
-		this.resH = uniform( 1 );
-		this.temporalAlpha = uniform( options.temporalAlpha ?? 0.1 );
-		this.phiNormal = uniform( options.phiNormal ?? 128.0 );
-		this.phiDepth = uniform( options.phiDepth ?? 0.5 );
-		this.maxHistory = uniform( options.maxHistory ?? 128.0 );
-		this.spatialRadius = uniform( options.spatialRadius ?? 4, 'int' );
-		this.spatialWeight = uniform( options.spatialWeight ?? 0.4 );
-		// 0 on reset → temporal pass skips cache; incremented each render frame
-		this._framesSinceReset = uniform( 0, 'int' );
-
-		// ─── Input TextureNodes (set from pipeline context each frame) ───
-		this._colorTexNode = new TextureNode();
-		this._ndTexNode = new TextureNode();
-		this._motionTexNode = new TextureNode();
-
-		// ─── Read-side wrappers for ping-pong StorageTextures ───
-		this._readCacheTexNode = new TextureNode(); // prev cache (for temporal pass)
-		this._readPrevNDTexNode = new TextureNode(); // prev normalDepth (for edge-stopping)
-		this._readPass1CacheTexNode = new TextureNode(); // current cache (for spatial pass)
-
-		// ─── StorageTextures (5 total) ───
-		// StorageTextures stay at max alloc — see resize crash fix (three.js #33061).
-		const w = 1, h = 1; // RTs/uniforms resized on first render
-
-		// Ping-pong temporal cache: .rgb = radiance, .w = history count
-		this._cacheTexA = this._createStorageTex( MAX_STORAGE_TEXTURE_SIZE, MAX_STORAGE_TEXTURE_SIZE, NearestFilter );
-		this._cacheTexB = this._createStorageTex( MAX_STORAGE_TEXTURE_SIZE, MAX_STORAGE_TEXTURE_SIZE, NearestFilter );
-
-		// Ping-pong previous-frame normalDepth (for edge-stopping in temporal pass)
-		this._prevNDTexA = this._createStorageTex( MAX_STORAGE_TEXTURE_SIZE, MAX_STORAGE_TEXTURE_SIZE, NearestFilter );
-		this._prevNDTexB = this._createStorageTex( MAX_STORAGE_TEXTURE_SIZE, MAX_STORAGE_TEXTURE_SIZE, NearestFilter );
-
-		// Final output (LinearFilter for Display fragment shader sampling)
-		this._outputTex = this._createStorageTex( MAX_STORAGE_TEXTURE_SIZE, MAX_STORAGE_TEXTURE_SIZE, LinearFilter );
-
-		// Active-region copy target — published downstream (storage tex is over-allocated)
-		this._srcRegion = new Box2( new Vector2( 0, 0 ), new Vector2( 0, 0 ) );
-		this.outputTarget = new RenderTarget( w, h, {
-			type: HalfFloatType,
-			format: RGBAFormat,
-			minFilter: LinearFilter,
-			magFilter: LinearFilter,
-			depthBuffer: false,
-			stencilBuffer: false
-		} );
-
-		// ─── State ───
-		this._currentPingPong = 0; // 0: read B, write A; 1: read A, write B
-		this._dispatchX = 1;
-		this._dispatchY = 1;
-
-		// ─── Compute nodes ───
-		this._buildComputeNodes();
-
-	}
-
-	// ──────────────────────────────────────────────────
-	// Lifecycle
-	// ──────────────────────────────────────────────────
-
-	setupEventListeners() {
-
-		this.on( 'pipeline:reset', () => this._resetCache() );
-		this.on( 'camera:moved', () => this._resetCache() );
-
-	}
-
-	render( context ) {
-
-		if ( ! this.enabled ) {
-
-			context.removeTexture( 'ssrc:output' );
-			return;
-
-		}
-
-		// Auto-resize if render resolution changed
-		const colorTex = context.getTexture( 'pathtracer:color' );
-		if ( colorTex?.image ) {
-
-			const { width, height } = colorTex.image;
-			if ( width !== this.outputTarget.width || height !== this.outputTarget.height ) {
-
-				this.setSize( width, height );
-
-			}
-
-		}
-
-		// Bind current-frame inputs from context
-		const normalDepthTex = context.getTexture( 'pathtracer:normalDepth' );
-		if ( ! normalDepthTex || ! colorTex ) return;
-
-		this._colorTexNode.value = colorTex;
-		this._ndTexNode.value = normalDepthTex;
-
-		const motionTex = context.getTexture( 'motionVector:screenSpace' );
-		if ( motionTex ) this._motionTexNode.value = motionTex;
-
-		// ─── Ping-pong assignment ───
-		// _currentPingPong 0: pass1 reads B, writes A; pass2 reads A
-		// _currentPingPong 1: pass1 reads A, writes B; pass2 reads B
-		const [ readCache, writeCache, readPrevND ] =
-			this._currentPingPong === 0
-				? [ this._cacheTexB, this._cacheTexA, this._prevNDTexB ]
-				: [ this._cacheTexA, this._cacheTexB, this._prevNDTexA ];
-
-		// ─── Pass 1: Temporal ───
-		this._readCacheTexNode.value = readCache;
-		this._readPrevNDTexNode.value = readPrevND;
-
-		// patch the write-side storages by recreating nodes is NOT needed — the pass was built
-		// with the actual StorageTexture references (not TextureNode wrappers), so we swap them
-		// via the ping-pong writeCacheTex / writePrevNDTex references in the closure.
-		// Since TSL captures StorageTexture directly for writes, we must rebuild or use a flag.
-		// Instead we use the swappable-write pattern: build two pass1 nodes (one per write target).
-		this.renderer.compute( this._currentPingPong === 0 ? this._pass1NodeA : this._pass1NodeB );
-
-		// ─── Pass 2: Spatial ───
-		// Spatial pass reads the just-written cache from pass 1
-		this._readPass1CacheTexNode.value = writeCache;
-
-		this.renderer.compute( this._pass2Node );
-
-		// Advance frames-since-reset counter (capped to avoid overflow)
-		this._framesSinceReset.value = Math.min( this._framesSinceReset.value + 1, 9999 );
-
-		// Copy active region out of the over-allocated StorageTexture into the
-		// right-sized RenderTarget; downstream stages UV-sample the latter.
-		this._srcRegion.max.set( this.outputTarget.width, this.outputTarget.height );
-		this.renderer.copyTextureToTexture( this._outputTex, this.outputTarget.texture, this._srcRegion );
-
-		// Publish final output
-		context.setTexture( 'ssrc:output', this.outputTarget.texture );
-
-		// Advance ping-pong
-		this._currentPingPong = 1 - this._currentPingPong;
-
-	}
-
-	// Free the 2048² StorageTextures when disabled; three.js re-creates them on the next dispatch
-	// after re-enable, and reset() clears the temporal cache. See ASVGF.releaseGPUMemory.
-	releaseGPUMemory() {
-
-		this._cacheTexA?.dispose();
-		this._cacheTexB?.dispose();
-		this._prevNDTexA?.dispose();
-		this._prevNDTexB?.dispose();
-		this._outputTex?.dispose();
-		// Render-res RT texture (dispose .texture, not the RT — RT.dispose() doesn't free it here).
-		this.context?.removeTexture( 'ssrc:output' );
-		this.outputTarget?.texture?.dispose();
-		this.reset();
-
-	}
-
-	reset() {
-
-		this._resetCache();
-
-	}
-
-	setSize( width, height ) {
-
-		if ( width < 1 || height < 1 ) return;
-
-		// StorageTextures stay at their max allocation (see constructor).
-		this.outputTarget.setSize( width, height );
-		this.outputTarget.texture.needsUpdate = true;
-
-		this.resW.value = width;
-		this.resH.value = height;
-
-		this._dispatchX = Math.ceil( width / 8 );
-		this._dispatchY = Math.ceil( height / 8 );
-
-		const dispatchSize = [ this._dispatchX, this._dispatchY, 1 ];
-		if ( this._pass1NodeA ) this._pass1NodeA.dispatchSize = dispatchSize;
-		if ( this._pass1NodeB ) this._pass1NodeB.dispatchSize = dispatchSize;
-		if ( this._pass2Node ) this._pass2Node.dispatchSize = dispatchSize;
-
-		this._resetCache();
-
-	}
-
-	dispose() {
-
-		this._pass1NodeA?.dispose();
-		this._pass1NodeB?.dispose();
-		this._pass2Node?.dispose();
-		this._cacheTexA.dispose();
-		this._cacheTexB.dispose();
-		this._prevNDTexA.dispose();
-		this._prevNDTexB.dispose();
-		this._outputTex.dispose();
-		this.outputTarget?.dispose();
-		this._colorTexNode?.dispose();
-		this._ndTexNode?.dispose();
-		this._motionTexNode?.dispose();
-		this._readCacheTexNode?.dispose();
-		this._readPrevNDTexNode?.dispose();
-		this._readPass1CacheTexNode?.dispose();
-
-	}
-
-	updateParameters( params ) {
-
-		if ( params.temporalAlpha !== undefined ) this.temporalAlpha.value = params.temporalAlpha;
-		if ( params.phiNormal !== undefined ) this.phiNormal.value = params.phiNormal;
-		if ( params.phiDepth !== undefined ) this.phiDepth.value = params.phiDepth;
-		if ( params.maxHistory !== undefined ) this.maxHistory.value = params.maxHistory;
-		if ( params.spatialRadius !== undefined ) this.spatialRadius.value = params.spatialRadius;
-		if ( params.spatialWeight !== undefined ) this.spatialWeight.value = params.spatialWeight;
-
-	}
-
-	// ──────────────────────────────────────────────────
-	// Private
-	// ──────────────────────────────────────────────────
-
-	_createStorageTex( w, h, filter ) {
-
-		const tex = new StorageTexture( w, h );
-		tex.type = HalfFloatType;
-		tex.format = RGBAFormat;
-		tex.minFilter = filter;
-		tex.magFilter = filter;
-		return tex;
-
-	}
-
-	_resetCache() {
-
-		this._currentPingPong = 0;
-		this._framesSinceReset.value = 0;
-
-	}
-
-	_buildComputeNodes() {
-
-		const commonArgs = {
-			colorTexNode: this._colorTexNode,
-			ndTexNode: this._ndTexNode,
-			motionTexNode: this._motionTexNode,
-			readCacheTexNode: this._readCacheTexNode,
-			readPrevNDTexNode: this._readPrevNDTexNode,
-			resW: this.resW,
-			resH: this.resH,
-			temporalAlpha: this.temporalAlpha,
-			phiNormal: this.phiNormal,
-			phiDepth: this.phiDepth,
-			maxHistory: this.maxHistory,
-		};
-
-		// Build two temporal nodes — one writing to cacheTexA, one to cacheTexB.
-		// This is required because StorageTexture write targets are fixed at compile time.
-		const pass1FnA = buildTemporalPass( {
-			...commonArgs,
-			writeCacheTex: this._cacheTexA,
-			writePrevNDTex: this._prevNDTexA,
-			framesSinceReset: this._framesSinceReset,
-		} );
-
-		const pass1FnB = buildTemporalPass( {
-			...commonArgs,
-			writeCacheTex: this._cacheTexB,
-			writePrevNDTex: this._prevNDTexB,
-			framesSinceReset: this._framesSinceReset,
-		} );
-
-		const dispatchCount = [ this._dispatchX, this._dispatchY, 1 ];
-		const wgSize = [ 8, 8, 1 ];
-
-		this._pass1NodeA = pass1FnA().compute( dispatchCount, wgSize );
-		this._pass1NodeB = pass1FnB().compute( dispatchCount, wgSize );
-
-		// Spatial pass: reads from _readPass1CacheTexNode (assigned per-frame to the just-written cache)
-		const pass2Fn = buildSpatialPass( {
-			colorTexNode: this._colorTexNode,
-			ndTexNode: this._ndTexNode,
-			readCacheTexNode: this._readPass1CacheTexNode,
-			outputTex: this._outputTex,
-			resW: this.resW,
-			resH: this.resH,
-			spatialRadius: this.spatialRadius,
-			spatialWeight: this.spatialWeight,
-			phiNormal: this.phiNormal,
-			phiDepth: this.phiDepth,
-		} );
-
-		this._pass2Node = pass2Fn().compute( dispatchCount, wgSize );
-
-	}
-
-}