rayzee 6.0.1 → 6.1.0

package/src/TSL/LightsSampling.js

@@ -21,9 +21,7 @@ import {
 	float,
 	vec2,
 	vec3,
-	vec4,
 	int,
-	uint,
 	bool as tslBool,
 	max,
 	min,
@@ -34,14 +32,10 @@ import {
 	dot,
 	cross,
 	normalize,
-	length,
-	clamp,
 	mix,
 	select,
 	If,
 	Loop,
-	Break,
-	texture,
 } from 'three/tsl';
 
 import {
@@ -59,9 +53,12 @@ import {
 	getDistanceAttenuation,
 	getSpotAttenuation,
 	intersectAreaLight,
+	sampleSpotGoboMask,
+	sampleDirectionalGoboMask,
+	sampleIESProfile,
 } from './LightsCore.js';
 
-import { MISStrategy } from './Struct.js';
+import { MISStrategy, DotProducts } from './Struct.js';
 import {
 	calculateDirectionalLightImportance,
 	estimateLightImportance,
@@ -71,7 +68,7 @@ import {
 } from './LightsDirect.js';
 
 import { traverseBVHShadow } from './BVHTraversal.js';
-import { evaluateMaterialResponse } from './MaterialEvaluation.js';
+import { evaluateMaterialResponseFromDots } from './MaterialEvaluation.js';
 import { calculateVNDFPDF } from './MaterialProperties.js';
 import { RandomValue } from './Random.js';
 import {
@@ -79,13 +76,12 @@ import {
 	PI,
 	PI_INV,
 	EPSILON,
-	MIN_PDF,
 	powerHeuristic,
 	balanceHeuristic,
+	computeDotProducts,
 } from './Common.js';
 import {
 	sampleEquirectProbability,
-	sampleEquirect,
 } from './Environment.js';
 
 const TWO_PI = 2.0 * PI;
@@ -151,7 +147,7 @@ export const sampleRectAreaLight = Fn( ( [ light, rayOrigin, ruv, lightSelection
 } );
 
 // Enhanced spot light sampling with radius support
-export const sampleSpotLightWithRadius = Fn( ( [ light, rayOrigin, ruv, lightSelectionPdf ] ) => {
+export const sampleSpotLightWithRadius = Fn( ( [ light, rayOrigin, lightSelectionPdf ] ) => {
 
 	const ls_valid = tslBool( false ).toVar();
 	const ls_direction = vec3( 0.0, 1.0, 0.0 ).toVar();
@@ -161,11 +157,13 @@ export const sampleSpotLightWithRadius = Fn( ( [ light, rayOrigin, ruv, lightSel
 	const ls_lightType = int( LIGHT_TYPE_SPOT ).toVar();
 
 	const toLight = light.position.sub( rayOrigin ).toVar();
-	const lightDist = length( toLight ).toVar();
+	// Guard via lengthSq so the sqrt is skipped on rejected (zero-distance) samples.
+	const lightDistSq = dot( toLight, toLight ).toVar();
 
 	// Guard against zero distance
-	If( lightDist.greaterThanEqual( 1e-10 ), () => {
+	If( lightDistSq.greaterThanEqual( 1e-20 ), () => {
 
+		const lightDist = sqrt( lightDistSq ).toVar();
 		const lightDir = toLight.div( lightDist ).toVar();
 
 		// Check cone attenuation
@@ -185,7 +183,11 @@ export const sampleSpotLightWithRadius = Fn( ( [ light, rayOrigin, ruv, lightSel
 			const coneAttenuation = getSpotAttenuation( { coneCosine: coneCosAngle, penumbraCosine: penumbraCosAngle, angleCosine: spotCosAngle } );
 			const distanceAttenuation = getDistanceAttenuation( { lightDistance: lightDist, cutoffDistance: light.distance, decayExponent: light.decay } );
 
-			ls_emission.assign( light.color.mul( light.intensity ).mul( distanceAttenuation ).mul( coneAttenuation ) );
+			// Gobo projection mask + IES photometric profile — both 1.0 when not assigned.
+			const goboMask = sampleSpotGoboMask( light, lightDir );
+			const iesProfile = sampleIESProfile( light, lightDir );
+
+			ls_emission.assign( light.color.mul( light.intensity ).mul( distanceAttenuation ).mul( coneAttenuation ).mul( goboMask ).mul( iesProfile ) );
 
 		} );
 
@@ -213,11 +215,13 @@ export const samplePointLightWithAttenuation = Fn( ( [ light, rayOrigin, lightSe
 	const ls_lightType = int( LIGHT_TYPE_POINT ).toVar();
 
 	const toLight = light.position.sub( rayOrigin ).toVar();
-	const lightDist = length( toLight ).toVar();
+	// Guard via lengthSq so the sqrt is skipped on rejected (zero-distance) samples.
+	const lightDistSq = dot( toLight, toLight ).toVar();
 
 	// Guard against zero distance
-	If( lightDist.greaterThanEqual( 1e-10 ), () => {
+	If( lightDistSq.greaterThanEqual( 1e-20 ), () => {
 
+		const lightDist = sqrt( lightDistSq ).toVar();
 		const lightDir = toLight.div( lightDist ).toVar();
 
 		// Calculate distance attenuation using the light's actual distance and decay properties
@@ -247,8 +251,12 @@ export const samplePointLightWithAttenuation = Fn( ( [ light, rayOrigin, lightSe
 // Importance-Weighted Light Sampling
 // =============================================================================
 
-// ANGLE-optimized: No early returns in loops, full initialization
-// 3-pass approach: 1) calculate total weight, 2) select light via CDF, 3) sample selected light
+// Single-pass weighted-reservoir sampling: each light's importance is evaluated
+// exactly once. Compared to the previous 3-pass CDF (sum-then-walk-then-sample)
+// this halves the importance evaluations and storage-buffer reads per NEE call.
+// Selection rule: with seen_weight = sum of weights so far, replace current
+// winner with this candidate with probability w_i / seen_weight. Result is
+// unbiased; PDF = winnerImportance / totalWeight, identical to the CDF form.
 export const sampleLightWithImportance = Fn( ( [
 	rayOrigin, normal, material, randomSeed, bounceIndex, rngState,
 	// Light buffers + counts
@@ -273,8 +281,13 @@ export const sampleLightWithImportance = Fn( ( [
 		const totalWeight = float( 0.0 ).toVar();
 		const lightIndex = int( 0 ).toVar();
 
+		// Reservoir state: winning light's type/index/importance.
+		const selectedType = int( - 1 ).toVar(); // 0=dir, 1=area, 2=point, 3=spot
+		const selectedIdx = int( - 1 ).toVar();
+		const selectedImportance = float( 0.0 ).toVar();
+
 		// =====================================================================
-		// PASS 1: Calculate Total Weight (no early exits)
+		// SINGLE PASS: reservoir-sample across all four light type buffers
 		// =====================================================================
 
 		If( numDirectionalLights.greaterThan( int( 0 ) ), () => {
@@ -284,7 +297,17 @@ export const sampleLightWithImportance = Fn( ( [
 				If( lightIndex.lessThan( int( 16 ) ), () => {
 
 					const light = DirectionalLight.wrap( getDirectionalLight( directionalLightsBuffer, i ) );
-					totalWeight.addAssign( calculateDirectionalLightImportance( light, rayOrigin, normal, material, bounceIndex ) );
+					const importance = calculateDirectionalLightImportance( light, normal, material, bounceIndex ).toVar();
+					totalWeight.addAssign( importance );
+					If( importance.greaterThan( 0.0 ).and(
+						RandomValue( rngState ).mul( totalWeight ).lessThan( importance )
+					), () => {
+
+						selectedType.assign( 0 );
+						selectedIdx.assign( i );
+						selectedImportance.assign( importance );
+
+					} );
 					lightIndex.addAssign( 1 );
 
 				} );
@@ -300,8 +323,17 @@ export const sampleLightWithImportance = Fn( ( [
 				If( lightIndex.lessThan( int( 16 ) ), () => {
 
 					const light = AreaLight.wrap( getAreaLight( areaLightsBuffer, i ) );
-					const importance = select( light.intensity.greaterThan( 0.0 ), estimateLightImportance( light, rayOrigin, normal, material ), float( 0.0 ) );
+					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 )
+					), () => {
+
+						selectedType.assign( 1 );
+						selectedIdx.assign( i );
+						selectedImportance.assign( importance );
+
+					} );
 					lightIndex.addAssign( 1 );
 
 				} );
@@ -317,7 +349,17 @@ export const sampleLightWithImportance = Fn( ( [
 				If( lightIndex.lessThan( int( 16 ) ), () => {
 
 					const light = PointLight.wrap( getPointLight( pointLightsBuffer, i ) );
-					totalWeight.addAssign( calculatePointLightImportance( light, rayOrigin, normal, material ) );
+					const importance = calculatePointLightImportance( light, rayOrigin, normal, material ).toVar();
+					totalWeight.addAssign( importance );
+					If( importance.greaterThan( 0.0 ).and(
+						RandomValue( rngState ).mul( totalWeight ).lessThan( importance )
+					), () => {
+
+						selectedType.assign( 2 );
+						selectedIdx.assign( i );
+						selectedImportance.assign( importance );
+
+					} );
 					lightIndex.addAssign( 1 );
 
 				} );
@@ -333,7 +375,17 @@ export const sampleLightWithImportance = Fn( ( [
 				If( lightIndex.lessThan( int( 16 ) ), () => {
 
 					const light = SpotLight.wrap( getSpotLight( spotLightsBuffer, i ) );
-					totalWeight.addAssign( calculateSpotLightImportance( light, rayOrigin, normal, material ) );
+					const importance = calculateSpotLightImportance( light, rayOrigin, normal, material ).toVar();
+					totalWeight.addAssign( importance );
+					If( importance.greaterThan( 0.0 ).and(
+						RandomValue( rngState ).mul( totalWeight ).lessThan( importance )
+					), () => {
+
+						selectedType.assign( 3 );
+						selectedIdx.assign( i );
+						selectedImportance.assign( importance );
+
+					} );
 					lightIndex.addAssign( 1 );
 
 				} );
@@ -366,8 +418,9 @@ export const sampleLightWithImportance = Fn( ( [
 
 					If( light.intensity.greaterThan( 0.0 ), () => {
 
+						const dirGoboMask = sampleDirectionalGoboMask( light, rayOrigin );
 						r_direction.assign( normalize( light.direction ) );
-						r_emission.assign( light.color.mul( light.intensity ) );
+						r_emission.assign( light.color.mul( light.intensity ).mul( dirGoboMask ) );
 						r_distance.assign( 1e6 );
 						r_lightType.assign( int( LIGHT_TYPE_DIRECTIONAL ) );
 						r_valid.assign( tslBool( true ) );
@@ -440,8 +493,7 @@ export const sampleLightWithImportance = Fn( ( [
 
 					If( light.intensity.greaterThan( 0.0 ), () => {
 
-						const uv = vec2( randomSeed.y, RandomValue( rngState ) ).toVar();
-						const spotSample = LightSample.wrap( sampleSpotLightWithRadius( light, rayOrigin, uv, lightSelectionPdf ) );
+						const spotSample = LightSample.wrap( sampleSpotLightWithRadius( light, rayOrigin, lightSelectionPdf ) );
 						r_valid.assign( spotSample.valid );
 						r_direction.assign( spotSample.direction );
 						r_emission.assign( spotSample.emission );
@@ -459,128 +511,8 @@ export const sampleLightWithImportance = Fn( ( [
 		} ).Else( () => {
 
 			// =================================================================
-			// PASS 2: Select and Sample Light (no early returns in loops)
-			// =================================================================
-
-			const selectionValue = randomSeed.x.mul( totalWeight ).toVar();
-			const cumulative = float( 0.0 ).toVar();
-			lightIndex.assign( 0 );
-
-			// Track which light was selected
-			const selectedType = int( - 1 ).toVar(); // 0=dir, 1=area, 2=point, 3=spot
-			const selectedIdx = int( - 1 ).toVar();
-			const selectedImportance = float( 0.0 ).toVar();
-
-			// Directional lights
-			If( numDirectionalLights.greaterThan( int( 0 ) ), () => {
-
-				Loop( { start: int( 0 ), end: numDirectionalLights, type: 'int', condition: '<' }, ( { i } ) => {
-
-					If( lightIndex.lessThan( int( 16 ) ).and( selectedType.lessThan( int( 0 ) ) ), () => {
-
-						const light = DirectionalLight.wrap( getDirectionalLight( directionalLightsBuffer, i ) );
-						const importance = calculateDirectionalLightImportance( light, rayOrigin, normal, material, bounceIndex ).toVar();
-						const prevCumulative = cumulative.toVar();
-						cumulative.addAssign( importance );
-
-						If( selectionValue.greaterThan( prevCumulative ).and( selectionValue.lessThanEqual( cumulative ) ), () => {
-
-							selectedType.assign( 0 );
-							selectedIdx.assign( i );
-							selectedImportance.assign( importance );
-
-						} );
-
-					} );
-					lightIndex.addAssign( 1 );
-
-				} );
-
-			} );
-
-			// Area lights
-			If( numAreaLights.greaterThan( int( 0 ) ), () => {
-
-				Loop( { start: int( 0 ), end: numAreaLights, type: 'int', condition: '<' }, ( { i } ) => {
-
-					If( lightIndex.lessThan( int( 16 ) ).and( selectedType.lessThan( int( 0 ) ) ), () => {
-
-						const light = AreaLight.wrap( getAreaLight( areaLightsBuffer, i ) );
-						const importance = select( light.intensity.greaterThan( 0.0 ), estimateLightImportance( light, rayOrigin, normal, material ), float( 0.0 ) ).toVar();
-						const prevCumulative = cumulative.toVar();
-						cumulative.addAssign( importance );
-
-						If( selectionValue.greaterThan( prevCumulative ).and( selectionValue.lessThanEqual( cumulative ) ), () => {
-
-							selectedType.assign( 1 );
-							selectedIdx.assign( i );
-							selectedImportance.assign( importance );
-
-						} );
-
-					} );
-					lightIndex.addAssign( 1 );
-
-				} );
-
-			} );
-
-			// Point lights
-			If( numPointLights.greaterThan( int( 0 ) ), () => {
-
-				Loop( { start: int( 0 ), end: numPointLights, type: 'int', condition: '<' }, ( { i } ) => {
-
-					If( lightIndex.lessThan( int( 16 ) ).and( selectedType.lessThan( int( 0 ) ) ), () => {
-
-						const light = PointLight.wrap( getPointLight( pointLightsBuffer, i ) );
-						const importance = calculatePointLightImportance( light, rayOrigin, normal, material ).toVar();
-						const prevCumulative = cumulative.toVar();
-						cumulative.addAssign( importance );
-
-						If( selectionValue.greaterThan( prevCumulative ).and( selectionValue.lessThanEqual( cumulative ) ), () => {
-
-							selectedType.assign( 2 );
-							selectedIdx.assign( i );
-							selectedImportance.assign( importance );
-
-						} );
-
-					} );
-					lightIndex.addAssign( 1 );
-
-				} );
-
-			} );
-
-			// Spot lights
-			If( numSpotLights.greaterThan( int( 0 ) ), () => {
-
-				Loop( { start: int( 0 ), end: numSpotLights, type: 'int', condition: '<' }, ( { i } ) => {
-
-					If( lightIndex.lessThan( int( 16 ) ).and( selectedType.lessThan( int( 0 ) ) ), () => {
-
-						const light = SpotLight.wrap( getSpotLight( spotLightsBuffer, i ) );
-						const importance = calculateSpotLightImportance( light, rayOrigin, normal, material ).toVar();
-						const prevCumulative = cumulative.toVar();
-						cumulative.addAssign( importance );
-
-						If( selectionValue.greaterThan( prevCumulative ).and( selectionValue.lessThanEqual( cumulative ) ), () => {
-
-							selectedType.assign( 3 );
-							selectedIdx.assign( i );
-							selectedImportance.assign( importance );
-
-						} );
-
-					} );
-					lightIndex.addAssign( 1 );
-
-				} );
-
-			} );
-
-			// =================================================================
-			// PASS 3: Sample the selected light (outside loops)
+			// Sample the reservoir-selected light. selectedType / selectedIdx /
+			// selectedImportance were populated during the single-pass walk above.
 			// =================================================================
 
 			// Guard division by zero
@@ -617,8 +549,9 @@ export const sampleLightWithImportance = Fn( ( [
 
 				} );
 
+				const dirGoboMask = sampleDirectionalGoboMask( light, rayOrigin );
 				r_direction.assign( direction );
-				r_emission.assign( light.color.mul( light.intensity ) );
+				r_emission.assign( light.color.mul( light.intensity ).mul( dirGoboMask ) );
 				r_distance.assign( 1e6 );
 				r_pdf.assign( dirPdf.mul( pdf ) );
 				r_lightType.assign( int( LIGHT_TYPE_DIRECTIONAL ) );
@@ -659,8 +592,7 @@ export const sampleLightWithImportance = Fn( ( [
 			If( selectedType.equal( int( 3 ) ).and( selectedIdx.greaterThanEqual( int( 0 ) ) ), () => {
 
 				const light = SpotLight.wrap( getSpotLight( spotLightsBuffer, selectedIdx ) );
-				const uv = vec2( randomSeed.y, RandomValue( rngState ) ).toVar();
-				const spotSample = LightSample.wrap( sampleSpotLightWithRadius( light, rayOrigin, uv, pdf ) );
+				const spotSample = LightSample.wrap( sampleSpotLightWithRadius( light, rayOrigin, pdf ) );
 				r_valid.assign( spotSample.valid );
 				r_direction.assign( spotSample.direction );
 				r_emission.assign( spotSample.emission );
@@ -689,14 +621,14 @@ export const sampleLightWithImportance = Fn( ( [
 // Material PDF Calculation for MIS
 // =============================================================================
 
-// Helper function to calculate material PDF for a given direction
-export const calculateMaterialPDF = Fn( ( [ viewDir, lightDir, normal, material ] ) => {
+// PDF computation given precomputed dot products. Use this when the caller
+// already has dots from a paired evaluateMaterialResponseFromDots invocation
+// to avoid recomputing H + dots.
+export const calculateMaterialPDFFromDots = Fn( ( [ material, dots ] ) => {
 
-	const NoV = max( float( 0.0 ), dot( normal, viewDir ) ).toVar();
-	const NoL = max( float( 0.0 ), dot( normal, lightDir ) ).toVar();
-	const H = normalize( viewDir.add( lightDir ) ).toVar();
-	const NoH = max( float( 0.0 ), dot( normal, H ) ).toVar();
-	const VoH = max( float( 0.0 ), dot( viewDir, H ) ).toVar();
+	const NoV = dots.NoV.toVar();
+	const NoL = dots.NoL.toVar();
+	const NoH = dots.NoH.toVar();
 
 	// Calculate lobe weights
 	const diffuseWeight = float( 1.0 ).sub( material.metalness ).mul(
@@ -739,6 +671,15 @@ export const calculateMaterialPDF = Fn( ( [ viewDir, lightDir, normal, material
 
 } );
 
+// 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( computeDotProducts( normal, viewDir, lightDir ) );
+	return calculateMaterialPDFFromDots( material, dots );
+
+} );
+
 // =============================================================================
 // Unified Direct Lighting System
 // =============================================================================
@@ -752,7 +693,7 @@ export const calculateDirectLightingUnified = Fn( ( [
 	// BRDF sample (DirectionSample fields)
 	brdfSampleDirection, brdfSamplePdf, brdfSampleValue,
 	// Tracing context
-	sampleIndex, bounceIndex, rngState,
+	bounceIndex, rngState,
 	// Light data
 	directionalLightsBuffer, numDirectionalLights,
 	areaLightsBuffer, numAreaLights,
@@ -772,13 +713,18 @@ export const calculateDirectLightingUnified = Fn( ( [
 	const totalContribution = vec3( 0.0 ).toVar();
 	const rayOrigin = hitPoint.add( hitNormal.mul( 0.001 ) ).toVar();
 
+	// Binds BVH params so shadow-ray sites at varying call depths use a 3-arg call
+	const shadow = Fn( ( [ origin, dir, maxDist ] ) =>
+		traceShadowRay( origin, dir, maxDist, traverseBVHShadow, bvhBuffer, triangleBuffer, materialBuffer )
+	);
+
 	// Early exit for highly emissive surfaces
 	If( material.emissiveIntensity.lessThanEqual( 10.0 ), () => {
 
 		// Adaptive MIS Strategy Selection
 		const currentThroughput = vec3( 1.0 ).toVar();
 		const misResult = MISStrategy.wrap( selectOptimalMISStrategy(
-			material.roughness, material.metalness, material.transmission, bounceIndex, currentThroughput
+			material.roughness, material.metalness, bounceIndex, currentThroughput
 		) );
 
 		// Extract MIS fields to mutable variables
@@ -872,18 +818,15 @@ export const calculateDirectLightingUnified = Fn( ( [
 				If( NoL.greaterThan( 0.0 ).and( lightImportance.mul( NoL ).greaterThan( importanceThreshold ) ).and( isDirectionValid( { direction: lightSample.direction, surfaceNormal: hitNormal } ) ), () => {
 
 					const shadowDistance = min( lightSample.distance.sub( 0.001 ), float( 1000.0 ) ).toVar();
-					const visibility = traceShadowRay(
-						rayOrigin, lightSample.direction, shadowDistance, rngState,
-						traverseBVHShadow,
-						bvhBuffer,
-						triangleBuffer,
-						materialBuffer,
-					);
+					const visibility = shadow( rayOrigin, lightSample.direction, shadowDistance );
 
 					If( visibility.greaterThan( 0.0 ), () => {
 
-						const brdfValue = evaluateMaterialResponse( viewDir, lightSample.direction, hitNormal, material );
-						const bPdf = calculateMaterialPDF( viewDir, lightSample.direction, hitNormal, material ).toVar();
+						// Share H + dot products between BRDF eval and PDF — otherwise each
+						// would recompute normalize(V+L) + 5 dot products independently.
+						const sharedDots = DotProducts.wrap( computeDotProducts( hitNormal, viewDir, lightSample.direction ) );
+						const brdfValue = evaluateMaterialResponseFromDots( material, sharedDots );
+						const bPdf = calculateMaterialPDFFromDots( material, sharedDots ).toVar();
 
 						const misW = float( 1.0 ).toVar();
 
@@ -974,13 +917,7 @@ export const calculateDirectLightingUnified = Fn( ( [
 							If( hitDistance.greaterThan( 0.0 ), () => {
 
 								const shadowDistance = min( hitDistance.sub( 0.001 ), float( 1000.0 ) ).toVar();
-								const visibility = traceShadowRay(
-									rayOrigin, brdfSampleDirection, shadowDistance, rngState,
-									traverseBVHShadow,
-									bvhBuffer,
-									triangleBuffer,
-									materialBuffer,
-								);
+								const visibility = shadow( rayOrigin, brdfSampleDirection, shadowDistance );
 
 								If( visibility.greaterThan( 0.0 ), () => {
 
@@ -1046,18 +983,15 @@ export const calculateDirectLightingUnified = Fn( ( [
 
 				If( NoL.greaterThan( 0.0 ).and( isDirectionValid( { direction: envDirection, surfaceNormal: hitNormal } ) ), () => {
 
-					const visibility = traceShadowRay(
-						rayOrigin, envDirection, float( 1000.0 ), rngState,
-						traverseBVHShadow,
-						bvhBuffer,
-						triangleBuffer,
-						materialBuffer,
-					);
+					const visibility = shadow( rayOrigin, envDirection, float( 1000.0 ) );
 
 					If( visibility.greaterThan( 0.0 ), () => {
 
-						const brdfValue = evaluateMaterialResponse( viewDir, envDirection, hitNormal, material );
-						const bPdf = calculateMaterialPDF( viewDir, envDirection, hitNormal, material ).toVar();
+						// Share H + dots between env BRDF/PDF — same redundancy fix as the
+						// discrete-light path above.
+						const envDots = DotProducts.wrap( computeDotProducts( hitNormal, viewDir, envDirection ) );
+						const brdfValue = evaluateMaterialResponseFromDots( material, envDots );
+						const bPdf = calculateMaterialPDFFromDots( material, envDots ).toVar();
 
 						// Balance heuristic for env MIS — optimal for MIS-compensated PDFs (Karlík et al. 2019).
 						// The implicit path uses material combinedPdf as prevBouncePdf at the miss check.

package/src/TSL/MaterialEvaluation.js

@@ -3,14 +3,14 @@ import {
 	If, max, min, clamp, mix
 } from 'three/tsl';
 
-import { DotProducts } from './Struct.js';
+import { DotProducts, DFGResult } from './Struct.js';
 import {
 	PI, PI_INV, EPSILON, MIN_CLEARCOAT_ROUGHNESS,
 	computeDotProducts,
 } from './Common.js';
 import { fresnelSchlick, fresnelSchlickFloat, dielectricF0 } from './Fresnel.js';
 import {
-	DistributionGGX, SheenDistribution, GeometrySmith, multiscatterCompensation, specularDirectionalAlbedo,
+	DistributionGGX, SheenDistribution, GeometrySmith, evaluateDFG,
 } from './MaterialProperties.js';
 import { evalIridescence } from './MaterialProperties.js';
 
@@ -22,7 +22,10 @@ import { evalIridescence } from './MaterialProperties.js';
 // Main Material Response Evaluation
 // -----------------------------------------------------------------------------
 
-export const evaluateMaterialResponse = Fn( ( [ V, L, N, material ] ) => {
+// Body of evaluateMaterialResponse taking precomputed dot products. Callers
+// that also need calculateMaterialPDF for the same (V, L, N) should share dots
+// to save one computeDotProducts call.
+export const evaluateMaterialResponseFromDots = Fn( ( [ material, dots ] ) => {
 
 	const result = vec3( 0.0 ).toVar();
 
@@ -37,9 +40,6 @@ export const evaluateMaterialResponse = Fn( ( [ V, L, N, material ] ) => {
 
 	} ).Else( () => {
 
-		// Calculate all dot products once
-		const dots = DotProducts.wrap( computeDotProducts( N, V, L ) );
-
 		// Calculate base F0 with specular parameters, clamped to physically valid range
 		const F0 = clamp(
 			mix( dielectricF0( material.ior ).mul( material.specularColor ), material.color.rgb, material.metalness )
@@ -82,12 +82,13 @@ export const evaluateMaterialResponse = Fn( ( [ V, L, N, material ] ) => {
 		// Single-scatter specular BRDF
 		const specularSS = D.mul( G ).mul( F ).div( max( float( 4.0 ).mul( dots.NoV ).mul( dots.NoL ), EPSILON ) );
 
-		// Kulla-Conty multiscatter energy compensation for rough surfaces
-		const specular = specularSS.mul( multiscatterCompensation( F0, dots.NoV, material.roughness ) );
+		// Shared DFG evaluation — compensation factor and total directional albedo
+		// come from the same polynomial.
+		const dfg = DFGResult.wrap( evaluateDFG( F0, dots.NoV, material.roughness ) );
+		const specular = specularSS.mul( dfg.compensation );
 
 		// Diffuse energy budget from hemisphere-integrated specular albedo (includes multiscatter)
-		const E_total = specularDirectionalAlbedo( F0, dots.NoV, material.roughness );
-		const kD = vec3( 1.0 ).sub( E_total ).mul( float( 1.0 ).sub( material.metalness ) );
+		const kD = vec3( 1.0 ).sub( dfg.E_total ).mul( float( 1.0 ).sub( material.metalness ) );
 		const diffuse = kD.mul( materialColor ).mul( PI_INV );
 
 		const baseLayer = diffuse.add( specular ).toVar();
@@ -118,6 +119,15 @@ export const evaluateMaterialResponse = Fn( ( [ V, L, N, material ] ) => {
 
 } );
 
+// Wrapper that computes dot products internally. Use this when you don't already
+// have dots; otherwise prefer evaluateMaterialResponseFromDots to share the work.
+export const evaluateMaterialResponse = Fn( ( [ V, L, N, material ] ) => {
+
+	const dots = DotProducts.wrap( computeDotProducts( N, V, L ) );
+	return evaluateMaterialResponseFromDots( material, dots );
+
+} );
+
 // -----------------------------------------------------------------------------
 // Layered BRDF Evaluation (for clearcoat)
 // -----------------------------------------------------------------------------
@@ -138,12 +148,13 @@ export const evaluateLayeredBRDF = Fn( ( [ dots, material ] ) => {
 	const F = fresnelSchlick( dots.VoH, F0 ).toVar();
 	const baseBRDFSS = D.mul( G ).mul( F ).div( max( float( 4.0 ).mul( dots.NoV ).mul( dots.NoL ), EPSILON ) );
 
-	// Kulla-Conty multiscatter energy compensation for rough surfaces
-	const baseBRDF = baseBRDFSS.mul( multiscatterCompensation( F0, dots.NoV, material.roughness ) );
+	// Shared DFG evaluation — compensation factor and total directional albedo
+	// come from the same polynomial.
+	const dfg = DFGResult.wrap( evaluateDFG( F0, dots.NoV, material.roughness ) );
+	const baseBRDF = baseBRDFSS.mul( dfg.compensation );
 
 	// Diffuse energy budget from hemisphere-integrated specular albedo (includes multiscatter)
-	const E_total = specularDirectionalAlbedo( F0, dots.NoV, material.roughness );
-	const kD = vec3( 1.0 ).sub( E_total ).mul( float( 1.0 ).sub( material.metalness ) );
+	const kD = vec3( 1.0 ).sub( dfg.E_total ).mul( float( 1.0 ).sub( material.metalness ) );
 	const diffuse = kD.mul( material.color.rgb ).div( PI );
 	const baseLayer = diffuse.add( baseBRDF );