rayzee 6.2.0 → 6.3.0

package/src/Stages/NormalDepth.js

@@ -7,44 +7,23 @@ import { Ray, HitInfo } from '../TSL/Struct.js';
 import { traverseBVH } from '../TSL/BVHTraversal.js';
 
 /**
- * NormalDepth Stage for WebGPU (Compute Shader)
+ * NormalDepth — primary-ray G-buffer for SVGF gates.
  *
- * Produces a G-buffer containing surface normals and linear depth by casting
- * primary rays through the BVH. This is a lightweight pass (~1-2 ms) that
- * shares the same BVH / triangle / material storage buffers as the path tracer.
+ * RGB = geometric world normal · 0.5 + 0.5, A = linear ray distance (sky=1e6).
+ * Geometric (not shading) normals because shading normals carry sub-pixel
+ * jitter that breaks the temporal gate's same-pixel-across-frames comparison.
+ * The path tracer's MRT already carries shading normals for OIDN; this stage
+ * is a separate, cheap, jitter-free signal for the denoiser.
  *
- * The output is required by denoising stages (ASVGF, BilateralFiltering)
- * and by the MotionVector.
+ * Ping-pong RenderTargets hold current/prev. On a dispatch we swap so prev
+ * is last frame's geometry. On a skipped dispatch (static camera) prev
+ * aliases current — without that aliasing prev would point at older data
+ * while this frame's motion vector reflects zero motion → false rejection.
  *
- * Architecture (copy approach — proven working in PathTracer):
- *   1. Compute shader writes to a StorageTexture via textureStore
- *   2. After dispatch, copyTextureToTexture transfers StorageTexture → RenderTarget
- *   3. RenderTarget texture is published to context (NOT StorageTexture —
- *      cross-dispatch reads from StorageTexture return zeros in Three.js WebGPU)
- *
- * Output format (RGBA Float):
- *   RGB — world-space normal encoded as (N * 0.5 + 0.5)
- *   A   — linear depth (distance along primary ray)
- *
- * Caching: Only re-renders when the camera moves or the scene is rebuilt.
- * During static accumulation the previous result is reused.
- *
- * Execution mode: ALWAYS (but internal dirty flag skips redundant work)
- *
- * Events listened:
- *   camera:moved   — mark dirty
- *   pipeline:reset  — mark dirty
- *
- * Textures published:
- *   pathtracer:normalDepth — RGBA Float G-buffer (from RenderTarget, not StorageTexture)
+ * Publishes: pathtracer:normalDepth, pathtracer:prevNormalDepth
  */
 export class NormalDepth extends RenderStage {
 
-	/**
-	 * @param {WebGPURenderer} renderer
-	 * @param {Object} options
-	 * @param {Object} options.pathTracer — reference to PathTracer (for shared buffers)
-	 */
 	constructor( renderer, options = {} ) {
 
 		super( 'NormalDepth', {
@@ -55,62 +34,48 @@ export class NormalDepth extends RenderStage {
 		this.renderer = renderer;
 		this.pathTracer = options.pathTracer;
 
-		// Dirty flag — only re-render when true
 		this._dirty = true;
 
-		// Own camera uniforms (updated from PathTracer values each frame)
 		this.cameraWorldMatrix = uniform( new Matrix4(), 'mat4' );
 		this.cameraProjectionMatrixInverse = uniform( new Matrix4(), 'mat4' );
-
-		// Resolution uniforms
 		this.resolutionWidth = uniform( options.width || 1 );
 		this.resolutionHeight = uniform( options.height || 1 );
 
 		const w = options.width || 1;
 		const h = options.height || 1;
 
-		// Write-only StorageTexture (compute output)
 		this._outputStorageTex = new StorageTexture( w, h );
 		this._outputStorageTex.type = HalfFloatType;
 		this._outputStorageTex.format = RGBAFormat;
 		this._outputStorageTex.minFilter = NearestFilter;
 		this._outputStorageTex.magFilter = NearestFilter;
 
-		// Readable RenderTarget (copy destination — published to context)
-		this.renderTarget = new RenderTarget( w, h, {
+		// Ping-pong RTs share format with the StorageTexture so copyTextureToTexture works.
+		const rtOpts = {
 			type: HalfFloatType,
 			format: RGBAFormat,
 			minFilter: NearestFilter,
 			magFilter: NearestFilter,
 			depthBuffer: false,
 			stencilBuffer: false
-		} );
+		};
+		this._rtA = new RenderTarget( w, h, rtOpts );
+		this._rtB = new RenderTarget( w, h, rtOpts );
+		this._currentIdx = 0;
+		this._hasHistory = false;
 
-		// Dispatch dimensions (8x8 workgroups)
 		this._dispatchX = Math.ceil( w / 8 );
 		this._dispatchY = Math.ceil( h / 8 );
 
-		// Own storage nodes — created lazily when data is available
 		this._triStorageNode = null;
 		this._bvhStorageNode = null;
-
-		// Last-seen attribute identities. PathTracer replaces these in-place
-		// across model load / BVH rebuild; the compute's bind group is locked
-		// to whatever buffer was bound at pipeline compile time, so we rebuild
-		// when any of them swaps to a new object.
 		this._lastTriAttr = null;
 		this._lastBvhAttr = null;
-
-		// Compute node — built once when storage buffers are ready
 		this._computeNode = null;
 		this._computeBuilt = false;
 
 	}
 
-	// ──────────────────────────────────────────────────
-	// Pipeline lifecycle
-	// ──────────────────────────────────────────────────
-
 	setupEventListeners() {
 
 		this.on( 'camera:moved', () => {
@@ -122,40 +87,23 @@ export class NormalDepth extends RenderStage {
 		this.on( 'pipeline:reset', () => {
 
 			this._dirty = true;
+			this._hasHistory = false;
 
 		} );
 
 	}
 
-	// ──────────────────────────────────────────────────
-	// Storage buffer synchronisation
-	// ──────────────────────────────────────────────────
-
-	/**
-	 * Synchronise storage buffer nodes from PathTracer.
-	 *
-	 * Creates own `storage()` nodes pointing at the same underlying
-	 * StorageInstancedBufferAttribute so the GPU buffer is shared,
-	 * but each compute node has its own binding (avoids the module-scope
-	 * TextureNode issue that breaks MRT).
-	 */
 	_syncStorageBuffers() {
 
 		const pt = this.pathTracer;
 		if ( ! pt ) return false;
 
-		// Detect attribute identity swap (PathTracer.setTriangleData /
-		// setBVHData replace the attribute object on growth). The compute
-		// node's bind group is locked to the buffer bound at compile time —
-		// updating the storage node's .value alone leaves the GPU binding
-		// pointing at the now-discarded buffer, so every traversal misses.
 		const triSwapped = pt.triangleStorageAttr && pt.triangleStorageAttr !== this._lastTriAttr;
 		const bvhSwapped = pt.bvhStorageAttr && pt.bvhStorageAttr !== this._lastBvhAttr;
 
 		if ( triSwapped || bvhSwapped ) {
 
-			// Drop compute + storage nodes so they get rebuilt against the
-			// current buffers. Cheap: this only happens on model load.
+			// Buffer identity changed → compute's bind group is stale; rebuild.
 			this._computeNode?.dispose?.();
 			this._computeNode = null;
 			this._computeBuilt = false;
@@ -188,10 +136,6 @@ export class NormalDepth extends RenderStage {
 
 	}
 
-	// ──────────────────────────────────────────────────
-	// Compute node (built once when buffers are ready)
-	// ──────────────────────────────────────────────────
-
 	_buildCompute() {
 
 		const triStorage = this._triStorageNode;
@@ -204,8 +148,8 @@ export class NormalDepth extends RenderStage {
 
 		const WG_SIZE = 8;
 
-		// Pass mat4 uniforms as Fn parameters so TSL wraps them
-		// with bracket-indexing support (closure captures don't get this)
+		// mat4 uniforms as Fn parameters so TSL emits bracket indexing
+		// (closure captures don't get this).
 		const computeFn = Fn( ( [ camWorldMat, camProjInvMat ] ) => {
 
 			const gx = int( workgroupId.x ).mul( WG_SIZE ).add( int( localId.x ) );
@@ -213,13 +157,13 @@ export class NormalDepth extends RenderStage {
 
 			If( gx.lessThan( int( resW ) ).and( gy.lessThan( int( resH ) ) ), () => {
 
-				// Pixel coordinate → NDC
-				// Negate Y: in WebGPU, pixel Y=0 at top of screen
+				// 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 );
 
-				// Camera ray (no DOF)
+				// 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(
@@ -231,15 +175,11 @@ export class NormalDepth extends RenderStage {
 				const rayOrigin = vec3( camWorldMat[ 3 ] );
 
 				const ray = Ray( { origin: rayOrigin, direction: rayDirWorld } );
-
-				// BVH traversal (primary ray only) — wrap result for struct field access
 				const hit = HitInfo.wrap( traverseBVH( ray, bvhStorage, triStorage ) );
 
-				// Encode: normal * 0.5 + 0.5 in RGB, linear depth in A
 				const encodedNormal = hit.normal.mul( 0.5 ).add( 0.5 );
 				const depth = hit.dst;
 
-				// Sky / miss: zero normal, large depth
 				const result = hit.didHit.select(
 					vec4( encodedNormal, depth ),
 					vec4( 0.0, 0.0, 0.0, float( 1e6 ) )
@@ -264,26 +204,15 @@ export class NormalDepth extends RenderStage {
 
 	}
 
-	// ──────────────────────────────────────────────────
-	// Render
-	// ──────────────────────────────────────────────────
-
 	render( context ) {
 
 		if ( ! this.enabled ) return;
 
-		// Sync storage buffers from path tracer
 		const buffersReady = this._syncStorageBuffers();
 		if ( ! buffersReady ) return;
 
-		// Build compute node on first call (deferred until buffers exist)
-		if ( ! this._computeBuilt ) {
-
-			this._buildCompute();
-
-		}
+		if ( ! this._computeBuilt ) this._buildCompute();
 
-		// Sync camera uniforms from PathTracer
 		const pt = this.pathTracer;
 		if ( pt ) {
 
@@ -292,22 +221,24 @@ export class NormalDepth extends RenderStage {
 
 		}
 
-		// Skip if not dirty (camera hasn't moved, scene hasn't changed)
-		if ( ! this._dirty && this.renderTarget.texture ) {
+		// Static camera: republish current and alias prev to current. Without
+		// the alias, prev would still hold older geometry while motion vector
+		// reflects zero motion → false rejection at every pixel.
+		if ( ! this._dirty && this._hasHistory ) {
 
-			// Still publish the cached texture
-			context.setTexture( 'pathtracer:normalDepth', this.renderTarget.texture );
+			const currentRT = this._currentIdx === 0 ? this._rtA : this._rtB;
+			context.setTexture( 'pathtracer:normalDepth', currentRT.texture );
+			context.setTexture( 'pathtracer:prevNormalDepth', currentRT.texture );
 			return;
 
 		}
 
-		// Auto-match size to path tracer output
 		const ptColor = context.getTexture( 'pathtracer:color' );
 		if ( ptColor && ptColor.image ) {
 
 			const img = ptColor.image;
 			if ( img.width > 0 && img.height > 0 &&
-				( img.width !== this.renderTarget.width || img.height !== this.renderTarget.height ) ) {
+				( img.width !== this._rtA.width || img.height !== this._rtA.height ) ) {
 
 				this.setSize( img.width, img.height );
 
@@ -315,40 +246,46 @@ export class NormalDepth extends RenderStage {
 
 		}
 
-		// Dispatch compute shader
+		// Swap roles: what was current becomes prev, write into the free slot.
+		if ( this._hasHistory ) this._currentIdx = 1 - this._currentIdx;
+		const writeRT = this._currentIdx === 0 ? this._rtA : this._rtB;
+		const prevRT = this._currentIdx === 0 ? this._rtB : this._rtA;
+
 		this.renderer.compute( this._computeNode );
+		this.renderer.copyTextureToTexture( this._outputStorageTex, writeRT.texture );
+
+		// First dispatch: seed prev from current so ASVGF doesn't see false
+		// disocclusion on frame 1.
+		if ( ! this._hasHistory ) {
 
-		// Copy StorageTexture → RenderTarget (cross-dispatch reads from
-		// StorageTexture return zeros — must use RenderTarget for downstream stages)
-		this.renderer.copyTextureToTexture( this._outputStorageTex, this.renderTarget.texture );
+			this.renderer.copyTextureToTexture( this._outputStorageTex, prevRT.texture );
+			this._hasHistory = true;
 
-		// Publish RenderTarget texture to context
-		context.setTexture( 'pathtracer:normalDepth', this.renderTarget.texture );
+		}
+
+		context.setTexture( 'pathtracer:normalDepth', writeRT.texture );
+		context.setTexture( 'pathtracer:prevNormalDepth', prevRT.texture );
 
-		// Clear dirty flag — next frame will reuse cached result
 		this._dirty = false;
 
 	}
 
-	// ──────────────────────────────────────────────────
-	// Lifecycle
-	// ──────────────────────────────────────────────────
-
 	reset() {
 
 		this._dirty = true;
+		this._hasHistory = false;
 
 	}
 
 	setSize( width, height ) {
 
 		this._outputStorageTex.setSize( width, height );
-		this.renderTarget.setSize( width, height );
-		this.renderTarget.texture.needsUpdate = true;
+		this._rtA.setSize( width, height );
+		this._rtB.setSize( width, height );
+		this._hasHistory = false;
 		this.resolutionWidth.value = width;
 		this.resolutionHeight.value = height;
 
-		// Update dispatch dimensions
 		this._dispatchX = Math.ceil( width / 8 );
 		this._dispatchY = Math.ceil( height / 8 );
 		if ( this._computeNode ) {
@@ -365,7 +302,8 @@ export class NormalDepth extends RenderStage {
 
 		this._computeNode?.dispose();
 		this._outputStorageTex?.dispose();
-		this.renderTarget?.dispose();
+		this._rtA?.dispose();
+		this._rtB?.dispose();
 
 	}
 

package/src/TSL/BVHTraversal.js

@@ -44,37 +44,66 @@ const createStack = () => array( 'int', MAX_STACK_DEPTH ).toVar();
 // RAY INTERSECTION HELPERS (inlined for BVH traversal performance)
 // ================================================================================
 
+// Woop watertight intersection (Woop/Benthin/Wald 2013). Eliminates edge leakage
+// at shared triangle edges that Möller-Trumbore exhibits under FP32. Per-ray shears
+// are precomputed once via computeWoopRayParams; per-triangle test is FMA-friendly
+// and uses sign-aware depth comparison so it works for any det orientation.
 const RayTriangleGeometry = wgslFn( `
-	fn RayTriangleGeometry( rayOrigin: vec3f, rayDir: vec3f, pA: vec3f, pB: vec3f, pC: vec3f, closestHitDst: f32 ) -> vec4f {
+	fn RayTriangleGeometry( rayOrigin: vec3f, rayDir: vec3f, pA: vec3f, pB: vec3f, pC: vec3f, closestHitDst: f32, woopParams: vec4f ) -> vec4f {
 
-		// Returns vec4(t, u, v, hit) where hit > 0.5 means intersection
+		// Returns vec4(t, u, v, hit) where hit > 0.5 means intersection.
+		// woopParams: (Sx, Sy, Sz, bitcast<f32>(packed kx|ky<<2|kz<<4))
 		var result = vec4f( 1e20f, 0.0f, 0.0f, 0.0f );
 
-		let edge1 = pB - pA;
-		let edge2 = pC - pA;
-		let h = cross( rayDir, edge2 );
-		let a = dot( edge1, h );
+		let Sx = woopParams.x;
+		let Sy = woopParams.y;
+		let Sz = woopParams.z;
+		// Packed as regular f32 (values 0–42), not bitcast — avoids subnormal FTZ on Apple GPUs.
+		let packed = i32( woopParams.w );
+		let kx = packed & 3;
+		let ky = ( packed >> 2 ) & 3;
+		let kz = ( packed >> 4 ) & 3;
 
-		if ( abs( a ) >= 1e-8f ) {
+		let A = pA - rayOrigin;
+		let B = pB - rayOrigin;
+		let C = pC - rayOrigin;
 
-			let f = 1.0f / a;
-			let s = rayOrigin - pA;
-			let u = f * dot( s, h );
+		let Akz = A[ kz ];
+		let Bkz = B[ kz ];
+		let Ckz = C[ kz ];
 
-			if ( u >= 0.0f && u <= 1.0f ) {
+		let Ax = A[ kx ] - Sx * Akz;
+		let Ay = A[ ky ] - Sy * Akz;
+		let Bx = B[ kx ] - Sx * Bkz;
+		let By = B[ ky ] - Sy * Bkz;
+		let Cx = C[ kx ] - Sx * Ckz;
+		let Cy = C[ ky ] - Sy * Ckz;
 
-				let q = cross( s, edge1 );
-				let v = f * dot( rayDir, q );
+		// Edge function tests — all three must share sign (or be exactly zero) for hit.
+		let U = Cx * By - Cy * Bx;
+		let V = Ax * Cy - Ay * Cx;
+		let W = Bx * Ay - By * Ax;
 
-				if ( v >= 0.0f && ( u + v ) <= 1.0f ) {
+		let neg = U < 0.0f || V < 0.0f || W < 0.0f;
+		let pos = U > 0.0f || V > 0.0f || W > 0.0f;
+		if ( !( neg && pos ) ) {
 
-					let t = f * dot( edge2, q );
+			let det = U + V + W;
+			if ( det != 0.0f ) {
 
-					if ( t > 0.0f && t < closestHitDst ) {
+				let T = U * ( Sz * Akz ) + V * ( Sz * Bkz ) + W * ( Sz * Ckz );
 
-						result = vec4f( t, u, v, 1.0f );
+				// Sign-aware bounds check on t (multiply both sides by sign(det) once).
+				let detSign = select( -1.0f, 1.0f, det > 0.0f );
+				let tSigned = T * detSign;
+				let detAbs = abs( det );
 
-					}
+				if ( tSigned > 0.0f && tSigned < closestHitDst * detAbs ) {
+
+					// Match Möller-Trumbore convention: u = weight of B, v = weight of C.
+					// In Woop's edge functions, U → weight of A, V → weight of B, W → weight of C.
+					let invDet = 1.0f / det;
+					result = vec4f( T * invDet, V * invDet, W * invDet, 1.0f );
 
 				}
 
@@ -87,6 +116,40 @@ const RayTriangleGeometry = wgslFn( `
 	}
 ` );
 
+// Compute Woop ray-space transform (Woop 2013, §3.1) — runs once per ray and
+// amortizes across hundreds of triangle tests. Returns Sx/Sy/Sz shears plus the
+// permuted axis indices packed via bitcast into the .w slot.
+const computeWoopRayParams = wgslFn( `
+	fn computeWoopRayParams( rayDir: vec3f ) -> vec4f {
+
+		let absDir = abs( rayDir );
+
+		// kz = argmax(|dir|)
+		var kz: i32 = 0;
+		if ( absDir.y >= absDir.x ) { kz = 1; }
+		if ( absDir.z >= absDir[ u32( kz ) ] ) { kz = 2; }
+
+		var kx: i32 = ( kz + 1 ) % 3;
+		var ky: i32 = ( kx + 1 ) % 3;
+
+		// Preserve triangle winding when the dominant axis component is negative.
+		if ( rayDir[ u32( kz ) ] < 0.0f ) {
+			let tmp = kx;
+			kx = ky;
+			ky = tmp;
+		}
+
+		let dz = rayDir[ u32( kz ) ];
+		let Sx = rayDir[ u32( kx ) ] / dz;
+		let Sy = rayDir[ u32( ky ) ] / dz;
+		let Sz = 1.0f / dz;
+
+		let packed = kx | ( ky << 2 ) | ( kz << 4 );
+		return vec4f( Sx, Sy, Sz, f32( packed ) );
+
+	}
+` );
+
 const fastRayAABBDst = wgslFn( `
 	fn fastRayAABBDst( rayOrigin: vec3f, invDir: vec3f, boxMin: vec3f, boxMax: vec3f ) -> f32 {
 
@@ -151,6 +214,9 @@ export const traverseBVH = Fn( ( [
 	const rayOrigin = ray.origin;
 	const rayDirection = ray.direction;
 
+	// Woop watertight intersection: precompute per-ray shears + axis permutation.
+	const woopParams = computeWoopRayParams( { rayDir: rayDirection } ).toVar();
+
 	const iterCount = int( 0 ).toVar();
 
 	Loop( stackPtr.greaterThan( int( 0 ) ).and( iterCount.lessThan( int( MAX_BVH_ITERATIONS ) ) ), () => {
@@ -186,7 +252,7 @@ export const traverseBVH = Fn( ( [
 					const pB = getDatafromStorageBuffer( triangleBuffer, triIndex, int( 1 ), int( TRI_STRIDE ) ).xyz;
 					const pC = getDatafromStorageBuffer( triangleBuffer, triIndex, int( 2 ), int( TRI_STRIDE ) ).xyz;
 
-					const triResult = RayTriangleGeometry( { rayOrigin, rayDir: rayDirection, pA, pB, pC, closestHitDst: closestHit.dst } );
+					const triResult = RayTriangleGeometry( { rayOrigin, rayDir: rayDirection, pA, pB, pC, closestHitDst: closestHit.dst, woopParams } );
 
 					// RayTriangleGeometry already guarantees t < closestHit.dst when w > 0.5
 					If( triResult.w.greaterThan( 0.5 ), () => {
@@ -205,13 +271,15 @@ export const traverseBVH = Fn( ( [
 						const nC = normalCData.xyz;
 						const side = int( normalCData.w ).toVar();
 
-						// Interpolate normal
+						// Interpolate normal for the side-culling dot product (kept local,
+						// not stored on closestHit — re-derived post-loop from closestTriIdx).
 						const w = float( 1.0 ).sub( u ).sub( v );
-						const normal = normalize( nA.mul( w ).add( nB.mul( u ) ).add( nC.mul( v ) ) ).toVar();
+						const rayDotNormal = rayDirection.dot(
+							normalize( nA.mul( w ).add( nB.mul( u ) ).add( nC.mul( v ) ) )
+						);
 
 						// Side culling (inline; per-mesh visibility is at the BLAS-pointer level).
 						// 0=front (reject back-facing), 1=back (reject front-facing), 2=double (pass).
-						const rayDotNormal = rayDirection.dot( normal );
 						const sidePass = side.equal( int( 2 ) )
 							.or( side.equal( int( 0 ) ).and( rayDotNormal.lessThan( - 0.0001 ) ) )
 							.or( side.equal( int( 1 ) ).and( rayDotNormal.greaterThan( 0.0001 ) ) );
@@ -219,10 +287,9 @@ export const traverseBVH = Fn( ( [
 
 							closestHit.didHit.assign( true );
 							closestHit.dst.assign( t );
-							closestHit.normal.assign( normal );
 
-							// Defer materialIndex/meshIndex/hitPoint/UV to post-traversal
-							// (all re-derived from closestTriIdx with a single uvData2 fetch below).
+							// Defer normal/materialIndex/meshIndex/hitPoint/UV to post-traversal
+							// (all re-derived from closestTriIdx after the loop exits).
 							closestTriIdx.assign( triIndex );
 							closestU.assign( u );
 							closestV.assign( v );
@@ -245,11 +312,9 @@ export const traverseBVH = Fn( ( [
 				// BLAS-pointer leaf (marker -2) — push BLAS root onto stack if mesh is visible
 				// nodeData0: [blasRootNodeIndex, meshIndex, visibility, -2]
 				// Visibility is free-fetched with the leaf — no extra storage read.
-				const blasRoot = int( nodeData0.x ).toVar();
-
 				If( nodeData0.z.greaterThan( 0.5 ).and( stackPtr.lessThan( int( MAX_STACK_DEPTH ) ) ), () => {
 
-					stack.element( stackPtr ).assign( blasRoot );
+					stack.element( stackPtr ).assign( int( nodeData0.x ) );
 					stackPtr.addAssign( 1 );
 
 				} );
@@ -275,14 +340,11 @@ export const traverseBVH = Fn( ( [
 
 				// Improved node ordering with fewer conditionals
 				const aCloser = dstA.lessThan( dstB );
-				const nearChild = select( aCloser, leftChild, rightChild ).toVar();
-				const farChild = select( aCloser, rightChild, leftChild ).toVar();
-				const farDst = select( aCloser, dstB, dstA ).toVar();
 
 				// Push far child first (processed last)
-				If( farDst.lessThan( closestHit.dst ).and( stackPtr.lessThan( int( MAX_STACK_DEPTH ) ) ), () => {
+				If( select( aCloser, dstB, dstA ).lessThan( closestHit.dst ).and( stackPtr.lessThan( int( MAX_STACK_DEPTH ) ) ), () => {
 
-					stack.element( stackPtr ).assign( farChild );
+					stack.element( stackPtr ).assign( select( aCloser, rightChild, leftChild ) );
 					stackPtr.addAssign( 1 );
 
 				} );
@@ -290,7 +352,7 @@ export const traverseBVH = Fn( ( [
 				// Push near child second (processed first)
 				If( stackPtr.lessThan( int( MAX_STACK_DEPTH ) ), () => {
 
-					stack.element( stackPtr ).assign( nearChild );
+					stack.element( stackPtr ).assign( select( aCloser, leftChild, rightChild ) );
 					stackPtr.addAssign( 1 );
 
 				} );
@@ -301,12 +363,20 @@ export const traverseBVH = Fn( ( [
 
 	} );
 
-	// Deferred: compute hitPoint, UVs, and fetch matIdx/meshIndex once for the final closest hit
+	// Deferred: compute normal, hitPoint, UVs, and fetch matIdx/meshIndex once for the final closest hit
 	If( closestHit.didHit, () => {
 
 		closestHit.hitPoint.assign( ray.origin.add( ray.direction.mul( closestHit.dst ) ) );
 
 		const w = float( 1.0 ).sub( closestU ).sub( closestV );
+
+		// Re-fetch the winning triangle's normals — trading 3 storage reads (once)
+		// for ~3 regs freed across every BVH iteration.
+		const nA = getDatafromStorageBuffer( triangleBuffer, closestTriIdx, int( 3 ), int( TRI_STRIDE ) ).xyz;
+		const nB = getDatafromStorageBuffer( triangleBuffer, closestTriIdx, int( 4 ), int( TRI_STRIDE ) ).xyz;
+		const nC = getDatafromStorageBuffer( triangleBuffer, closestTriIdx, int( 5 ), int( TRI_STRIDE ) ).xyz;
+		closestHit.normal.assign( normalize( nA.mul( w ).add( nB.mul( closestU ) ).add( nC.mul( closestV ) ) ) );
+
 		const uvData1 = getDatafromStorageBuffer( triangleBuffer, closestTriIdx, int( 6 ), int( TRI_STRIDE ) );
 		const uvData2 = getDatafromStorageBuffer( triangleBuffer, closestTriIdx, int( 7 ), int( TRI_STRIDE ) );
 		closestHit.uv.assign(
@@ -356,6 +426,9 @@ export const traverseBVHShadow = Fn( ( [
 		lessThan( abs( ray.direction ), vec3( 1e-8 ) )
 	).toVar();
 
+	// Woop watertight intersection: precompute per-ray shears + axis permutation.
+	const woopParams = computeWoopRayParams( { rayDir: ray.direction } ).toVar();
+
 	const sIterCount = int( 0 ).toVar();
 
 	Loop( stackPtr.greaterThan( int( 0 ) ).and( closestHit.didHit.not() ).and( sIterCount.lessThan( int( MAX_BVH_ITERATIONS ) ) ), () => {
@@ -383,7 +456,7 @@ export const traverseBVHShadow = Fn( ( [
 					const pB = getDatafromStorageBuffer( triangleBuffer, triIndex, int( 1 ), int( TRI_STRIDE ) ).xyz;
 					const pC = getDatafromStorageBuffer( triangleBuffer, triIndex, int( 2 ), int( TRI_STRIDE ) ).xyz;
 
-					const triResult = RayTriangleGeometry( { rayOrigin: ray.origin, rayDir: ray.direction, pA, pB, pC, closestHitDst: closestHit.dst } );
+					const triResult = RayTriangleGeometry( { rayOrigin: ray.origin, rayDir: ray.direction, pA, pB, pC, closestHitDst: closestHit.dst, woopParams } );
 
 					If( triResult.w.greaterThan( 0.5 ), () => {
 
@@ -418,11 +491,9 @@ export const traverseBVHShadow = Fn( ( [
 
 				// BLAS-pointer leaf (marker -2) — push BLAS root onto stack if mesh is visible
 				// nodeData0: [blasRootNodeIndex, meshIndex, visibility, -2]
-				const blasRoot = int( nodeData0.x ).toVar();
-
 				If( nodeData0.z.greaterThan( 0.5 ).and( stackPtr.lessThan( int( MAX_STACK_DEPTH ) ) ), () => {
 
-					stack.element( stackPtr ).assign( blasRoot );
+					stack.element( stackPtr ).assign( int( nodeData0.x ) );
 					stackPtr.addAssign( 1 );
 
 				} );
@@ -449,14 +520,11 @@ export const traverseBVHShadow = Fn( ( [
 			If( minDst.lessThan( closestHit.dst ), () => {
 
 				const aCloser = dstA.lessThan( dstB );
-				const nearChild = select( aCloser, leftChild, rightChild ).toVar();
-				const farChild = select( aCloser, rightChild, leftChild ).toVar();
-				const farDst = select( aCloser, dstB, dstA ).toVar();
 
 				// Push far child first (processed last)
-				If( farDst.lessThan( closestHit.dst ).and( stackPtr.lessThan( int( MAX_STACK_DEPTH ) ) ), () => {
+				If( select( aCloser, dstB, dstA ).lessThan( closestHit.dst ).and( stackPtr.lessThan( int( MAX_STACK_DEPTH ) ) ), () => {
 
-					stack.element( stackPtr ).assign( farChild );
+					stack.element( stackPtr ).assign( select( aCloser, rightChild, leftChild ) );
 					stackPtr.addAssign( 1 );
 
 				} );
@@ -464,7 +532,7 @@ export const traverseBVHShadow = Fn( ( [
 				// Push near child second (processed first)
 				If( stackPtr.lessThan( int( MAX_STACK_DEPTH ) ), () => {
 
-					stack.element( stackPtr ).assign( nearChild );
+					stack.element( stackPtr ).assign( select( aCloser, leftChild, rightChild ) );
 					stackPtr.addAssign( 1 );
 
 				} );
@@ -510,9 +578,6 @@ export const generateRayFromCamera = Fn( ( [
 	// Check if DOF is disabled or conditions make it ineffective
 	If( enableDOF.and( focalLength.greaterThan( 0.0 ) ).and( aperture.lessThan( 64.0 ) ).and( focusDistance.greaterThan( 0.001 ) ), () => {
 
-		// Calculate focal point - where rays converge
-		const focalPoint = rayOriginWorld.add( rayDirectionWorld.mul( focusDistance ) ).toVar();
-
 		// Physical aperture calculation
 		const effectiveAperture = focalLength.div( aperture );
 		// Apply scene scale to maintain correct physical aperture size
@@ -534,7 +599,7 @@ export const generateRayFromCamera = Fn( ( [
 
 		// Calculate new ray from offset origin to focal point
 		resultOrigin.assign( rayOriginWorld.add( offset ) );
-		resultDirection.assign( normalize( focalPoint.sub( resultOrigin ) ) );
+		resultDirection.assign( normalize( rayOriginWorld.add( rayDirectionWorld.mul( focusDistance ) ).sub( resultOrigin ) ) );
 
 	} );