rayzee 9.4.2 → 9.5.0

package/src/TSL/LightsSampling.js

@@ -37,6 +37,7 @@ import {
 	select,
 	If,
 	Loop,
+	sampler,
 } from 'three/tsl';
 
 import {
@@ -71,8 +72,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,
@@ -84,9 +85,7 @@ import {
 	offsetRayOrigin,
 	SHADOW_END,
 } 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';
 
@@ -757,8 +756,20 @@ 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;
 
 } );
 
@@ -766,8 +777,9 @@ export const calculateMaterialPDF = Fn( ( [ viewDir, lightDir, normal, material
 // 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 ) => Fn( ( [
 	// Surface hit data
 	hitPoint, hitNormal, geomNormal, material,
 	// View direction
@@ -791,7 +803,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.
@@ -817,6 +829,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
@@ -849,24 +901,21 @@ 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 ) );
 
 				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.
@@ -902,9 +951,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 +986,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 +1062,31 @@ 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();
+				const back = throughSurface( direction ).toVar();
+				const NoL = cosineTo( direction ).toVar();
 
-				If( NoL.greaterThan( 0.0 ).and( isDirectionValid( { direction, surfaceNormal: geomNormal } ) ), () => {
+				If( reachesSurface( direction, back ), () => {
 
-					const visibility = shadow( lightShadowOrigin( direction ), direction, float( 1e20 ) );
+					const visibility = shadow( originFor( back, lightShadowOrigin( direction ) ), direction, float( 1e20 ) );
 
 					If( visibility.greaterThan( 0.0 ).or( wantUnoccluded ), () => {
 
-						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.
@@ -1073,3 +1122,6 @@ export const calculateDirectLightingUnified = Fn( ( [
 	return DirectLightingDual( { shadowed: totalContribution, unoccluded: unoccludedContribution } );
 
 } );
+
+export const calculateDirectLightingUnified = /*@__PURE__*/ makeDirectLighting( false );
+export const calculateDirectLightingThroughSurfaces = /*@__PURE__*/ makeDirectLighting( true );

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;
 
 } );
 

package/src/TSL/MaterialProperties.js

@@ -6,6 +6,7 @@ import { BRDFWeights, MaterialCache, MaterialClassification, DFGResult, BaseFres
 import { PI, PI_INV, TWO_PI, EPSILON, MIN_ROUGHNESS, MIN_CLEARCOAT_ROUGHNESS, MAX_ROUGHNESS, XYZ_TO_REC709, square, classifyMaterial } from './Common.js';
 
 import { fresnelSchlickFloat, fresnel0ToIor, iorToFresnel0Vec3, iorToFresnel0, dielectricF0 } from './Fresnel.js';
+import { materialLayers } from './SceneResources.js';
 
 // -----------------------------------------------------------------------------
 // Microfacet Distribution Functions
@@ -407,8 +408,9 @@ export const evalIridescence = Fn( ( [ outsideIOR, eta2, cosTheta1, thinFilmThic
 // BRDF Weight Calculation
 // -----------------------------------------------------------------------------
 
-export const calculateBRDFWeights = Fn( ( [ material, mc, cache ] ) => {
+export const calculateBRDFWeights = Fn( ( [ material, mc, cache ], builder ) => {
 
+	const layers = materialLayers( builder );
 	// Use precomputed values from cache
 	const invRoughness = cache.invRoughness;
 	const metalFactor = cache.metalFactor;
@@ -438,10 +440,10 @@ export const calculateBRDFWeights = Fn( ( [ material, mc, cache ] ) => {
 	const diffuse = float( 1.0 ).sub( baseSpecularWeight )
 		.mul( float( 1.0 ).sub( material.metalness ) )
 		.mul( float( 1.0 ).sub( material.transmission ) ).toVar();
-	const sheen = material.sheen.mul( cache.maxSheenColor ).toVar();
+	const sheen = ( layers.sheen ? material.sheen.mul( cache.maxSheenColor ) : float( 0.0 ) ).toVar();
 
 	const clearcoat = float( 0.0 ).toVar();
-	If( mc.hasClearcoat, () => {
+	if ( layers.clearcoat ) If( mc.hasClearcoat, () => {
 
 		clearcoat.assign( material.clearcoat.mul( invRoughness ).mul( 0.4 ) );
 
@@ -471,17 +473,22 @@ export const calculateBRDFWeights = Fn( ( [ material, mc, cache ] ) => {
 	// Iridescence: shifts energy from diffuse to specular since it modifies specular F0
 	// This preserves the total weight (no inflation) while increasing specular importance
 	const iridescenceBase = invRoughness.mul( mc.isSmooth.select( float( 0.6 ), float( 0.5 ) ) );
-	const iridescenceWeight = material.iridescence.mul( iridescenceBase )
+	// Off, the weight is 0 but the shift is kept: min( 0, diffuse ) still moves a negative diffuse weight to specular.
+	const iridescenceWeight = layers.iridescence ? material.iridescence.mul( iridescenceBase )
 		.mul( float( 0.5 ).add( float( 0.5 ).mul(
 			material.iridescenceThicknessRange.y.sub( material.iridescenceThicknessRange.x ).div( 1000.0 )
 		) ) )
-		.mul( float( 0.5 ).add( float( 0.5 ).mul( material.iridescenceIOR.div( 2.0 ) ) ) );
+		.mul( float( 0.5 ).add( float( 0.5 ).mul( material.iridescenceIOR.div( 2.0 ) ) ) ) : float( 0.0 );
 	const iridescenceShift = min( iridescenceWeight, diffuse );
 	specular.addAssign( iridescenceShift );
 	diffuse.subAssign( iridescenceShift );
 
+	// The diffuse lobe's transmitted share is drawn on the other side, in proportion.
+	const diffuseTransmission = ( layers.diffuseTransmission ? diffuse.mul( material.diffuseTransmission ) : float( 0.0 ) ).toVar();
+	diffuse.subAssign( diffuseTransmission );
+
 	// Single normalization pass
-	const total = specular.add( diffuse ).add( sheen ).add( clearcoat ).add( transmission );
+	const total = specular.add( diffuse ).add( sheen ).add( clearcoat ).add( transmission ).add( diffuseTransmission );
 	const invTotal = float( 1.0 ).div( max( total, 0.001 ) );
 
 	return BRDFWeights( {
@@ -491,6 +498,7 @@ export const calculateBRDFWeights = Fn( ( [ material, mc, cache ] ) => {
 		clearcoat: clearcoat.mul( invTotal ),
 		transmission: transmission.mul( invTotal ),
 		iridescence: float( 0.0 ),
+		diffuseTransmission: diffuseTransmission.mul( invTotal ),
 	} );
 
 } );
@@ -508,8 +516,9 @@ export const calculateBRDFWeights = Fn( ( [ material, mc, cache ] ) => {
 //
 // Transmission is absent because it only produces NoL < 0. `weights` is normalised over all
 // lobes including transmission, so omitting its term is exact, not an approximation.
-export const calculateBSDFSamplingPDF = Fn( ( [ material, weights, dots ] ) => {
+export const calculateBSDFSamplingPDF = Fn( ( [ material, weights, dots ], builder ) => {
 
+	const layers = materialLayers( builder );
 	const pdf = float( 0.0 ).toVar();
 
 	If( dots.NoL.greaterThan( 0.0 ), () => {
@@ -517,21 +526,24 @@ export const calculateBSDFSamplingPDF = Fn( ( [ material, weights, dots ] ) => {
 		pdf.addAssign( weights.diffuse.mul( dots.NoL ).mul( PI_INV ) );
 
 		const specPdf = float( 0.0 ).toVar();
-		If( material.anisotropy.greaterThan( 0.0 ), () => {
+		// Raw roughness, not clamped: sampleGGXVNDF is called with material.roughness, and a
+		// clamp here would report a density the sampler never drew from.
+		const isotropic = () => {
 
-			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 ) );
+			specPdf.assign( calculateVNDFPDF( dots.NoH, dots.NoV, material.roughness ) );
 
-		} ).Else( () => {
+		};
 
-			// Raw roughness, not clamped: sampleGGXVNDF is called with material.roughness, and a
-			// clamp here would report a density the sampler never drew from.
-			specPdf.assign( calculateVNDFPDF( dots.NoH, dots.NoV, material.roughness ) );
+		if ( ! layers.anisotropy ) isotropic();
+		else 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( isotropic );
 		pdf.addAssign( weights.specular.mul( specPdf ) );
 
-		If( weights.sheen.greaterThan( 0.0 ), () => {
+		if ( layers.sheen ) If( weights.sheen.greaterThan( 0.0 ), () => {
 
 			const sheenPdf = SheenDistribution( dots.NoH, material.sheenRoughness )
 				.mul( dots.NoH ).div( max( float( 4.0 ).mul( dots.VoH ), EPSILON ) );
@@ -539,7 +551,7 @@ export const calculateBSDFSamplingPDF = Fn( ( [ material, weights, dots ] ) => {
 
 		} );
 
-		If( weights.clearcoat.greaterThan( 0.0 ), () => {
+		if ( layers.clearcoat ) If( weights.clearcoat.greaterThan( 0.0 ), () => {
 
 			const ccRoughness = clamp( material.clearcoatRoughness, MIN_CLEARCOAT_ROUGHNESS, MAX_ROUGHNESS );
 			pdf.addAssign( weights.clearcoat.mul( calculateVNDFPDF( dots.NoH, dots.NoV, ccRoughness ) ) );
@@ -552,6 +564,21 @@ export const calculateBSDFSamplingPDF = Fn( ( [ material, weights, dots ] ) => {
 
 } );
 
+// The sampling density below the surface (cosBelow = −N·L > 0): only the diffuse transmission lobe draws there,
+// chosen with probability `weight` (BRDFWeights.diffuseTransmission).
+export const diffuseTransmissionPdf = Fn( ( [ weight, cosBelow ] ) => {
+
+	return weight.mul( cosBelow ).mul( PI_INV );
+
+} );
+
+// The diffuse transmission lobe's selection probability, for samplers outside the classify-once path.
+export const diffuseTransmissionWeight = Fn( ( [ material ] ) => {
+
+	return BRDFWeights.wrap( calculateBRDFWeightsFromMaterial( material ) ).diffuseTransmission;
+
+} );
+
 // Selection probabilities from `material` alone, for samplers outside the wavefront's
 // classify-once path. Must be the same weights whose density calculateBSDFSamplingPDF reports.
 export const calculateBRDFWeightsFromMaterial = Fn( ( [ material ] ) => {