rayzee 7.20.2 → 7.21.0

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

@@ -122,8 +122,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 +152,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;
 
 		}
 
@@ -367,13 +372,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;
 
 	}
 

package/src/Stages/PathTracer.js

@@ -272,6 +272,7 @@ export class PathTracer extends PathTracerStage {
 
 		this._updateAccumulationUniforms( frameValue, renderMode );
 		this.frame.value = frameValue;
+		this.seedFrame.value = this._seedTick ++;
 
 		this._setWfDispatch();
 
@@ -942,7 +943,9 @@ export class PathTracer extends PathTracerStage {
 			rngBufferRW: pb.rngBuffer.rw,
 			gBufferRW,
 			resolution: this.resolution,
-			frame: this.frame,
+			// RNG axis only (baseSeed + stratified jitter) — takes the seed counter, not the
+			// accumulation index. FinalWrite keeps `frame`.
+			frame: this.seedFrame,
 			cameraWorldMatrix: this.cameraWorldMatrix,
 			cameraProjectionMatrixInverse: this.cameraProjectionMatrixInverse,
 			enableDOF: this.enableDOF,
@@ -1180,7 +1183,6 @@ export class PathTracer extends PathTracerStage {
 			environmentIntensity: this.environmentIntensity,
 			envMatrix: this.environmentMatrix,
 			enableEnvironmentLight: this.enableEnvironment,
-			useEnvMapIS: this.useEnvMapIS,
 			groundProjectionEnabled: this.groundProjectionEnabled,
 			groundProjectionRadius: this.groundProjectionRadius,
 			groundProjectionHeight: this.groundProjectionHeight,
@@ -1210,7 +1212,9 @@ export class PathTracer extends PathTracerStage {
 			cameraProjectionMatrix: this.cameraProjectionMatrix,
 			cameraViewMatrix: this.cameraViewMatrix,
 			fireflyThreshold: this.fireflyThreshold,
-			frame: this.frame,
+			// RNG axis only (keys STBN via frame & 63).
+			frame: this.seedFrame,
+			accumFrame: this.frame,
 			resolution: this.resolution,
 			emissiveTriangleCount: this.emissiveTriangleCount,
 			emissiveVec4Offset: this.emissiveVec4Offset,

package/src/Stages/PathTracerStage.js

@@ -51,7 +51,6 @@ const BVH_VEC4_PER_NODE = 4;
  * - camera:moved - When camera position/orientation changes
  * - asvgf:reset - Request ASVGF to reset temporal data
  * - asvgf:updateParameters - Update ASVGF parameters
- * - asvgf:setTemporal - Enable/disable ASVGF temporal accumulation
  *
  * Textures published to context:
  * - pathtracer:color - Main color output
@@ -143,6 +142,11 @@ export class PathTracerStage extends RenderStage {
 		this.lastCameraMatrix = new Matrix4();
 		this.lastProjectionMatrix = new Matrix4();
 
+		// Sampler seed axis — advances per rendered frame, survives accumulation resets.
+		// Pinned back to the accumulation index in deterministic mode.
+		this._seedTick = 0;
+		this._pinSeedToFrame = false;
+
 		// Denoising management state
 		this.lastRenderMode = - 1;
 		this.renderModeChangeTimeout = null;
@@ -293,18 +297,6 @@ export class PathTracerStage extends RenderStage {
 
 					}
 				},
-				useEnvMapIS: {
-					get value() {
-
-						return self.useEnvMapIS.value;
-
-					},
-					set value( v ) {
-
-						self.useEnvMapIS.value = v;
-
-					}
-				},
 				enableAccumulation: {
 					get value() {
 
@@ -348,7 +340,6 @@ export class PathTracerStage extends RenderStage {
 			enabled: DEFAULT_STATE.interactionModeEnabled,
 			qualitySettings: {
 				maxBounceCount: 1,
-				useEnvMapIS: false,
 				enableAccumulation: false,
 				enableEmissiveTriangleSampling: false,
 			},
@@ -651,10 +642,14 @@ export class PathTracerStage extends RenderStage {
 		this.isComplete = false;
 		this.performanceMonitor?.reset();
 
-		this.lastRenderMode = - 1;
-
+		// lastRenderMode is deliberately NOT invalidated here — clearing it made
+		// manageASVGFForRenderMode see a phantom mode change 50 ms after every reset, wiping
+		// ASVGF's history. A real mode change is still caught by the renderMode comparison.
 		this.lastInteractionModeState = false;
 
+		// Only deterministic mode rewinds the seed axis; see _pinSeedToFrame.
+		if ( this._pinSeedToFrame ) this._seedTick = 0;
+
 	}
 
 	/**
@@ -1238,7 +1233,10 @@ export class PathTracerStage extends RenderStage {
 				if ( this.pendingRenderMode !== null && this.pendingRenderMode !== this.lastRenderMode ) {
 
 					this.lastRenderMode = this.pendingRenderMode;
-					this._onRenderModeChanged( this.pendingRenderMode );
+					// History from the previous mode is not comparable. temporalAlpha is NOT
+					// touched here — it is owned by ASVGF_QUALITY_PRESETS, and overwriting it
+					// with a hardcoded value meant `medium` and `high` never took effect.
+					this.emit( 'asvgf:reset' );
 
 				}
 
@@ -1249,35 +1247,6 @@ export class PathTracerStage extends RenderStage {
 
 		}
 
-		this._handleFullQuadASVGF();
-
-	}
-
-	_onRenderModeChanged( newMode ) {
-
-		if ( newMode === 1 ) {
-
-			this.emit( 'asvgf:updateParameters', {
-				enableDebug: false,
-				temporalAlpha: 0.15
-			} );
-
-		} else {
-
-			this.emit( 'asvgf:updateParameters', {
-				temporalAlpha: 0.1,
-			} );
-
-		}
-
-		this.emit( 'asvgf:reset' );
-
-	}
-
-	_handleFullQuadASVGF() {
-
-		this.emit( 'asvgf:setTemporal', { enabled: true } );
-
 	}
 
 	// ===== UNIFORM & DATA SETTERS =====

package/src/TSL/Clearcoat.js

@@ -1,7 +1,7 @@
 import {
 	Fn,
 	vec3,
-	float,
+	int,
 	dot,
 	normalize,
 	reflect,
@@ -11,12 +11,14 @@ import {
 
 import { struct } from './patches.js';
 
-import { AnisoFrame, DotProducts } from './Struct.js';
-import { PI, MIN_CLEARCOAT_ROUGHNESS, computeDotProductsAniso, anisoTangentFrame } from './Common.js';
-import { DistributionGGX, computeAnisoAlphas, calculateVNDFPDFAniso } from './MaterialProperties.js';
-import { ImportanceSampleGGX, ImportanceSampleCosine, sampleGGXVNDFAniso } from './MaterialSampling.js';
-import { evaluateLayeredBRDF } from './MaterialEvaluation.js';
-import { RandomValue } from './Random.js';
+import { AnisoFrame, DotProducts,
+	BRDFWeights,
+} from './Struct.js';
+import { MIN_CLEARCOAT_ROUGHNESS, computeDotProductsAniso, anisoTangentFrame, constructTBN } from './Common.js';
+import { computeAnisoAlphas, calculateBRDFWeightsFromMaterial, calculateBSDFSamplingPDF } from './MaterialProperties.js';
+import { ImportanceSampleCosine, sampleGGXVNDF, sampleGGXVNDFAniso } from './MaterialSampling.js';
+import { evaluateMaterialResponseFromDots } from './MaterialEvaluation.js';
+import { getRandomSample1D } from './Random.js';
 
 export const ClearcoatResult = struct( {
 	brdf: 'vec3',
@@ -29,6 +31,7 @@ export const ClearcoatResult = struct( {
 // L (light direction) is returned via the out pattern as a separate return
 export const sampleClearcoat = Fn( ( [
 	ray, hitInfo, material, randomSample, rngState,
+	pixelCoord, resolution, frame, dimBase,
 ] ) => {
 
 	const N = hitInfo.normal;
@@ -38,27 +41,26 @@ export const sampleClearcoat = Fn( ( [
 	const clearcoatRoughness = max( material.clearcoatRoughness, MIN_CLEARCOAT_ROUGHNESS );
 	const baseRoughness = max( material.roughness, MIN_CLEARCOAT_ROUGHNESS );
 
-	// Calculate sampling weights based on material properties
-	const specularWeight = float( 1.0 ).sub( baseRoughness ).mul( float( 0.5 ).add( float( 0.5 ).mul( material.metalness ) ) ).toVar();
-	const clearcoatWeight = material.clearcoat.mul( float( 1.0 ).sub( clearcoatRoughness ) ).toVar();
-	const diffuseWeight = float( 1.0 ).sub( specularWeight ).mul( float( 1.0 ).sub( material.metalness ) ).toVar();
-
-	// Normalize weights
-	const total = specularWeight.add( clearcoatWeight ).add( diffuseWeight );
-	specularWeight.divAssign( total );
-	clearcoatWeight.divAssign( total );
-	diffuseWeight.divAssign( total );
+	// The shared selection probabilities, NOT a fourth private scheme. This function used to
+	// derive its own specular/clearcoat/diffuse split, so a clearcoat material was sampled with
+	// one set of probabilities while every MIS site evaluated the density of another — the white
+	// furnace read the resulting mismatch as an energy error that flipped sign once the other
+	// sites were unified.
+	const weights = BRDFWeights.wrap( calculateBRDFWeightsFromMaterial( material ) ).toVar();
+	const clearcoatWeight = weights.clearcoat.toVar();
+	const specularWeight = weights.specular.toVar();
 
 	// Choose which layer to sample
-	const rand = RandomValue( rngState );
+	const rand = getRandomSample1D( pixelCoord, int( 0 ), dimBase.add( int( 13 ) ), rngState, resolution, frame );
 
 	const L = vec3( 0.0 ).toVar();
 	const H = vec3( 0.0 ).toVar();
 
 	If( rand.lessThan( clearcoatWeight ), () => {
 
-		// Sample clearcoat layer
-		H.assign( ImportanceSampleGGX( { N, roughness: clearcoatRoughness, Xi: randomSample } ) );
+		// Sample clearcoat layer (VNDF — see the base-specular note below)
+		const ccTBN = constructTBN( { N } );
+		H.assign( ccTBN.mul( sampleGGXVNDF( { V: ccTBN.transpose().mul( V ), roughness: clearcoatRoughness, Xi: randomSample } ) ) );
 		L.assign( reflect( V.negate(), H ) );
 
 	} ).ElseIf( rand.lessThan( clearcoatWeight.add( specularWeight ) ), () => {
@@ -74,7 +76,9 @@ export const sampleClearcoat = Fn( ( [
 
 		} ).Else( () => {
 
-			H.assign( ImportanceSampleGGX( { N, roughness: baseRoughness, Xi: randomSample } ) );
+			// VNDF to match the density the MIS sites evaluate for this lobe.
+			const tbn = constructTBN( { N } );
+			H.assign( tbn.mul( sampleGGXVNDF( { V: tbn.transpose().mul( V ), roughness: baseRoughness, Xi: randomSample } ) ) );
 
 		} );
 		L.assign( reflect( V.negate(), H ) );
@@ -90,27 +94,12 @@ export const sampleClearcoat = Fn( ( [
 	// Calculate dot products (aniso-aware: also projects onto the anisotropy frame)
 	const dots = DotProducts.wrap( computeDotProductsAniso( N, V, L, material ) );
 
-	// Calculate individual PDFs. Clearcoat layer is always isotropic; the base specular
-	// matches its sampler — VNDF-aniso when anisotropy>0, else the half-vector GGX pdf.
-	const clearcoatPDF = DistributionGGX( dots.NoH, clearcoatRoughness ).mul( dots.NoH ).div( float( 4.0 ).mul( dots.VoH ) ).mul( clearcoatWeight );
-	const specularPDF = float( 0.0 ).toVar();
-	If( material.anisotropy.greaterThan( 0.0 ), () => {
-
-		const a = computeAnisoAlphas( material.roughness, material.anisotropy );
-		specularPDF.assign( calculateVNDFPDFAniso( a.x, a.y, dots.NoH, dots.ToH, dots.BoH, dots.NoV, dots.ToV, dots.BoV ).mul( specularWeight ) );
-
-	} ).Else( () => {
-
-		specularPDF.assign( DistributionGGX( dots.NoH, baseRoughness ).mul( dots.NoH ).div( float( 4.0 ).mul( dots.VoH ) ).mul( specularWeight ) );
-
-	} );
-	const diffusePDF = dots.NoL.div( PI ).mul( diffuseWeight );
-
-	// Combined PDF using MIS
-	const pdf = max( clearcoatPDF.add( specularPDF ).add( diffusePDF ), 0.001 );
+	// One density for every MIS site — see calculateBSDFSamplingPDF.
+	const pdf = max( calculateBSDFSamplingPDF( material, weights, dots ), 0.001 );
 
 	// Evaluate complete BRDF
-	const brdf = evaluateLayeredBRDF( dots, material );
+	// The same BRDF every other site evaluates — see the clearcoat note in MaterialEvaluation.
+	const brdf = evaluateMaterialResponseFromDots( material, dots );
 
 	// Return brdf, L direction, and pdf packed together
 	// Caller needs L and pdf - return as struct-like output

package/src/TSL/Common.js

@@ -1,10 +1,9 @@
-import { Fn, wgslFn, float, vec2, vec3, vec4, int, mat3, If, max, dot, clamp, bool as tslBool } from 'three/tsl';
+import { Fn, wgslFn, float, vec2, vec3, vec4, int, mat3, If, max, dot, clamp } from 'three/tsl';
 
 import {
 	AnisoFrame,
 	DotProducts,
 	MaterialClassification,
-	MISStrategy,
 	RayTracingMaterial,
 	ShadowMaterial,
 } from './Struct.js';
@@ -299,51 +298,6 @@ export const classifyMaterial = Fn( ( [ metalness, roughness, transmission, clea
 
 } );
 
-// Dynamic MIS strategy based on material properties
-export const selectOptimalMISStrategy = Fn( ( [ roughness, metalness, bounceIndex, throughput ] ) => {
-
-	const throughputStrength = maxComponent( { v: throughput } ).toVar();
-
-	// Environment is now handled via deterministic NEE — not part of stochastic selection.
-	// Only lights and BRDF are stochastically selected.
-	const brdfWeight = float( 0.5 ).toVar();
-	const lightWeight = float( 0.5 ).toVar();
-	const useBRDFSampling = tslBool( true );
-	const useLightSampling = throughputStrength.greaterThan( 0.01 );
-
-	If( roughness.lessThan( 0.1 ).and( metalness.greaterThan( 0.8 ) ), () => {
-
-		// Highly specular materials — favor BRDF
-		brdfWeight.assign( 0.7 );
-		lightWeight.assign( 0.3 );
-
-	} ).ElseIf( roughness.greaterThan( 0.7 ), () => {
-
-		// Diffuse materials — favor light sampling
-		brdfWeight.assign( 0.4 );
-		lightWeight.assign( 0.6 );
-
-	} );
-
-	// Gentle adjustment for very deep bounces — shift toward BRDF
-	If( bounceIndex.greaterThan( int( 5 ) ), () => {
-
-		brdfWeight.assign( 0.6 );
-		lightWeight.assign( 0.4 );
-
-	} );
-
-	return MISStrategy( {
-		brdfWeight,
-		lightWeight,
-		envWeight: float( 0.0 ),
-		useBRDFSampling,
-		useLightSampling,
-		useEnvSampling: tslBool( false ),
-	} );
-
-} );
-
 // Storage buffer access — flat 1D indexing (WebGPU native)
 // No 2D coordinate math needed: directly indexes into the buffer
 export const getDatafromStorageBuffer = Fn( ( [ buffer, stride, sampleIndex, dataOffset ] ) => {

package/src/TSL/EmissiveSampling.js

@@ -3,7 +3,6 @@
 
 import {
 	Fn,
-	vec2,
 	vec3,
 	float,
 	int,
@@ -27,7 +26,7 @@ import {
 
 import { struct } from './patches.js';
 import { MIN_PDF, getDatafromStorageBuffer, powerHeuristic, MATERIAL_SLOTS, MATERIAL_SLOT, computeDotProductsAniso } from './Common.js';
-import { RandomValue } from './Random.js';
+import { getRandomSample1D, getRandomSample2D } from './Random.js';
 import { calculateMaterialPDFFromDots } from './LightsSampling.js';
 import { evaluateMaterialResponseFromDots } from './MaterialEvaluation.js';
 import { DotProducts } from './Struct.js';
@@ -390,6 +389,7 @@ const binarySearchCDF = Fn( ( [ emissiveTriangleBuffer, emissiveOffset, emissive
 export const sampleEmissiveTriangle = Fn( ( [
 	hitPoint, surfaceNormal,
 	rngState,
+	pixelCoord, resolution, frame, dimBase,
 	emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower,
 	triangleBuffer,
 ] ) => {
@@ -410,7 +410,7 @@ export const sampleEmissiveTriangle = Fn( ( [
 	If( emissiveTriangleCount.greaterThan( int( 0 ) ), () => {
 
 		// CDF importance-weighted triangle selection (brighter triangles sampled more)
-		const randEmissive = RandomValue( rngState );
+		const randEmissive = getRandomSample1D( pixelCoord, int( 0 ), dimBase.add( int( 1 ) ), rngState, resolution, frame );
 		const emissiveIndex = binarySearchCDF( emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, randEmissive ).toVar();
 
 		// Fetch emissive triangle data from packed light buffer (2 vec4s per entry)
@@ -427,10 +427,7 @@ export const sampleEmissiveTriangle = Fn( ( [
 		// Fetch triangle geometry
 		const triData = TriangleData.wrap( fetchTriangleData( triangleIndex, triangleBuffer ) );
 
-		// Generate random numbers for sampling
-		const xi_r1 = RandomValue( rngState ).toVar();
-		const xi_r2 = RandomValue( rngState ).toVar();
-		const xi = vec2( xi_r1, xi_r2 );
+		const xi = getRandomSample2D( pixelCoord, int( 0 ), dimBase.add( int( 3 ) ), rngState, resolution, frame ).toVar();
 
 		const geoNormal = normalize( cross( triData.v1.sub( triData.v0 ), triData.v2.sub( triData.v0 ) ) );
 
@@ -532,6 +529,7 @@ export const sampleEmissiveTriangle = Fn( ( [
 export const calculateEmissiveTriangleContributionDebug = Fn( ( [
 	hitPoint, normal, viewDir, material,
 	bounceIndex, rngState,
+	pixelCoord, resolution, frame, dimBase,
 	emissiveBoost,
 	emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower,
 	triangleBuffer,
@@ -547,60 +545,57 @@ export const calculateEmissiveTriangleContributionDebug = Fn( ( [
 		distance: float( 0.0 ),
 	} ).toVar();
 
-	// Skip for very rough diffuse surfaces on secondary bounces
-	const skip = bounceIndex.greaterThan( int( 1 ) ).and( material.roughness.greaterThan( 0.9 ) ).and( material.metalness.lessThan( 0.1 ) );
+	// No rough-diffuse secondary-bounce skip: dropping NEE while the emissive-hit MIS still
+	// down-weights BSDF hits deletes emitter energy from deep GI.
 
-	If( skip.not(), () => {
-
-		// Sample emissive triangle (CDF importance-weighted)
-		const emissiveSample = EmissiveSample.wrap( sampleEmissiveTriangle(
-			hitPoint, normal, rngState,
-			emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower,
-			triangleBuffer,
-		) );
-
-		If( emissiveSample.valid.and( emissiveSample.pdf.greaterThan( 0.0 ) ), () => {
+	// Sample emissive triangle (CDF importance-weighted)
+	const emissiveSample = EmissiveSample.wrap( sampleEmissiveTriangle(
+		hitPoint, normal, rngState,
+		pixelCoord, resolution, frame, dimBase,
+		emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower,
+		triangleBuffer,
+	) );
 
-			result.hasEmissive.assign( true );
-			result.emissionOnly.assign( emissiveSample.emission );
-			result.distance.assign( emissiveSample.distance );
+	If( emissiveSample.valid.and( emissiveSample.pdf.greaterThan( 0.0 ) ), () => {
 
-			// Check geometric validity
-			const NoL = max( float( 0.0 ), dot( normal, emissiveSample.direction ) );
+		result.hasEmissive.assign( true );
+		result.emissionOnly.assign( emissiveSample.emission );
+		result.distance.assign( emissiveSample.distance );
 
-			If( NoL.greaterThan( 0.0 ), () => {
+		// Check geometric validity
+		const NoL = max( float( 0.0 ), dot( normal, emissiveSample.direction ) );
 
-				// Calculate ray offset for shadow ray
-				const rayOffset = calculateRayOffsetFn( hitPoint, normal, material );
-				const rayOrigin = hitPoint.add( rayOffset );
+		If( NoL.greaterThan( 0.0 ), () => {
 
-				// Trace shadow ray
-				const shadowDist = emissiveSample.distance.sub( 0.001 );
-				const visibility = traceShadowRayFn( rayOrigin, emissiveSample.direction, shadowDist );
+			// Calculate ray offset for shadow ray
+			const rayOffset = calculateRayOffsetFn( hitPoint, normal, material );
+			const rayOrigin = hitPoint.add( rayOffset );
 
-				If( visibility.greaterThan( 0.0 ), () => {
+			// Trace shadow ray
+			const shadowDist = emissiveSample.distance.sub( 0.001 );
+			const visibility = traceShadowRayFn( rayOrigin, emissiveSample.direction, shadowDist );
 
-					// Share H + dot products between BRDF eval and PDF (computeDotProducts
-					// would otherwise run twice with identical inputs).
-					const dots = DotProducts.wrap( computeDotProductsAniso( normal, viewDir, emissiveSample.direction, material ) );
-					const brdfValue = evaluateMaterialResponseFromDots( material, dots );
-					const brdfPdf = calculateMaterialPDFFromDots( material, dots );
+			If( visibility.greaterThan( 0.0 ), () => {
 
-					// MIS weight: balance light sampling vs BRDF sampling
-					const misWeight = select(
-						brdfPdf.greaterThan( 0.0 ),
-						powerHeuristic( { pdf1: emissiveSample.pdf, pdf2: brdfPdf } ),
-						float( 1.0 )
-					);
+				// Share H + dot products between BRDF eval and PDF (computeDotProducts
+				// would otherwise run twice with identical inputs).
+				const dots = DotProducts.wrap( computeDotProductsAniso( normal, viewDir, emissiveSample.direction, material ) );
+				const brdfValue = evaluateMaterialResponseFromDots( material, dots );
+				const brdfPdf = calculateMaterialPDFFromDots( material, dots );
 
-					// MC estimator: Le * brdf * cos_surface / pdf_solidAngle
-					// emissiveBoost is an additional user-controlled intensity multiplier
-					result.contribution.assign(
-						emissiveSample.emission.mul( brdfValue ).mul( NoL )
-							.div( emissiveSample.pdf ).mul( visibility ).mul( emissiveBoost ).mul( misWeight )
-					);
+				// MIS weight: balance light sampling vs BRDF sampling
+				const misWeight = select(
+					brdfPdf.greaterThan( 0.0 ),
+					powerHeuristic( { pdf1: emissiveSample.pdf, pdf2: brdfPdf } ),
+					float( 1.0 )
+				);
 
-				} );
+				// MC estimator: Le * brdf * cos_surface / pdf_solidAngle
+				// emissiveBoost is an additional user-controlled intensity multiplier
+				result.contribution.assign(
+					emissiveSample.emission.mul( brdfValue ).mul( NoL )
+						.div( emissiveSample.pdf ).mul( visibility ).mul( emissiveBoost ).mul( misWeight )
+				);
 
 			} );
 
@@ -616,6 +611,7 @@ export const calculateEmissiveTriangleContributionDebug = Fn( ( [
 export const calculateEmissiveTriangleContribution = Fn( ( [
 	hitPoint, normal, viewDir, material,
 	bounceIndex, rngState,
+	pixelCoord, resolution, frame, dimBase,
 	emissiveBoost,
 	emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower,
 	triangleBuffer,
@@ -626,6 +622,7 @@ export const calculateEmissiveTriangleContribution = Fn( ( [
 	const result = EmissiveContributionResult.wrap( calculateEmissiveTriangleContributionDebug(
 		hitPoint, normal, viewDir, material,
 		bounceIndex, rngState,
+		pixelCoord, resolution, frame, dimBase,
 		emissiveBoost,
 		emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower,
 		triangleBuffer,