rayzee 9.4.2 → 9.5.0

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

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

package/src/TSL/ConnectKernel.js

@@ -0,0 +1,147 @@
+/**
+ * ConnectKernel.js — connects each camera vertex Shade left pending to one vertex of a random light
+ * path, weighted by how many of that path's vertices fit the bounce budget (Davidovič et al. 2014).
+ */
+
+import {
+	Fn, float, vec2, vec4, int, uint, If, instanceIndex, atomicLoad, Return, dot, sqrt, min, max, length,
+} from 'three/tsl';
+
+import { getRandomSample1D, pcgHash, SAMPLER_DIMS_PER_BOUNCE } from './Random.js';
+import { evaluateMaterialResponse } from './MaterialEvaluation.js';
+import { calculateMaterialPDF } from './LightsSampling.js';
+import { traceShadowRayRefractiveOpaque } from './LightsDirect.js';
+import { traverseBVHShadow } from './BVHTraversal.js';
+import { offsetRayOrigin, SHADOW_END, luminance } from './Common.js';
+import { regularizePathContribution } from './PathTracerCore.js';
+import {
+	resolveSurfaceMaterial, lightEndCosine, misPartial, misWeight, strategyWeight, STRATEGY, DIM_CONNECT_PATH, DIM_CONNECT_VERTEX,
+} from './Bidirectional.js';
+import { COUNTER } from '../Processor/QueueManager.js';
+import {
+	readRayRadiance, writeRayRadiance, readRngState,
+	pendingVertex, cachedVertex, readVertexTag, readVertexRecord, readLightPathLength,
+} from '../Processor/PackedRayBuffer.js';
+
+const WG_SIZE = 256;
+
+export function buildConnectKernel( params ) {
+
+	const {
+		rayBufferRW, hitBufferRO, activeIndicesRO, counters,
+		bvhBuffer, triangleBuffer, materialBuffer,
+		resolution, frame, accumFrame, currentBounce, chunkRowBase,
+		lightPaths, slotsPerPath, lightTag, passTag, strategyView,
+		maxBounceCount, globalIlluminationIntensity, fireflyThreshold,
+		// Vertex merging's η² at a point (Bidirectional.js mergeVmAt), or null without it.
+		mergeVm = null,
+	} = params;
+
+	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 camRecord = readVertexRecord( hitBufferRO, pending );
+		const cam = { ...camRecord, vm: mergeVm?.( camRecord.position ) ?? null };
+		const cameraVertices = int( cam.extra ).add( int( 1 ) ).toVar();
+
+		const resX = int( resolution.x );
+		const globalPixel = int( rayID ).add( chunkRowBase.mul( resX ) );
+		const pixel = vec2( float( globalPixel.mod( resX ) ).add( 0.5 ), float( globalPixel.div( resX ) ).add( 0.5 ) ).toVar();
+		const dimBase = int( currentBounce ).mul( int( SAMPLER_DIMS_PER_BOUNCE ) );
+		// Only PCG reads it; hashed so the path's own stream, already saved by Shade, is not replayed.
+		const rng = pcgHash( { state: readRngState( hitBufferRO, rayID ).bitXor( uint( 0x9E3779B9 ) ) } ).toVar();
+		const uPath = getRandomSample1D( pixel, int( 0 ), dimBase.add( int( DIM_CONNECT_PATH ) ), rng, resolution, frame ).toVar();
+		const uVertex = getRandomSample1D( pixel, int( 0 ), dimBase.add( int( DIM_CONNECT_VERTEX ) ), rng, resolution, frame ).toVar();
+
+		const path = min( uint( float( lightPaths ).mul( uPath ) ), lightPaths.sub( uint( 1 ) ) ).toVar();
+		const first = path.mul( slotsPerPath ).toVar();
+		const stored = int( readLightPathLength( hitBufferRO, cachedVertex( first ), lightTag ) );
+		const usable = min( stored, int( maxBounceCount ).add( int( 1 ) ).sub( cameraVertices ) ).toVar();
+		If( usable.lessThan( int( 1 ) ), () => {
+
+			Return();
+
+		} );
+
+		const c = min( int( float( usable ).mul( uVertex ) ), usable.sub( int( 1 ) ) ).toVar();
+		const lightRecord = readVertexRecord( hitBufferRO, cachedVertex( first.add( uint( c ) ) ) );
+		const light = { ...lightRecord, vm: mergeVm?.( lightRecord.position ) ?? null };
+
+		const toLight = light.position.sub( cam.position ).toVar();
+		const dist2 = max( dot( toLight, toLight ), 1e-12 ).toVar();
+		const dir = toLight.div( sqrt( dist2 ) ).toVar();
+
+		const cosCamera = dot( dir, cam.N ).toVar();
+		const cosCameraFacet = dot( dir, cam.facetN ).toVar();
+		const cosLightFacet = dot( dir, light.facetN ).negate().toVar();
+		// The camera end tests as NEE does; at the light end the camera vertex is the viewer, which only the facet bounds.
+		If( cosCamera.lessThanEqual( 0.0 ).or( cosCameraFacet.lessThanEqual( 0.0 ) ).or( cosLightFacet.lessThanEqual( 0.0 ) ), () => {
+
+			Return();
+
+		} );
+
+		const cameraMaterial = resolveSurfaceMaterial( cam.materialIndex, cam.uv, cam.N, materialBuffer );
+		const lightMaterial = resolveSurfaceMaterial( light.materialIndex, light.uv, light.N, materialBuffer );
+		const toCamera = dir.negate();
+
+		const fCamera = evaluateMaterialResponse( cam.V, dir, cam.N, cameraMaterial ).toVar();
+		const fLight = evaluateMaterialResponse( toCamera, light.V, light.N, lightMaterial ).toVar();
+		const geometry = cosCamera.mul( lightEndCosine( light.V, light.N, light.facetN, toCamera ) ).div( dist2 );
+
+		const cameraForward = calculateMaterialPDF( cam.V, dir, cam.N, cameraMaterial );
+		const cameraReverse = calculateMaterialPDF( dir, cam.V, cam.N, cameraMaterial );
+		const lightForward = calculateMaterialPDF( light.V, toCamera, light.N, lightMaterial );
+		const lightReverse = calculateMaterialPDF( toCamera, light.V, light.N, lightMaterial );
+
+		// Georgiev (40)-(41): each side's sum, from the other side's density of reaching it.
+		const wLight = misPartial( cameraForward.mul( cosLightFacet ).div( dist2 ), light, lightReverse );
+		const wCamera = misPartial( lightForward.mul( cosCameraFacet ).div( dist2 ), cam, cameraReverse );
+
+		const scattering = cameraVertices.add( c ).add( int( 1 ) );
+		// Alone, a path of k scattering vertices is reached by k − 1 connections.
+		const weight = strategyWeight( strategyView, STRATEGY.CONNECT, misWeight( wLight, wCamera ), float( 1.0 ).div( float( scattering.sub( int( 1 ) ) ) ) );
+		const contribution = regularizePathContribution(
+			cam.throughput.mul( fCamera ).mul( fLight ).mul( light.throughput )
+				.mul( geometry.mul( weight ).mul( float( usable ) ).mul( globalIlluminationIntensity ) ),
+			float( scattering.sub( int( 1 ) ) ), fireflyThreshold, int( accumFrame ),
+		).toVar();
+
+		If( luminance( contribution ).greaterThan( 0.0 ), () => {
+
+			const origin = offsetRayOrigin( cam.position, cam.facetN ).toVar();
+			const segment = offsetRayOrigin( light.position, light.facetN ).sub( origin ).toVar();
+			const segmentLength = length( segment ).toVar();
+			const visibility = traceShadowRayRefractiveOpaque(
+				origin, segment.div( segmentLength ), segmentLength.mul( SHADOW_END ),
+				traverseBVHShadow, bvhBuffer, triangleBuffer, materialBuffer,
+			);
+
+			If( visibility.greaterThan( 0.0 ), () => {
+
+				const radiance = readRayRadiance( rayBufferRW, rayID ).toVar();
+				writeRayRadiance( rayBufferRW, rayID, vec4( radiance.xyz.add( contribution.mul( visibility ) ), radiance.w ) );
+
+			} );
+
+		} );
+
+	} );
+
+}
+
+export { WG_SIZE as CONNECT_WG_SIZE };

package/src/TSL/Debugger.js

@@ -72,7 +72,7 @@ export const TraceDebugMode = Fn( ( [
 	visMode, debugVisScale,
 	// Screen info
 	pixelCoord, resolution,
-	// Material textures are read from the module-level bucket nodes (setMaterialBucketTextures).
+	// Material textures come from the kernel's SceneResources.
 	// Camera matrices (for depth debug mode)
 	cameraProjectionMatrix, cameraViewMatrix,
 	// Frame counter (for stochastic debug modes)

package/src/TSL/Displacement.js

@@ -1,8 +1,9 @@
+import { sceneResources } from './SceneResources.js';
 import { Fn, float, vec2, int, If, Loop, abs, normalize, dot, max, uintBitsToFloat } from 'three/tsl';
 
 import { struct } from './patches.js';
 import { triangleRow, instanceRows, instanceDirToWorld } from './Common.js';
-import { sampleDisplacementMap, bucketTexelSize, getLinearBucketTextures } from './TextureSampling.js';
+import { sampleDisplacementMap, bucketTexelSize } from './TextureSampling.js';
 
 // Ray-displacement intersection configuration
 const MAX_MARCH_STEPS = 32;
@@ -32,7 +33,7 @@ export const DisplacementResult = struct( {
  */
 export const refineDisplacedIntersection = Fn( ( [
 	ray, hitInfo, triangleBuffer, material, bounceIndex, bvhBuffer, instanceLeaf
-] ) => {
+], builder ) => {
 
 	const resultHitPoint = hitInfo.hitPoint.toVar();
 	const resultUV = hitInfo.uv.toVar();
@@ -205,7 +206,7 @@ export const refineDisplacedIntersection = Fn( ( [
 
 				// Compute displaced normal from height-field gradients using UV tangent vectors.
 				// Finite-difference step = one texel of the SELECTED bucket array's real dimensions.
-				const texel = bucketTexelSize( getLinearBucketTextures(), material.displacementMapIndex ).toVar();
+				const texel = bucketTexelSize( sceneResources( builder ).linearBuckets, material.displacementMapIndex ).toVar();
 				const hC = finalHeight;
 				const hU = sampleDisplacementMap(
 					material.displacementMapIndex, finalUV.add( vec2( texel.x, 0.0 ) ), material.displacementTransform,

package/src/TSL/EmissiveSampling.js

@@ -35,8 +35,10 @@ import {
 import { TRI_MATERIAL_MASK } from '../EngineDefaults.js';
 import { getRandomSample1D, getRandomSample2D } from './Random.js';
 import { calculateMaterialPDFFromDots } from './LightsSampling.js';
-import { evaluateMaterialResponseFromDots } from './MaterialEvaluation.js';
+import { evaluateMaterialResponseFromDots, evaluateDiffuseTransmission } from './MaterialEvaluation.js';
+import { diffuseTransmissionWeight, diffuseTransmissionPdf } from './MaterialProperties.js';
 import { DotProducts } from './Struct.js';
+import { triangleSide, sideAccepts } from './BVHTraversal.js';
 
 // ================================================================================
 // STRUCTS
@@ -54,6 +56,21 @@ export const EmissiveSample = struct( {
 	valid: 'bool', // Whether sample is valid
 } );
 
+// EmissiveSample plus the triangle it landed on, for the bidirectional MIS weight.
+export const EmissiveSampleIndexed = struct( {
+	position: 'vec3',
+	normal: 'vec3',
+	emission: 'vec3',
+	direction: 'vec3',
+	distance: 'float',
+	pdf: 'float',
+	area: 'float',
+	cosThetaLight: 'float',
+	valid: 'bool',
+	triangleIndex: 'int',
+	faceNormal: 'vec3', // winding normal
+} );
+
 export const EmissiveContributionResult = struct( {
 	contribution: 'vec3',
 	hasEmissive: 'bool',
@@ -285,6 +302,7 @@ export const TriangleData = struct( {
 	v0: 'vec3', v1: 'vec3', v2: 'vec3',
 	n0: 'vec3', n1: 'vec3', n2: 'vec3',
 	materialIndex: 'int',
+	side: 'int', // 0 front, 1 back, 2 double (BVHTraversal.js triangleSide)
 } );
 
 // Fetch triangle vertices from storage buffer
@@ -323,6 +341,7 @@ export const fetchTriangleData = Fn( ( [ triangleIndex, triangleBuffer, bvhBuffe
 	return TriangleData( {
 		v0, v1, v2, n0, n1, n2,
 		materialIndex: int( uvMat.z.bitAnd( uint( TRI_MATERIAL_MASK ) ) ),
+		side: triangleSide( uvMat.z ),
 	} );
 
 } );
@@ -359,14 +378,16 @@ export const calculateEmissiveLightPdf = Fn( ( [
 
 		// Area: PDF = (power/totalPower) / area, converted to solid angle
 		const geoNormal = normalize( cross( triData.v1.sub( triData.v0 ), triData.v2.sub( triData.v0 ) ) );
-		const cosLight = max( dot( rayDir.negate(), geoNormal ), 0.001 );
+		const cosLight = max( abs( dot( rayDir, geoNormal ) ), 0.001 );
 		const distSq = hitDistance.mul( hitDistance );
 		const pdfArea = selectionPdf.div( area );
 		result.assign( pdfArea.mul( distSq ).div( cosLight ) );
 
 	} );
 
-	return max( result, MIN_PDF );
+	// The sampler draws only the sides the triangle emits from (a unit normal: sideAccepts has a threshold).
+	const winding = normalize( cross( triData.v1.sub( triData.v0 ), triData.v2.sub( triData.v0 ) ) );
+	return select( sideAccepts( triData.side, dot( rayDir, winding ) ), max( result, MIN_PDF ), float( 0.0 ) );
 
 } );
 
@@ -378,7 +399,7 @@ export const calculateEmissiveLightPdf = Fn( ( [
 // CDF values are stored in the .b channel of the emissive buffer.
 // `emissiveOffset` is the vec4-element offset into the packed light buffer
 // where emissive entries start (0 if using a non-packed buffer).
-const binarySearchCDF = Fn( ( [ emissiveTriangleBuffer, emissiveOffset, emissiveTriangleCount, rand ] ) => {
+export const binarySearchCDF = Fn( ( [ emissiveTriangleBuffer, emissiveOffset, emissiveTriangleCount, rand ] ) => {
 
 	const lo = int( 0 ).toVar();
 	const hi = emissiveTriangleCount.sub( 1 ).toVar();
@@ -407,15 +428,17 @@ const binarySearchCDF = Fn( ( [ emissiveTriangleBuffer, emissiveOffset, emissive
 // Sample from emissive triangle index using CDF importance sampling.
 // `emissiveTriangleBuffer` may be the shared packed light buffer; `emissiveVec4Offset`
 // gives the vec4 offset where emissive entries begin.
-export const sampleEmissiveTriangle = Fn( ( [
+const makeSampleEmissiveTriangle = ( indexed ) => Fn( ( [
 	hitPoint, surfaceNormal,
 	rngState,
 	pixelCoord, resolution, frame, dimBase,
 	emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower,
 	triangleBuffer, bvhBuffer,
+	// The surface passes light through diffusely: a point behind it is as good as one in front.
+	throughSurface,
 ] ) => {
 
-	const result = EmissiveSample( {
+	const fields = {
 		position: vec3( 0.0 ),
 		normal: vec3( 0.0 ),
 		emission: vec3( 0.0 ),
@@ -425,7 +448,10 @@ export const sampleEmissiveTriangle = Fn( ( [
 		area: float( 0.0 ),
 		cosThetaLight: float( 0.0 ),
 		valid: false,
-	} ).toVar();
+	};
+	const result = ( indexed
+		? EmissiveSampleIndexed( { ...fields, triangleIndex: int( - 1 ), faceNormal: vec3( 0.0 ) } )
+		: EmissiveSample( fields ) ).toVar();
 
 	// Check if we have emissive triangles
 	If( emissiveTriangleCount.greaterThan( int( 0 ) ), () => {
@@ -469,9 +495,9 @@ export const sampleEmissiveTriangle = Fn( ( [
 				const samplePos = sphResult.position;
 
 				const surfaceFacing = dot( dir, surfaceNormal );
-				const emissiveFacing = dot( dir, geoNormal.negate() );
+				const emissiveFacing = abs( dot( dir, geoNormal ) );
 
-				If( surfaceFacing.greaterThan( 0.0 ).and( emissiveFacing.greaterThan( 0.0 ) ), () => {
+				If( surfaceFacing.greaterThan( 0.0 ).or( throughSurface ).and( sideAccepts( triData.side, dot( dir, geoNormal ) ) ), () => {
 
 					// Interpolate normal at sampled point via barycentric coords
 					const bary = barycentricFromPoint( samplePos, triData.v0, triData.v1, triData.v2 );
@@ -495,6 +521,12 @@ export const sampleEmissiveTriangle = Fn( ( [
 					result.area.assign( area );
 					result.cosThetaLight.assign( emissiveFacing );
 					result.valid.assign( true );
+					if ( indexed ) {
+
+						result.triangleIndex.assign( triangleIndex );
+						result.faceNormal.assign( geoNormal );
+
+					}
 
 				} );
 
@@ -512,9 +544,11 @@ export const sampleEmissiveTriangle = Fn( ( [
 			const dir = toEmissive.div( dist );
 
 			const surfaceFacing = dot( dir, surfaceNormal );
-			const emissiveFacing = dot( dir, sampleNormal.negate() );
+			// The facet's cosine, not the shading normal's: it is what turns an area density into a solid-angle one.
+			const emissiveFacing = abs( dot( dir, geoNormal ) );
 
-			If( surfaceFacing.greaterThan( 0.0 ).and( emissiveFacing.greaterThan( 0.0 ) ), () => {
+			// Edge-on (a two-sided emitter passes its side test there) the density is infinite and the light zero.
+			If( surfaceFacing.greaterThan( 0.0 ).or( throughSurface ).and( sideAccepts( triData.side, dot( dir, geoNormal ) ) ).and( emissiveFacing.greaterThan( 0.0 ) ), () => {
 
 				// PDF: CDF selection (power/totalPower) * uniform area (1/area)
 				// Converted to solid angle: pdfArea * distSq / cosLight
@@ -530,6 +564,12 @@ export const sampleEmissiveTriangle = Fn( ( [
 				result.area.assign( area );
 				result.cosThetaLight.assign( emissiveFacing );
 				result.valid.assign( true );
+				if ( indexed ) {
+
+					result.triangleIndex.assign( triangleIndex );
+					result.faceNormal.assign( geoNormal );
+
+				}
 
 			} );
 
@@ -541,6 +581,9 @@ export const sampleEmissiveTriangle = Fn( ( [
 
 } );
 
+export const sampleEmissiveTriangle = /*@__PURE__*/ makeSampleEmissiveTriangle( false );
+export const sampleEmissiveTriangleIndexed = /*@__PURE__*/ makeSampleEmissiveTriangle( true );
+
 // ================================================================================
 // EMISSIVE TRIANGLE DIRECT LIGHTING CONTRIBUTION
 // ================================================================================
@@ -573,11 +616,12 @@ export const calculateEmissiveTriangleContributionDebug = Fn( ( [
 	// down-weights BSDF hits deletes emitter energy from deep GI.
 
 	// Sample emissive triangle (CDF importance-weighted)
+	const transmits = material.diffuseTransmission.greaterThan( 0.0 );
 	const emissiveSample = EmissiveSample.wrap( sampleEmissiveTriangle(
 		hitPoint, normal, rngState,
 		pixelCoord, resolution, frame, dimBase,
 		emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower,
-		triangleBuffer, bvhBuffer,
+		triangleBuffer, bvhBuffer, transmits,
 	) );
 
 	If( emissiveSample.valid.and( emissiveSample.pdf.greaterThan( 0.0 ) ), () => {
@@ -586,10 +630,12 @@ export const calculateEmissiveTriangleContributionDebug = Fn( ( [
 		result.emissionOnly.assign( emissiveSample.emission );
 		result.distance.assign( emissiveSample.distance );
 
-		// Check geometric validity
-		const NoL = max( float( 0.0 ), dot( normal, emissiveSample.direction ) );
+		// Check geometric validity: in front, or behind a surface that passes light through diffusely
+		const back = transmits.and( dot( normal, emissiveSample.direction ).lessThan( 0.0 ) )
+			.and( dot( emissiveSample.direction, geomNormal ).lessThan( 0.0 ) ).toVar();
+		const NoL = abs( dot( normal, emissiveSample.direction ) );
 
-		If( NoL.greaterThan( 0.0 ).and( dot( emissiveSample.direction, geomNormal ).greaterThan( 0.0 ) ), () => {
+		If( back.or( NoL.greaterThan( 0.0 ).and( dot( emissiveSample.direction, geomNormal ).greaterThan( 0.0 ) ) ), () => {
 
 			// Aimed at the sampled point and stopped a relative hair short, as for area lights.
 			const rayOrigin = hitPoint.add( calculateRayOffsetFn( hitPoint, geomNormal, emissiveSample.direction ) );
@@ -602,8 +648,9 @@ export const calculateEmissiveTriangleContributionDebug = Fn( ( [
 				// Share H + dot products between BRDF eval and PDF (computeDotProducts
 				// would otherwise run twice with identical inputs).
 				const dots = DotProducts.wrap( computeDotProductsAniso( normal, viewDir, emissiveSample.direction, material ) );
-				const brdfValue = evaluateMaterialResponseFromDots( material, dots );
-				const brdfPdf = calculateMaterialPDFFromDots( material, dots );
+				const brdfValue = select( back, evaluateDiffuseTransmission( material, max( dot( normal, viewDir ), 0.001 ) ), evaluateMaterialResponseFromDots( material, dots ) );
+				const brdfPdf = select( back,
+					diffuseTransmissionPdf( diffuseTransmissionWeight( material ), NoL ), calculateMaterialPDFFromDots( material, dots ) );
 
 				// MIS weight: balance light sampling vs BRDF sampling
 				const misWeight = select(