rayzee 9.4.1 → 9.5.0

package/src/TSL/MaterialTransmission.js

@@ -10,6 +10,7 @@ import { DistributionGGX } from './MaterialProperties.js';
 import { ImportanceSampleGGX } from './MaterialSampling.js';
 import { getRandomSample1D, getRandomSample2D, pcgHash } from './Random.js';
 import { handleSubsurfaceEntry, SubsurfaceEntryResult } from './Subsurface.js';
+import { materialLayers } from './SceneResources.js';
 
 // ================================================================================
 // STRUCTS (local to transmission)
@@ -158,8 +159,9 @@ export const calculateBeerLawAbsorption = /*@__PURE__*/ wgslFn( `
 export const sampleMicrofacetTransmission = Fn( ( [
 	V, N, ior, roughness, entering, dispersion, xi, rngState, pathWavelength,
 	pixelCoord, resolution, frame, dimBase,
-] ) => {
+], builder ) => {
 
+	const layers = materialLayers( builder );
 	const result = MicrofacetTransmissionResult( {
 		direction: vec3( 0.0 ),
 		halfVector: vec3( 0.0 ),
@@ -169,48 +171,7 @@ export const sampleMicrofacetTransmission = Fn( ( [
 		pathWavelength: pathWavelength,
 	} ).toVar();
 
-	// For smooth surfaces with dispersion, use perfect refraction with spectral IOR
-	If( roughness.lessThanEqual( 0.05 ).and( dispersion.greaterThan( 0.0 ) ), () => {
-
-		result.halfVector.assign( N );
-		result.didReflect.assign( false );
-
-		const eta = ior;
-		const etaRatio = select( entering, float( 1.0 ).div( eta ), eta ).toVar();
-
-		// Reuse the path's locked wavelength if any; else sample a new one and tint once.
-		If( pathWavelength.greaterThan( 0.0 ), () => {
-
-			const lockedIOR = iorFromWavelength( ior, dispersion, pathWavelength );
-			etaRatio.assign( select( entering, float( 1.0 ).div( lockedIOR ), lockedIOR ) );
-
-		} ).Else( () => {
-
-			const spectralSample = SpectralSample.wrap( sampleWavelengthForDispersion( ior, dispersion, getRandomSample1D( pixelCoord, int( 0 ), dimBase.add( int( 5 ) ), rngState, resolution, frame ) ) );
-			etaRatio.assign( select( entering, float( 1.0 ).div( spectralSample.ior ), spectralSample.ior ) );
-			result.colorWeight.assign( spectralSample.colorWeight );
-			result.pathWavelength.assign( spectralSample.wavelength );
-
-		} );
-
-		// Perfect refraction using surface normal
-		const refractDir = refract( V.negate(), N, etaRatio ).toVar();
-
-		// Check for total internal reflection
-		If( dot( refractDir, refractDir ).lessThan( 0.001 ), () => {
-
-			result.direction.assign( reflect( V.negate(), N ) );
-			result.didReflect.assign( true );
-			result.pdf.assign( 1.0 );
-
-		} ).Else( () => {
-
-			result.direction.assign( refractDir );
-			result.pdf.assign( 1.0 );
-
-		} );
-
-	} ).Else( () => {
+	const microfacet = () => {
 
 		// Use minimum roughness to avoid numerical issues for rough surfaces
 		const transmissionRoughness = max( MIN_ROUGHNESS, roughness );
@@ -223,7 +184,7 @@ export const sampleMicrofacetTransmission = Fn( ( [
 		const etaRatio = select( entering, float( 1.0 ).div( ior ), ior ).toVar();
 
 		// Reuse the path's locked wavelength if any; else sample a new one and tint once.
-		If( dispersion.greaterThan( 0.0 ), () => {
+		if ( layers.dispersion ) If( dispersion.greaterThan( 0.0 ), () => {
 
 			If( pathWavelength.greaterThan( 0.0 ), () => {
 
@@ -278,7 +239,51 @@ export const sampleMicrofacetTransmission = Fn( ( [
 
 		} );
 
-	} );
+	};
+
+	// For smooth surfaces with dispersion, use perfect refraction with spectral IOR
+	if ( ! layers.dispersion ) microfacet();
+	else If( roughness.lessThanEqual( 0.05 ).and( dispersion.greaterThan( 0.0 ) ), () => {
+
+		result.halfVector.assign( N );
+		result.didReflect.assign( false );
+
+		const eta = ior;
+		const etaRatio = select( entering, float( 1.0 ).div( eta ), eta ).toVar();
+
+		// Reuse the path's locked wavelength if any; else sample a new one and tint once.
+		If( pathWavelength.greaterThan( 0.0 ), () => {
+
+			const lockedIOR = iorFromWavelength( ior, dispersion, pathWavelength );
+			etaRatio.assign( select( entering, float( 1.0 ).div( lockedIOR ), lockedIOR ) );
+
+		} ).Else( () => {
+
+			const spectralSample = SpectralSample.wrap( sampleWavelengthForDispersion( ior, dispersion, getRandomSample1D( pixelCoord, int( 0 ), dimBase.add( int( 5 ) ), rngState, resolution, frame ) ) );
+			etaRatio.assign( select( entering, float( 1.0 ).div( spectralSample.ior ), spectralSample.ior ) );
+			result.colorWeight.assign( spectralSample.colorWeight );
+			result.pathWavelength.assign( spectralSample.wavelength );
+
+		} );
+
+		// Perfect refraction using surface normal
+		const refractDir = refract( V.negate(), N, etaRatio ).toVar();
+
+		// Check for total internal reflection
+		If( dot( refractDir, refractDir ).lessThan( 0.001 ), () => {
+
+			result.direction.assign( reflect( V.negate(), N ) );
+			result.didReflect.assign( true );
+			result.pdf.assign( 1.0 );
+
+		} ).Else( () => {
+
+			result.direction.assign( refractDir );
+			result.pdf.assign( 1.0 );
+
+		} );
+
+	} ).Else( microfacet );
 
 	return result;
 
@@ -430,7 +435,7 @@ export const handleMaterialTransparency = Fn( ( [
 	transmissiveTraversals,
 	currentMediumIOR, previousMediumIOR,
 	pathWavelength,
-] ) => {
+], builder ) => {
 
 	const result = MaterialInteractionResult( {
 		continueRay: false,
@@ -534,7 +539,7 @@ export const handleMaterialTransparency = Fn( ( [
 
 		// Subsurface (independent of transmission; works at transmission==0). Entry is a lottery
 		// (prob = weight) so 1-weight falls through to the opaque BRDF; exit is deterministic.
-		If( handled.not().and( material.subsurface.greaterThan( 0.0 ) ), () => {
+		if ( materialLayers( builder ).subsurface ) If( handled.not().and( material.subsurface.greaterThan( 0.0 ) ), () => {
 
 			const entering = dot( ray.direction, normal ).lessThan( 0.0 );
 			const doEnter = entering.not().or( getRandomSample1D( pixelCoord, int( 0 ), dimBase.add( int( 8 ) ), rngState, resolution, frame ).lessThan( material.subsurface ) );

package/src/TSL/MergeKernel.js

@@ -0,0 +1,218 @@
+/**
+ * MergeKernel.js — vertex merging (Georgiev et al. 2012, "Light Transport Simulation with Vertex Connection and
+ * Merging"): each camera vertex Shade left pending gathers the light vertices within the merge radius, as photon
+ * mapping does, MIS-weighted against every other strategy. It is the one strategy for light no path can connect:
+ * a lamp behind glass seen in a mirror, a caustic seen through water.
+ *
+ * The radius is a few pixels' footprint where the camera vertex is (Bidirectional.js mergeRadiusAt), so it grows
+ * with the distance from the camera. The light vertex cache is filed by that radius in shells, each a hash grid of
+ * cells two of its largest radii wide: one list a cell, threaded through the cached records' spare lane (`next`),
+ * built after the light pass by mergeInsert. A gather searches the one or two shells its sphere reaches, 2³ cells each.
+ */
+
+import {
+	Fn, float, vec3, vec4, int, uint, ivec3, If, Loop, instanceIndex, atomicLoad, atomicStore, atomicFunc, Return, dot, floor, max, min, select,
+	length, log2, exp2, Break,
+} from 'three/tsl';
+
+import { evaluateMaterialResponse } from './MaterialEvaluation.js';
+import { calculateMaterialPDF } from './LightsSampling.js';
+import { luminance } from './Common.js';
+import { regularizePathContribution } from './PathTracerCore.js';
+import { resolveSurfaceMaterial, misMergePartial, misWeight, strategyWeight, mergeRadiusAt, mergeEta, STRATEGY } from './Bidirectional.js';
+import { COUNTER } from '../Processor/QueueManager.js';
+import {
+	readRayRadiance, writeRayRadiance, pendingVertex, cachedVertex, readVertexTag, readVertexRecord, readVertexPosition,
+	readVertexNext, writeVertexNext, readLightPathLength,
+} from '../Processor/PackedRayBuffer.js';
+
+const WG_SIZE = 256;
+export const MERGE_EMPTY = 0xFFFFFFFF;
+// A cell's list is walked at most this far: a bound on the work, never reached at the radius the radius scale gives.
+const MAX_CELL_STEPS = 1024;
+
+// Shells of radius ratio 1.25: a sphere whose radius changes by (1 ± slope) across it spans at most two.
+export const MERGE_SHELL_RATIO = 1.25;
+const LOG2_RATIO = Math.log2( MERGE_SHELL_RATIO );
+
+const shellOf = ( bdpt, radius ) => int( max( floor( log2( radius.div( bdpt.mergeMin ) ).div( LOG2_RATIO ) ), 0.0 ) );
+
+// Twice the largest radius whose sphere can reach the shell (its own largest, over 1 − slope).
+const shellCell = ( bdpt, shell ) => bdpt.mergeMin.mul( exp2( float( shell.add( int( 1 ) ) ).mul( LOG2_RATIO ) ) ).mul( 2.0 )
+	.div( max( float( 1.0 ).sub( bdpt.mergeSlope ), 0.5 ) );
+
+const cellHash = ( shell, cell, hashMask ) => uint( cell.x ).mul( uint( 73856093 ) )
+	.bitXor( uint( cell.y ).mul( uint( 19349663 ) ) )
+	.bitXor( uint( cell.z ).mul( uint( 83492791 ) ) )
+	.bitXor( uint( shell ).mul( uint( 2654435761 ) ) )
+	.bitAnd( hashMask );
+
+// A light vertex's shell and cell.
+const filing = ( bdpt, p ) => {
+
+	const shell = shellOf( bdpt, mergeRadiusAt( bdpt, p ) ).toVar();
+	return { shell, cell: ivec3( floor( p.div( shellCell( bdpt, shell ) ) ) ).toVar() };
+
+};
+
+/** Empties every list head. */
+export function buildMergeClearKernel( { head, hashSize } ) {
+
+	return Fn( () => {
+
+		If( instanceIndex.lessThan( uint( hashSize ) ), () => {
+
+			atomicStore( head.element( instanceIndex ), uint( MERGE_EMPTY ) );
+
+		} );
+
+	} )().compute( Math.ceil( hashSize / WG_SIZE ) * WG_SIZE, [ WG_SIZE ] );
+
+}
+
+/** Files each light vertex of this frame at the head of its cell's list. */
+export function buildMergeInsertKernel( { hitBufferRW, head, bidirectional: bdpt } ) {
+
+	const { lightPaths, slotsPerPath, lightTag, hashMask } = bdpt;
+
+	return Fn( () => {
+
+		const slot = instanceIndex.toVar();
+		If( slot.greaterThanEqual( lightPaths.mul( slotsPerPath ) ), () => {
+
+			Return();
+
+		} );
+
+		const depth = slot.mod( slotsPerPath ).toVar();
+		If( depth.greaterThanEqual( readLightPathLength( hitBufferRW, cachedVertex( slot.sub( depth ) ), lightTag ) ), () => {
+
+			Return();
+
+		} );
+
+		const at = cachedVertex( slot );
+		const { shell, cell } = filing( bdpt, readVertexPosition( hitBufferRW, at ) );
+		const bucket = cellHash( shell, cell, hashMask );
+		writeVertexNext( hitBufferRW, at, atomicFunc( 'atomicExchange', head.element( bucket ), slot ) );
+
+	} );
+
+}
+
+export function buildMergeKernel( params ) {
+
+	const {
+		rayBufferRW, hitBufferRO, activeIndicesRO, counters, head, materialBuffer, bidirectional: bdpt,
+		maxBounceCount, globalIlluminationIntensity, fireflyThreshold, accumFrame,
+	} = params;
+	const { passTag, slotsPerPath, strategyView, hashMask } = bdpt;
+
+	return Fn( () => {
+
+		const tid = instanceIndex;
+		If( tid.greaterThanEqual( atomicLoad( counters.element( uint( COUNTER.ENTERING_COUNT ) ) ) ), () => {
+
+			Return();
+
+		} );
+
+		const rayID = activeIndicesRO.element( tid ).toVar();
+		const pending = pendingVertex( rayID );
+		If( readVertexTag( hitBufferRO, pending ).notEqual( passTag ), () => {
+
+			Return();
+
+		} );
+
+		const cam = readVertexRecord( hitBufferRO, pending );
+		const cameraDepth = int( cam.extra ).toVar();
+		// A merged path of k scattering vertices: the camera's cameraDepth + 1 and the light's l share one.
+		const lightBudget = int( maxBounceCount ).add( int( 1 ) ).sub( cameraDepth ).toVar();
+		const material = resolveSurfaceMaterial( cam.materialIndex, cam.uv, cam.N, materialBuffer );
+		const gathered = vec3( 0.0 ).toVar();
+
+		const radius = mergeRadiusAt( bdpt, cam.position ).toVar();
+		const radius2 = radius.mul( radius ).toVar();
+		const eta = mergeEta( bdpt, radius ).toVar();
+		const trusted = eta.mul( bdpt.mergeTrust );
+		const vc = float( 1.0 ).div( max( trusted.mul( trusted ), 1e-30 ) ).toVar();
+		// The shells the sphere reaches: its radius at its nearest and farthest points from the camera.
+		const distance = length( cam.position.sub( bdpt.cameraPosition ) ).toVar();
+		const nearShell = shellOf( bdpt, max( bdpt.mergeConst.add( bdpt.mergeSlope.mul( max( distance.sub( radius ), 0.0 ) ) ), bdpt.mergeMin ) ).toVar();
+		const farShell = min( shellOf( bdpt, bdpt.mergeConst.add( bdpt.mergeSlope.mul( distance.add( radius ) ) ) ), nearShell.add( int( 1 ) ) ).toVar();
+
+		// Per shell, the 2 × 2 × 2 cells the sphere can reach, the cells being at least two radii wide.
+		Loop( { start: int( 0 ), end: int( 16 ), type: 'int', condition: '<' }, ( { i } ) => {
+
+			const shell = nearShell.add( i.shiftRight( int( 3 ) ) ).toVar();
+			If( shell.greaterThan( farShell ), () => {
+
+				Break();
+
+			} );
+			const cellSize = shellCell( bdpt, shell ).toVar();
+			const corner = i.bitAnd( int( 7 ) );
+			const cell = ivec3( floor( cam.position.div( cellSize ).sub( 0.5 ) ) )
+				.add( ivec3( corner.bitAnd( int( 1 ) ), corner.shiftRight( int( 1 ) ).bitAnd( int( 1 ) ), corner.shiftRight( int( 2 ) ) ) ).toVar();
+			const slot = atomicLoad( head.element( cellHash( shell, cell, hashMask ) ) ).toVar();
+			const steps = int( 0 ).toVar();
+
+			Loop( slot.notEqual( uint( MERGE_EMPTY ) ).and( steps.lessThan( int( MAX_CELL_STEPS ) ) ), () => {
+
+				const at = cachedVertex( slot );
+				const position = readVertexPosition( hitBufferRO, at ).toVar();
+				const offset = position.sub( cam.position );
+				const l = int( slot.mod( slotsPerPath ) ).add( int( 1 ) ).toVar();
+				If( dot( offset, offset ).lessThan( radius2 ).and( l.lessThanEqual( lightBudget ) ), () => {
+
+					// Its own shell and cell only: two lists sharing a bucket (a hash collision) must not count it twice.
+					const own = filing( bdpt, position );
+					If( own.shell.equal( shell ).and( own.cell.x.equal( cell.x ) ).and( own.cell.y.equal( cell.y ) ).and( own.cell.z.equal( cell.z ) ), () => {
+
+						const light = readVertexRecord( hitBufferRO, at );
+						const cosShading = dot( light.V, cam.N ).toVar();
+						const cosFacet = dot( light.V, cam.facetN ).toVar();
+						// Light arriving on this side. A corner's other wall stays in: its light vertices stand in for the
+						// part of the sphere past the corner, which the density divides by too.
+						If( cosShading.greaterThan( 0.0 ).and( cosFacet.greaterThan( 0.0 ) ), () => {
+
+							const f = evaluateMaterialResponse( cam.V, light.V, cam.N, material );
+							const wLight = misMergePartial( light, calculateMaterialPDF( cam.V, light.V, cam.N, material ), vc );
+							const wCamera = misMergePartial( cam, calculateMaterialPDF( light.V, cam.V, cam.N, material ), vc );
+							const scattering = cameraDepth.add( l );
+							// Alone, a path of k scattering vertices is reached by k merges.
+							const weight = strategyWeight( strategyView, STRATEGY.MERGE, misWeight( wLight, wCamera ), float( 1.0 ).div( float( scattering ) ) );
+							const gi = select( scattering.greaterThan( int( 1 ) ), globalIlluminationIntensity, float( 1.0 ) );
+							// The photon's flux is per unit area; the BSDF wants it per projected solid angle (Veach 5.3.2).
+							const correction = cosShading.div( max( cosFacet, 1e-4 ) );
+							gathered.addAssign( regularizePathContribution(
+								cam.throughput.mul( f ).mul( light.throughput ).mul( weight.mul( correction ).div( eta ).mul( gi ) ),
+								float( scattering.sub( int( 1 ) ) ), fireflyThreshold, int( accumFrame ),
+							) );
+
+						} );
+
+					} );
+
+				} );
+
+				slot.assign( readVertexNext( hitBufferRO, at ) );
+				steps.addAssign( int( 1 ) );
+
+			} );
+
+		} );
+
+		If( luminance( gathered ).greaterThan( 0.0 ), () => {
+
+			const radiance = readRayRadiance( rayBufferRW, rayID ).toVar();
+			writeRayRadiance( rayBufferRW, rayID, vec4( radiance.xyz.add( gathered ), radiance.w ) );
+
+		} );
+
+	} );
+
+}
+
+export { WG_SIZE as MERGE_WG_SIZE };

package/src/TSL/PathTracerCore.js

@@ -45,8 +45,10 @@ import {
 	computeAnisoAlphas,
 	calculateBRDFWeights,
 	sheenSamplingRoughness,
+	diffuseTransmissionPdf,
 } from './MaterialProperties.js';
-import { evaluateMaterialResponseFromDots, evaluateSpecularDeltaFromDots } from './MaterialEvaluation.js';
+import { evaluateMaterialResponseFromDots, evaluateSpecularDeltaFromDots, evaluateDiffuseTransmission } from './MaterialEvaluation.js';
+import { materialLayers } from './SceneResources.js';
 
 import {
 	ImportanceSampleCosine,
@@ -71,14 +73,16 @@ export const generateSampledDirection = Fn( ( [
 	mc,
 	weightsComputed, cachedBrdfWeights,
 	materialCacheCached, cachedMaterialCache,
-] ) => {
+], builder ) => {
 
+	const layers = materialLayers( builder );
 	const resultDirection = vec3( 0.0 ).toVar();
 	const resultValue = vec3( 0.0 ).toVar();
 	const resultPdf = float( 0.0 ).toVar();
 	const resultIsTransmission = tslBool( false ).toVar();
 	const resultColorWeight = vec3( 1.0 ).toVar();
 	const resultIsDelta = tslBool( false ).toVar();
+	const resultIsDiffuseTransmission = tslBool( false ).toVar();
 
 	// Compute BRDF weights
 	const weights = cachedBrdfWeights.toVar();
@@ -114,17 +118,42 @@ export const generateSampledDirection = Fn( ( [
 	const cumulativeDiffuse = weights.diffuse.toVar();
 	const cumulativeSpecular = cumulativeDiffuse.add( weights.specular ).toVar();
 	const cumulativeSheen = cumulativeSpecular.add( weights.sheen ).toVar();
-	const cumulativeClearcoat = cumulativeSheen.add( weights.clearcoat );
+	const cumulativeClearcoat = cumulativeSheen.add( weights.clearcoat ).toVar();
+	const cumulativeDiffuseTransmission = cumulativeClearcoat.add( weights.diffuseTransmission );
 
 	// Chained If/ElseIf so emitted WGSL becomes a single mutually-exclusive branch
-	// (replaces five separate If blocks gated on a `sampled` flag — divergence hotspot)
-	If( rand.lessThan( cumulativeDiffuse ), () => {
+	// (replaces five separate If blocks gated on a `sampled` flag — divergence hotspot). A layer no material uses
+	// has weight 0, so its link could never be taken and is left out.
+	const isotropicSpecular = () => {
+
+		If( material.roughness.greaterThan( 0.0 ), () => {
+
+			const TBN = constructTBN( { N } );
+			const localV = TBN.transpose().mul( V );
+
+			// VNDF sampling
+			const localH = sampleGGXVNDF( { V: localV, roughness: material.roughness, Xi: xi } );
+			H.assign( TBN.mul( localH ) );
+
+			resultDirection.assign( reflect( V.negate(), H ) );
+
+		} ).Else( () => {
+
+			resultDirection.assign( reflect( V.negate(), N ) );
+			resultIsDelta.assign( true );
+
+		} );
+
+	};
+
+	let lobes = If( rand.lessThan( cumulativeDiffuse ), () => {
 
 		resultDirection.assign( ImportanceSampleCosine( { N, xi } ) );
 
 	} ).ElseIf( rand.lessThan( cumulativeSpecular ), () => {
 
-		If( material.anisotropy.greaterThan( 0.0 ), () => {
+		if ( ! layers.anisotropy ) isotropicSpecular();
+		else If( material.anisotropy.greaterThan( 0.0 ), () => {
 
 			// Shared frame → sampler and eval/PDF stay bit-identical (MIS consistency)
 			const f = AnisoFrame.wrap( anisoTangentFrame( N, material.anisotropyRotation ) );
@@ -138,25 +167,11 @@ export const generateSampledDirection = Fn( ( [
 
 			resultDirection.assign( reflect( V.negate(), H ) );
 
-		} ).ElseIf( material.roughness.greaterThan( 0.0 ), () => {
-
-			const TBN = constructTBN( { N } );
-			const localV = TBN.transpose().mul( V );
-
-			// VNDF sampling
-			const localH = sampleGGXVNDF( { V: localV, roughness: material.roughness, Xi: xi } );
-			H.assign( TBN.mul( localH ) );
-
-			resultDirection.assign( reflect( V.negate(), H ) );
-
-		} ).Else( () => {
-
-			resultDirection.assign( reflect( V.negate(), N ) );
-			resultIsDelta.assign( true );
+		} ).Else( isotropicSpecular );
 
-		} );
+	} );
 
-	} ).ElseIf( rand.lessThan( cumulativeSheen ), () => {
+	if ( layers.sheen ) lobes = lobes.ElseIf( rand.lessThan( cumulativeSheen ), () => {
 
 		H.assign( ImportanceSampleGGX( { N, roughness: sheenSamplingRoughness( material.sheenRoughness ), Xi: xi } ) );
 		resultDirection.assign( reflect( V.negate(), H ) );
@@ -165,7 +180,9 @@ export const generateSampledDirection = Fn( ( [
 		// would add a P(reject)·cos term to the true density that calculateBSDFSamplingPDF cannot
 		// model, and dividing by the smaller modelled density inflated the lobe 23 %.
 
-	} ).ElseIf( rand.lessThan( cumulativeClearcoat ), () => {
+	} );
+
+	if ( layers.clearcoat ) lobes = lobes.ElseIf( rand.lessThan( cumulativeClearcoat ), () => {
 
 		// VNDF, not ImportanceSampleGGX: the mixture density reports this lobe with
 		// calculateVNDFPDF, and sampling the half-vector GGX distribution instead would make the
@@ -175,7 +192,16 @@ export const generateSampledDirection = Fn( ( [
 		H.assign( ccTBN.mul( sampleGGXVNDF( { V: ccTBN.transpose().mul( V ), roughness: clearcoatRoughness, Xi: xi } ) ) );
 		resultDirection.assign( reflect( V.negate(), H ) );
 
-	} ).Else( () => {
+	} );
+
+	if ( layers.diffuseTransmission ) lobes = lobes.ElseIf( rand.lessThan( cumulativeDiffuseTransmission ), () => {
+
+		resultDirection.assign( ImportanceSampleCosine( { N: N.negate(), xi } ) );
+		resultIsDiffuseTransmission.assign( true );
+
+	} );
+
+	lobes.Else( () => {
 
 		const entering = dot( V, N ).greaterThan( 0.0 );
 		// pathWavelength=0 — the spectral lock happens downstream; colorWeight is carried out on
@@ -193,10 +219,11 @@ export const generateSampledDirection = Fn( ( [
 
 	} );
 
-	// One mixture density for every reflection lobe: any of them could have produced this
-	// direction, so the chosen lobe's own pdf is not the density we sampled from.
-	If( resultIsTransmission.not(), () => {
+	// Below the surface only the diffuse transmission lobe draws, so its own density is the mixture's.
+	const reflected = () => {
 
+		// One mixture density for every reflection lobe: any of them could have produced this
+		// direction, so the chosen lobe's own pdf is not the density we sampled from.
 		const dotsOut = DotProducts.wrap( computeDotProductsAniso( N, V, resultDirection, material ) );
 		If( resultIsDelta, () => {
 
@@ -213,7 +240,15 @@ export const generateSampledDirection = Fn( ( [
 
 		} );
 
-	} );
+	};
+
+	if ( ! layers.diffuseTransmission ) If( resultIsTransmission.not(), reflected );
+	else If( resultIsDiffuseTransmission, () => {
+
+		resultValue.assign( evaluateDiffuseTransmission( material, max( dot( N, V ), 0.001 ) ) );
+		resultPdf.assign( diffuseTransmissionPdf( weights.diffuseTransmission, dot( N, resultDirection ).negate() ) );
+
+	} ).ElseIf( resultIsTransmission.not(), reflected );
 
 	resultPdf.assign( max( resultPdf, MIN_PDF ) );
 
@@ -223,6 +258,7 @@ export const generateSampledDirection = Fn( ( [
 		pdf: resultPdf,
 		isTransmission: resultIsTransmission,
 		colorWeight: resultColorWeight,
+		isDiffuseTransmission: resultIsDiffuseTransmission,
 	} );
 
 } );

package/src/TSL/Random.js

@@ -123,6 +123,8 @@ export const RandomPointInCircle = ( rngState ) => {
 //      +13  clearcoat lobe               (Clearcoat)
 //      +14  area/spot light phi          (LightsSampling)
 //      +15  light uv second component    (LightsSampling)
+//      +16  light path to connect to     (ConnectKernel, bidirectional)
+//      +17  light vertex on that path    (ConnectKernel, bidirectional)
 //
 // Stride is 32 rather than the ~16 in use so a new call site does not force a renumbering.
 // The index only keys a scramble seed, so spare slots cost nothing.
@@ -131,6 +133,8 @@ export const RandomPointInCircle = ( rngState ) => {
 // the next bounce's dimensions, so they live above AUX_BASE:
 //   AUX_BASE +  0..63   env-backdrop blur taps      (ShadeKernel)
 //   AUX_BASE + 64..    light reservoir, one dimension per scene light (LightsSampling)
+//   AUX_BASE + 2048..  light subpath emission (LightGenerateKernel); light paths draw at pixels
+//                      offset by LIGHT_PIXEL_ROW_OFFSET rows, so no camera path shares a sequence
 export const SAMPLER_DIMS_PER_BOUNCE = 32;
 export const SAMPLER_DIM_AUX_BASE = 4096;
 

package/src/TSL/SceneResources.js

@@ -0,0 +1,51 @@
+/**
+ * A renderer's own scene resources for its shaders: material texture buckets, the albedo maps alpha-cutout
+ * shadow rays read, gobo and IES textures, and the alpha-shadow switch. They ride in the build context of each
+ * kernel that reads them: a TSL function's body runs when its kernel compiles, often at the first dispatch, so
+ * module-level state was read from whichever renderer — or pipeline stage — had set it last.
+ *
+ * @typedef {Object} SceneResources
+ * @property {Array<Node>} srgbBuckets - sRGB material bucket texture nodes (albedo, emissive, sheen, specular colour)
+ * @property {Array<Node>} linearBuckets - linear material bucket texture nodes
+ * @property {?Array<Node>} shadowAlbedoMaps - sRGB buckets alpha-cutout shadow rays sample, or null
+ * @property {?Node} goboMaps - spot / directional gobo texture array, or null
+ * @property {?Node} iesProfiles - IES profile texture array, or null
+ * @property {?Node} alphaShadows - int uniform, 1 = shadow rays test texture alpha; null = never
+ * @property {?Object<string, boolean>} materialLayers - the MATERIAL_LAYERS some material uses; null = all of them
+ */
+
+import { context } from 'three/tsl';
+
+const KEY = 'rayzeeScene';
+
+/** Builds `node` (a kernel's root call) with these resources in its context. */
+export const withSceneResources = ( node, resources ) => context( node, { [ KEY ]: resources } );
+
+/**
+ * The resources of the kernel being built; call from a TSL function body with its builder.
+ * @returns {SceneResources}
+ */
+export function sceneResources( builder ) {
+
+	const resources = builder.context[ KEY ];
+	if ( ! resources ) throw new Error( 'this kernel samples scene resources: build its root with withSceneResources()' );
+	return resources;
+
+}
+
+/** The material layers a kernel compiles only while some material in its scene has them. */
+export const MATERIAL_LAYERS = Object.freeze( [ 'clearcoat', 'sheen', 'iridescence', 'anisotropy', 'subsurface', 'dispersion', 'diffuseTransmission' ] );
+
+/** Every layer compiled in. */
+export const ALL_MATERIAL_LAYERS = Object.freeze( Object.fromEntries( MATERIAL_LAYERS.map( ( layer ) => [ layer, true ] ) ) );
+
+/**
+ * The material layers the kernel being built compiles; call from a TSL function body with its builder. A layer no
+ * material uses is left out of every function that reads it. Outside a scene kernel (a test), every layer is in.
+ * @returns {Object<string, boolean>}
+ */
+export function materialLayers( builder ) {
+
+	return builder.context[ KEY ]?.materialLayers ?? ALL_MATERIAL_LAYERS;
+
+}