rayzee 7.11.0 → 7.12.0

package/src/Stages/PathTracer.js

@@ -25,7 +25,7 @@ import {
 } from '../TSL/SortGlobalKernels.js';
 import { ENGINE_DEFAULTS } from '../EngineDefaults.js';
 import {
-	Fn, uint, atomicStore, atomicLoad, instanceIndex, If, Return,
+	Fn, uint, int, atomicStore, atomicLoad, atomicAdd, instanceIndex, If, Return,
 } from 'three/tsl';
 
 export class PathTracer extends PathTracerStage {
@@ -39,6 +39,12 @@ export class PathTracer extends PathTracerStage {
 		this._queueManager = null;
 		this._kernelManager = null;
 		this._gBufferAttr = null; // per-pixel first-hit MRT (ND + albedo); see _buildWavefrontKernels
+		this._m2Attr = null; // per-pixel running mean of luminance² for the Tier-1 convergence early-stop
+		this._streakAttr = null; // Tier-2: per-pixel freeze-candidate streak (u32); frozen := streak >= K
+		// Tier-2 dilation: per-pixel frozen mask (1=skip), written race-free in buildActivePixels; a frozen pixel
+		// stays active if any 8-neighbour is still active (Cycles box-filter) to avoid hard frozen/active seams.
+		this._frozenMaskAttr = null;
+		this._dilateFrozenUniform = uniform( 1, 'int' ); // 1 = dilate (default); 0 = plain per-pixel freeze
 		this._wavefrontReady = false;
 
 		// Aux MRT (normalDepth + albedo) feeds only the denoiser/OIDN. When no denoiser is active the
@@ -46,6 +52,11 @@ export class PathTracer extends PathTracerStage {
 		// uniform — NOT baked — so DenoisingManager can toggle it without a (UI-freezing) kernel rebuild.
 		this._auxGBufferEnabled = false;
 		this._auxGBufferUniform = uniform( 0, 'uint' );
+		// Clean-aux mode: temporally accumulate + renormalize the aux NORMAL (like albedo) so a clean-aux
+		// OIDN model (calb_cnrm/high, alb_nrm/balanced) gets the prefiltered-ish normal it expects instead
+		// of the point-sampled per-frame value that leaks noise. Off for fast/ASVGF (they want the bump normal).
+		this._cleanAuxNormalEnabled = false;
+		this._cleanAuxNormalUniform = uniform( 0, 'uint' );
 
 		// CPU sizes per-bounce kernels from last frame's survivor curve; kernels bound on ENTERING_COUNT so over-sizing is safe. (indirect dispatch not viable — three.js doesn't sync compute-written indirect buffers across submissions)
 		this._useDynamicDispatch = true;
@@ -74,6 +85,16 @@ export class PathTracer extends PathTracerStage {
 		// 0.1% of primary ray count, floored at 100; -1 to disable. Updated per-scene in _buildWavefrontKernels.
 		this._bounceEarlyExitThreshold = 100;
 
+		// Tier-1 convergence early-stop: fraction of pixels converged in the last settled-view readback, and a
+		// single-flight guard for its async counter read. Zeroed on reset/camera-move/resize; never refreshed
+		// mid-motion (the readback early-return + frozen frameCount keep the stop from firing while moving).
+		this._convergedFraction = 0;
+		this._convergedReadbackPending = 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.
+		this._lastActivePixelCount = 0;
+
 		this._wfRenderWidth = uniform( 1920, 'int' );
 		this._wfRenderHeight = uniform( 1080, 'int' );
 		this._wfMaxRayCount = uniform( 0, 'uint' );
@@ -112,8 +133,17 @@ export class PathTracer extends PathTracerStage {
 
 		} );
 
-		// Per-pixel first-hit G-buffer (normal/depth + albedo)
-		t.register( 'gbuffer', () => this._gBufferAttr ? [ this._gBufferAttr ] : null );
+		// Per-pixel first-hit G-buffer (normal/depth + albedo) + convergence m2 buffer + Tier-2 freeze streak
+		t.register( 'gbuffer', () => {
+
+			const a = [];
+			if ( this._gBufferAttr ) a.push( this._gBufferAttr );
+			if ( this._m2Attr ) a.push( this._m2Attr );
+			if ( this._streakAttr ) a.push( this._streakAttr );
+			if ( this._frozenMaskAttr ) a.push( this._frozenMaskAttr );
+			return a.length ? a : null;
+
+		} );
 
 		// Accumulation pool: 3 write StorageTextures (2048²) + readable MRT RenderTarget
 		t.register( 'accum', () => {
@@ -169,7 +199,7 @@ export class PathTracer extends PathTracerStage {
 		// Kernels not built yet (first frame / mid-resize) — skip until ready.
 		if ( ! this.isReady || ! this._wavefrontReady ) return;
 
-		if ( this.isComplete || this.frameCount >= this.completionThreshold ) {
+		if ( this.isComplete || this.frameCount >= this.completionThreshold || this._isConvergedComplete() ) {
 
 			if ( ! this.isComplete ) this.isComplete = true;
 			return;
@@ -207,6 +237,10 @@ export class PathTracer extends PathTracerStage {
 
 			this._curveSizingValid = false;
 			this._readbackGeneration ++;
+			// Drop the stale converged fraction so the early-stop can't fire on the pose we're leaving.
+			this._convergedFraction = 0;
+			// Tier-2: drop the stale active-pixel count so bounce 0 full-sizes until the new pose re-measures.
+			this._lastActivePixelCount = 0;
 
 		}
 
@@ -220,6 +254,7 @@ export class PathTracer extends PathTracerStage {
 
 			this.shaderBuilder.prevColorTexNode.value = readTextures.color;
 			this.shaderBuilder.prevAlbedoTexNode.value = readTextures.albedo;
+			this.shaderBuilder.prevNormalDepthTexNode.value = readTextures.normalDepth;
 
 		}
 
@@ -249,16 +284,37 @@ export class PathTracer extends PathTracerStage {
 
 		}
 
-		km.dispatch( 'resetCounters' );
-		km.dispatch( 'generate' );
-		// Generate traces every pixel; seed ENTERING_COUNT from the full identity active list.
-		km.dispatch( 'initActiveIndices' );
-
 		const maxBounces = this.maxBounces.value;
 		// Transmissive/SSS steps consume iterations without advancing camera-bounce depth, so the loop must run far enough for deep glass/subsurface walks (mirror PathTracerCore); the survivor curve + early-exit break it early on non-SSS scenes.
 		const loopBound = maxBounces + this.transmissiveBounces.value + this.maxSubsurfaceSteps.value;
 		const maxRays = this._wfMaxRayCount.value;
 
+		// Tier-2 bounce-0 grid size from the stale settled active-pixel count (maxRays until one lands).
+		// Monotonic freeze ⇒ a stale count is a safe over-estimate; reset/camera-move → _curveSizingValid=false → maxRays.
+		const adaptiveFreeze = this.usePixelFreeze.value > 0;
+		const activeBounce0 = ( adaptiveFreeze && this._curveSizingValid && this._lastActivePixelCount > 0 )
+			? this._lastActivePixelCount : maxRays;
+
+		if ( adaptiveFreeze ) {
+
+			// reset counters → compact non-frozen pixel IDs → publish count → list-driven 1D generate.
+			const genSized = Math.min( maxRays, Math.ceil( activeBounce0 * 1.5 ) + 1024 );
+			km.setDispatchCount( 'buildActivePixels', [ Math.ceil( maxRays / 256 ), 1, 1 ] );
+			km.setDispatchCount( 'generateList', [ Math.ceil( genSized / 256 ), 1, 1 ] );
+			km.dispatch( 'resetFrameCounters' );
+			km.dispatch( 'buildActivePixels' );
+			km.dispatch( 'seedEnter' );
+			km.dispatch( 'generateList' );
+
+		} else {
+
+			km.dispatch( 'generate' );
+			// Generate traces every pixel; seed ACTIVE + ENTERING_COUNT from the full identity active list
+			// (initActiveIndices overwrites both counters, so no separate frame-start reset is needed).
+			km.dispatch( 'initActiveIndices' );
+
+		}
+
 		// The survivor curve survives a maxBounces change (reset() preserves it), and is reusable
 		// across one: for loop iterations below BOTH the old and new camera-bounce caps, no ray has
 		// been killed by either cap, so the counts are cap-independent. Trust the curve up to that
@@ -307,6 +363,11 @@ export class PathTracer extends PathTracerStage {
 
 					entering = prev > 0 ? prev : maxRays;
 
+				} else if ( bounce === 0 && adaptiveFreeze ) {
+
+					// Bounce 0 traces only non-frozen pixels — size from the stale active count (full until a readback).
+					entering = activeBounce0;
+
 				}
 
 				const sized = Math.min( maxRays, Math.ceil( entering * 1.5 ) + 1024 );
@@ -342,12 +403,18 @@ export class PathTracer extends PathTracerStage {
 
 			}
 
-			km.dispatch( 'shade' );
-
-			km.dispatch( 'resetActiveCounter' );
+			km.dispatch( 'shade' ); // shade thread 0 folds resetActiveCounter (zeroes ACTIVE_RAY_COUNT before compact)
 			km.dispatch( 'compact' );
-			if ( useFunctionalCompaction ) km.dispatch( 'compactCopyback' );
-			km.dispatch( 'snapshotBounceCount' );
+			if ( useFunctionalCompaction ) {
+
+				// compactCopyback thread 0 folds snapshotBounceCount (records the survivor curve + seeds ENTERING).
+				km.dispatch( 'compactCopyback' );
+
+			} else {
+
+				km.dispatch( 'snapshotBounceCount' );
+
+			}
 			// No swap: pingPong stays 0 (kernels are build-time-bound to buffer A).
 
 			// Early-exit on last frame's per-bounce snapshot (stale via async readback, fine for a heuristic).
@@ -385,6 +452,26 @@ export class PathTracer extends PathTracerStage {
 
 	}
 
+	// Tier-1 convergence early-stop: retire the WHOLE frame once enough samples have accumulated AND ~all pixels
+	// hit the relative-error floor. Keeps the global 1/(frame+1) alpha untouched — only the stop condition
+	// changes. Naturally gated off while moving: frameCount is frozen in interaction mode (< minSamples) and
+	// _convergedFraction is zeroed on camera-move and never refreshed mid-motion (readback early-returns).
+	_isConvergedComplete() {
+
+		return this.useAdaptiveSampling.value > 0
+			&& this.frameCount >= this.adaptiveMinSamples.value
+			&& this._convergedFraction >= this.adaptiveStopFraction.value;
+
+	}
+
+	reset() {
+
+		super.reset();
+		this._convergedFraction = 0;
+		this._lastActivePixelCount = 0;
+
+	}
+
 	// Parent resizes storageTextures/shaderBuilder; wavefront also needs its buffers/uniforms/kernels rebuilt.
 	_handleResize() {
 
@@ -410,6 +497,19 @@ export class PathTracer extends PathTracerStage {
 
 	}
 
+	// Clean-aux normal: when a clean-aux OIDN model is active (calb_cnrm/high, alb_nrm/balanced), FinalWrite
+	// temporally accumulates + renormalizes the aux normal so the model isn't fed per-frame point-sampled
+	// noise. DenoisingManager calls this on OIDN enable + quality change. Live uniform → value flip + reset.
+	setCleanAuxNormal( enabled ) {
+
+		enabled = !! enabled;
+		if ( this._cleanAuxNormalEnabled === enabled ) return;
+		this._cleanAuxNormalEnabled = enabled;
+		this._cleanAuxNormalUniform.value = enabled ? 1 : 0;
+		this.reset();
+
+	}
+
 	// UI-driven resize (Resolution dropdown) — parent bypasses _handleResize(), so hook here too.
 	setSize( width, height ) {
 
@@ -472,6 +572,40 @@ export class PathTracer extends PathTracerStage {
 
 		} );
 
+		// Tier-1 convergence: on the SAME settled-view cadence, read the converged-pixel count and derive the
+		// fraction that drives the whole-frame early-stop. Separate single-flight flag (different buffer) + the
+		// same _readbackGeneration guard so a count measured before a camera-move/resize is dropped when stale.
+		if ( ! this._convergedReadbackPending ) {
+
+			const cAttr = this._queueManager?.getCountersAttribute();
+			if ( cAttr ) {
+
+				this._convergedReadbackPending = true;
+				const cgen = this._readbackGeneration;
+				const total = this._wfMaxRayCount.value;
+				this.renderer.getArrayBufferAsync( cAttr ).then( ( buf ) => {
+
+					if ( cgen === this._readbackGeneration && total > 0 ) {
+
+						const c = new Uint32Array( buf );
+						this._convergedFraction = c[ COUNTER.CONVERGED_COUNT ] / total;
+						// Tier-2: bounce-0 active-pixel count measured this settled frame → sizes next frame's grid.
+						this._lastActivePixelCount = c[ COUNTER.ACTIVE_PIXEL_COUNT ];
+
+					}
+
+					this._convergedReadbackPending = false;
+
+				} ).catch( () => {
+
+					this._convergedReadbackPending = false;
+
+				} );
+
+			}
+
+		}
+
 	}
 
 	// Sync wavefront's texture nodes with current env/material textures; only a changed ref triggers GPU rebind.
@@ -507,6 +641,8 @@ export class PathTracer extends PathTracerStage {
 		this._curveSizingValid = false;
 		this._readbackFrameCounter = 0;
 		this._readbackGeneration ++;
+		this._convergedFraction = 0;
+		this._lastActivePixelCount = 0;
 
 		// Recompile only when buffers reallocate (capacity grows); otherwise resize uniforms in place.
 		const neededCap = PackedRayBuffer.requiredCapacity( newW * newH );
@@ -580,6 +716,25 @@ export class PathTracer extends PathTracerStage {
 		const gBufferRW = storage( this._gBufferAttr, 'uvec4' );
 		const gBufferRO = storage( this._gBufferAttr, 'uvec4' ).toReadOnly();
 
+		// Tier-1 convergence: one f32/pixel holding the running mean of luminance² (Welford second moment),
+		// read+written by FinalWrite. 1.25× margin (same as the per-ray buffers) so it survives in-place resize;
+		// allocated only on this capacity-growth/rebuild path, never in _resizeWavefrontInPlace.
+		freeStorageAttribute( this.renderer, this._m2Attr );
+		this._m2Attr = new StorageInstancedBufferAttribute( new Float32Array( PackedRayBuffer.requiredCapacity( maxRays ) ), 1 );
+		const m2RW = storage( this._m2Attr, 'float' );
+
+		// Tier-2: one u32/pixel freeze-candidate streak. FinalWrite writes (RW), buildActivePixels reads (RO).
+		freeStorageAttribute( this.renderer, this._streakAttr );
+		this._streakAttr = new StorageInstancedBufferAttribute( new Uint32Array( PackedRayBuffer.requiredCapacity( maxRays ) ), 1 );
+		const streakRW = storage( this._streakAttr, 'uint' );
+		const streakRO = storage( this._streakAttr, 'uint' ).toReadOnly();
+
+		// Tier-2: dilated frozen mask (1 = skip). buildActivePixels writes; active-list + FinalWrite read → race-free.
+		freeStorageAttribute( this.renderer, this._frozenMaskAttr );
+		this._frozenMaskAttr = new StorageInstancedBufferAttribute( new Uint32Array( PackedRayBuffer.requiredCapacity( maxRays ) ), 1 );
+		const frozenMaskRW = storage( this._frozenMaskAttr, 'uint' );
+		const frozenMaskRO = storage( this._frozenMaskAttr, 'uint' ).toReadOnly();
+
 		if ( ! this._queueManager ) {
 
 			this._queueManager = new QueueManager( this._packedBuffers.capacity, this.renderer );
@@ -605,28 +760,14 @@ export class PathTracer extends PathTracerStage {
 
 		const prevColor = this.shaderBuilder.prevColorTexNode;
 		const prevAlbedo = this.shaderBuilder.prevAlbedoTexNode;
+		const prevNormalDepth = this.shaderBuilder.prevNormalDepthTexNode;
 		const writeTex = this.storageTextures.getWriteTextures();
 
 		const counters = qm.getCounters();
-		const resetFn = Fn( () => {
-
-			atomicStore( counters.element( uint( COUNTER.ACTIVE_RAY_COUNT ) ), uint( 0 ) );
-
-		} );
-		this._kernelManager.register( 'resetCounters',
-			resetFn().compute( [ 1, 1, 1 ], [ 1, 1, 1 ] )
-		);
-
-		const resetActiveFn = Fn( () => {
-
-			atomicStore( counters.element( uint( COUNTER.ACTIVE_RAY_COUNT ) ), uint( 0 ) );
-
-		} );
-		this._kernelManager.register( 'resetActiveCounter',
-			resetActiveFn().compute( [ 1, 1, 1 ], [ 1, 1, 1 ] )
-		);
 
 		// Copy ACTIVE_RAY_COUNT into bounceCounts[currentBounce] for the readback survivor curve.
+		// Standalone kernel is dispatched only on the non-dynamic path; the dynamic path folds this
+		// into compactCopyback's thread 0.
 		const bounceCountsBuf = qm.getBounceCounts();
 		const wfCurrentBounce = this._wfCurrentBounce;
 		const snapshotFn = Fn( () => {
@@ -652,6 +793,10 @@ export class PathTracer extends PathTracerStage {
 
 				atomicStore( counters.element( uint( COUNTER.ACTIVE_RAY_COUNT ) ), this._wfMaxRayCount );
 				atomicStore( counters.element( uint( COUNTER.ENTERING_COUNT ) ), this._wfMaxRayCount );
+				// Tier-1 convergence: zero the per-frame converged-pixel counter here — once/frame at frame start,
+				// before FinalWrite atomicAdds into it. (Was in the now-removed resetCounters kernel; must NOT go
+				// in shade's per-bounce reset, since FinalWrite accumulates only once, at frame end.)
+				atomicStore( counters.element( uint( COUNTER.CONVERGED_COUNT ) ), uint( 0 ) );
 
 			} );
 
@@ -660,7 +805,7 @@ export class PathTracer extends PathTracerStage {
 			initFn().compute( [ Math.ceil( maxRays / 256 ), 1, 1 ], [ 256, 1, 1 ] )
 		);
 
-		const genFn = buildGenerateKernel( {
+		const genParams = {
 			rayBufferRW: pb.rayBuffer.rw,
 			rngBufferRW: pb.rngBuffer.rw,
 			gBufferRW,
@@ -680,7 +825,8 @@ export class PathTracer extends PathTracerStage {
 			transmissiveBounces: this.transmissiveBounces,
 			transparentBackground: this.transparentBackground,
 			auxGBufferEnabled: this._auxGBufferUniform,
-		} );
+		};
+		const genFn = buildGenerateKernel( genParams );
 		this._kernelManager.register( 'generate',
 			genFn().compute(
 				[ Math.ceil( w / GENERATE_WG_SIZE ), Math.ceil( h / GENERATE_WG_SIZE ), 1 ],
@@ -688,6 +834,100 @@ export class PathTracer extends PathTracerStage {
 			)
 		);
 
+		// --- Tier-2 freeze seed path (gated by usePixelFreeze in render()) ---
+		// Replaces generate+initActiveIndices with: reset counters → scatter non-frozen pixel IDs into the active
+		// list → publish count → 1D list-driven generate. Split so ACTIVE_RAY_COUNT is zeroed BEFORE the scatter.
+		const freezeK = this.pixelFreezeStability;
+		const resetFrameFn = Fn( () => {
+
+			atomicStore( counters.element( uint( COUNTER.ACTIVE_RAY_COUNT ) ), uint( 0 ) );
+			atomicStore( counters.element( uint( COUNTER.CONVERGED_COUNT ) ), uint( 0 ) );
+			atomicStore( counters.element( uint( COUNTER.FROZEN_COUNT ) ), uint( 0 ) );
+
+		} );
+		this._kernelManager.register( 'resetFrameCounters',
+			resetFrameFn().compute( [ 1, 1, 1 ], [ 1, 1, 1 ] )
+		);
+
+		const buildActiveFn = Fn( () => {
+
+			const tid = instanceIndex;
+			If( tid.lessThan( this._wfMaxRayCount ), () => {
+
+				// frozen=1 skips the pixel this frame. Frame 0 seeds all (streak may be stale post-reset). A pixel
+				// freezes once streak>=K; with dilation ON it stays active if any 8-neighbour is still active
+				// (streak<K), softening the boundary. Mask is read by FinalWrite too → race-free.
+				const frozen = uint( 0 ).toVar();
+
+				If( this.frame.greaterThan( uint( 0 ) ).and( streakRO.element( tid ).greaterThanEqual( uint( freezeK ) ) ), () => {
+
+					frozen.assign( uint( 1 ) );
+
+					If( this._dilateFrozenUniform.greaterThan( int( 0 ) ), () => {
+
+						const px = int( tid ).mod( this._wfRenderWidth );
+						const py = int( tid ).div( this._wfRenderWidth );
+
+						for ( const [ dx, dy ] of [[ - 1, - 1 ], [ 0, - 1 ], [ 1, - 1 ], [ - 1, 0 ], [ 1, 0 ], [ - 1, 1 ], [ 0, 1 ], [ 1, 1 ]] ) {
+
+							const nx = px.add( int( dx ) );
+							const ny = py.add( int( dy ) );
+							If( nx.greaterThanEqual( int( 0 ) ).and( nx.lessThan( this._wfRenderWidth ) )
+								.and( ny.greaterThanEqual( int( 0 ) ) ).and( ny.lessThan( this._wfRenderHeight ) ), () => {
+
+								If( streakRO.element( uint( ny.mul( this._wfRenderWidth ).add( nx ) ) ).lessThan( uint( freezeK ) ), () => {
+
+									frozen.assign( uint( 0 ) ); // a still-active neighbour keeps this pixel active
+
+								} );
+
+							} );
+
+						}
+
+					} );
+
+				} );
+
+				frozenMaskRW.element( tid ).assign( frozen );
+
+				If( frozen.equal( uint( 0 ) ), () => {
+
+					const slot = atomicAdd( counters.element( uint( COUNTER.ACTIVE_RAY_COUNT ) ), uint( 1 ) );
+					activeWriteA.element( slot ).assign( tid );
+
+				} );
+
+			} );
+
+		} );
+		this._kernelManager.register( 'buildActivePixels',
+			buildActiveFn().compute( [ Math.ceil( maxRays / 256 ), 1, 1 ], [ 256, 1, 1 ] )
+		);
+
+		const seedEnterFn = Fn( () => {
+
+			const active = atomicLoad( counters.element( uint( COUNTER.ACTIVE_RAY_COUNT ) ) );
+			// ENTERING_COUNT drives the bounce loop; ACTIVE_PIXEL_COUNT is a stable snapshot for the sizing readback.
+			atomicStore( counters.element( uint( COUNTER.ENTERING_COUNT ) ), active );
+			atomicStore( counters.element( uint( COUNTER.ACTIVE_PIXEL_COUNT ) ), active );
+
+		} );
+		this._kernelManager.register( 'seedEnter',
+			seedEnterFn().compute( [ 1, 1, 1 ], [ 1, 1, 1 ] )
+		);
+
+		// 1D list-driven generate: one thread per active-list slot, bounded on ENTERING_COUNT.
+		const genListFn = buildGenerateKernel( {
+			...genParams,
+			listDriven: true,
+			activeIndicesRO: qm.activeIndicesRO.a,
+			counters,
+		} );
+		this._kernelManager.register( 'generateList',
+			genListFn().compute( [ Math.ceil( maxRays / 256 ), 1, 1 ], [ 256, 1, 1 ] )
+		);
+
 		const freshBvh = this.bvhStorageNode;
 		const freshTri = this.triangleStorageNode;
 		const freshMat = this.materialData.materialStorageNode;
@@ -880,7 +1120,19 @@ export class PathTracer extends PathTracerStage {
 		const copyFn = Fn( () => {
 
 			const tid = instanceIndex;
-			If( tid.greaterThanEqual( atomicLoad( counters.element( uint( COUNTER.ACTIVE_RAY_COUNT ) ) ) ), () => {
+			const active = atomicLoad( counters.element( uint( COUNTER.ACTIVE_RAY_COUNT ) ) );
+
+			// Folds snapshotBounceCount: thread 0 records the survivor count for the readback curve and
+			// seeds ENTERING_COUNT for the next bounce. Above the guard so it runs even when active is 0.
+			If( tid.equal( uint( 0 ) ), () => {
+
+				const slot = uint( wfCurrentBounce ).clamp( uint( 0 ), uint( qm.MAX_BOUNCE_SNAPSHOTS - 1 ) );
+				bounceCountsBuf.element( slot ).assign( active );
+				atomicStore( counters.element( uint( COUNTER.ENTERING_COUNT ) ), active );
+
+			} );
+
+			If( tid.greaterThanEqual( active ), () => {
 
 				Return();
 
@@ -907,10 +1159,24 @@ export class PathTracer extends PathTracerStage {
 			transparentBackground: this.transparentBackground,
 			prevAccumTexture: prevColor,
 			prevAlbedoTexture: prevAlbedo,
+			prevNormalDepthTexture: prevNormalDepth,
 			renderWidth: this._wfRenderWidth,
 			renderHeight: this._wfRenderHeight,
 			visMode: this.visMode,
 			auxGBufferEnabled: this._auxGBufferUniform,
+			cleanAuxNormalEnabled: this._cleanAuxNormalUniform,
+			counters,
+			m2BufferRW: m2RW,
+			useAdaptiveSampling: this.useAdaptiveSampling,
+			noiseThreshold: this.noiseThreshold,
+			darkNoiseFloor: this.darkNoiseFloor,
+			adaptiveMinSamples: this.adaptiveMinSamples,
+			// Tier-2 freeze (stamp + pass-through)
+			usePixelFreeze: this.usePixelFreeze,
+			pixelFreezeThreshold: this.pixelFreezeThreshold,
+			pixelFreezeStability: this.pixelFreezeStability,
+			streakBufferRW: streakRW,
+			frozenMaskRO, // dilated frozen mask (read-only; matches the active-list decision)
 		} );
 		this._kernelManager.register( 'finalWrite',
 			// Per-pixel (w×h) — kernel averages the S sample-slots internally.
@@ -990,10 +1256,16 @@ export class PathTracer extends PathTracerStage {
 		this._queueManager?.dispose();
 		this._kernelManager?.dispose();
 		this._gBufferAttr?.dispose?.();
+		this._m2Attr?.dispose?.();
+		this._streakAttr?.dispose?.();
+		this._frozenMaskAttr?.dispose?.();
 		this._packedBuffers = null;
 		this._queueManager = null;
 		this._kernelManager = null;
 		this._gBufferAttr = null;
+		this._m2Attr = null;
+		this._streakAttr = null;
+		this._frozenMaskAttr = null;
 		this._wavefrontReady = false;
 
 	}

package/src/TSL/BVHTraversal.js

@@ -175,7 +175,10 @@ const fastRayAABBDst = wgslFn( `
 // Side culling is performed inline inside traverseBVH/traverseBVHShadow using
 // the per-triangle side flag stored in normalCData.w (slot 5, .w channel).
 
-export const traverseBVH = Fn( ( [
+// Factory: the boxTests/triTests debug counters are compiled OUT of the hot closest-hit
+// path (extend/normalDepth use traverseBVH = trackStats false) — only the debug viz reads
+// them, and keeping them live across the traversal loop costs registers/occupancy.
+const makeTraverseBVH = ( trackStats ) => Fn( ( [
 	ray,
 	bvhBuffer,
 	triangleBuffer,
@@ -236,7 +239,7 @@ export const traverseBVH = Fn( ( [
 		// Inner: vec4(0) = [leftMin.xyz, leftChild], vec4(1) = [leftMax.xyz, rightChild],
 		//        vec4(2) = [rightMin.xyz, 0], vec4(3) = [rightMax.xyz, 0]
 		const nodeData0 = getDatafromStorageBuffer( bvhBuffer, nodeIndex, int( 0 ), int( BVH_STRIDE ) );
-		closestHit.boxTests.addAssign( 1 );
+		if ( trackStats ) closestHit.boxTests.addAssign( 1 );
 
 		If( nodeData0.w.lessThan( 0.0 ), () => {
 
@@ -250,7 +253,7 @@ export const traverseBVH = Fn( ( [
 				// Process triangles in leaf
 				Loop( { start: int( 0 ), end: triCount }, ( { i } ) => {
 
-					closestHit.triTests.addAssign( 1 );
+					if ( trackStats ) closestHit.triTests.addAssign( 1 );
 					const triIndex = triStart.add( i ).toVar();
 
 					// Fetch geometry first (3 fetches from storage buffer)
@@ -398,6 +401,10 @@ export const traverseBVH = Fn( ( [
 
 } );
 
+// Hot path (extend/normalDepth): no debug counters. Debug viz uses traverseBVHDebug.
+export const traverseBVH = /*@__PURE__*/ makeTraverseBVH( false );
+export const traverseBVHDebug = /*@__PURE__*/ makeTraverseBVH( true );
+
 // ================================================================================
 // SHADOW RAY TRAVERSAL (OPTIMIZED - early exit on any hit)
 // ================================================================================

package/src/TSL/Debugger.js

@@ -21,7 +21,7 @@ import {
 } from 'three/tsl';
 
 import { Ray, HitInfo, RayTracingMaterial, MaterialSamples } from './Struct.js';
-import { traverseBVH } from './BVHTraversal.js';
+import { traverseBVHDebug as traverseBVH } from './BVHTraversal.js';
 import { sampleEnvironment } from './Environment.js';
 import { REC709_LUMINANCE_COEFFICIENTS, getMaterial } from './Common.js';
 import { sampleAllMaterialTextures } from './TextureSampling.js';