rayzee 10.0.0 → 11.0.0

package/src/TSL/BVHTraversal.js

@@ -1,3 +1,4 @@
+import { sceneResources } from './SceneResources.js';
 import {
 	Fn,
 	wgslFn,
@@ -24,7 +25,10 @@ import {
 	bool as tslBool,
 } from 'three/tsl';
 
-import { BVH_LEAF_MARKERS, BVH_MAX_INDEX, BVH_FOLDED_LEAF_MAX, TRI_MATERIAL_MASK, TRI_SIDE_SHIFT, TLAS_LEAF_IDENTITY, MATERIAL_SIDE_CUTAWAY } from '../EngineDefaults.js';
+import {
+	TRI_MATERIAL_MASK, TRI_SIDE_SHIFT, BVH_LEAF_MARKERS, BVH_MAX_INDEX, BVH_FOLDED_LEAF_MAX,
+	TLAS_LEAF_IDENTITY,
+} from '../Processor/BufferLayout.js';
 import { HitInfo } from './Struct.js';
 import {
 	getDatafromStorageBuffer, instanceRows, instanceNormalToWorld, unpackTriangleNormal, triangleRow, shadowFlagsSettle
@@ -88,8 +92,10 @@ const toObjectDir = ( rows, d ) => vec3(
 // at shared triangle edges that Möller-Trumbore exhibits under FP32. Per-ray shears
 // are precomputed once via computeWoopFromInvDir; per-triangle test is FMA-friendly
 // and uses sign-aware depth comparison so it works for any det orientation.
-const RayTriangleGeometry = wgslFn( `
-	fn RayTriangleGeometry( rayOrigin: vec3f, rayDir: vec3f, pA: vec3f, pB: vec3f, pC: vec3f, closestHitDst: f32, woopParams: vec4f ) -> vec4f {
+// guardT: reject t within its own rounding error. Closest-hit rays need it to leave a large triangle; shadow rays
+// start lifted off their surface and skip it — its registers cost Shade's shadow traversal ~4 %.
+const rayTriangle = ( name, guardT ) => wgslFn( `
+	fn ${ name }( rayOrigin: vec3f, rayDir: vec3f, pA: vec3f, pB: vec3f, pC: vec3f, closestHitDst: f32, woopParams: vec4f ) -> vec4f {
 
 		// Returns vec4(t, u, v, hit) where hit > 0.5 means intersection.
 		// woopParams: (Sx, Sy, Sz, bitcast<f32>(packed kx|ky<<2|kz<<4))
@@ -138,7 +144,19 @@ const RayTriangleGeometry = wgslFn( `
 				let tSigned = T * detSign;
 				let detAbs = abs( det );
 
-				if ( tSigned > 0.0f && tSigned < closestHitDst * detAbs ) {
+${ guardT ? `
+				// t must clear its own rounding error (pbrt-v4 Triangle::Intersect, γn = n·2⁻²⁴ / (1 − n·2⁻²⁴)), or a
+				// ray leaving a large triangle can hit it again: its error grows with the distance to the vertices.
+				let maxZ = max( max( abs( Sz * Akz ), abs( Sz * Bkz ) ), abs( Sz * Ckz ) );
+				let maxX = max( max( abs( Ax ), abs( Bx ) ), abs( Cx ) );
+				let maxY = max( max( abs( Ay ), abs( By ) ), abs( Cy ) );
+				let maxE = max( max( abs( U ), abs( V ) ), abs( W ) );
+				let deltaX = 2.98023e-7f * ( maxX + maxZ );
+				let deltaY = 2.98023e-7f * ( maxY + maxZ );
+				let deltaE = 2.0f * ( 1.19209e-7f * maxX * maxY + deltaY * maxX + deltaX * maxY );
+				let errT = 3.0f * maxZ * ( 3.57628e-7f * maxE + deltaE );
+` : '' }
+				if ( tSigned > ${ guardT ? 'errT' : '0.0f' } && tSigned < closestHitDst * detAbs ) {
 
 					// Match Möller-Trumbore convention: u = weight of B, v = weight of C.
 					// In Woop's edge functions, U → weight of A, V → weight of B, W → weight of C.
@@ -156,6 +174,9 @@ const RayTriangleGeometry = wgslFn( `
 	}
 ` );
 
+const RayTriangleGeometry = rayTriangle( 'RayTriangleGeometry', true );
+const RayTriangleGeometryShadow = rayTriangle( 'RayTriangleGeometryShadow', false );
+
 // Compute Woop ray-space transform (Woop 2013, §3.1) — runs once per ray and
 // amortizes across hundreds of triangle tests. Returns Sx/Sy/Sz shears plus the
 // permuted axis indices packed via bitcast into the .w slot.
@@ -213,12 +234,12 @@ const fastRayAABBDst = wgslFn( `
 // MAIN BVH TRAVERSAL
 // ================================================================================
 
-// Side from a triangle's flags word (row 4 .z): 0 front, 1 back, 2 double, 3 cutaway (front, every ray).
+// Side from a triangle's flags word (row 4 .z): 0 front, 1 back, 2 double.
 export const triangleSide = ( flags ) => int( flags.shiftRight( uint( TRI_SIDE_SHIFT ) ).bitAnd( uint( 3 ) ) );
 
 // Whether a face of this side is seen by a ray; rayDotNormal < 0 is a front hit.
 export const sideAccepts = ( side, rayDotNormal ) => side.equal( int( 2 ) )
-	.or( side.equal( int( 0 ) ).or( side.equal( int( MATERIAL_SIDE_CUTAWAY ) ) ).and( rayDotNormal.lessThan( - 0.0001 ) ) )
+	.or( side.equal( int( 0 ) ).and( rayDotNormal.lessThan( - 0.0001 ) ) )
 	.or( side.equal( int( 1 ) ).and( rayDotNormal.greaterThan( 0.0001 ) ) );
 
 // Factory: the boxTests/triTests debug counters are compiled OUT of the hot closest-hit
@@ -324,7 +345,7 @@ const makeTraverseBVH = ( trackStats ) => Fn( ( [
 				);
 
 				// Side culling (inline; per-mesh visibility is at the BLAS-pointer level).
-				If( eitherSide.and( side.notEqual( int( MATERIAL_SIDE_CUTAWAY ) ) ).or( sideAccepts( side, rayDotNormal ) ), () => {
+				If( eitherSide.or( sideAccepts( side, rayDotNormal ) ), () => {
 
 					closestHit.didHit.assign( true );
 					closestHit.dst.assign( t );
@@ -517,12 +538,15 @@ export const traverseBVHDebug = /*@__PURE__*/ makeTraverseBVH( true );
 // SHADOW RAY TRAVERSAL (OPTIMIZED - early exit on any hit)
 // ================================================================================
 
-export const traverseBVHShadow = Fn( ( [
+// cameraCulled: skip the faces a camera ray along −direction would cull, for a ray standing in for one.
+const makeTraverseBVHShadow = ( cameraCulled ) => Fn( ( [
 	ray,
 	bvhBuffer,
 	triangleBuffer,
 	maxShadowDist,
-] ) => {
+], builder ) => {
+
+	const { alphaShadows } = sceneResources( builder );
 
 	const folded = bvhBuffer.value?.foldedLeaves === true;
 	const isLeafTag = leafTagTest( folded );
@@ -572,26 +596,14 @@ export const traverseBVHShadow = Fn( ( [
 			const pB = uintBitsToFloat( triangleRow( triangleBuffer, triIndex, 1 ).xyz );
 			const pC = uintBitsToFloat( triangleRow( triangleBuffer, triIndex, 2 ).xyz );
 
-			const triResult = RayTriangleGeometry( { rayOrigin, rayDir: rayDirection, pA, pB, pC, closestHitDst: closestHit.dst, woopParams } );
+			const triResult = RayTriangleGeometryShadow( { rayOrigin, rayDir: rayDirection, pA, pB, pC, closestHitDst: closestHit.dst, woopParams } );
 
 			If( triResult.w.greaterThan( 0.5 ), () => {
 
 				// Per-mesh visibility is handled at the BLAS-pointer level.
 				const uvData2 = triangleRow( triangleBuffer, triIndex, 4 ).toVar();
 
-				// A cutaway face is see-through from behind for shadow rays too.
-				const seen = tslBool( true ).toVar();
-				If( triangleSide( uvData2.z ).equal( int( MATERIAL_SIDE_CUTAWAY ) ), () => {
-
-					const w = float( 1.0 ).sub( triResult.y ).sub( triResult.z );
-					const n = unpackTriangleNormal( triangleRow( triangleBuffer, triIndex, 0 ).w ).mul( w )
-						.add( unpackTriangleNormal( triangleRow( triangleBuffer, triIndex, 1 ).w ).mul( triResult.y ) )
-						.add( unpackTriangleNormal( triangleRow( triangleBuffer, triIndex, 2 ).w ).mul( triResult.z ) );
-					seen.assign( rayDirection.dot( normalize( n ) ).lessThan( - 0.0001 ) );
-
-				} );
-
-				If( seen, () => {
+				const record = () => {
 
 					closestHit.didHit.assign( true );
 					closestHit.dst.assign( triResult.x );
@@ -610,14 +622,24 @@ export const traverseBVHShadow = Fn( ( [
 
 					// An opaque blocker settles the ray. A surface light passes through has to be
 					// the nearest one, or the layers behind the first find are never counted.
-					If( shadowFlagsSettle( uvData2.z ), () => {
+					If( shadowFlagsSettle( uvData2.z, alphaShadows ), () => {
 
 						blocked.assign( true );
 						Break();
 
 					} );
 
-				} );
+				};
+
+				if ( cameraCulled ) {
+
+					const w = float( 1.0 ).sub( triResult.y ).sub( triResult.z );
+					const n = normalize( unpackTriangleNormal( triangleRow( triangleBuffer, triIndex, 0 ).w ).mul( w )
+						.add( unpackTriangleNormal( triangleRow( triangleBuffer, triIndex, 1 ).w ).mul( triResult.y ) )
+						.add( unpackTriangleNormal( triangleRow( triangleBuffer, triIndex, 2 ).w ).mul( triResult.z ) ) );
+					If( sideAccepts( triangleSide( uvData2.z ), rayDirection.dot( n ).negate() ), record );
+
+				} else record();
 
 			} );
 
@@ -742,3 +764,6 @@ export const traverseBVHShadow = Fn( ( [
 	return closestHit;
 
 } );
+
+export const traverseBVHShadow = /*@__PURE__*/ makeTraverseBVHShadow( false );
+export const traverseBVHShadowCameraCulled = /*@__PURE__*/ makeTraverseBVHShadow( true );

package/src/TSL/Bidirectional.js

@@ -0,0 +1,204 @@
+/**
+ * Bidirectional path tracing — shared by the light pass, ConnectKernel and LightSplatKernel.
+ * MIS is Georgiev 2012's dVCM/dVC recursion; every density comes from calculateMaterialPDF, both ways
+ * round, so every strategy evaluates the same weights. With vertex merging (integrator 'vcm') a state also
+ * carries `vm`, η² at its vertex (η = πr² · light paths, r that vertex's merge radius): Georgiev's dVM there is
+ * dVC / η², so it is never stored.
+ */
+
+import {
+	float, vec2, vec4, int, uint, If, max, select, abs, dot, length,
+} from 'three/tsl';
+
+import { getMaterial, MIN_ROUGHNESS, REC709_LUMINANCE_COEFFICIENTS } from './Common.js';
+import { RayTracingMaterial, MaterialSamples, ExtMapResult } from './Struct.js';
+import { sampleAllMaterialTextures, processAnisotropyMap, applyExtensionMaps, getTransformedUV } from './TextureSampling.js';
+import { SAMPLER_DIM_AUX_BASE } from './Random.js';
+
+// 1D dimensions of a camera vertex's bounce block (Random.js budget) picking its connection.
+export const DIM_CONNECT_PATH = 16;
+export const DIM_CONNECT_VERTEX = 17;
+// Emission: 1D triangle pick, 2D point, 2D direction, 1D side, 1D sun or emitter, 2D sun direction, 2D disc point.
+export const DIM_EMIT = SAMPLER_DIM_AUX_BASE + 2048;
+
+// Light paths draw at pixels far below the image, so their sequences never repeat a camera path's.
+export const LIGHT_PIXEL_ROW_OFFSET = 65536;
+
+// Light tracing adds into u32 per channel: value · SPLAT_SCALE, rounded stochastically.
+export const SPLAT_SCALE = 16384;
+export const SPLAT_MAX = 4096;
+
+// Pending-connection tags set the high bit: a light path's data in that lane is a positive float's bits.
+export const PASS_TAG_BIT = 0x80000000;
+
+const MIS_MAX = 1e30;
+
+const finite = ( x ) => select( x.equal( x ), x, float( 0.0 ) ).clamp( 0.0, MIS_MAX );
+
+export const lightPathPixel = ( index, resolution ) => {
+
+	const w = uint( resolution.x );
+	return vec2( float( uint( index ).mod( w ) ).add( 0.5 ), float( uint( index ).div( w ).add( uint( LIGHT_PIXEL_ROW_OFFSET ) ) ).add( 0.5 ) );
+
+};
+
+// The power heuristic (β = 2). The recursion stores every density ratio already raised to it.
+export const mis = ( x ) => x.mul( x );
+
+// MIS recursion: `state` holds two .toVar()s, { dVCM, dVC }, updated in place, and `vm` when merging.
+
+/** Arriving at a vertex `dist` from the last one, at |cos| `cosIn` to its facet. */
+export const misOnHit = ( state, dist, cosIn ) => {
+
+	const c = max( cosIn, 1e-6 );
+	state.dVCM.assign( finite( state.dVCM.mul( mis( dist.mul( dist ).div( c ) ) ) ) );
+	state.dVC.assign( finite( state.dVC.div( mis( c ) ) ) );
+
+};
+
+/** Leaving through a delta lobe, a refraction or a subsurface boundary: nothing can connect here. */
+export const misOnSpecular = ( state, cosOut ) => {
+
+	state.dVC.assign( finite( state.dVC.mul( mis( cosOut ) ) ) );
+	state.dVCM.assign( 0.0 );
+
+};
+
+/** Leaving by a BSDF sample; densities are solid angle, forward the sampler's and reverse its partner's. */
+export const misOnScatter = ( state, cosOut, pdfForward, pdfReverse ) => {
+
+	const p = max( pdfForward, 1e-12 );
+	const partial = state.dVC.mul( mis( pdfReverse ) ).add( state.dVCM );
+	state.dVC.assign( finite( mis( cosOut.div( p ) ).mul( finite( state.vm ? partial.add( state.vm ) : partial ) ) ) );
+	state.dVCM.assign( finite( mis( float( 1.0 ).div( p ) ) ) );
+
+};
+
+// Georgiev (40)-(46): `lead` is the other side's density of reaching this end, `reverse` this end's density back.
+export const misPartial = ( lead, state, reverse ) => {
+
+	const partial = state.dVCM.add( state.dVC.mul( mis( reverse ) ) );
+	return finite( finite( mis( lead ) ).mul( finite( state.vm ? partial.add( state.vm ) : partial ) ) );
+
+};
+
+// Vertex merging's radius at p: a few pixels' footprint seen from the camera (`mergeConst` + `mergeSlope` · distance),
+// at least `mergeMin`. A function of position alone, so both subpaths weigh a merge at any vertex alike.
+export const mergeRadiusAt = ( bdpt, p ) =>
+	max( bdpt.mergeConst.add( bdpt.mergeSlope.mul( length( p.sub( bdpt.cameraPosition ) ) ) ), bdpt.mergeMin );
+
+// η = πr² · light paths: a merge's density over a connection's, there.
+export const mergeEta = ( bdpt, radius ) => radius.mul( radius ).mul( Math.PI ).mul( float( bdpt.lightPaths ) );
+
+/**
+ * η² at p as the weights take it, a state's `vm` (Georgiev's vmFactor, per vertex): η scaled by `mergeTrust`. Any
+ * density the strategies agree on still sums their weights to one; trust below 1 hands light other strategies can
+ * also reach back to them, unblurred, and leaves light only a merge reaches (a caustic in a mirror) all to merging.
+ */
+export const mergeVmAt = ( bdpt, p ) => {
+
+	const eta = mergeEta( bdpt, mergeRadiusAt( bdpt, p ) ).mul( bdpt.mergeTrust );
+	return eta.mul( eta );
+
+};
+
+// Georgiev (38)-(39), a merge at a camera vertex: each side's sum, `density` the camera vertex's BSDF density
+// (of the light's arrival direction for the light side, back along its own for the camera side); `vc` = 1 / η².
+export const misMergePartial = ( state, density, vc ) => finite( finite( state.dVCM.add( state.dVC.mul( mis( density ) ) ) ).mul( vc ) );
+
+export const misWeight = ( wLight, wCamera ) => float( 1.0 ).div( float( 1.0 ).add( finite( wLight ) ).add( finite( wCamera ) ) );
+
+// Verification: a view keeps one strategy, MIS-weighted, or alone at full weight (+ STRATEGY_ALONE).
+export const STRATEGY = { ALL: 0, HIT: 1, NEE: 2, CONNECT: 3, LIGHT_TRACE: 4, MERGE: 5 };
+export const STRATEGY_ALONE = 8;
+
+export const strategyWeight = ( view, strategy, weight, alone = float( 1.0 ) ) =>
+	select( view.equal( uint( STRATEGY.ALL ) ).or( view.equal( uint( strategy ) ) ), weight,
+		select( view.equal( uint( strategy + STRATEGY_ALONE ) ), alone, float( 0.0 ) ) );
+
+// Chance a light path leaves this side of a triangle toward `cosToward` (cosine to the winding normal).
+export const emitterSideProbability = ( side, cosToward ) => select( side.equal( int( 2 ) ), float( 0.5 ),
+	select( side.equal( int( 1 ) ), select( cosToward.lessThan( 0.0 ), float( 1.0 ), float( 0.0 ) ),
+		select( cosToward.greaterThan( 0.0 ), float( 1.0 ), float( 0.0 ) ) ) );
+
+/** Area density of a light path's start on a triangle with this emission — power over total, per area. */
+export const emitterAreaPdf = ( emission, totalPower, share = 1 ) =>
+	max( dot( emission, REC709_LUMINANCE_COEFFICIENTS ), 0.0 ).div( max( totalPower, 1e-10 ) ).mul( share );
+
+// The sun as a light subpath start: a direction over its disc, then a point on the scene's bounding disc at `discPdf`
+// (LightGuide.js guidedDiscPdf).
+export const sunEmissionPdf = ( bdpt, sunParams, discPdf ) => bdpt.sunPick.mul( discPdf ).div( max( sunParams.y, 1e-30 ) );
+
+// Where a light subpath starts, in its pick table's order (`sourceCdf`, a running sum); each lamp list follows
+// at `sourceOffsets[ type ]`, by LIGHT_TYPE. A light path's origin code is its triangle, or −1 − its source.
+export const SOURCE = { SUN: 0, EMITTERS: 1, ENVIRONMENT: 2, LAMPS: 3 };
+
+export const sourcePick = ( bdpt, source ) => {
+
+	const s = int( source );
+	return bdpt.sourceCdf.element( s ).sub( select( s.greaterThan( int( 0 ) ), bdpt.sourceCdf.element( max( s.sub( int( 1 ) ), int( 0 ) ) ), float( 0.0 ) ) );
+
+};
+
+export const lampSource = ( bdpt, type, index ) => select( type.equal( int( 0 ) ), int( bdpt.sourceOffsets[ 0 ] ),
+	select( type.equal( int( 1 ) ), int( bdpt.sourceOffsets[ 1 ] ), select( type.equal( int( 2 ) ), int( bdpt.sourceOffsets[ 2 ] ), int( bdpt.sourceOffsets[ 3 ] ) ) ) ).add( index );
+
+export const sourceLampType = ( bdpt, source ) => select( source.lessThan( int( bdpt.sourceOffsets[ 1 ] ) ), int( 0 ),
+	select( source.lessThan( int( bdpt.sourceOffsets[ 2 ] ) ), int( 1 ), select( source.lessThan( int( bdpt.sourceOffsets[ 3 ] ) ), int( 2 ), int( 3 ) ) ) );
+
+export const sourceLampIndex = ( bdpt, source, type ) => source.sub( select( type.equal( int( 0 ) ), int( bdpt.sourceOffsets[ 0 ] ),
+	select( type.equal( int( 1 ) ), int( bdpt.sourceOffsets[ 1 ] ), select( type.equal( int( 2 ) ), int( bdpt.sourceOffsets[ 2 ] ), int( bdpt.sourceOffsets[ 3 ] ) ) ) ) );
+
+// The material at a stored vertex, folded as ShadeKernel folds it; its shading normal is already stored.
+export function resolveSurfaceMaterial( materialIndex, uv, N, materialBuffer ) {
+
+	const material = RayTracingMaterial.wrap( getMaterial( int( materialIndex ), materialBuffer ) ).toVar();
+	material.normalMapIndex.assign( int( - 1 ) );
+	material.bumpMapIndex.assign( int( - 1 ) );
+	material.displacementMapIndex.assign( int( - 1 ) );
+	// Shade leaves diffuse transmission out in this integrator (its strategies do not cross surfaces yet).
+	material.diffuseTransmission.assign( 0.0 );
+
+	const samples = MaterialSamples.wrap( sampleAllMaterialTextures( material, uv, N, vec4( 0.0 ) ) ).toVar();
+	const rawRough = samples.roughness.toVar();
+
+	material.color.assign( samples.albedo );
+	material.metalness.assign( samples.metalness.clamp( 0.0, 1.0 ) );
+	material.roughness.assign( samples.roughness.clamp( MIN_ROUGHNESS, 1.0 ) );
+	material.sheenRoughness.assign( material.sheenRoughness.clamp( 0.05, 1.0 ) );
+
+	const extUV = getTransformedUV( { uv, transform: material.albedoTransform } ).toVar();
+
+	If( material.anisotropyMapIndex.greaterThanEqual( int( 0 ) ), () => {
+
+		const aniso = processAnisotropyMap( material, extUV ).toVar();
+		material.anisotropy.assign( aniso.x );
+		material.anisotropyRotation.assign( aniso.y );
+
+	} );
+
+	const ext = ExtMapResult.wrap( applyExtensionMaps( material, extUV ) ).toVar();
+	material.transmission.assign( ext.transmission );
+	material.clearcoat.assign( ext.clearcoat );
+	material.clearcoatRoughness.assign( ext.clearcoatRoughness );
+	material.sheenColor.assign( ext.sheenColor );
+	material.sheenRoughness.assign( ext.sheenRoughness );
+	material.iridescence.assign( ext.iridescence );
+	material.iridescenceThicknessRange.assign( vec2( material.iridescenceThicknessRange.x, ext.iridescenceThickness ) );
+	material.specularIntensity.assign( ext.specularIntensity );
+	material.specularColor.assign( ext.specularColor );
+
+	If( rawRough.lessThan( MIN_ROUGHNESS ).and( material.anisotropy.equal( 0.0 ) ).and( material.clearcoat.equal( 0.0 ) )
+		.and( material.transmission.equal( 0.0 ) ).and( material.subsurface.equal( 0.0 ) ), () => {
+
+		material.roughness.assign( 0.0 );
+
+	} );
+
+	return material;
+
+}
+
+// The light end's cosine with the shading-normal correction (Veach 5.3.2): |V·N| |d·Ng| / |V·Ng|.
+export const lightEndCosine = ( V, N, facetN, toOther ) =>
+	abs( dot( V, N ) ).mul( abs( dot( toOther, facetN ) ) ).div( max( abs( dot( V, facetN ) ), 1e-4 ) );

package/src/TSL/BidirectionalLamps.js

@@ -0,0 +1,132 @@
+/**
+ * The analytic lights as bidirectional sources: the camera side's lamp choice, made as the path tracer
+ * makes it, and the densities a light path needs to weigh the strategies against it.
+ */
+
+import { float, int, If, Loop, select, cos, max, min } from 'three/tsl';
+
+import { struct } from './patches.js';
+import {
+	DirectionalLight, AreaLight, PointLight, SpotLight,
+	getDirectionalLight, getAreaLight, getPointLight, getSpotLight,
+	LIGHT_TYPE_DIRECTIONAL, LIGHT_TYPE_AREA, LIGHT_TYPE_POINT, sphQuadSolidAngle,
+} from './LightsCore.js';
+import {
+	calculateDirectionalLightImportance, estimateLightImportance, calculatePointLightImportance, calculateSpotLightImportance,
+} from './LightsDirect.js';
+import { SAMPLER_DIM_AUX_BASE } from './Random.js';
+import { PI } from './Common.js';
+
+export const LampPick = struct( { kind: 'int', index: 'int', pdf: 'float', total: 'float' } );
+
+/** @param lamps { directional, numDirectional, area, numArea, point, numPoint, spot, numSpot } */
+export const lampCount = ( lamps ) => lamps.numDirectional.add( lamps.numArea ).add( lamps.numPoint ).add( lamps.numSpot );
+
+export const lampTypeAt = ( lamps, flat ) => select( flat.lessThan( lamps.numDirectional ), int( LIGHT_TYPE_DIRECTIONAL ),
+	select( flat.lessThan( lamps.numDirectional.add( lamps.numArea ) ), int( LIGHT_TYPE_AREA ),
+		select( flat.lessThan( lamps.numDirectional.add( lamps.numArea ).add( lamps.numPoint ) ), int( LIGHT_TYPE_POINT ), int( 3 ) ) ) );
+
+const typeStart = ( lamps, type ) => select( type.equal( int( LIGHT_TYPE_DIRECTIONAL ) ), int( 0 ),
+	select( type.equal( int( LIGHT_TYPE_AREA ) ), lamps.numDirectional,
+		select( type.equal( int( LIGHT_TYPE_POINT ) ), lamps.numDirectional.add( lamps.numArea ),
+			lamps.numDirectional.add( lamps.numArea ).add( lamps.numPoint ) ) ) );
+
+// The path tracer's importance (LightsDirect.js) without its bounce-depth factor, which a light path cannot know.
+const walkLamps = ( lamps, hitPoint, N, material, visit ) => {
+
+	const each = ( type, count, read ) => If( count.greaterThan( int( 0 ) ), () => {
+
+		Loop( { start: int( 0 ), end: count, type: 'int', condition: '<' }, ( { i } ) => {
+
+			visit( int( type ), i, read( i ).toVar() );
+
+		} );
+
+	} );
+	each( LIGHT_TYPE_DIRECTIONAL, lamps.numDirectional, ( i ) =>
+		calculateDirectionalLightImportance( DirectionalLight.wrap( getDirectionalLight( lamps.directional, i ) ), N, material, int( 0 ) ) );
+	each( LIGHT_TYPE_AREA, lamps.numArea, ( i ) => {
+
+		const light = AreaLight.wrap( getAreaLight( lamps.area, i ) );
+		return select( light.intensity.greaterThan( 0.0 ), estimateLightImportance( light, hitPoint, N, material ), float( 0.0 ) );
+
+	} );
+	each( LIGHT_TYPE_POINT, lamps.numPoint, ( i ) =>
+		calculatePointLightImportance( PointLight.wrap( getPointLight( lamps.point, i ) ), hitPoint, N, material ) );
+	each( 3, lamps.numSpot, ( i ) =>
+		calculateSpotLightImportance( SpotLight.wrap( getSpotLight( lamps.spot, i ) ), hitPoint, N, material ) );
+
+};
+
+/**
+ * One lamp, as the path tracer's reservoir picks it, on the same dimensions; uniform when nothing has importance.
+ * `sample1D( dim )` draws a 1D variate, `u` is the fallback's.
+ */
+export function pickLamp( lamps, hitPoint, N, material, u, sample1D ) {
+
+	const type = int( - 1 ).toVar();
+	const index = int( - 1 ).toVar();
+	const chosen = float( 0.0 ).toVar();
+	const total = float( 0.0 ).toVar();
+	walkLamps( lamps, hitPoint, N, material, ( t, i, w ) => {
+
+		total.addAssign( w );
+		If( w.greaterThan( 0.0 ).and( sample1D( int( SAMPLER_DIM_AUX_BASE + 64 ).add( typeStart( lamps, t ) ).add( i ) ).mul( total ).lessThan( w ) ), () => {
+
+			type.assign( t );
+			index.assign( i );
+			chosen.assign( w );
+
+		} );
+
+	} );
+
+	const count = lampCount( lamps ).toVar();
+	const pdf = chosen.div( max( total, 1e-10 ) ).toVar();
+	If( total.lessThanEqual( 0.0 ), () => {
+
+		const flat = min( int( u.mul( float( count ) ) ), count.sub( int( 1 ) ) ).toVar();
+		type.assign( lampTypeAt( lamps, flat ) );
+		index.assign( flat.sub( typeStart( lamps, type ) ) );
+		pdf.assign( float( 1.0 ).div( max( float( count ), 1.0 ) ) );
+
+	} );
+
+	return LampPick( { kind: type, index, pdf, total } );
+
+}
+
+/** The chance `pickLamp` at this point takes lamp (type, index). */
+export function lampPickPdf( lamps, type, index, hitPoint, N, material ) {
+
+	const total = float( 0.0 ).toVar();
+	const own = float( 0.0 ).toVar();
+	walkLamps( lamps, hitPoint, N, material, ( t, i, w ) => {
+
+		total.addAssign( w );
+		If( t.equal( type ).and( i.equal( index ) ), () => {
+
+			own.assign( w );
+
+		} );
+
+	} );
+	return select( total.greaterThan( 0.0 ), own.div( total ), float( 1.0 ).div( max( float( lampCount( lamps ) ), 1.0 ) ) );
+
+}
+
+// Solid angle of a spot's cone, over which its light paths leave uniformly.
+export const spotConeSolidAngle = ( light ) => float( 2 * PI ).mul( max( float( 1.0 ).sub( cos( light.angle ) ), 1e-10 ) );
+
+// A soft directional light's cone (angle = angular diameter), as sampleDirectionalLight computes it.
+export const directionalConeSolidAngle = ( light ) => float( 2 * PI ).mul( max( float( 1.0 ).sub( cos( light.angle.mul( 0.5 ) ) ), 1e-10 ) );
+
+/** Area-light NEE's solid-angle density for any point of the light, seen from `from` (sampleRectAreaLight). */
+export const areaLightDirectPdfW = ( light, from, dist, cosLight ) => {
+
+	const corner = light.position.sub( light.u ).sub( light.v );
+	const solidAngle = sphQuadSolidAngle( from, corner, light.u.mul( 2.0 ), light.v.mul( 2.0 ) ).toVar();
+	return select( light.shape.lessThan( 0.5 ).and( solidAngle.greaterThan( 1e-5 ) ), float( 1.0 ).div( solidAngle ),
+		dist.mul( dist ).div( max( light.area.mul( max( cosLight, 0.001 ) ), 1e-10 ) ) );
+
+};

package/src/TSL/Clearcoat.js

@@ -7,6 +7,7 @@ import {
 	reflect,
 	max,
 	If,
+	bool as tslBool,
 } from 'three/tsl';
 
 import { struct } from './patches.js';
@@ -15,15 +16,16 @@ import { AnisoFrame, DotProducts,
 	BRDFWeights,
 } from './Struct.js';
 import { MIN_CLEARCOAT_ROUGHNESS, computeDotProductsAniso, anisoTangentFrame, constructTBN } from './Common.js';
-import { computeAnisoAlphas, calculateBRDFWeightsFromMaterial, calculateBSDFSamplingPDF } from './MaterialProperties.js';
+import { computeAnisoAlphas, calculateBRDFWeightsFromMaterial, calculateBSDFSamplingPDF, diffuseTransmissionPdf } from './MaterialProperties.js';
 import { ImportanceSampleCosine, sampleGGXVNDF, sampleGGXVNDFAniso } from './MaterialSampling.js';
-import { evaluateMaterialResponseFromDots } from './MaterialEvaluation.js';
+import { evaluateMaterialResponseFromDots, evaluateDiffuseTransmission } from './MaterialEvaluation.js';
 import { getRandomSample1D } from './Random.js';
 
 export const ClearcoatResult = struct( {
 	brdf: 'vec3',
 	L: 'vec3',
 	pdf: 'float',
+	isDiffuseTransmission: 'bool',
 } );
 
 // Improved clearcoat sampling function
@@ -55,6 +57,7 @@ export const sampleClearcoat = Fn( ( [
 
 	const L = vec3( 0.0 ).toVar();
 	const H = vec3( 0.0 ).toVar();
+	const transmitted = tslBool( false ).toVar();
 
 	If( rand.lessThan( clearcoatWeight ), () => {
 
@@ -83,6 +86,11 @@ export const sampleClearcoat = Fn( ( [
 		} );
 		L.assign( reflect( V.negate(), H ) );
 
+	} ).ElseIf( rand.lessThan( clearcoatWeight.add( specularWeight ).add( weights.diffuseTransmission ) ), () => {
+
+		L.assign( ImportanceSampleCosine( { N: N.negate(), xi: randomSample } ) );
+		transmitted.assign( true );
+
 	} ).Else( () => {
 
 		// Sample diffuse
@@ -94,16 +102,17 @@ export const sampleClearcoat = Fn( ( [
 	// Calculate dot products (aniso-aware: also projects onto the anisotropy frame)
 	const dots = DotProducts.wrap( computeDotProductsAniso( N, V, L, material ) );
 
-	// One density for every MIS site — see calculateBSDFSamplingPDF.
-	const pdf = max( calculateBSDFSamplingPDF( material, weights, dots ), 0.001 );
+	// One density for every MIS site — see calculateBSDFSamplingPDF. Below the surface only the
+	// diffuse transmission lobe draws.
+	const pdf = max( transmitted.select( diffuseTransmissionPdf( weights.diffuseTransmission, dot( N, L ).negate() ), calculateBSDFSamplingPDF( material, weights, dots ) ), 0.001 );
 
 	// Evaluate complete BRDF
 	// The same BRDF every other site evaluates — see the clearcoat note in MaterialEvaluation.
-	const brdf = evaluateMaterialResponseFromDots( material, dots );
+	const brdf = transmitted.select( evaluateDiffuseTransmission( material, max( dot( N, V ), 0.001 ) ), evaluateMaterialResponseFromDots( material, dots ) );
 
 	// Return brdf, L direction, and pdf packed together
 	// Caller needs L and pdf - return as struct-like output
 	// We pack: result.xyz = brdf, result.w = pdf, L stored in separate output
-	return ClearcoatResult( { brdf, L, pdf } );
+	return ClearcoatResult( { brdf, L, pdf, isDiffuseTransmission: transmitted } );
 
 } );

package/src/TSL/Common.js

@@ -39,7 +39,7 @@ export const FP16_MAX = 65504.0;
 export const sanitize1 = ( x, ceiling = 1e7 ) => select( x.equal( x ), x, float( 0.0 ) ).clamp( 0.0, ceiling );
 export const sanitizeRGB = ( c, ceiling = 1e7 ) =>
 	vec3( sanitize1( c.x, ceiling ), sanitize1( c.y, ceiling ), sanitize1( c.z, ceiling ) );
-import { MATERIAL_DATA_LAYOUT, TRI_BLOCKER_SHIFT, TRI_BLOCKER_ALPHA_SHIFT } from '../EngineDefaults.js';
+import { TRI_BLOCKER_SHIFT, TRI_BLOCKER_ALPHA_SHIFT, MATERIAL_DATA_LAYOUT } from '../Processor/BufferLayout.js';
 
 export const MATERIAL_SLOTS = MATERIAL_DATA_LAYOUT.SLOTS_PER_MATERIAL;
 export const MATERIAL_SLOT = MATERIAL_DATA_LAYOUT.SLOT;
@@ -432,6 +432,13 @@ export const getMaterial = Fn( ( [ materialIndex, materialBuffer ] ) => {
 	const data30 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.EXT_MAP_INDICES_A ), int( MATERIAL_SLOTS ) ).toVar();
 	const data31 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.EXT_MAP_INDICES_B ), int( MATERIAL_SLOTS ) ).toVar();
 	const data32 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.EXT_MAP_INDICES_C ), int( MATERIAL_SLOTS ) ).toVar();
+	// Only a material with diffuse transmission has maps for it.
+	const data33 = vec4( - 1.0, - 1.0, 0.0, 0.0 ).toVar();
+	If( data5.a.greaterThan( 0.0 ), () => {
+
+		data33.assign( getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.EXT_MAP_INDICES_D ), int( MATERIAL_SLOTS ) ) );
+
+	} );
 
 	return RayTracingMaterial( {
 		color: vec4( data0.rgb, 1.0 ),
@@ -470,6 +477,10 @@ export const getMaterial = Fn( ( [ materialIndex, materialBuffer ] ) => {
 		iridescenceThicknessMapIndex: int( data31.b ),
 		specularIntensityMapIndex: int( data31.a ),
 		specularColorMapIndex: int( data32.r ),
+		diffuseTransmission: data5.a,
+		diffuseTransmissionColor: data32.gba,
+		diffuseTransmissionMapIndex: int( data33.r ),
+		diffuseTransmissionColorMapIndex: int( data33.g ),
 		albedoMapIndex: int( data8.r ),
 		normalMapIndex: int( data8.g ),
 		roughnessMapIndex: int( data8.b ),
@@ -569,6 +580,10 @@ export const diffuseGroundMaterial = Fn( () => {
 		iridescenceThicknessMapIndex: int( - 1 ),
 		specularIntensityMapIndex: int( - 1 ),
 		specularColorMapIndex: int( - 1 ),
+		diffuseTransmission: float( 0.0 ),
+		diffuseTransmissionColor: vec3( 1.0 ),
+		diffuseTransmissionMapIndex: int( - 1 ),
+		diffuseTransmissionColorMapIndex: int( - 1 ),
 	} );
 
 } );
@@ -612,22 +627,12 @@ export const getShadowMaterial = Fn( ( [ materialIndex, materialBuffer ] ) => {
  * rides along in the rest — no second binding, which matters on a backend that
  * allows ten storage buffers per stage.
  */
-// Runtime uniform that toggles alpha-cutout shadows; set by ShaderBuilder before the kernels build.
-let _enableAlphaShadows = null;
-
-export function setAlphaShadowsUniform( node ) {
-
-	_enableAlphaShadows = node;
-
-}
-
-export const getAlphaShadowsUniform = () => _enableAlphaShadows;
-
-// Does a hit on a triangle with these flags settle the shadow ray without a material fetch?
-export const shadowFlagsSettle = ( flags ) => {
+// Does a hit on a triangle with these flags settle the shadow ray without a material fetch? `alphaShadows` is the
+// kernel's switch (SceneResources); null means alpha is never tested.
+export const shadowFlagsSettle = ( flags, alphaShadows ) => {
 
 	const bit = ( shift ) => flags.shiftRight( uint( shift ) ).bitAnd( uint( 1 ) ).equal( uint( 1 ) );
-	const alphaOff = _enableAlphaShadows ? _enableAlphaShadows.equal( int( 0 ) ) : tslBool( true );
+	const alphaOff = alphaShadows ? alphaShadows.equal( int( 0 ) ) : tslBool( true );
 	return bit( TRI_BLOCKER_SHIFT ).or( bit( TRI_BLOCKER_ALPHA_SHIFT ).and( alphaOff ) );
 
 };