rayzee 7.20.2 → 7.20.3

package/src/TSL/LightsIndirect.js

@@ -7,398 +7,79 @@
  * strategy — it is handled via deterministic NEE in LightsSampling.js.
  *
  * Contains:
- *  - calculateTransmissionPDF  — transmission PDF for MIS
- *  - calculateClearcoatPDF     — clearcoat PDF for MIS
- *  - computeSamplingInfo       — compute importance weights for material strategies
- *  - selectSamplingStrategy    — CDF-based strategy selection (specular, diffuse, transmission, clearcoat)
  *  - calculateIndirectLighting — material multi-strategy MIS for bounce direction
  */
 
-import {
-	Fn,
-	float,
-	vec2,
-	vec3,
-	int,
-	bool as tslBool,
-	max,
-	abs,
-	sqrt,
-	dot,
-	If,
-	select,
-} from 'three/tsl';
+import { Fn, float, vec3, int, max, dot, If, select } from 'three/tsl';
 
-import {
-	IndirectLightingResult,
-} from './LightsCore.js';
-import {
-	SamplingStrategyWeights,
-} from './Struct.js';
-import {
-	PI_INV,
-	EPSILON,
-	MIN_PDF,
-} from './Common.js';
-import { DistributionGGX, calculateVNDFPDF, specularVNDFPDFForDir } from './MaterialProperties.js';
-import { evaluateMaterialResponse } from './MaterialEvaluation.js';
-import { RandomValue } from './Random.js';
-import { sampleMicrofacetTransmission, MicrofacetTransmissionResult } from './MaterialTransmission.js';
+import { IndirectLightingResult } from './LightsCore.js';
+import { MIN_PDF } from './Common.js';
+import { getRandomSample2D } from './Random.js';
 import { cosineWeightedSample } from './MaterialSampling.js';
 
-// =============================================================================
-// PDF Calculation Helpers
-// =============================================================================
-
-// Transmission PDF (Walter et al. 2007)
-export const calculateTransmissionPDF = Fn( ( [ V, L, N, ior, roughness, entering ] ) => {
-
-	// eta is the relative IOR: eta_transmitted / eta_incident
-	// When entering: air(1.0) -> material(ior), so eta = ior
-	// When exiting: material(ior) -> air(1.0), so eta = 1.0/ior
-	const eta = select( entering, ior, float( 1.0 ).div( ior ) ).toVar();
-
-	// Transmission half-vector formula
-	const H_raw = V.add( L.mul( eta ) ).toVar();
-	const lenSq = dot( H_raw, H_raw ).toVar();
-	const H = select( lenSq.greaterThan( EPSILON ), H_raw.div( sqrt( lenSq ) ), N ).toVar();
-
-	// Ensure H points into the correct hemisphere
-	If( dot( H, N ).lessThan( 0.0 ), () => {
-
-		H.assign( H.negate() );
-
-	} );
-
-	const VoH = abs( dot( V, H ) );
-	const LoH = abs( dot( L, H ) ).toVar();
-	const NoH = abs( dot( N, H ) ).toVar();
-
-	// GGX distribution
-	const D = DistributionGGX( NoH, roughness );
-
-	// Jacobian for transmission
-	const denom_inner = VoH.add( LoH.mul( eta ) ).toVar();
-	const denom = denom_inner.mul( denom_inner );
-	const jacobian = LoH.mul( eta ).mul( eta ).div( max( denom, EPSILON ) );
-
-	return D.mul( NoH ).mul( jacobian );
-
-} );
-
-// Clearcoat PDF
-export const calculateClearcoatPDF = Fn( ( [ V, L, N, clearcoatRoughness ] ) => {
-
-	const H_raw = V.add( L ).toVar();
-	const lenSq = dot( H_raw, H_raw ).toVar();
-	const H = select( lenSq.greaterThan( EPSILON ), H_raw.div( sqrt( lenSq ) ), N );
-
-	const NoH = max( dot( N, H ), 0.0 );
-	const NoV = max( dot( N, V ), 0.0 );
-
-	return calculateVNDFPDF( NoH, NoV, clearcoatRoughness );
-
-} );
-
-// =============================================================================
-// Sampling Strategy Computation
-// =============================================================================
-
-// Compute normalized strategy weights based on importance info
-export const computeSamplingInfo = Fn( ( [
-	samplingInfo,
-] ) => {
-
-	// Material-only strategies (env handled via deterministic NEE in direct lighting)
-	const specularW = samplingInfo.specularImportance.toVar();
-	const useSpecular = specularW.greaterThan( 0.001 ).toVar();
-
-	const diffuseW = samplingInfo.diffuseImportance.toVar();
-	const useDiffuse = diffuseW.greaterThan( 0.001 ).toVar();
-
-	const transmissionW = samplingInfo.transmissionImportance.toVar();
-	const useTransmission = transmissionW.greaterThan( 0.001 ).toVar();
-
-	const clearcoatW = samplingInfo.clearcoatImportance.toVar();
-	const useClearcoat = clearcoatW.greaterThan( 0.001 ).toVar();
-
-	const totalW = specularW.add( diffuseW ).add( transmissionW ).add( clearcoatW ).toVar();
-
-	If( totalW.lessThan( 0.001 ), () => {
-
-		specularW.assign( 0.0 );
-		diffuseW.assign( 1.0 );
-		transmissionW.assign( 0.0 );
-		clearcoatW.assign( 0.0 );
-		totalW.assign( 1.0 );
-		useSpecular.assign( tslBool( false ) );
-		useDiffuse.assign( tslBool( true ) );
-		useTransmission.assign( tslBool( false ) );
-		useClearcoat.assign( tslBool( false ) );
-
-	} ).Else( () => {
-
-		const invTotal = float( 1.0 ).div( totalW ).toVar();
-		specularW.mulAssign( invTotal );
-		diffuseW.mulAssign( invTotal );
-		transmissionW.mulAssign( invTotal );
-		clearcoatW.mulAssign( invTotal );
-		totalW.assign( 1.0 );
-
-	} );
-
-	return SamplingStrategyWeights( {
-		envWeight: float( 0.0 ),
-		specularWeight: specularW,
-		diffuseWeight: diffuseW,
-		transmissionWeight: transmissionW,
-		clearcoatWeight: clearcoatW,
-		totalWeight: totalW,
-		useEnv: tslBool( false ),
-		useSpecular,
-		useDiffuse,
-		useTransmission,
-		useClearcoat,
-	} );
-
-} );
-
-// =============================================================================
-// Strategy Selection via Cumulative Distribution
-// =============================================================================
-
-// Strategy IDs: 1=specular, 2=diffuse, 3=transmission, 4=clearcoat
-// (env removed — handled via deterministic NEE in direct lighting)
-export const selectSamplingStrategy = Fn( ( [ weights, randomValue ] ) => {
-
-	const selectedStrategy = int( 2 ).toVar(); // Default: diffuse
-
-	const cumulative = float( 0.0 ).toVar();
-	const found = tslBool( false ).toVar();
-
-	If( weights.useSpecular.and( found.not() ), () => {
-
-		cumulative.addAssign( weights.specularWeight );
-
-		If( randomValue.lessThan( cumulative ), () => {
-
-			selectedStrategy.assign( 1 );
-			found.assign( tslBool( true ) );
-
-		} );
-
-	} );
-
-	If( weights.useDiffuse.and( found.not() ), () => {
 
-		cumulative.addAssign( weights.diffuseWeight );
 
-		If( randomValue.lessThan( cumulative ), () => {
 
-			selectedStrategy.assign( 2 );
-			found.assign( tslBool( true ) );
 
-		} );
-
-	} );
-
-	If( weights.useTransmission.and( found.not() ), () => {
-
-		cumulative.addAssign( weights.transmissionWeight );
-
-		If( randomValue.lessThan( cumulative ), () => {
-
-			selectedStrategy.assign( 3 );
-			found.assign( tslBool( true ) );
-
-		} );
-
-	} );
-
-	If( weights.useClearcoat.and( found.not() ), () => {
-
-		selectedStrategy.assign( 4 );
-
-	} );
-
-	return selectedStrategy;
-
-} );
-
-// =============================================================================
-// Cosine Weighted PDF helper
-// =============================================================================
-
-const cosineWeightedPDF = Fn( ( [ NoL ] ) => {
-
-	return max( NoL, 0.0 ).mul( PI_INV );
-
-} );
 
 // =============================================================================
 // Indirect Lighting Calculation
 // =============================================================================
 
 export const calculateIndirectLighting = Fn( ( [
-	V, N, material,
+	N, material,
 	// brdfSample fields (DirectionSample)
 	brdfSampleDirection, brdfSamplePdf, brdfSampleValue,
+	// DirectionSample carries these so refraction throughput does not need a second sampler run.
+	isTransmission, brdfSampleColorWeight,
 	rngState,
-	samplingInfo,
+	pixelCoord, resolution, frame, dimBase,
 ] ) => {
 
 	// Initialize result
 	const r_direction = vec3( 0.0 ).toVar();
 	const r_throughput = vec3( 0.0 ).toVar();
-	const r_misWeight = float( 0.0 ).toVar();
-	const r_pdf = float( 0.0 ).toVar();
 	const r_combinedPdf = float( 0.0 ).toVar();
 
-	// Validate input sampling info
-	const validInput = samplingInfo.diffuseImportance.greaterThanEqual( 0.0 )
-		.and( samplingInfo.specularImportance.greaterThanEqual( 0.0 ) )
-		.and( samplingInfo.transmissionImportance.greaterThanEqual( 0.0 ) )
-		.and( samplingInfo.clearcoatImportance.greaterThanEqual( 0.0 ) );
+	// A non-finite pdf would poison the accumulation buffer permanently, so fall back to a
+	// cosine bounce rather than dividing by it.
+	If( brdfSamplePdf.greaterThan( 0.0 ).not(), () => {
 
-	If( validInput.not(), () => {
-
-		// Fallback to diffuse sampling
-		const r1_fb = RandomValue( rngState ).toVar();
-		const r2_fb = RandomValue( rngState ).toVar();
-		const sampleRand = vec2( r1_fb, r2_fb );
+		const sampleRand = getRandomSample2D( pixelCoord, int( 0 ), dimBase.add( int( 8 ) ), rngState, resolution, frame );
 		r_direction.assign( cosineWeightedSample( N, sampleRand ) );
 		r_throughput.assign( material.color.xyz );
-		r_misWeight.assign( 1.0 );
-		r_pdf.assign( 1.0 );
+		r_combinedPdf.assign( 1.0 );
 
 	} ).Else( () => {
 
-		// Use corrected sampling info
-		const weights = SamplingStrategyWeights.wrap( computeSamplingInfo(
-			samplingInfo,
-		).toVar() );
-
-		const selectionRand = RandomValue( rngState ).toVar();
-		const r1 = RandomValue( rngState ).toVar();
-		const r2 = RandomValue( rngState ).toVar();
-		const sampleRand = vec2( r1, r2 ).toVar();
-
-		// Strategy selection
-		const selectedStrategy = selectSamplingStrategy( weights, selectionRand ).toVar();
-
-		const sampleDir = vec3( 0.0 ).toVar();
-		const samplePdf = float( 0.0 ).toVar();
-		const sampleBrdfValue = vec3( 0.0 ).toVar();
-		// Transmission lobe uses this weight instead of a reflection-BRDF eval, which is
-		// invalid for the below-surface refraction direction.
-		const transColorWeight = vec3( 1.0 ).toVar();
-
-		// Execute selected strategy (chained If/ElseIf/Else for exclusive branches)
-		// Environment removed — handled via deterministic NEE in direct lighting
+		// generateSampledDirection IS the sampler — this used to re-select a strategy on top of
+		// it, and its strategies 1 and 4 both just returned brdfSampleDirection. So a sample that
+		// the inner selection had drawn from the diffuse or sheen lobe was reported to MIS as a
+		// specular-VNDF draw, making combinedPdf something no strategy actually sampled from.
+		// Since prevBouncePdf is that value, and the NEE sites evaluate a mixture, the two MIS
+		// strategies' weights stopped summing to 1.
+		//
+		// brdfSamplePdf is now the true mixture density (calculateBSDFSamplingPDF), so the
+		// estimator is just f·NoL/pdf and the MIS pairs share one function by construction.
+		const NoL = max( dot( N, brdfSampleDirection ), 0.0 ).toVar();
+		const pdf = max( brdfSamplePdf, MIN_PDF ).toVar();
+
+		r_direction.assign( brdfSampleDirection );
+		r_combinedPdf.assign( pdf );
+
+		// The reflection BRDF eval is invalid below the surface, so refraction carries the
+		// sampler's own tint (material.color × colorWeight), mirroring handleTransmission.
+		r_throughput.assign( select(
+			isTransmission,
+			material.color.xyz.mul( brdfSampleColorWeight ),
+			brdfSampleValue.mul( NoL ).div( pdf ),
+		) );
 
-		// Strategy 1: Specular
-		If( selectedStrategy.equal( int( 1 ) ), () => {
-
-			sampleDir.assign( brdfSampleDirection );
-			samplePdf.assign( brdfSamplePdf );
-			sampleBrdfValue.assign( brdfSampleValue );
-
-		} ).ElseIf( selectedStrategy.equal( int( 2 ) ), () => {
-
-			// Strategy 2: Diffuse
-			sampleDir.assign( cosineWeightedSample( N, sampleRand ) );
-			samplePdf.assign( cosineWeightedPDF( max( dot( N, sampleDir ), 0.0 ) ) );
-			sampleBrdfValue.assign( evaluateMaterialResponse( V, sampleDir, N, material ) );
-
-		} ).ElseIf( selectedStrategy.equal( int( 3 ) ), () => {
-
-			// Strategy 3: Transmission
-			const entering = dot( V, N ).greaterThan( 0.0 );
-			const mtResult = MicrofacetTransmissionResult.wrap( sampleMicrofacetTransmission(
-				V, N, material.ior, material.roughness, entering, material.dispersion, sampleRand, rngState, float( 0.0 )
-			).toVar() );
-			sampleDir.assign( mtResult.direction );
-			samplePdf.assign( mtResult.pdf );
-			// evaluateMaterialResponse is reflection-only and returns a non-physical value for
-			// the below-surface refraction direction (its dots are floored to 0.001). Carry the
-			// sampler's spectral tint and apply an energy-consistent transmission throughput
-			// below (mirrors handleTransmission's material.color × colorWeight convention).
-			transColorWeight.assign( mtResult.colorWeight );
-
-		} ).Else( () => {
-
-			// Strategy 4: Clearcoat (fallback)
-			sampleDir.assign( brdfSampleDirection );
-			samplePdf.assign( brdfSamplePdf );
-			sampleBrdfValue.assign( brdfSampleValue );
-
-		} );
-
-		const NoL = max( dot( N, sampleDir ), 0.0 ).toVar();
-
-		// Calculate combined PDF for MIS (material strategies only)
-		const combinedPdf = float( 0.0 ).toVar();
-
-		If( weights.useSpecular, () => {
-
-			// Evaluate specular PDF at sampleDir (not brdfSampleDirection which may differ);
-			// auto-selects iso/aniso to stay consistent with the BRDF sampler.
-			const specPdfAtSampleDir = specularVNDFPDFForDir( material, N, V, sampleDir );
-			combinedPdf.addAssign( weights.specularWeight.mul( specPdfAtSampleDir ) );
-
-		} );
-
-		If( weights.useDiffuse, () => {
-
-			combinedPdf.addAssign( weights.diffuseWeight.mul( cosineWeightedPDF( NoL ) ) );
-
-		} );
-
-		If( weights.useTransmission.and( material.transmission.greaterThan( 0.0 ) ), () => {
-
-			// Calculate transmission PDF for this direction
-			const entering = dot( V, N ).greaterThan( 0.0 );
-			combinedPdf.addAssign( weights.transmissionWeight.mul(
-				calculateTransmissionPDF( V, sampleDir, N, material.ior, material.roughness, entering )
-			) );
-
-		} );
-
-		If( weights.useClearcoat.and( material.clearcoat.greaterThan( 0.0 ) ), () => {
-
-			// Calculate clearcoat PDF for this direction
-			combinedPdf.addAssign( weights.clearcoatWeight.mul(
-				calculateClearcoatPDF( V, sampleDir, N, material.clearcoatRoughness )
-			) );
-
-		} );
-
-		// Ensure valid PDFs
-		samplePdf.assign( max( samplePdf, MIN_PDF ) );
-		combinedPdf.assign( max( combinedPdf, MIN_PDF ) );
-
-		// MIS weight calculation
-		const misWeight = samplePdf.div( combinedPdf ).toVar();
-
-		// Reflection lobes: f·NoL·mis/pdf. Transmission lobe: the sampler's energy-consistent
-		// weight (material tint × dispersion colorWeight × mis) — the reflection BRDF value is
-		// invalid below the surface, so it is not used for transmission.
-		const reflThroughput = sampleBrdfValue.mul( NoL ).mul( misWeight ).div( samplePdf );
-		const transThroughput = material.color.xyz.mul( transColorWeight ).mul( misWeight );
-
-		r_direction.assign( sampleDir );
-		r_throughput.assign( select( selectedStrategy.equal( int( 3 ) ), transThroughput, reflThroughput ) );
-		r_misWeight.assign( misWeight );
-		r_pdf.assign( samplePdf );
-		r_combinedPdf.assign( combinedPdf );
-
-	} ); // End validInput check
+	} );
 
 	return IndirectLightingResult( {
 		direction: r_direction,
 		throughput: r_throughput,
-		misWeight: r_misWeight,
-		pdf: r_pdf,
 		combinedPdf: r_combinedPdf,
 	} );
 

package/src/TSL/LightsSampling.js

@@ -72,8 +72,8 @@ import {
 
 import { traverseBVHShadow } from './BVHTraversal.js';
 import { evaluateMaterialResponseFromDots } from './MaterialEvaluation.js';
-import { calculateVNDFPDF, calculateVNDFPDFAniso, computeAnisoAlphas } from './MaterialProperties.js';
-import { RandomValue } from './Random.js';
+import { calculateBSDFSamplingPDFFromMaterial } from './MaterialProperties.js';
+import { getRandomSample1D, getRandomSample2D, SAMPLER_DIM_AUX_BASE } from './Random.js';
 import {
 	selectOptimalMISStrategy,
 	PI,
@@ -340,6 +340,7 @@ export const samplePointLightWithAttenuation = Fn( ( [ light, rayOrigin, lightSe
 // unbiased; PDF = winnerImportance / totalWeight, identical to the CDF form.
 export const sampleLightWithImportance = Fn( ( [
 	rayOrigin, normal, material, randomSeed, bounceIndex, rngState,
+	pixelCoord, resolution, frame, dimBase,
 	// Light buffers + counts
 	directionalLightsBuffer, numDirectionalLights,
 	areaLightsBuffer, numAreaLights,
@@ -380,7 +381,9 @@ export const sampleLightWithImportance = Fn( ( [
 					const importance = calculateDirectionalLightImportance( light, normal, material, bounceIndex ).toVar();
 					totalWeight.addAssign( importance );
 					If( importance.greaterThan( 0.0 ).and(
-						RandomValue( rngState ).mul( totalWeight ).lessThan( importance )
+						getRandomSample1D( pixelCoord, int( 0 ),
+							int( SAMPLER_DIM_AUX_BASE + 64 + 0 * 16 ).add( i ), rngState, resolution, frame
+						).mul( totalWeight ).lessThan( importance )
 					), () => {
 
 						selectedType.assign( 0 );
@@ -405,7 +408,9 @@ export const sampleLightWithImportance = Fn( ( [
 					const importance = select( light.intensity.greaterThan( 0.0 ), estimateLightImportance( light, rayOrigin, normal, material ), float( 0.0 ) ).toVar();
 					totalWeight.addAssign( importance );
 					If( importance.greaterThan( 0.0 ).and(
-						RandomValue( rngState ).mul( totalWeight ).lessThan( importance )
+						getRandomSample1D( pixelCoord, int( 0 ),
+							int( SAMPLER_DIM_AUX_BASE + 64 + 1 * 16 ).add( i ), rngState, resolution, frame
+						).mul( totalWeight ).lessThan( importance )
 					), () => {
 
 						selectedType.assign( 1 );
@@ -430,7 +435,9 @@ export const sampleLightWithImportance = Fn( ( [
 					const importance = calculatePointLightImportance( light, rayOrigin, normal, material ).toVar();
 					totalWeight.addAssign( importance );
 					If( importance.greaterThan( 0.0 ).and(
-						RandomValue( rngState ).mul( totalWeight ).lessThan( importance )
+						getRandomSample1D( pixelCoord, int( 0 ),
+							int( SAMPLER_DIM_AUX_BASE + 64 + 2 * 16 ).add( i ), rngState, resolution, frame
+						).mul( totalWeight ).lessThan( importance )
 					), () => {
 
 						selectedType.assign( 2 );
@@ -455,7 +462,9 @@ export const sampleLightWithImportance = Fn( ( [
 					const importance = calculateSpotLightImportance( light, rayOrigin, normal, material ).toVar();
 					totalWeight.addAssign( importance );
 					If( importance.greaterThan( 0.0 ).and(
-						RandomValue( rngState ).mul( totalWeight ).lessThan( importance )
+						getRandomSample1D( pixelCoord, int( 0 ),
+							int( SAMPLER_DIM_AUX_BASE + 64 + 3 * 16 ).add( i ), rngState, resolution, frame
+						).mul( totalWeight ).lessThan( importance )
 					), () => {
 
 						selectedType.assign( 3 );
@@ -518,7 +527,7 @@ export const sampleLightWithImportance = Fn( ( [
 
 					If( light.intensity.greaterThan( 0.0 ), () => {
 
-						const uv = vec2( randomSeed.y, RandomValue( rngState ) ).toVar();
+						const uv = vec2( randomSeed.y, getRandomSample1D( pixelCoord, int( 0 ), dimBase.add( int( 15 ) ), rngState, resolution, frame ) ).toVar();
 						const areaSample = LightSample.wrap( sampleRectAreaLight( light, rayOrigin, uv, lightSelectionPdf ) );
 						r_valid.assign( areaSample.valid );
 						r_direction.assign( areaSample.direction );
@@ -607,7 +616,7 @@ export const sampleLightWithImportance = Fn( ( [
 					const cosHalfAngle = cos( light.angle.mul( 0.5 ) ).toVar();
 					const cosTheta = mix( cosHalfAngle, float( 1.0 ), randomSeed.y ).toVar();
 					const sinTheta = sqrt( max( float( 0.0 ), float( 1.0 ).sub( cosTheta.mul( cosTheta ) ) ) ).toVar();
-					const phi = float( TWO_PI ).mul( RandomValue( rngState ) ).toVar();
+					const phi = float( TWO_PI ).mul( getRandomSample1D( pixelCoord, int( 0 ), dimBase.add( int( 14 ) ), rngState, resolution, frame ) ).toVar();
 
 					const w = normalize( light.direction ).toVar();
 					const u = normalize( cross(
@@ -639,7 +648,7 @@ export const sampleLightWithImportance = Fn( ( [
 			If( selectedType.equal( int( 1 ) ).and( selectedIdx.greaterThanEqual( int( 0 ) ) ), () => {
 
 				const light = AreaLight.wrap( getAreaLight( areaLightsBuffer, selectedIdx ) );
-				const uv = vec2( randomSeed.y, RandomValue( rngState ) ).toVar();
+				const uv = vec2( randomSeed.y, getRandomSample1D( pixelCoord, int( 0 ), dimBase.add( int( 15 ) ), rngState, resolution, frame ) ).toVar();
 				const areaSample = LightSample.wrap( sampleRectAreaLight( light, rayOrigin, uv, pdf ) );
 				r_valid.assign( areaSample.valid );
 				r_direction.assign( areaSample.direction );
@@ -700,66 +709,14 @@ export const sampleLightWithImportance = Fn( ( [
 // PDF computation given precomputed dot products. Use this when the caller
 // already has dots from a paired evaluateMaterialResponseFromDots invocation
 // to avoid recomputing H + dots.
+// BSDF-sampling density for MIS — must be the exact function the sampler draws from, or the two
+// strategies' weights stop summing to 1.
 export const calculateMaterialPDFFromDots = Fn( ( [ material, dots ] ) => {
 
-	const NoV = dots.NoV;
-	const NoL = dots.NoL.toVar();
-	const NoH = dots.NoH;
-
-	// Calculate lobe weights
-	const diffuseWeight = float( 1.0 ).sub( material.metalness ).mul(
-		float( 1.0 ).sub( material.transmission )
-	).toVar();
-
-	const specularWeight = float( 1.0 ).sub(
-		diffuseWeight.mul( float( 1.0 ).sub( material.metalness ) )
-	).toVar();
-
-	const totalWeight = diffuseWeight.add( specularWeight ).toVar();
-
-	const pdf = float( 0.0 ).toVar();
-
-	If( totalWeight.greaterThan( 0.0 ), () => {
-
-		// Guard division
-		const invTotalWeight = float( 1.0 ).div( max( totalWeight, 1e-10 ) ).toVar();
-		diffuseWeight.mulAssign( invTotalWeight );
-		specularWeight.mulAssign( invTotalWeight );
-
-		// Diffuse PDF (cosine-weighted hemisphere)
-		If( diffuseWeight.greaterThan( 0.0 ).and( NoL.greaterThan( 0.0 ) ), () => {
-
-			pdf.addAssign( diffuseWeight.mul( NoL ).mul( PI_INV ) );
-
-		} );
-
-		// Specular PDF (VNDF sampling used in path tracer)
-		If( specularWeight.greaterThan( 0.0 ).and( NoL.greaterThan( 0.0 ) ), () => {
-
-			const roughness = max( material.roughness, 0.02 );
-			const specPdf = float( 0.0 ).toVar();
-			If( material.anisotropy.greaterThan( 0.0 ), () => {
-
-				const a = computeAnisoAlphas( material.roughness, material.anisotropy );
-				specPdf.assign( calculateVNDFPDFAniso( a.x, a.y, dots.NoH, dots.ToH, dots.BoH, dots.NoV, dots.ToV, dots.BoV ) );
-
-			} ).Else( () => {
-
-				specPdf.assign( calculateVNDFPDF( NoH, NoV, roughness ) );
-
-			} );
-			pdf.addAssign( specularWeight.mul( specPdf ) );
-
-		} );
-
-	} );
-
-	return max( pdf, 1e-8 );
+	return max( calculateBSDFSamplingPDFFromMaterial( material, dots ), 1e-8 );
 
 } );
 
-// Wrapper that computes dots internally. Use this when the caller doesn't
-// already have dots; otherwise prefer calculateMaterialPDFFromDots.
 export const calculateMaterialPDF = Fn( ( [ viewDir, lightDir, normal, material ] ) => {
 
 	const dots = DotProducts.wrap( computeDotProductsAniso( normal, viewDir, lightDir, material ) );
@@ -861,6 +818,9 @@ export const calculateDirectLightingUnified = Fn( ( [
 	brdfSampleDirection, brdfSamplePdf, brdfSampleValue,
 	// Tracing context
 	bounceIndex, rngState,
+	// Sampler context — NEE's continuous variates come off the sampler keyed on
+	// (pixel, dimension, frame). dimBase is this bounce's block; see Random.js budget.
+	pixelCoord, resolution, frame, dimBase,
 	// Light data
 	directionalLightsBuffer, numDirectionalLights,
 	areaLightsBuffer, numAreaLights,
@@ -937,11 +897,8 @@ export const calculateDirectLightingUnified = Fn( ( [
 
 		} );
 
-		const stratRand1 = RandomValue( rngState ).toVar();
-		const stratRand2 = RandomValue( rngState ).toVar();
-
 		// Determine sampling technique: stochastic {lights, BRDF}
-		const rand = stratRand1;
+		const rand = getRandomSample1D( pixelCoord, int( 0 ), dimBase, rngState, resolution, frame ).toVar();
 		const sampleLights = tslBool( false ).toVar();
 		const sampleBRDF = tslBool( false ).toVar();
 
@@ -973,9 +930,10 @@ export const calculateDirectLightingUnified = Fn( ( [
 		If( sampleLights, () => {
 
 			// Importance-weighted light sampling
-			const lightRandom = vec2( stratRand2, RandomValue( rngState ) ).toVar();
+			const lightRandom = getRandomSample2D( pixelCoord, int( 0 ), dimBase.add( int( 2 ) ), rngState, resolution, frame ).toVar();
 			const lightSample = LightSample.wrap( sampleLightWithImportance(
 				rayOrigin, hitNormal, material, lightRandom, bounceIndex, rngState,
+				pixelCoord, resolution, frame, dimBase,
 				directionalLightsBuffer, numDirectionalLights,
 				areaLightsBuffer, numAreaLights,
 				pointLightsBuffer, numPointLights,
@@ -1172,9 +1130,7 @@ export const calculateDirectLightingUnified = Fn( ( [
 
 		If( enableEnvironmentLight, () => {
 
-			const env_r1 = RandomValue( rngState ).toVar();
-			const env_r2 = RandomValue( rngState ).toVar();
-			const envRandom = vec2( env_r1, env_r2 ).toVar();
+			const envRandom = getRandomSample2D( pixelCoord, int( 0 ), dimBase.add( int( 1 ) ), rngState, resolution, frame ).toVar();
 			const envColor = vec3( 0.0 ).toVar();
 
 			// Sample direction + PDF + color from importance-sampled environment