rayzee 10.0.0 → 11.1.0

package/src/TSL/LightsSampling.js

@@ -35,8 +35,10 @@ import {
 	length,
 	mix,
 	select,
+	min,
 	If,
 	Loop,
+	sampler,
 } from 'three/tsl';
 
 import {
@@ -71,8 +73,8 @@ import {
 } from './LightsDirect.js';
 
 import { traverseBVHShadow } from './BVHTraversal.js';
-import { evaluateMaterialResponseFromDots } from './MaterialEvaluation.js';
-import { calculateBSDFSamplingPDFFromMaterial } from './MaterialProperties.js';
+import { evaluateMaterialResponseFromDots, evaluateDiffuseTransmission } from './MaterialEvaluation.js';
+import { calculateBSDFSamplingPDFFromMaterial, diffuseTransmissionWeight, diffuseTransmissionPdf } from './MaterialProperties.js';
 import { getRandomSample1D, getRandomSample2D, SAMPLER_DIM_AUX_BASE } from './Random.js';
 import {
 	PI,
@@ -83,12 +85,12 @@ import {
 	computeDotProductsAniso,
 	offsetRayOrigin,
 	SHADOW_END,
+	REC709_LUMINANCE_COEFFICIENTS,
 } from './Common.js';
-import {
-	sampleEquirectProbability,
-} from './Environment.js';
+import { sampleEnvironment, sampleEnvironmentExact } from './Environment.js';
 import { shadowTerminatorOrigin } from './ShadowTerminator.js';
 import { sunRadianceToward, sampleSunDisc } from './Sun.js';
+import { VISIBILITY_KIND, visibilityShare, recordVisibility } from './LightVisibility.js';
 
 const TWO_PI = 2.0 * PI;
 
@@ -757,17 +759,114 @@ export const calculateMaterialPDFFromDots = Fn( ( [ material, dots ] ) => {
 
 export const calculateMaterialPDF = Fn( ( [ viewDir, lightDir, normal, material ] ) => {
 
-	const dots = DotProducts.wrap( computeDotProductsAniso( normal, viewDir, lightDir, material ) );
-	return calculateMaterialPDFFromDots( material, dots );
+	const pdf = float( 0.0 ).toVar();
+
+	If( dot( normal, lightDir ).lessThan( 0.0 ).and( material.diffuseTransmission.greaterThan( 0.0 ) ), () => {
+
+		pdf.assign( max( diffuseTransmissionPdf( diffuseTransmissionWeight( material ), dot( normal, lightDir ).negate() ), 1e-8 ) );
+
+	} ).Else( () => {
+
+		const dots = DotProducts.wrap( computeDotProductsAniso( normal, viewDir, lightDir, material ) );
+		pdf.assign( calculateMaterialPDFFromDots( material, dots ) );
+
+	} );
+
+	return pdf;
+
+} );
+
+// Fewer shadow rays a hit (setting shadowRays). Each light kind offers its sample unshadowed; `variant`:
+//   'one' — keeps one with chance ∝ luminance × √(its kind's learned visibility), traced and divided by that chance;
+//   'two' — always traces the strongest as well, and picks one of the rest.
+const ONE_BELOW = 0.99999994;
 
+const slotOf = () => ( {
+	kind: int( 0 ).toVar(), weight: float( 0.0 ).toVar(), value: vec3( 0.0 ).toVar(),
+	origin: vec3( 0.0 ).toVar(), direction: vec3( 0.0, 1.0, 0.0 ).toVar(), distance: float( 0.0 ).toVar(),
 } );
 
+const FIELDS = [ 'kind', 'weight', 'value', 'origin', 'direction', 'distance' ];
+const assignSlot = ( slot, from ) => FIELDS.forEach( ( f ) => slot[ f ].assign( from[ f ] ) );
+
+// `learned` (LightVisibility.js) gives `share( kind )` and `record( kind, visible )`.
+export const lightPick = ( u0, learned = null, variant = 'one' ) => {
+
+	const u = float( u0 ).toVar();
+	const total = float( 0.0 ).toVar();
+	const kept = slotOf();
+	const best = variant === 'two' ? slotOf() : null;
+
+	const keep = ( c ) => {
+
+		If( c.weight.greaterThan( 0.0 ), () => {
+
+			total.addAssign( c.weight );
+			const p = c.weight.div( total ).toVar();
+			If( u.lessThan( p ), () => {
+
+				u.assign( min( u.div( p ), ONE_BELOW ) );
+				assignSlot( kept, c );
+
+			} ).Else( () => {
+
+				u.assign( min( u.sub( p ).div( float( 1.0 ).sub( p ) ), ONE_BELOW ) );
+
+			} );
+
+		} );
+
+	};
+
+	const offer = ( contribution, from, dir, maxDist, lightKind = 0 ) => {
+
+		const luminance = dot( contribution, REC709_LUMINANCE_COEFFICIENTS );
+		const c = {
+			kind: int( lightKind ), value: contribution, origin: from, direction: dir, distance: maxDist,
+			weight: ( learned ? luminance.mul( learned.share( lightKind ) ) : luminance ).toVar(),
+		};
+		if ( ! best ) return keep( c );
+
+		const better = c.weight.greaterThan( best.weight ).toVar();
+		const loser = Object.fromEntries( FIELDS.map( ( f ) => [ f, select( better, best[ f ], c[ f ] ).toVar() ] ) );
+		keep( loser );
+		If( better, () => assignSlot( best, c ) );
+
+	};
+
+	// The direct light, tracing what the variant keeps through `shadow( origin, direction, distance )`.
+	const trace = ( shadow ) => {
+
+		const result = vec3( 0.0 ).toVar();
+		Loop( { start: int( 0 ), end: int( best ? 2 : 1 ), type: 'int', condition: '<' }, ( { i } ) => {
+
+			const isBest = best ? i.equal( int( 0 ) ) : tslBool( false );
+			const pickOf = ( f ) => ( best ? select( isBest, best[ f ], kept[ f ] ) : kept[ f ] );
+			const weight = pickOf( 'weight' ).toVar();
+			If( weight.greaterThan( 0.0 ), () => {
+
+				const visibility = shadow( pickOf( 'origin' ), pickOf( 'direction' ), pickOf( 'distance' ) ).toVar();
+				if ( learned ) learned.record( pickOf( 'kind' ), visibility.greaterThan( 0.0 ) );
+				result.addAssign( pickOf( 'value' ).mul( visibility ).mul( select( isBest, float( 1.0 ), total.div( weight ) ) ) );
+
+			} );
+
+		} );
+		return result;
+
+	};
+
+	return { offer, total, trace };
+
+};
+
 // =============================================================================
 // Unified Direct Lighting System
 // =============================================================================
 
-// Optimized direct lighting function with importance-based sampling and better MIS
-export const calculateDirectLightingUnified = Fn( ( [
+// Optimized direct lighting function with importance-based sampling and better MIS. `throughSurfaces` (compile
+// time) adds light from behind a surface that passes it through diffusely; without it the code is exactly as before.
+const makeDirectLighting = ( throughSurfaces, picked = null ) => Fn( ( [
 	// Surface hit data
 	hitPoint, hitNormal, geomNormal, material,
 	// View direction
@@ -791,7 +890,7 @@ export const calculateDirectLightingUnified = Fn( ( [
 	// Environment resources
 	envTexture, environmentIntensity, envMatrix,
 	envCDFTexture,
-	envTotalSum, envCompensationDelta, envResolution,
+	envTotalSum, envResolution,
 	enableEnvironmentLight,
 	// Shadow catcher: when true, also accumulate the unoccluded (visibility=1) reference
 	// at every light/env site so the caller can form a shadow ratio. Dead path otherwise.
@@ -801,6 +900,9 @@ export const calculateDirectLightingUnified = Fn( ( [
 	terminatorLift, facetNormal, terminatorCutoff,
 	// The physical sky's sun (Sun.js); its BSDF-sampled partner is the miss branch in ShadeKernel.
 	hasSun, sunDirection, sunRadiance, sunParams,
+	// picked: the caller's emitter sample, unshadowed, and the learned visibility (LightVisibility.js) at this point
+	emissiveValue, emissiveOrigin, emissiveDirection, emissiveDistance,
+	visibilityCounters, visibilityCell,
 ] ) => {
 
 	const totalContribution = vec3( 0.0 ).toVar();
@@ -817,6 +919,46 @@ export const calculateDirectLightingUnified = Fn( ( [
 		traceShadowRay( origin, dir, maxDist, traverseBVHShadow, bvhBuffer, triangleBuffer, materialBuffer )
 	);
 
+	// Light from behind a surface that passes light through diffusely: its shadow ray leaves from the other side,
+	// and the BSDF is the transmission lobe.
+	const throughSurface = L => ( throughSurfaces
+		? material.diffuseTransmission.greaterThan( 0.0 ).and( dot( hitNormal, L ).lessThan( 0.0 ) ).and( dot( L, geomNormal ).lessThan( 0.0 ) )
+		: tslBool( false ) );
+	const backOrigin = throughSurfaces ? offsetRayOrigin( hitPoint, facetNormal.negate() ) : null;
+	const inFront = L => dot( hitNormal, L ).greaterThan( 0.0 ).and( isDirectionValid( { direction: L, surfaceNormal: geomNormal } ) );
+	const reachesSurface = ( L, back ) => ( throughSurfaces ? back.or( inFront( L ) ) : inFront( L ) );
+	const cosineTo = L => ( throughSurfaces ? abs( dot( hitNormal, L ) ) : max( float( 0.0 ), dot( hitNormal, L ) ) );
+	const originFor = ( back, front ) => ( throughSurfaces ? select( back, backOrigin, front ) : front );
+	const reflection = L => {
+
+		// Share H + dot products between BRDF eval and PDF — otherwise each
+		// would recompute normalize(V+L) + 5 dot products independently.
+		const dots = DotProducts.wrap( computeDotProductsAniso( hitNormal, viewDir, L, material ) );
+		return { value: evaluateMaterialResponseFromDots( material, dots ), pdf: calculateMaterialPDFFromDots( material, dots ).toVar() };
+
+	};
+
+	const bsdfToward = ( L, back ) => {
+
+		if ( ! throughSurfaces ) return reflection( L );
+		const value = vec3( 0.0 ).toVar();
+		const pdf = float( 0.0 ).toVar();
+		If( back, () => {
+
+			value.assign( evaluateDiffuseTransmission( material, max( dot( hitNormal, viewDir ), 0.001 ) ) );
+			pdf.assign( max( diffuseTransmissionPdf( diffuseTransmissionWeight( material ), dot( hitNormal, L ).negate() ), 1e-8 ) );
+
+		} ).Else( () => {
+
+			const r = reflection( L );
+			value.assign( r.value );
+			pdf.assign( r.pdf );
+
+		} );
+		return { value, pdf };
+
+	};
+
 
 	// NEE and BSDF-hit both run at every vertex, one sample each, so the MIS weights are the
 	// plain power heuristic over the raw densities. Picking one strategy stochastically and
@@ -828,6 +970,13 @@ export const calculateDirectLightingUnified = Fn( ( [
 	// rather than re-walking every light buffer to rebuild the same sum.
 	const neeTotalWeight = float( 0.0 ).toVar();
 
+	const learned = picked ? {
+		share: ( kind ) => visibilityShare( visibilityCounters, visibilityCell, kind ),
+		record: ( kind, visible ) => recordVisibility( visibilityCounters, visibilityCell, kind, visible ),
+	} : null;
+	const pick = picked ? lightPick( getRandomSample1D( pixelCoord, int( 0 ), dimBase, rngState, resolution, frame ), learned, picked ) : null;
+	if ( pick ) pick.offer( emissiveValue, emissiveOrigin, emissiveDirection, emissiveDistance, VISIBILITY_KIND.EMITTERS );
+
 	// =====================================================================
 	// LIGHT SAMPLING PATH
 	// =====================================================================
@@ -849,24 +998,19 @@ export const calculateDirectLightingUnified = Fn( ( [
 
 		If( lightSample.valid.and( lightSample.pdf.greaterThan( 0.0 ) ), () => {
 
-			const NoL = max( float( 0.0 ), dot( hitNormal, lightSample.direction ) ).toVar();
+			const back = throughSurface( lightSample.direction ).toVar();
+			const NoL = cosineTo( lightSample.direction ).toVar();
 
-			If( NoL.greaterThan( 0.0 ).and( isDirectionValid( { direction: lightSample.direction, surfaceNormal: geomNormal } ) ), () => {
+			If( reachesSurface( lightSample.direction, back ), () => {
 
 				// Light geometry is measured from the hit point; only the visibility ray starts on the lifted
 				// origin, aimed at the sampled point and stopped a relative hair short of it.
-				const lightOrigin = lightShadowOrigin( lightSample.direction ).toVar();
+				const lightOrigin = originFor( back, lightShadowOrigin( lightSample.direction ) ).toVar();
 				const toSample = hitPoint.add( lightSample.direction.mul( lightSample.distance ) ).sub( lightOrigin ).toVar();
 				const shadowDistance = length( toSample ).toVar();
-				const visibility = shadow( lightOrigin, toSample.div( shadowDistance ), shadowDistance.mul( SHADOW_END ) );
+				const lampLight = () => {
 
-				If( visibility.greaterThan( 0.0 ).or( wantUnoccluded ), () => {
-
-					// Share H + dot products between BRDF eval and PDF — otherwise each
-					// would recompute normalize(V+L) + 5 dot products independently.
-					const sharedDots = DotProducts.wrap( computeDotProductsAniso( hitNormal, viewDir, lightSample.direction, material ) );
-					const brdfValue = evaluateMaterialResponseFromDots( material, sharedDots );
-					const bPdf = calculateMaterialPDFFromDots( material, sharedDots ).toVar();
+					const { value: brdfValue, pdf: bPdf } = bsdfToward( lightSample.direction, back );
 
 					// Power heuristic only for area lights — they are the only type the BRDF
 					// path can intersect, so elsewhere MIS would just delete energy.
@@ -878,17 +1022,33 @@ export const calculateDirectLightingUnified = Fn( ( [
 
 					} );
 
-					// Base contribution WITHOUT visibility; shadowed = base × visibility (identical to the
-					// pre-dual-sum math), unoccluded = base × 1 (shadow-catcher reference only).
-					const baseContribution = lightSample.emission.mul( brdfValue ).mul( NoL ).mul( misW ).div( max( lightSample.pdf, 1e-10 ) );
-					totalContribution.addAssign( baseContribution.mul( visibility ) );
-					If( wantUnoccluded, () => {
+					return lightSample.emission.mul( brdfValue ).mul( NoL ).mul( misW ).div( max( lightSample.pdf, 1e-10 ) );
+
+				};
+
+				if ( pick ) {
+
+					pick.offer( lampLight(), lightOrigin, toSample.div( shadowDistance ), shadowDistance.mul( SHADOW_END ), VISIBILITY_KIND.LAMPS );
+
+				} else {
+
+					const visibility = shadow( lightOrigin, toSample.div( shadowDistance ), shadowDistance.mul( SHADOW_END ) );
+
+					If( visibility.greaterThan( 0.0 ).or( wantUnoccluded ), () => {
+
+						// Base contribution WITHOUT visibility; shadowed = base × visibility (identical to the
+						// pre-dual-sum math), unoccluded = base × 1 (shadow-catcher reference only).
+						const baseContribution = lampLight();
+						totalContribution.addAssign( baseContribution.mul( visibility ) );
+						If( wantUnoccluded, () => {
+
+							unoccludedContribution.addAssign( baseContribution );
 
-						unoccludedContribution.addAssign( baseContribution );
+						} );
 
 					} );
 
-				} );
+				}
 
 			} );
 
@@ -902,9 +1062,10 @@ export const calculateDirectLightingUnified = Fn( ( [
 
 	If( brdfSamplePdf.greaterThan( 0.0 ).and( numAreaLights.greaterThan( int( 0 ) ) ), () => {
 
-		const NoL = max( float( 0.0 ), dot( hitNormal, brdfSampleDirection ) ).toVar();
+		const back = throughSurface( brdfSampleDirection ).toVar();
+		const NoL = cosineTo( brdfSampleDirection ).toVar();
 
-		If( NoL.greaterThan( 0.0 ).and( isDirectionValid( { direction: brdfSampleDirection, surfaceNormal: geomNormal } ) ), () => {
+		If( reachesSurface( brdfSampleDirection, back ), () => {
 
 			// Nearest hit — the ray stops at the first emitter, so a brighter one behind it is
 			// the wrong emitter and the wrong pdf. No importance gate: skipping a light drops
@@ -936,9 +1097,10 @@ export const calculateDirectLightingUnified = Fn( ( [
 			If( nearestLight.greaterThanEqual( int( 0 ) ), () => {
 
 				const light = AreaLight.wrap( getAreaLight( areaLightsBuffer, nearestLight ) );
-				const toLight = hitPoint.add( brdfSampleDirection.mul( nearestT ) ).sub( rayOrigin ).toVar();
+				const hitOrigin = originFor( back, rayOrigin ).toVar();
+				const toLight = hitPoint.add( brdfSampleDirection.mul( nearestT ) ).sub( hitOrigin ).toVar();
 				const shadowDistance = length( toLight ).toVar();
-				const visibility = shadow( rayOrigin, toLight.div( shadowDistance ), shadowDistance.mul( SHADOW_END ) );
+				const visibility = shadow( hitOrigin, toLight.div( shadowDistance ), shadowDistance.mul( SHADOW_END ) );
 
 				If( visibility.greaterThan( 0.0 ).or( wantUnoccluded ), () => {
 
@@ -1011,33 +1173,29 @@ export const calculateDirectLightingUnified = Fn( ( [
 				radiance.assign( sunRadianceToward( direction, sunDirection, sunRadiance, sunParams ).mul( environmentIntensity ) );
 				lightPdf.assign( select( radiance.x.add( radiance.y ).add( radiance.z ).greaterThan( 0.0 ), float( 1.0 ).div( sunParams.y ), float( 0.0 ) ) );
 
-			} ).Else( () => {
+			} ).ElseIf( envTotalSum.greaterThan( 0.0 ), () => {
 
-				const envRandom = getRandomSample2D( pixelCoord, int( 0 ), dimBase.add( int( 1 ) ), rngState, resolution, frame ).toVar();
-				const envColor = vec3( 0.0 ).toVar();
-				const envSampleResult = sampleEquirectProbability(
-					envTexture, envCDFTexture,
-					envMatrix, environmentIntensity, envTotalSum, envCompensationDelta, envResolution, envRandom, envColor
-				).toVar();
-				direction.assign( envSampleResult.xyz );
-				radiance.assign( envColor );
-				lightPdf.assign( envSampleResult.w );
+				// Drawn from the table its density is read back from; a total of 0 is no table, or a black map.
+				const drawn = sampleEnvironmentExact( envCDFTexture, envMatrix, envResolution,
+					getRandomSample2D( pixelCoord, int( 0 ), dimBase.add( int( 1 ) ), rngState, resolution, frame ) );
+				direction.assign( drawn.direction );
+				radiance.assign( sampleEnvironment( {
+					tex: envTexture, samp: sampler( envTexture ), direction, environmentMatrix: envMatrix, environmentIntensity, enableEnvironmentLight: float( 1.0 ),
+				} ).xyz );
+				lightPdf.assign( drawn.pdf );
 
 			} );
 
 			If( lightPdf.greaterThan( 0.0 ), () => {
 
-				const NoL = max( float( 0.0 ), dot( hitNormal, direction ) ).toVar();
-
-				If( NoL.greaterThan( 0.0 ).and( isDirectionValid( { direction, surfaceNormal: geomNormal } ) ), () => {
+				const back = throughSurface( direction ).toVar();
+				const NoL = cosineTo( direction ).toVar();
 
-					const visibility = shadow( lightShadowOrigin( direction ), direction, float( 1e20 ) );
+				If( reachesSurface( direction, back ), () => {
 
-					If( visibility.greaterThan( 0.0 ).or( wantUnoccluded ), () => {
+					const skyLight = () => {
 
-						const envDots = DotProducts.wrap( computeDotProductsAniso( hitNormal, viewDir, direction, material ) );
-						const brdfValue = evaluateMaterialResponseFromDots( material, envDots );
-						const bPdf = calculateMaterialPDFFromDots( material, envDots ).toVar();
+						const { value: brdfValue, pdf: bPdf } = bsdfToward( direction, back );
 
 						// The map pairs with the balance heuristic — optimal for its MIS-compensated pdf
 						// (Karlík et al. 2019); the sun, a small bright source, with the power heuristic.
@@ -1047,8 +1205,24 @@ export const calculateDirectLightingUnified = Fn( ( [
 							float( 1.0 )
 						).toVar();
 
+						return radiance.mul( brdfValue ).mul( NoL ).mul( misW ).div( max( lightPdf, 1e-10 ) );
+
+					};
+
+					if ( pick ) {
+
+						pick.offer( skyLight(), originFor( back, lightShadowOrigin( direction ) ), direction, float( 1e20 ),
+							select( isSun, int( VISIBILITY_KIND.SUN ), int( VISIBILITY_KIND.ENVIRONMENT ) ) );
+						return;
+
+					}
+
+					const visibility = shadow( originFor( back, lightShadowOrigin( direction ) ), direction, float( 1e20 ) );
+
+					If( visibility.greaterThan( 0.0 ).or( wantUnoccluded ), () => {
+
 						// Base contribution WITHOUT visibility (deterministic estimator; no stochastic scaling).
-						const baseContribution = radiance.mul( brdfValue ).mul( NoL ).mul( misW ).div( max( lightPdf, 1e-10 ) );
+						const baseContribution = skyLight();
 						totalContribution.addAssign( baseContribution.mul( visibility ) );
 						If( wantUnoccluded, () => {
 
@@ -1066,6 +1240,8 @@ export const calculateDirectLightingUnified = Fn( ( [
 
 	} );
 
+	if ( pick ) totalContribution.addAssign( pick.trace( shadow ) );
+
 	// EMISSIVE TRIANGLE DIRECT LIGHTING
 	// NOTE: Emissive triangle sampling is handled separately in pathtracer_core.fs
 	// to bypass firefly suppression. Do not add it here to avoid double-counting.
@@ -1073,3 +1249,15 @@ export const calculateDirectLightingUnified = Fn( ( [
 	return DirectLightingDual( { shadowed: totalContribution, unoccluded: unoccludedContribution } );
 
 } );
+
+export const calculateDirectLightingUnified = /*@__PURE__*/ makeDirectLighting( false );
+export const calculateDirectLightingThroughSurfaces = /*@__PURE__*/ makeDirectLighting( true );
+const pickedLighting = new Map();
+/** The direct light with fewer shadow rays a hit; `variant` as lightPick takes it. */
+export const calculateDirectLightingPicked = ( throughSurfaces, variant ) => {
+
+	const key = `${throughSurfaces}:${variant}`;
+	if ( ! pickedLighting.has( key ) ) pickedLighting.set( key, makeDirectLighting( throughSurfaces, variant ) );
+	return pickedLighting.get( key );
+
+};

package/src/TSL/MaterialEvaluation.js

@@ -1,11 +1,12 @@
 import {
-	Fn, float, vec3,
+	Fn, float, vec3, dot,
 	If, max, min, clamp, mix
 } from 'three/tsl';
 
 import { DotProducts, DFGResult, BaseFresnel } from './Struct.js';
 import { PI_INV, MIN_CLEARCOAT_ROUGHNESS, computeDotProductsAniso } from './Common.js';
 import { fresnelSchlick, fresnelDielectric, dielectricFresnelWeight } from './Fresnel.js';
+import { materialLayers } from './SceneResources.js';
 import {
 	DistributionGGX, SheenDistribution, VisibilitySheen, VisibilityGGXSmithCorrelated,
 	sheenDirectionalAlbedo, evaluateSpecularDFG, baseFresnelParams,
@@ -21,27 +22,32 @@ import { evalIridescence } from './MaterialProperties.js';
 // Main Material Response Evaluation
 // -----------------------------------------------------------------------------
 
+// A rough plain dielectric: its BSDF is a bare Lambert term (no specular lobe, no DFG budget).
+const isLambertian = ( material ) => material.roughness.greaterThan( 0.98 )
+	.and( material.metalness.lessThan( 0.02 ) )
+	.and( material.transmission.equal( 0.0 ) )
+	.and( material.clearcoat.equal( 0.0 ) )
+	.and( material.sheen.equal( 0.0 ) )
+	.and( material.iridescence.equal( 0.0 ) );
+
 // 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.
 // Roughness 0 marks an exact mirror (ShadeKernel): its delta lobe is left out of this BSDF, and
 // deltaOnly returns that lobe's reflectance instead, under the same sheen and coat attenuation.
-const makeEvaluateMaterialResponse = ( deltaOnly ) => Fn( ( [ material, dots ] ) => {
+const makeEvaluateMaterialResponse = ( deltaOnly ) => Fn( ( [ material, dots ], builder ) => {
 
+	const layers = materialLayers( builder );
 	const result = vec3( 0.0 ).toVar();
 
 	// Early exit for purely diffuse materials (skip if iridescent)
 	// `sheen` is in the guard because this fast path returns a bare Lambert term: without it a
 	// rough sheen material lost its sheen lobe entirely — silently, since the fast path is only
 	// taken above roughness 0.98.
-	If( material.roughness.greaterThan( 0.98 )
-		.and( material.metalness.lessThan( 0.02 ) )
-		.and( material.transmission.equal( 0.0 ) )
-		.and( material.clearcoat.equal( 0.0 ) )
-		.and( material.sheen.equal( 0.0 ) )
-		.and( material.iridescence.equal( 0.0 ) ), () => {
+	If( isLambertian( material ), () => {
 
-		result.assign( material.color.rgb.mul( float( 1.0 ).sub( material.metalness ) ).mul( PI_INV ) );
+		result.assign( material.color.rgb.mul( float( 1.0 ).sub( material.metalness ) )
+			.mul( float( 1.0 ).sub( material.diffuseTransmission ) ).mul( PI_INV ) );
 
 	} ).Else( () => {
 
@@ -51,7 +57,7 @@ const makeEvaluateMaterialResponse = ( deltaOnly ) => Fn( ( [ material, dots ] )
 
 		// Modify material color for dispersive materials to enhance color separation
 		const materialColor = material.color.rgb.toVar();
-		If( material.dispersion.greaterThan( 0.0 ).and( material.transmission.greaterThan( 0.5 ) ), () => {
+		if ( layers.dispersion ) If( material.dispersion.greaterThan( 0.0 ).and( material.transmission.greaterThan( 0.5 ) ), () => {
 
 			// For highly dispersive transmissive materials, boost color saturation
 			const dispersionEffect = clamp( material.dispersion.mul( 0.1 ), 0.0, 0.8 );
@@ -67,7 +73,7 @@ const makeEvaluateMaterialResponse = ( deltaOnly ) => Fn( ( [ material, dots ] )
 		} );
 
 		// Add iridescence effect if enabled
-		If( material.iridescence.greaterThan( 0.0 ), () => {
+		if ( layers.iridescence ) If( material.iridescence.greaterThan( 0.0 ), () => {
 
 			// Per glTF KHR_materials_iridescence spec: use max thickness when no texture
 			const thickness = material.iridescenceThicknessRange.y;
@@ -78,29 +84,29 @@ const makeEvaluateMaterialResponse = ( deltaOnly ) => Fn( ( [ material, dots ] )
 
 		// Dielectric on the exact Fresnel curve, metal and iridescence on Schlick.
 		const Fd = mix( bf.f0, vec3( bf.f90 ), dielectricFresnelWeight( dots.VoH, bf.eta ) );
-		const F = mix(
-			mix( Fd, fresnelSchlick( dots.VoH, bf.F0m ), material.metalness ),
-			fresnelSchlick( dots.VoH, iridF ),
-			material.iridescence,
-		).toVar();
+		const Fbase = mix( Fd, fresnelSchlick( dots.VoH, bf.F0m ), material.metalness );
+		const F = ( layers.iridescence ? mix( Fbase, fresnelSchlick( dots.VoH, iridF ), material.iridescence ) : Fbase ).toVar();
 
 		// Single-scatter specular BRDF (anisotropic when material.anisotropy > 0; the aniso
 		// visibility term already carries the 1/(4·NoV·NoL) denominator)
 		const specularSS = vec3( 0.0 ).toVar();
-		If( material.anisotropy.greaterThan( 0.0 ), () => {
+		const isotropic = () => {
+
+			const D = DistributionGGX( dots.NoH, material.roughness );
+			const Vis = VisibilityGGXSmithCorrelated( dots.NoV, dots.NoL, material.roughness );
+			specularSS.assign( D.mul( Vis ).mul( F ) );
+
+		};
+
+		if ( layers.anisotropy ) If( material.anisotropy.greaterThan( 0.0 ), () => {
 
 			const a = computeAnisoAlphas( material.roughness, material.anisotropy );
 			const Da = DistributionGGXAniso( a.x, a.y, dots.NoH, dots.ToH, dots.BoH );
 			const Va = VisibilityGGXAniso( a.x, a.y, dots.ToV, dots.BoV, dots.ToL, dots.BoL, dots.NoV, dots.NoL );
 			specularSS.assign( F.mul( Da.mul( Va ) ) );
 
-		} ).ElseIf( material.roughness.greaterThan( 0.0 ), () => {
-
-			const D = DistributionGGX( dots.NoH, material.roughness );
-			const Vis = VisibilityGGXSmithCorrelated( dots.NoV, dots.NoL, material.roughness );
-			specularSS.assign( D.mul( Vis ).mul( F ) );
-
-		} );
+		} ).ElseIf( material.roughness.greaterThan( 0.0 ), isotropic );
+		else If( material.roughness.greaterThan( 0.0 ), isotropic );
 
 		// Compensation factor and total directional albedo from the same table fetch.
 		const dfg = DFGResult.wrap( evaluateSpecularDFG(
@@ -112,15 +118,17 @@ const makeEvaluateMaterialResponse = ( deltaOnly ) => Fn( ( [ material, dots ] )
 		// Diffuse energy budget from hemisphere-integrated specular albedo (includes multiscatter)
 		// Transmission removes energy from diffuse just as metalness does — KHR_materials_transmission
 		// defines transmission as replacing the diffuse component.
+		// Diffuse transmission takes its share of the diffuse lobe to the other side (evaluateDiffuseTransmission).
 		const kD = vec3( 1.0 ).sub( dfg.E_total )
 			.mul( float( 1.0 ).sub( material.metalness ) )
-			.mul( float( 1.0 ).sub( material.transmission ) );
+			.mul( float( 1.0 ).sub( material.transmission ) )
+			.mul( float( 1.0 ).sub( material.diffuseTransmission ) );
 		const diffuse = deltaOnly ? vec3( 0.0 ) : kD.mul( materialColor ).mul( PI_INV );
 
 		const baseLayer = diffuse.add( specular ).toVar();
 
-		// Optimize sheen calculation
-		If( material.sheen.greaterThan( 0.0 ), () => {
+		if ( ! layers.sheen ) result.assign( baseLayer );
+		else If( material.sheen.greaterThan( 0.0 ), () => {
 
 			// D · V, not · NoL — callers apply the cosine when they integrate.
 			const sheenDist = SheenDistribution( dots.NoH, material.sheenRoughness );
@@ -143,7 +151,7 @@ const makeEvaluateMaterialResponse = ( deltaOnly ) => Fn( ( [ material, dots ] )
 
 		// The coat lives here, not in a separate layered-BRDF function: every strategy has to
 		// evaluate the same integrand or MIS is biased however good the weights are.
-		If( material.clearcoat.greaterThan( 0.0 ), () => {
+		if ( layers.clearcoat ) If( material.clearcoat.greaterThan( 0.0 ), () => {
 
 			const ccRoughness = max( material.clearcoatRoughness, MIN_CLEARCOAT_ROUGHNESS );
 			const ccF0 = vec3( 0.04 ); // IOR 1.5
@@ -176,12 +184,86 @@ const makeEvaluateMaterialResponse = ( deltaOnly ) => Fn( ( [ material, dots ] )
 export const evaluateMaterialResponseFromDots = /*@__PURE__*/ makeEvaluateMaterialResponse( false );
 export const evaluateSpecularDeltaFromDots = /*@__PURE__*/ makeEvaluateMaterialResponse( true );
 
+/**
+ * KHR_materials_diffuse_transmission's BTDF, for light arriving from the far side of a thin surface: the diffuse
+ * budget the reflected diffuse lobe has (what the specular lobes leave, less metal and specular transmission) × the
+ * transmitted share × its colour / π, under the same sheen and coat attenuation. Zero when the material has none.
+ */
+export const evaluateDiffuseTransmission = Fn( ( [ material, NoV ], builder ) => {
+
+	const layers = materialLayers( builder );
+	const result = vec3( 0.0 ).toVar();
+
+	if ( layers.diffuseTransmission ) If( material.diffuseTransmission.greaterThan( 0.0 ), () => {
+
+		const kD = vec3( float( 1.0 ).sub( material.metalness ).mul( float( 1.0 ).sub( material.transmission ) ) ).toVar();
+
+		If( isLambertian( material ).not(), () => {
+
+			const bf = BaseFresnel.wrap( baseFresnelParams( material, material.color.rgb ) );
+			const F0 = bf.F0.toVar();
+			const iridF = vec3( 0.0 ).toVar();
+			if ( layers.iridescence ) If( material.iridescence.greaterThan( 0.0 ), () => {
+
+				// No half vector across the surface: the iridescent F0 at normal incidence to the view.
+				iridF.assign( evalIridescence( float( 1.0 ), material.iridescenceIOR, NoV, material.iridescenceThicknessRange.y, F0 ) );
+				F0.assign( mix( F0, iridF, material.iridescence ) );
+
+			} );
+			const dfg = DFGResult.wrap( evaluateSpecularDFG(
+				bf.f0, bf.f90, bf.eta, bf.F0m, material.metalness, iridF, material.iridescence, F0,
+				NoV, material.roughness,
+			) );
+			kD.mulAssign( vec3( 1.0 ).sub( dfg.E_total ) );
+
+		} );
+
+		result.assign( kD.mul( material.diffuseTransmission ).mul( material.diffuseTransmissionColor ).mul( PI_INV ) );
+
+		if ( layers.sheen ) If( material.sheen.greaterThan( 0.0 ), () => {
+
+			const sheenE = sheenDirectionalAlbedo( NoV, material.sheenRoughness );
+			result.mulAssign( vec3( 1.0 ).sub( clamp( material.sheenColor.mul( material.sheen ).mul( sheenE ), vec3( 0.0 ), vec3( 1.0 ) ) ) );
+
+		} );
+
+		if ( layers.clearcoat ) If( material.clearcoat.greaterThan( 0.0 ), () => {
+
+			const ccDfg = DFGResult.wrap( evaluateSpecularDFG(
+				vec3( 0.04 ), float( 1.0 ), float( 1.5 ), vec3( 0.0 ), float( 0.0 ), vec3( 0.0 ), float( 0.0 ), vec3( 0.04 ),
+				NoV, max( material.clearcoatRoughness, MIN_CLEARCOAT_ROUGHNESS ),
+			) );
+			result.mulAssign( vec3( 1.0 ).sub( ccDfg.E_total.mul( material.clearcoat ) ) );
+
+		} );
+
+	} );
+
+	return result;
+
+} );
+
 // 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 ] ) => {
+// L below N reaches only the diffuse transmission lobe.
+export const evaluateMaterialResponse = Fn( ( [ V, L, N, material ], builder ) => {
+
+	const result = vec3( 0.0 ).toVar();
+	const reflected = () => {
 
-	const dots = DotProducts.wrap( computeDotProductsAniso( N, V, L, material ) );
-	return evaluateMaterialResponseFromDots( material, dots );
+		const dots = DotProducts.wrap( computeDotProductsAniso( N, V, L, material ) );
+		result.assign( evaluateMaterialResponseFromDots( material, dots ) );
+
+	};
+
+	if ( ! materialLayers( builder ).diffuseTransmission ) reflected();
+	else If( dot( N, L ).lessThan( 0.0 ).and( material.diffuseTransmission.greaterThan( 0.0 ) ), () => {
+
+		result.assign( evaluateDiffuseTransmission( material, max( dot( N, V ), 0.001 ) ) );
+
+	} ).Else( reflected );
+
+	return result;
 
 } );