rayzee 7.20.3 → 7.22.0

package/src/RenderSettings.js

@@ -1,4 +1,4 @@
-import { EventDispatcher, Color } from 'three';
+import { EventDispatcher, Color, Vector2, MathUtils } from 'three';
 import { ENGINE_DEFAULTS } from './EngineDefaults.js';
 import { EngineEvents } from './EngineEvents.js';
 
@@ -32,6 +32,7 @@ const SETTING_ROUTES = {
 	enableGroundCatcher: { uniform: 'enableGroundCatcher', reset: true },
 	groundCatcherHeight: { uniform: 'groundCatcherHeight', reset: true },
 	globalIlluminationIntensity: { uniform: 'globalIlluminationIntensity', reset: true },
+	panoramaLevelHorizon: { uniform: 'panoLevelHorizon', reset: true },
 	enableDOF: { uniform: 'enableDOF', reset: true },
 	focusDistance: { uniform: 'focusDistance', reset: false },
 	focalLength: { uniform: 'focalLength', reset: true },
@@ -56,6 +57,9 @@ const SETTING_ROUTES = {
 
 	// ── Multi-stage / special handling ────────────────────────────
 
+	cameraProjection: { handler: 'handleCameraProjection', reset: true },
+	panoramaLonRange: { handler: 'handlePanoramaLonRange', reset: true },
+	panoramaLatRange: { handler: 'handlePanoramaLatRange', reset: true },
 	interactionModeEnabled: { handler: 'handleInteractionModeEnabled', reset: false },
 	maxSamples: { handler: 'handleMaxSamples', reset: false },
 	transparentBackground: { handler: 'handleTransparentBackground' },
@@ -122,13 +126,15 @@ export class RenderSettings extends EventDispatcher {
 	 * @param {Object} params.stages           - Pipeline stages { pathTracer, compositor, autoExposure, ... }
 	 * @param {Function} params.resetCallback   - Called to reset accumulation
 	 * @param {Function} [params.reconcileCompletion] - Called when completion limits change
+	 * @param {Object} [params.denoisingManager] - Needed to force ASVGF off under panorama
+	 * @param {Object} [params.cameraManager]    - Needed to force auto-focus manual under panorama
 	 */
-	bind( { stages, renderer, resetCallback, reconcileCompletion } ) {
+	bind( params ) {
 
-		this._pathTracer = stages.pathTracer;
-		this._resetCallback = resetCallback;
+		this._pathTracer = params.stages.pathTracer;
+		this._resetCallback = params.resetCallback;
 		this._delegates = {};
-		this._handlers = this._buildHandlers( stages, renderer, reconcileCompletion );
+		this._handlers = this._buildHandlers( params );
 
 	}
 
@@ -136,10 +142,39 @@ export class RenderSettings extends EventDispatcher {
 	 * Builds handler functions for multi-stage settings that can't
 	 * be routed with a simple uniform forward.
 	 */
-	_buildHandlers( stages, renderer, reconcileCompletion ) {
+	_buildHandlers( { stages, renderer, reconcileCompletion, denoisingManager, cameraManager } ) {
+
+		// UniformManager copies into the existing node, so one scratch vector serves every write.
+		const panoScratch = new Vector2();
+		const setPanoRange = ( uniform, value ) => {
+
+			panoScratch.set( value?.[ 0 ] ?? 0, value?.[ 1 ] ?? 0 ).multiplyScalar( MathUtils.DEG2RAD );
+			stages.pathTracer?.setUniform( uniform, panoScratch );
+
+		};
 
 		return {
 
+			handleCameraProjection: ( value ) => {
+
+				const isPanorama = value === 'equirectangular';
+				stages.pathTracer?.setUniform( 'cameraProjection', isPanorama ? 1 : 0 );
+
+				if ( ! isPanorama ) return;
+
+				// ASVGF is driven entirely by MotionVector, which unprojects through
+				// projectionMatrixInverse — meaningless once every pixel is its own direction.
+				// Fall back to the spatial-only denoiser rather than leaving no strategy.
+				if ( denoisingManager?.denoiserStrategy === 'asvgf' ) denoisingManager.setDenoiserStrategy( 'edgeaware' );
+				// Auto-focus raycasts via Raycaster.setFromCamera, which only knows the frustum.
+				cameraManager?.setAutoFocusMode( 'manual' );
+
+			},
+
+			handlePanoramaLonRange: ( value ) => setPanoRange( 'panoLonRange', value ),
+
+			handlePanoramaLatRange: ( value ) => setPanoRange( 'panoLatRange', value ),
+
 			handleTransparentBackground: ( value ) => {
 
 				stages.pathTracer?.setUniform( 'transparentBackground', value );

package/src/Stages/ASVGF.js

@@ -40,7 +40,8 @@ export class ASVGF extends RenderStage {
 		this.renderer = renderer;
 
 		this.temporalAlpha = uniform( options.temporalAlpha ?? 0.0 );
-		this.gradientStrength = uniform( options.gradientStrength ?? 0.0 );
+		// > 0 is required for firefly rejection, not just anti-lag — see ENGINE_DEFAULTS.
+		this.gradientStrength = uniform( options.gradientStrength ?? 1.0 );
 		// σ multiplier for the per-pixel noise floor (NRD luminanceSigmaScale ≈ 2).
 		this.gradientSigmaScale = uniform( options.gradientSigmaScale ?? 2.0 );
 		// Secondary relative floor on the normalised gradient (0 = rely on σ alone).
@@ -380,7 +381,12 @@ export class ASVGF extends RenderStage {
 			If( gx.lessThan( int( resW ) ).and( gy.lessThan( int( resH ) ) ), () => {
 
 				const coord = ivec2( gx, gy );
-				const currentColor = textureLoad( colorTex, coord ).xyz;
+				const currentSample = textureLoad( colorTex, coord );
+				const currentColor = currentSample.xyz;
+				// Coverage from the path tracer — 0 on background rays when
+				// transparentBackground is on. Forcing 1.0 here made the whole frame opaque,
+				// so a transparent render composited as black.
+				const currentAlpha = currentSample.w;
 				const currentAlbedo = textureLoad( albedoTex, coord ).xyz;
 
 				// Same safeAlbedo on both demod and re-mod sides → exact
@@ -390,7 +396,7 @@ export class ASVGF extends RenderStage {
 
 				// Defaults = fresh sample (no temporal blend).
 				const demodResult = vec4( currentLighting, 1.0 ).toVar();
-				const modulatedResult = vec4( currentColor, 1.0 ).toVar();
+				const modulatedResult = vec4( currentColor, currentAlpha ).toVar();
 
 				// forceResetU skips the blend for one frame after asvgf:reset → re-anchors
 				// history to the current (post-reset) scene instead of the stale ping-pong.
@@ -491,7 +497,7 @@ export class ASVGF extends RenderStage {
 							const newHistory = min( prevHistory.add( 1.0 ), maxAccumFrames );
 
 							demodResult.assign( vec4( blendedLighting, newHistory ) );
-							modulatedResult.assign( vec4( blendedLighting.mul( safeAlbedo ), 1.0 ) );
+							modulatedResult.assign( vec4( blendedLighting.mul( safeAlbedo ), currentAlpha ) );
 
 						} );
 
@@ -643,12 +649,6 @@ export class ASVGF extends RenderStage {
 
 		this.on( 'asvgf:reset', () => this.resetTemporalData() );
 
-		this.on( 'asvgf:setTemporal', ( data ) => {
-
-			if ( data && data.enabled !== undefined ) this.setTemporalEnabled( data.enabled );
-
-		} );
-
 		this.on( 'asvgf:updateParameters', ( data ) => this.updateParameters( data ) );
 
 	}

package/src/Stages/BilateralFilter.js

@@ -24,7 +24,9 @@ const bilateralWeight = /*@__PURE__*/ wgslFn( `
 		let lumW = exp( -abs( centerLum - sLum ) / sigmaL );
 		// clamp dot to [0,1]: miss-ray normals decode to (-1,-1,-1) with
 		// dot=3 → pow saturates to +inf → inf*0 = NaN. See project_tsl_pitfalls.
-		let normW = pow( clamp( dot( centerNormal, sNormal ), 0.0, 1.0 ), phiNorm );
+		// max(phiNorm, 1e-6): pow(0.0, 0.0) is undefined in WGSL and returned NaN on ~12%
+		// of pixels when phiNormal was set to 0.
+		let normW = pow( clamp( dot( centerNormal, sNormal ), 0.0, 1.0 ), max( phiNorm, 1e-6 ) );
 		let depW = exp( -abs( centerDepth - sDepth ) / max( centerDepth * phiDep, 0.001 ) );
 		let maxDiff = max( max( abs( centerColor.x - sColor.x ),
 			abs( centerColor.y - sColor.y ) ),
@@ -79,6 +81,8 @@ export class BilateralFilter extends RenderStage {
 		this.stepSizeU = uniform( 1, 'int' );
 		// 1 on the final iteration → multiply by albedo to remodulate.
 		this.isLastIterationU = uniform( 0, 'int' );
+		// 1 on pass 0 → seed variance from variance:output; later passes read the carried value.
+		this.isFirstIterationU = uniform( 1, 'int' );
 		this.resW = uniform( options.width || 1 );
 		this.resH = uniform( options.height || 1 );
 
@@ -87,6 +91,8 @@ export class BilateralFilter extends RenderStage {
 		this._shadingNormalTexNode = new TextureNode();
 		this._albedoTexNode = new TextureNode();
 		this._varianceTexNode = new TextureNode();
+		// pathtracer:color, read only for its alpha (coverage) on the final pass.
+		this._srcAlphaTexNode = new TextureNode();
 
 		const w = options.width || 1;
 		const h = options.height || 1;
@@ -144,6 +150,7 @@ export class BilateralFilter extends RenderStage {
 		const snTexNode = this._shadingNormalTexNode;
 		const albedoTexNode = this._albedoTexNode;
 		const varTexNode = this._varianceTexNode;
+		const srcAlphaTexNode = this._srcAlphaTexNode;
 		const phiColor = this.phiColor;
 		const phiNormal = this.phiNormal;
 		const phiDepth = this.phiDepth;
@@ -151,6 +158,7 @@ export class BilateralFilter extends RenderStage {
 		const spatialVarianceWeight = this.spatialVarianceWeight;
 		const stepSize = this.stepSizeU;
 		const isLastIterationU = this.isLastIterationU;
+		const isFirstIterationU = this.isFirstIterationU;
 		const resW = this.resW;
 		const resH = this.resH;
 
@@ -173,7 +181,8 @@ export class BilateralFilter extends RenderStage {
 			If( gx.lessThan( int( resW ) ).and( gy.lessThan( int( resH ) ) ), () => {
 
 				const coord = ivec2( gx, gy );
-				const centerColor = textureLoad( readTexNode, coord ).xyz;
+				const centerSample = textureLoad( readTexNode, coord );
+				const centerColor = centerSample.xyz;
 				const centerND = textureLoad( ndTexNode, coord );
 				// Normal edge-stop reads the mapped (shading) normal; depth gate stays geometric.
 				const centerNormal = textureLoad( snTexNode, coord ).xyz.mul( 2.0 ).sub( 1.0 );
@@ -182,22 +191,43 @@ export class BilateralFilter extends RenderStage {
 				const centerSafeAlbedo = max( textureLoad( albedoTexNode, coord ).xyz, vec3( ALBEDO_EPS ) );
 				const centerAlbedoLum = max( luminance( centerSafeAlbedo ), float( ALBEDO_EPS ) ).toVar();
 
+				// Variance is filtered alongside colour and carried between passes in the
+				// ping-pong's spare alpha, so sigma_l tightens as the signal smooths. Without
+				// it every pass re-read the unfiltered variance:output and filter strength
+				// never backed off as the render converged.
+				//
+				// Stored as the ROOT: converged variance reaches ~1e-6, a half-float subnormal
+				// that flushes to zero on some drivers. select() rather than If() — an If
+				// around a texture read lets the inactive branch contaminate the result.
+				// .z = temporal, .w = spatial 3×3; blending toward max widens sigma_l where
+				// history is thin.
+				const isFirst = isFirstIterationU.equal( int( 1 ) );
+				const seedVariance = ( at ) => {
+
+					const v = textureLoad( varTexNode, at );
+					return mix( v.z, max( v.z, v.w ), spatialVarianceWeight );
+
+				};
+
+				const centerVariance = isFirst.select(
+					seedVariance( coord ),
+					centerSample.w.mul( centerSample.w )
+				).toVar();
+
 				// sigma_l = phiLum * √variance / albedoLum + ε. Dividing by
 				// albedoLum compensates for the 1/albedo noise amplification
 				// from demodulation — otherwise dark materials get an
 				// under-estimated sigma → over-strict luminance gate → no
 				// blending → silhouette dark-outline artifact.
-				// .z = temporal variance, .w = spatial (3×3) variance. Blend toward
-				// max(temporal, spatial) so disoccluded/low-history pixels widen sigma_l.
-				const vSample = textureLoad( varTexNode, coord );
-				const variance = mix( vSample.z, max( vSample.z, vSample.w ), spatialVarianceWeight );
 				const sigmaL = phiLuminance
-					.mul( sqrt( max( variance, float( 0.0 ) ) ) )
+					.mul( sqrt( max( centerVariance, float( 0.0 ) ) ) )
 					.div( centerAlbedoLum )
 					.add( float( 0.0001 ) );
 
 				const colorSum = vec3( 0.0 ).toVar();
 				const weightSum = float( 0.0 ).toVar();
+				// Squared weights, normalised by weightSum² — the variance of a weighted mean.
+				const varianceSum = float( 0.0 ).toVar();
 
 				// 5×5 à-trous kernel (Gaussian-approx, Σ=1)
 				for ( let iy = 0; iy < 5; iy ++ ) {
@@ -213,7 +243,8 @@ export class BilateralFilter extends RenderStage {
 						const sy = gy.add( stepSize.mul( dy ) )
 							.clamp( int( 0 ), int( resH ).sub( 1 ) );
 
-						const sColor = textureLoad( readTexNode, ivec2( sx, sy ) ).xyz;
+						const sSample = textureLoad( readTexNode, ivec2( sx, sy ) );
+						const sColor = sSample.xyz;
 						const sND = textureLoad( ndTexNode, ivec2( sx, sy ) );
 						const sNormal = textureLoad( snTexNode, ivec2( sx, sy ) ).xyz.mul( 2.0 ).sub( 1.0 );
 						const sDepth = sND.w;
@@ -228,24 +259,39 @@ export class BilateralFilter extends RenderStage {
 							sigmaL, phiNormal, phiDepth, phiColor
 						);
 
+						const sVariance = isFirst.select(
+							seedVariance( ivec2( sx, sy ) ),
+							sSample.w.mul( sSample.w )
+						);
+
 						colorSum.addAssign( sColor.mul( w ) );
 						weightSum.addAssign( w );
+						varianceSum.addAssign( w.mul( w ).mul( max( sVariance, float( 0.0 ) ) ) );
 
 					}
 
 				}
 
 				const filtered = colorSum.div( max( weightSum, float( 0.0001 ) ) );
+				const filteredVariance = varianceSum
+					.div( max( weightSum.mul( weightSum ), float( 1e-8 ) ) );
 
 				// Remodulate by albedo only on the final iteration so the
 				// inner ping-pong stays in demodulated space.
 				const isLast = isLastIterationU.equal( int( 1 ) );
 				const output = isLast.select( filtered.mul( centerSafeAlbedo ), filtered );
 
+				// The last pass restores the path tracer's coverage — Compositor reads .w as
+				// image alpha when transparentBackground is on.
+				const carriedAlpha = isLast.select(
+					textureLoad( srcAlphaTexNode, coord ).w,
+					sqrt( max( filteredVariance, float( 0.0 ) ) )
+				);
+
 				textureStore(
 					writeStorageTex,
 					uvec2( uint( gx ), uint( gy ) ),
-					vec4( output, 1.0 )
+					vec4( output, carriedAlpha )
 				).toWriteOnly();
 
 			} );
@@ -271,6 +317,7 @@ export class BilateralFilter extends RenderStage {
 		const snTex = context.getTexture( this.shadingNormalTextureName ) || ndTex;
 		const albedoTex = context.getTexture( this.albedoTextureName );
 		const varTex = context.getTexture( this.varianceTextureName );
+		const srcAlphaTex = context.getTexture( 'pathtracer:color' );
 
 		if ( ! inputTex ) return;
 
@@ -291,6 +338,18 @@ export class BilateralFilter extends RenderStage {
 		if ( ndTex ) this._normalDepthTexNode.value = ndTex;
 		if ( snTex ) this._shadingNormalTexNode.value = snTex;
 		if ( albedoTex ) this._albedoTexNode.value = albedoTex;
+		// Bind these BEFORE compile too: two TextureNodes still holding the default empty
+		// texture when the node builder runs share one GPU binding, which then resolves to
+		// whichever is assigned last. That aliased varTexNode onto the colour input.
+		//
+		// Safe only because inputTex is a RenderTarget texture, which produces the same
+		// `textureLoad(t, coord, level)` codegen as EmptyTexture — the form the StorageTexture
+		// ping-pong needs on passes 1+. Binding an actual StorageTexture here would emit the
+		// no-level form and later reads would return zero. EdgeFilter must NOT do this: its
+		// pass-0 input IS a StorageTexture.
+		this._readTexNode.value = inputTex;
+		if ( varTex ) this._varianceTexNode.value = varTex;
+		if ( srcAlphaTex ) this._srcAlphaTexNode.value = srcAlphaTex;
 
 		// First-frame compile while StorageTexture-typed nodes still hold
 		// EmptyTexture — codegen then emits textureLoad with the level
@@ -303,8 +362,6 @@ export class BilateralFilter extends RenderStage {
 
 		}
 
-		if ( varTex ) this._varianceTexNode.value = varTex;
-
 		// À-trous iterations: step size 2^i, ping-pong write direction.
 		// Last iteration multiplies by albedo to remodulate.
 		let readTex = inputTex;
@@ -316,6 +373,7 @@ export class BilateralFilter extends RenderStage {
 			this.stepSizeU.value = 1 << i;
 			this._readTexNode.value = readTex;
 			this.isLastIterationU.value = ( i === this.iterations - 1 ) ? 1 : 0;
+			this.isFirstIterationU.value = i === 0 ? 1 : 0;
 
 			this.renderer.compute( writeNode );
 
@@ -420,6 +478,7 @@ export class BilateralFilter extends RenderStage {
 		this._shadingNormalTexNode?.dispose();
 		this._albedoTexNode?.dispose();
 		this._varianceTexNode?.dispose();
+		this._srcAlphaTexNode?.dispose();
 
 	}
 

package/src/Stages/EdgeFilter.js

@@ -73,6 +73,8 @@ export class EdgeFilter extends RenderStage {
 
 		this.stepSizeU = uniform( 1, 'int' );
 		this.isLastIterationU = uniform( 0, 'int' );
+		// 1 on pass 0 → seed variance from variance:output; later passes read the carried value.
+		this.isFirstIterationU = uniform( 1, 'int' );
 		this.resW = uniform( options.width || 1 );
 		this.resH = uniform( options.height || 1 );
 
@@ -202,6 +204,7 @@ export class EdgeFilter extends RenderStage {
 		const phiDepth = this.phiDepth;
 		const stepSize = this.stepSizeU;
 		const isLastIterationU = this.isLastIterationU;
+		const isFirstIterationU = this.isFirstIterationU;
 		const resW = this.resW;
 		const resH = this.resH;
 
@@ -216,7 +219,8 @@ export class EdgeFilter extends RenderStage {
 
 				const coord = ivec2( gx, gy );
 
-				const centerLighting = textureLoad( readTex, coord ).xyz;
+				const centerSample = textureLoad( readTex, coord );
+				const centerLighting = centerSample.xyz;
 				const centerLum = luminance( centerLighting );
 				const centerND = textureLoad( ndTex, coord );
 				const centerDepth = centerND.w;
@@ -233,13 +237,30 @@ export class EdgeFilter extends RenderStage {
 				// max() falls back to the spatial estimate as temporal collapses on a
 				// converging accumulation buffer. Dividing by albedoLum rescales the
 				// modulated-space variance into demodulated space (std ∝ 1/albedo).
-				const vSample = textureLoad( varTex, coord );
-				const variance = max( vSample.z, vSample.w );
-				const sigmaL = phiLuminance.mul( sqrt( max( variance, float( 0.0 ) ) ) )
+				//
+				// Filtered alongside colour and carried between passes as √variance in the
+				// ping-pong's spare alpha, so sigma_l tightens as the signal smooths. Stored as
+				// the root because converged variance (~1e-6) is a half-float subnormal.
+				const isFirst = isFirstIterationU.equal( int( 1 ) );
+				const seedVariance = ( at ) => {
+
+					const v = textureLoad( varTex, at );
+					return max( v.z, v.w );
+
+				};
+
+				const centerVariance = isFirst.select(
+					seedVariance( coord ),
+					centerSample.w.mul( centerSample.w )
+				).toVar();
+
+				const sigmaL = phiLuminance.mul( sqrt( max( centerVariance, float( 0.0 ) ) ) )
 					.div( centerAlbedoLum ).add( float( 0.0001 ) );
 
 				const colorSum = vec3( 0.0 ).toVar();
 				const weightSum = float( 0.0 ).toVar();
+				// Squared weights, normalised by weightSum² — the variance of a weighted mean.
+				const varianceSum = float( 0.0 ).toVar();
 
 				for ( let iy = 0; iy < 5; iy ++ ) {
 
@@ -253,7 +274,8 @@ export class EdgeFilter extends RenderStage {
 						const sy = gy.add( stepSize.mul( dy ) ).clamp( int( 0 ), int( resH ).sub( 1 ) );
 						const sCoord = ivec2( sx, sy );
 
-						const sLighting = textureLoad( readTex, sCoord ).xyz;
+						const sSample = textureLoad( readTex, sCoord );
+						const sLighting = sSample.xyz;
 						const sLum = luminance( sLighting );
 						const sND = textureLoad( ndTex, sCoord );
 						const sDepth = sND.w;
@@ -276,14 +298,22 @@ export class EdgeFilter extends RenderStage {
 						const geomW = mix( float( 1.0 ), normW.mul( depW ), bothHit );
 						const w = float( kw ).mul( lumW ).mul( geomW ).mul( sameKind );
 
+						const sVariance = isFirst.select(
+							seedVariance( sCoord ),
+							sSample.w.mul( sSample.w )
+						);
+
 						colorSum.addAssign( sLighting.mul( w ) );
 						weightSum.addAssign( w );
+						varianceSum.addAssign( w.mul( w ).mul( max( sVariance, float( 0.0 ) ) ) );
 
 					}
 
 				}
 
 				const filtered = colorSum.div( max( weightSum, float( 0.0001 ) ) );
+				const filteredVariance = varianceSum
+					.div( max( weightSum.mul( weightSum ), float( 1e-8 ) ) );
 
 				// Final pass: remodulate by albedo and blend against the raw color by
 				// filterStrength. Inner passes stay in demodulated space.
@@ -293,7 +323,14 @@ export class EdgeFilter extends RenderStage {
 				const finalModulated = mix( rawColor, remodded, filterStrength );
 				const output = isLast.select( finalModulated, filtered );
 
-				textureStore( writeStorageTex, uvec2( uint( gx ), uint( gy ) ), vec4( output, 1.0 ) ).toWriteOnly();
+				// The last pass restores the path tracer's coverage — Compositor reads .w as
+				// image alpha when transparentBackground is on.
+				const carriedAlpha = isLast.select(
+					textureLoad( colorTex, coord ).w,
+					sqrt( max( filteredVariance, float( 0.0 ) ) )
+				);
+
+				textureStore( writeStorageTex, uvec2( uint( gx ), uint( gy ) ), vec4( output, carriedAlpha ) ).toWriteOnly();
 
 			} );
 
@@ -378,6 +415,7 @@ export class EdgeFilter extends RenderStage {
 
 			this.stepSizeU.value = 1 << i;
 			this.isLastIterationU.value = ( i === this.iterations - 1 ) ? 1 : 0;
+			this.isFirstIterationU.value = i === 0 ? 1 : 0;
 			this._readTexNode.value = readTex;
 
 			this.renderer.compute( writeNode );

package/src/Stages/NormalDepth.js

@@ -1,4 +1,4 @@
-import { Fn, vec3, vec4, float, int, uint, uvec2, uniform, normalize, mat3, min, storage, If,
+import { Fn, vec2, vec3, vec4, float, int, uint, uvec2, uniform, min, storage, If,
 	textureStore, workgroupId, localId } from 'three/tsl';
 import { RenderTarget, StorageTexture } from 'three/webgpu';
 import { HalfFloatType, RGBAFormat, NearestFilter, Matrix4, Box2, Vector2 } from 'three';
@@ -6,6 +6,7 @@ import { RenderStage, StageExecutionMode } from '../Pipeline/RenderStage.js';
 import { MAX_STORAGE_TEXTURE_SIZE } from '../EngineDefaults.js';
 import { Ray, HitInfo, RayTracingMaterial, UVCache } from '../TSL/Struct.js';
 import { traverseBVH } from '../TSL/BVHTraversal.js';
+import { cameraRayDirection } from '../TSL/CameraRay.js';
 import { getMaterial } from '../TSL/Common.js';
 import { computeUVCache, processNormal, processBump, buildBucketTextureNodes, refreshBucketTextureNodes, setMaterialBucketTextures } from '../TSL/TextureSampling.js';
 
@@ -48,6 +49,12 @@ export class NormalDepth extends RenderStage {
 
 		this.cameraWorldMatrix = uniform( new Matrix4(), 'mat4' );
 		this.cameraProjectionMatrixInverse = uniform( new Matrix4(), 'mat4' );
+		// Mirrored from the path tracer each frame — these rays must use the same camera model
+		// as the colour buffer or the denoiser's normal/depth edge-stops fight the image.
+		this.cameraProjection = uniform( 0, 'int' );
+		this.panoLonRange = uniform( new Vector2(), 'vec2' );
+		this.panoLatRange = uniform( new Vector2(), 'vec2' );
+		this.panoLevelHorizon = uniform( 1, 'int' );
 		this.resolutionWidth = uniform( options.width || 1 );
 		this.resolutionHeight = uniform( options.height || 1 );
 
@@ -122,8 +129,11 @@ export class NormalDepth extends RenderStage {
 
 		this.on( 'pipeline:reset', () => {
 
+			// _hasHistory is deliberately NOT cleared, mirroring MotionVector.reset(): the
+			// prev-frame G-buffer tracks camera motion, not accumulation, and a camera move
+			// resets accumulation every frame of a drag. Clearing it made render() overwrite
+			// prevRT with the current frame, so ASVGF's temporal gate could never reject.
 			this._dirty = true;
-			this._hasHistory = false;
 
 		} );
 
@@ -149,6 +159,8 @@ export class NormalDepth extends RenderStage {
 			this._bvhStorageNode = null;
 			this._matStorageNode = null;
 			this._dirty = true;
+			// New geometry — the previous frame describes a scene that is no longer there.
+			this._hasHistory = false;
 
 		}
 
@@ -213,20 +225,12 @@ export class NormalDepth extends RenderStage {
 
 			If( gx.lessThan( int( resW ) ).and( gy.lessThan( int( resH ) ) ), () => {
 
-				// Pixel center → NDC, Y negated for Three.js WebGPU.
-				const ndcX = float( gx ).add( 0.5 ).div( resW ).mul( 2.0 ).sub( 1.0 );
-				const ndcY = float( gy ).add( 0.5 ).div( resH ).mul( 2.0 ).sub( 1.0 ).negate();
-				const ndcPos = vec3( ndcX, ndcY, 1.0 );
-
 				// No jitter — deterministic per-pixel ray so the temporal gate
 				// sees stable per-pixel normals across frames.
-				const rayDirCS = camProjInvMat.mul( vec4( ndcPos, 1.0 ) );
-				const rayDirWorld = normalize(
-					mat3(
-						camWorldMat[ 0 ].xyz,
-						camWorldMat[ 1 ].xyz,
-						camWorldMat[ 2 ].xyz
-					).mul( rayDirCS.xyz.div( rayDirCS.w ) )
+				const uv = vec2( float( gx ).add( 0.5 ).div( resW ), float( gy ).add( 0.5 ).div( resH ) );
+				const rayDirWorld = cameraRayDirection(
+					uv, camWorldMat, camProjInvMat,
+					this.cameraProjection, this.panoLonRange, this.panoLatRange, this.panoLevelHorizon
 				);
 				const rayOrigin = vec3( camWorldMat[ 3 ] );
 
@@ -302,6 +306,10 @@ export class NormalDepth extends RenderStage {
 
 			this.cameraWorldMatrix.value.copy( pt.uniforms.get( 'cameraWorldMatrix' ).value );
 			this.cameraProjectionMatrixInverse.value.copy( pt.uniforms.get( 'cameraProjectionMatrixInverse' ).value );
+			this.cameraProjection.value = pt.uniforms.get( 'cameraProjection' ).value;
+			this.panoLonRange.value.copy( pt.uniforms.get( 'panoLonRange' ).value );
+			this.panoLatRange.value.copy( pt.uniforms.get( 'panoLatRange' ).value );
+			this.panoLevelHorizon.value = pt.uniforms.get( 'panoLevelHorizon' ).value;
 
 		}
 
@@ -367,13 +375,16 @@ export class NormalDepth extends RenderStage {
 		this._outputStorageTex?.dispose();
 		this._shadingStorageTex?.dispose();
 		this.reset();
+		// The textures backing the ping-pong are gone, so the prev-frame G-buffer is too.
+		this._hasHistory = false;
 
 	}
 
+	// Accumulation reset only — _hasHistory survives on purpose (see the pipeline:reset
+	// listener). It is invalidated by setSize(), a geometry swap, and releaseGPUMemory().
 	reset() {
 
 		this._dirty = true;
-		this._hasHistory = false;
 
 	}