rayzee 7.0.0 → 7.2.0

package/src/Stages/NormalDepth.js

@@ -1,11 +1,13 @@
 import { Fn, vec3, vec4, float, int, uint, uvec2, uniform, normalize, mat3, storage, If,
-	textureStore, workgroupId, localId } from 'three/tsl';
+	texture, textureStore, workgroupId, localId } from 'three/tsl';
 import { RenderTarget, StorageTexture } from 'three/webgpu';
-import { HalfFloatType, RGBAFormat, NearestFilter, Matrix4, Box2, Vector2 } from 'three';
+import { HalfFloatType, RGBAFormat, NearestFilter, LinearFilter, DataArrayTexture, Matrix4, Box2, Vector2 } from 'three';
 import { RenderStage, StageExecutionMode } from '../Pipeline/RenderStage.js';
 import { MAX_STORAGE_TEXTURE_SIZE } from '../EngineDefaults.js';
-import { Ray, HitInfo } from '../TSL/Struct.js';
+import { Ray, HitInfo, RayTracingMaterial, UVCache } from '../TSL/Struct.js';
 import { traverseBVH } from '../TSL/BVHTraversal.js';
+import { getMaterial } from '../TSL/Common.js';
+import { computeUVCache, processNormal, processBump } from '../TSL/TextureSampling.js';
 
 /**
  * NormalDepth — primary-ray G-buffer for SVGF gates.
@@ -21,7 +23,13 @@ import { traverseBVH } from '../TSL/BVHTraversal.js';
  * aliases current — without that aliasing prev would point at older data
  * while this frame's motion vector reflects zero motion → false rejection.
  *
- * Publishes: pathtracer:normalDepth, pathtracer:prevNormalDepth
+ * Also emits a SHADING normal (geometric normal perturbed by the normal/bump
+ * map, recomputed from the SAME deterministic hit — no extra ray) so the
+ * spatial denoiser's edge-stop can see normal-map detail the flat geometric
+ * normal hides. Deterministic ⇒ jitter-free, so it's safe for the gates.
+ *
+ * Publishes: pathtracer:normalDepth, pathtracer:prevNormalDepth,
+ *            pathtracer:shadingNormal
  */
 export class NormalDepth extends RenderStage {
 
@@ -52,6 +60,22 @@ export class NormalDepth extends RenderStage {
 		this._outputStorageTex.minFilter = NearestFilter;
 		this._outputStorageTex.magFilter = NearestFilter;
 
+		// Shading-normal output (geometric normal perturbed by normal/bump map).
+		// Single buffer — only the spatial filter (current frame) consumes it.
+		this._shadingStorageTex = new StorageTexture( MAX_STORAGE_TEXTURE_SIZE, MAX_STORAGE_TEXTURE_SIZE );
+		this._shadingStorageTex.type = HalfFloatType;
+		this._shadingStorageTex.format = RGBAFormat;
+		this._shadingStorageTex.minFilter = NearestFilter;
+		this._shadingStorageTex.magFilter = NearestFilter;
+		this._shadingRT = new RenderTarget( w, h, {
+			type: HalfFloatType,
+			format: RGBAFormat,
+			minFilter: NearestFilter,
+			magFilter: NearestFilter,
+			depthBuffer: false,
+			stencilBuffer: false
+		} );
+
 		this._srcRegion = new Box2( new Vector2( 0, 0 ), new Vector2( 0, 0 ) );
 
 		// Ping-pong RTs share format with the StorageTexture so copyTextureToTexture works.
@@ -73,11 +97,30 @@ export class NormalDepth extends RenderStage {
 
 		this._triStorageNode = null;
 		this._bvhStorageNode = null;
+		this._matStorageNode = null;
 		this._lastTriAttr = null;
 		this._lastBvhAttr = null;
+		this._lastMatAttr = null;
 		this._computeNode = null;
 		this._computeBuilt = false;
 
+		// Normal/bump map array nodes — persistent placeholders, value swapped to
+		// the real DataArrayTextures on model load. processNormal/processBump
+		// runtime-guard on map indices, so the placeholder is never sampled.
+		this._normalMapsTex = texture( this._makePlaceholderArray() );
+		this._bumpMapsTex = texture( this._makePlaceholderArray() );
+
+	}
+
+	_makePlaceholderArray() {
+
+		const t = new DataArrayTexture( new Uint8Array( [ 128, 128, 255, 255 ] ), 1, 1, 1 );
+		t.minFilter = LinearFilter;
+		t.magFilter = LinearFilter;
+		t.generateMipmaps = false;
+		t.needsUpdate = true;
+		return t;
+
 	}
 
 	setupEventListeners() {
@@ -102,10 +145,12 @@ export class NormalDepth extends RenderStage {
 		const pt = this.pathTracer;
 		if ( ! pt ) return false;
 
+		const matAttr = pt.materialData?.materialStorageAttr;
 		const triSwapped = pt.triangleStorageAttr && pt.triangleStorageAttr !== this._lastTriAttr;
 		const bvhSwapped = pt.bvhStorageAttr && pt.bvhStorageAttr !== this._lastBvhAttr;
+		const matSwapped = matAttr && matAttr !== this._lastMatAttr;
 
-		if ( triSwapped || bvhSwapped ) {
+		if ( triSwapped || bvhSwapped || matSwapped ) {
 
 			// Buffer identity changed → compute's bind group is stale; rebuild.
 			this._computeNode?.dispose?.();
@@ -113,6 +158,7 @@ export class NormalDepth extends RenderStage {
 			this._computeBuilt = false;
 			this._triStorageNode = null;
 			this._bvhStorageNode = null;
+			this._matStorageNode = null;
 			this._dirty = true;
 
 		}
@@ -133,10 +179,22 @@ export class NormalDepth extends RenderStage {
 
 		}
 
+		if ( matAttr && ! this._matStorageNode ) {
+
+			this._matStorageNode = storage( matAttr, 'vec4', matAttr.count ).toReadOnly();
+
+		}
+
+		// In-place map swaps (model change) — graph closes over the node, only .value changes.
+		const md = pt.materialData;
+		if ( md?.normalMaps ) this._normalMapsTex.value = md.normalMaps;
+		if ( md?.bumpMaps ) this._bumpMapsTex.value = md.bumpMaps;
+
 		this._lastTriAttr = pt.triangleStorageAttr || this._lastTriAttr;
 		this._lastBvhAttr = pt.bvhStorageAttr || this._lastBvhAttr;
+		this._lastMatAttr = matAttr || this._lastMatAttr;
 
-		return !! ( this._triStorageNode && this._bvhStorageNode );
+		return !! ( this._triStorageNode && this._bvhStorageNode && this._matStorageNode );
 
 	}
 
@@ -144,11 +202,15 @@ export class NormalDepth extends RenderStage {
 
 		const triStorage = this._triStorageNode;
 		const bvhStorage = this._bvhStorageNode;
+		const matStorage = this._matStorageNode;
+		const normalMaps = this._normalMapsTex;
+		const bumpMaps = this._bumpMapsTex;
 		const camWorld = this.cameraWorldMatrix;
 		const camProjInv = this.cameraProjectionMatrixInverse;
 		const resW = this.resolutionWidth;
 		const resH = this.resolutionHeight;
 		const outputTex = this._outputStorageTex;
+		const shadingTex = this._shadingStorageTex;
 
 		const WG_SIZE = 8;
 
@@ -195,6 +257,31 @@ export class NormalDepth extends RenderStage {
 					result
 				).toWriteOnly();
 
+				// Shading normal: perturb the geometric normal by the normal/bump map
+				// from the SAME hit (deterministic UV → jitter-free). Miss → geo default.
+				const shadingNormal = hit.normal.toVar();
+				If( hit.didHit, () => {
+
+					const material = RayTracingMaterial.wrap(
+						getMaterial( hit.materialIndex, matStorage )
+					).toVar();
+					const uvCache = UVCache.wrap( computeUVCache( hit.uv, material ) ).toVar();
+					const mapped = processNormal( normalMaps, hit.normal, material, uvCache ).toVar();
+					shadingNormal.assign( processBump( bumpMaps, mapped, material, uvCache ) );
+
+				} );
+
+				const shadingResult = hit.didHit.select(
+					vec4( shadingNormal.mul( 0.5 ).add( 0.5 ), depth ),
+					vec4( 0.0, 0.0, 0.0, float( 1e6 ) )
+				);
+
+				textureStore(
+					shadingTex,
+					uvec2( uint( gx ), uint( gy ) ),
+					shadingResult
+				).toWriteOnly();
+
 			} );
 
 		} );
@@ -233,6 +320,7 @@ export class NormalDepth extends RenderStage {
 			const currentRT = this._currentIdx === 0 ? this._rtA : this._rtB;
 			context.setTexture( 'pathtracer:normalDepth', currentRT.texture );
 			context.setTexture( 'pathtracer:prevNormalDepth', currentRT.texture );
+			context.setTexture( 'pathtracer:shadingNormal', this._shadingRT.texture );
 			return;
 
 		}
@@ -257,9 +345,10 @@ export class NormalDepth extends RenderStage {
 
 		this.renderer.compute( this._computeNode );
 
-		// Copy only the active region out of the over-allocated StorageTexture.
+		// Copy only the active region out of the over-allocated StorageTextures.
 		this._srcRegion.max.set( writeRT.width, writeRT.height );
 		this.renderer.copyTextureToTexture( this._outputStorageTex, writeRT.texture, this._srcRegion );
+		this.renderer.copyTextureToTexture( this._shadingStorageTex, this._shadingRT.texture, this._srcRegion );
 
 		// First dispatch: seed prev from current so ASVGF doesn't see false
 		// disocclusion on frame 1.
@@ -272,6 +361,7 @@ export class NormalDepth extends RenderStage {
 
 		context.setTexture( 'pathtracer:normalDepth', writeRT.texture );
 		context.setTexture( 'pathtracer:prevNormalDepth', prevRT.texture );
+		context.setTexture( 'pathtracer:shadingNormal', this._shadingRT.texture );
 
 		this._dirty = false;
 
@@ -294,6 +384,8 @@ export class NormalDepth extends RenderStage {
 		this._rtA.texture.needsUpdate = true;
 		this._rtB.setSize( width, height );
 		this._rtB.texture.needsUpdate = true;
+		this._shadingRT.setSize( width, height );
+		this._shadingRT.texture.needsUpdate = true;
 		this._hasHistory = false;
 		this.resolutionWidth.value = width;
 		this.resolutionHeight.value = height;
@@ -314,6 +406,8 @@ export class NormalDepth extends RenderStage {
 
 		this._computeNode?.dispose();
 		this._outputStorageTex?.dispose();
+		this._shadingStorageTex?.dispose();
+		this._shadingRT?.dispose();
 		this._rtA?.dispose();
 		this._rtB?.dispose();
 

package/src/Stages/Variance.js

@@ -1,4 +1,4 @@
-import { Fn, wgslFn, float, int, uint, ivec2, uvec2, uniform, If, max,
+import { Fn, wgslFn, float, int, uint, ivec2, uvec2, uniform, If, max, select,
 	textureLoad, textureStore, workgroupArray, workgroupBarrier, localId, workgroupId } from 'three/tsl';
 import { RenderTarget, TextureNode, StorageTexture } from 'three/webgpu';
 import { FloatType, RGBAFormat, LinearFilter, Box2, Vector2 } from 'three';
@@ -6,6 +6,10 @@ import { RenderStage, StageExecutionMode } from '../Pipeline/RenderStage.js';
 import { luminance } from '../TSL/Common.js';
 import { MAX_STORAGE_TEXTURE_SIZE } from '../EngineDefaults.js';
 
+// NaN/±Inf guard: a poisoned luminance would otherwise corrupt the moment EMA forever
+// (mean/meanSq → variance → BilateralFilter sigmaL). NaN (x!=x) → 0, ±Inf → [0,1e7].
+const sanitizeLum = ( x ) => select( x.equal( x ), x, float( 0.0 ) ).clamp( 0.0, 1e7 );
+
 // ── wgslFn helpers ──────────────────────────────────────────
 
 /**
@@ -203,7 +207,7 @@ export class Variance extends RenderStage {
 			const gy1 = tileOriginY.add( int( sy1 ) ).clamp( int( 0 ), int( resH ).sub( 1 ) );
 
 			const sColor1 = textureLoad( colorTex, ivec2( gx1, gy1 ) ).xyz;
-			sharedLum.element( linearIdx ).assign( luminance( sColor1 ) );
+			sharedLum.element( linearIdx ).assign( sanitizeLum( luminance( sColor1 ) ) );
 
 			// Load #2: threads 0-35 load positions 64-99
 			If( linearIdx.lessThan( uint( EXTRA_LOAD ) ), () => {
@@ -215,7 +219,7 @@ export class Variance extends RenderStage {
 				const gy2 = tileOriginY.add( int( sy2 ) ).clamp( int( 0 ), int( resH ).sub( 1 ) );
 
 				const sColor2 = textureLoad( colorTex, ivec2( gx2, gy2 ) ).xyz;
-				sharedLum.element( idx2 ).assign( luminance( sColor2 ) );
+				sharedLum.element( idx2 ).assign( sanitizeLum( luminance( sColor2 ) ) );
 
 			} );
 

package/src/TSL/GenerateKernel.js

@@ -19,7 +19,7 @@ import { Ray } from './Struct.js';
 import { RAY_FLAG } from '../Processor/QueueManager.js';
 import {
 	writeRayOriginMeta, writeRayDirFlags, writeRayThroughputPdf,
-	writeRayRadiance, writeGBuffer,
+	writeRayRadiance, writeGBuffer, writeGBufferSurfaceID,
 	writeMediumStack,
 } from '../Processor/PackedRayBuffer.js';
 
@@ -91,6 +91,8 @@ export function buildGenerateKernel( params ) {
 
 				// default: normal +Z, depth 1 (far), black albedo (background/miss)
 				writeGBuffer( gBufferRW, uint( pixelIndex ), vec3( 0.0, 0.0, 1.0 ), float( 1.0 ), vec3( 0.0 ) );
+				// surface-ID lane defaults to invalid (valid=0); Shade overwrites it at the bounce-0 hit.
+				writeGBufferSurfaceID( gBufferRW, uint( pixelIndex ), uint( 0 ), uint( 0 ), float( 0.0 ), float( 0.0 ), uint( 0 ) );
 
 			} );
 

package/src/TSL/ShadeKernel.js

@@ -48,9 +48,9 @@ import {
 	readMediumStack, writeMediumStack, readMediumSigmaA, writeMediumSigmaA,
 	readPathBounces, readSssSteps, readSSSMedium, writeSSSMedium,
 	readHitDistance, readHitBarycentrics, readHitNormal,
-	readHitMaterialIndex, readHitTriangleIndex,
+	readHitMaterialIndex, readHitTriangleIndex, readHitMeshIndex,
 	writeRayOriginMeta, writeRayDirFlags, writeRayThroughputPdf, writeRayRadiance,
-	writeGBuffer, readGBuffer, gbDecodeNormalDepth,
+	writeGBuffer, writeGBufferSurfaceID, readGBuffer, gbDecodeNormalDepth,
 	readRayRadiance,
 } from '../Processor/PackedRayBuffer.js';
 
@@ -374,6 +374,9 @@ export function buildShadeKernel( params ) {
 			If( sampleIndex.equal( int( 0 ) ), () => {
 
 				writeGBuffer( gBufferRW, pixelIndex, vec3( 0.0, 0.0, 1.0 ), linearDepth, vec3( 0.0 ) );
+				// Persist the primary-hit surface ID (Tier-1 A-SVGF correlated re-projection). Hit-only
+				// branch (misses Return above), so this marks the pixel valid; bary from the bounce-0 hit.
+				writeGBufferSurfaceID( gBufferRW, pixelIndex, hitTriIdx, readHitMeshIndex( hitBufferRO, rayID ), hitUV.x, hitUV.y, uint( 1 ) );
 
 			} );
 

package/src/managers/CameraManager.js

@@ -42,6 +42,7 @@ export class CameraManager extends EventDispatcher {
 		this._lastValidFocusDistance = null;
 		this._smoothedFocusDistance = null;
 		this._afPointDirty = false;
+		this._afSuspended = false;
 
 		// Saved state for default camera when switching to model cameras
 		this._defaultCameraState = null;
@@ -273,6 +274,24 @@ export class CameraManager extends EventDispatcher {
 
 		if ( this.autoFocusMode === 'manual' ) return;
 
+		// Depth-of-field is the only consumer of the auto-focus distance. With DOF
+		// off (the default) the per-frame scene raycast is pure waste, so skip it.
+		// Re-snap on the frame DOF turns back on so focus is correct immediately
+		// rather than racking from a stale smoothed value.
+		if ( ! pathTracer?.enableDOF?.value ) {
+
+			this._afSuspended = true;
+			return;
+
+		}
+
+		if ( this._afSuspended ) {
+
+			this._afSuspended = false;
+			this._smoothedFocusDistance = null;
+
+		}
+
 		// Lock focus during active tiled final rendering
 		const stage = pathTracer;
 		if ( stage?.isReady