rayzee 10.0.0 → 11.1.0

package/src/TSL/EnvironmentCDF.js

@@ -2,11 +2,11 @@ import { Fn, float, int, uint, vec2, vec4, If, Loop, Return, instanceIndex, max,
 
 import { REC709_LUMINANCE_COEFFICIENTS } from './Common.js';
 
-/** Floats per row of the packed table: width + 1 texels, padded to the 256 bytes a buffer→texture copy needs. */
-export const cdfRowStride = width => Math.ceil( ( width + 1 ) * 4 / 256 ) * 64;
+/** Floats per row of the packed table: width + 1 RGBA texels, padded to the 256 bytes a buffer→texture copy needs. */
+export const cdfRowStride = width => Math.ceil( ( width + 1 ) * 16 / 256 ) * 64;
 
-// First index in [0, n) whose value is ≥ target, n − 1 when none is — as the CPU builder's search.
-function lowerBound( n, valueAt, target ) {
+// First index in [0, n) whose value is above target, n − 1 when none is — as the CPU builder's cutpoints.
+function firstAbove( n, valueAt, target ) {
 
 	const lo = int( 0 ).toVar();
 	const hi = int( n - 1 ).toVar();
@@ -15,7 +15,7 @@ function lowerBound( n, valueAt, target ) {
 		If( lo.lessThan( hi ), () => {
 
 			const mid = lo.add( hi ).div( 2 ).toVar();
-			If( valueAt( mid ).lessThan( target ), () => {
+			If( valueAt( mid ).lessThanEqual( target ), () => {
 
 				lo.assign( mid.add( 1 ) );
 
@@ -36,13 +36,16 @@ function lowerBound( n, valueAt, target ) {
 // against the row total it ends on.
 
 /**
- * The GPU twin of `EquirectHDRInfo.computeCDF`, into the packed (width + 1) × height table the
- * sampler reads. `stats[ 1 ]` ends as ( totalSum, compensationDelta, compensated, 0 ).
+ * The GPU twin of `buildExactEnvironmentTable`, in packExactTable's (width + 1) × height RGBA layout (one cell a
+ * texel, compensated by the same mean, without its neighbour weighting: the sky has no sharp texel).
+ * `stats[ 1 ]` ends as ( totalSum, compensationDelta, compensated, 0 ).
  * @returns {Array} kernels, dispatched in order
  */
 export function buildEnvironmentCDFKernels( { pixels, rows, prefix, stats, cdf, width, height } ) {
 
 	const stride = cdfRowStride( width );
+	// Channel c of texel ( x, y ).
+	const at = ( x, y, c ) => uint( y ).mul( uint( stride ) ).add( uint( x ).mul( uint( 4 ) ) ).add( uint( c ) );
 	const sinTheta = y => sin( float( y ).add( 0.5 ).mul( Math.PI / height ) );
 	const weight = ( y, x, sinT ) => dot( pixels.element( y.mul( width ).add( x ) ).xyz, REC709_LUMINANCE_COEFFICIENTS ).mul( sinT );
 	const firstThreadOnly = () => If( instanceIndex.greaterThan( uint( 0 ) ), () => {
@@ -109,7 +112,7 @@ export function buildEnvironmentCDFKernels( { pixels, rows, prefix, stats, cdf,
 
 	} )().compute( height, [ 64 ] );
 
-	const marginal = Fn( () => {
+	const totals = Fn( () => {
 
 		firstThreadOnly();
 		const compensatedTotal = float( 0 ).toVar();
@@ -118,59 +121,102 @@ export function buildEnvironmentCDFKernels( { pixels, rows, prefix, stats, cdf,
 			compensatedTotal.addAssign( rows.element( i ).y );
 
 		} );
-		const useCompensated = compensatedTotal.greaterThan( 0 ).toVar();
+		const s = stats.element( 0 ).toVar();
+		stats.element( 1 ).assign( select( compensatedTotal.greaterThan( 0 ), vec4( compensatedTotal, s.y, 1, 0 ), vec4( s.x, 0, 0, 0 ) ) );
 
-		const cumulative = float( 0 ).toVar();
-		Loop( { start: int( 0 ), end: int( height ), type: 'int', condition: '<' }, ( { i } ) => {
+	} )().compute( 1, [ 1 ] );
+
+	// buildExactEnvironmentTable's floor: a share of the mean weight in every cell.
+	const exactFloor = () => stats.element( 0 ).x.mul( 1e-4 / ( width * height ) );
 
-			const r = rows.element( i ).toVar();
-			cumulative.addAssign( select( useCompensated, r.y, r.x ) );
-			rows.element( i ).assign( vec4( r.x, r.y, cumulative, 0 ) );
+	const exactRows = Fn( () => {
+
+		const y = instanceIndex;
+		If( y.greaterThanEqual( uint( height ) ), () => {
+
+			Return();
 
 		} );
 
-		const s = stats.element( 0 ).toVar();
-		stats.element( 1 ).assign( select( useCompensated, vec4( compensatedTotal, s.y, 1, 0 ), vec4( s.x, 0, 0, 0 ) ) );
+		const floor = exactFloor().toVar();
+		const compensated = stats.element( 1 ).z.greaterThan( 0 ).toVar();
+		const r = rows.element( y ).toVar();
+		const rowSum = select( compensated, r.y, r.x ).add( floor.mul( width ) ).toVar();
+		const below = float( 0 ).toVar();
+		Loop( { start: int( 0 ), end: int( width ), type: 'int', condition: '<' }, ( { i } ) => {
+
+			const p = prefix.element( y.mul( width ).add( uint( i ) ) ).toVar();
+			const c = select( compensated, p.y, p.x ).add( floor.mul( float( i ).add( 1 ) ) ).div( max( rowSum, 1e-30 ) );
+			const sum = select( rowSum.greaterThan( 0 ), select( i.equal( int( width - 1 ) ), float( 1 ), c ), float( 0 ) ).toVar();
+			cdf.element( at( i, y, 0 ) ).assign( sum );
+			cdf.element( at( i, y, 1 ) ).assign( below );
+			below.assign( sum );
+
+		} );
+
+	} )().compute( height, [ 64 ] );
+
+	const exactMarginal = Fn( () => {
 
-		Loop( { start: int( 0 ), end: int( height ), type: 'int', condition: '<', name: 'row' }, ( { row } ) => {
+		firstThreadOnly();
+		const floor = exactFloor().mul( width ).toVar();
+		const compensated = stats.element( 1 ).z.greaterThan( 0 ).toVar();
+		const rowSum = ( i ) => {
 
-			const k = select(
-				cumulative.greaterThan( 0 ),
-				float( lowerBound( height, j => rows.element( j ).z, float( row ).add( 1 ).div( height ).mul( cumulative ) ) ),
-				float( height - 1 ),
-			);
-			cdf.element( uint( row ).mul( stride ).add( width ) ).assign( k.add( 0.5 ).div( height ) );
+			const r = rows.element( i ); return select( compensated, r.y, r.x ).add( floor );
+
+		};
+
+		const total = float( 0 ).toVar();
+		Loop( { start: int( 0 ), end: int( height ), type: 'int', condition: '<' }, ( { i } ) => {
+
+			total.addAssign( rowSum( i ) );
+
+		} );
+		const cumulative = float( 0 ).toVar();
+		const below = float( 0 ).toVar();
+		Loop( { start: int( 0 ), end: int( height ), type: 'int', condition: '<' }, ( { i } ) => {
+
+			cumulative.addAssign( rowSum( i ) );
+			const c = select( i.equal( int( height - 1 ) ), float( 1 ), cumulative.div( max( total, 1e-30 ) ) );
+			const sum = select( total.greaterThan( 0 ), c, float( 0 ) ).toVar();
+			cdf.element( at( width, i, 0 ) ).assign( sum );
+			cdf.element( at( width, i, 1 ) ).assign( below );
+			below.assign( sum );
 
 		} );
 
 	} )().compute( 1, [ 1 ] );
 
-	const conditional = Fn( () => {
+	// GUIDES_PER_ENTRY (2) guides an entry, in its texel's z and w: the rows' in columns [0, width), the marginal's in
+	// column width.
+	const rowGuides = 2 * width * height;
+	const guides = Fn( () => {
 
 		const idx = instanceIndex;
-		If( idx.greaterThanEqual( uint( width * height ) ), () => {
+		If( idx.greaterThanEqual( uint( rowGuides + 2 * height ) ), () => {
 
 			Return();
 
 		} );
 
-		const x = idx.mod( width );
-		const y = idx.div( width );
-		const useCompensated = stats.element( 1 ).z.greaterThan( 0 ).toVar();
-		const r = rows.element( y ).toVar();
-		const rowTotal = select( useCompensated, r.y, r.x ).toVar();
-		const base = y.mul( width ).toVar();
-		const k = lowerBound( width, j => {
+		If( idx.lessThan( uint( rowGuides ) ), () => {
+
+			const g = idx.mod( 2 * width ).toVar();
+			const y = idx.div( 2 * width ).toVar();
+			const x = firstAbove( width, j => cdf.element( at( j, y, 0 ) ), float( g ).div( 2 * width ) );
+			cdf.element( at( g.shiftRight( uint( 1 ) ), y, uint( 2 ).add( g.bitAnd( uint( 1 ) ) ) ) ).assign( float( x ) );
 
-			const p = prefix.element( base.add( uint( j ) ) );
-			return select( useCompensated, p.y, p.x );
+		} ).Else( () => {
 
-		}, float( x ).add( 1 ).div( width ).mul( rowTotal ) );
-		const column = select( rowTotal.greaterThan( 0 ), float( k ), float( width - 1 ) );
-		cdf.element( y.mul( stride ).add( x ) ).assign( column.add( 0.5 ).div( width ) );
+			const g = idx.sub( uint( rowGuides ) ).toVar();
+			const y = firstAbove( height, j => cdf.element( at( width, j, 0 ) ), float( g ).div( 2 * height ) );
+			cdf.element( at( width, g.shiftRight( uint( 1 ) ), uint( 2 ).add( g.bitAnd( uint( 1 ) ) ) ) ).assign( float( y ) );
+
+		} );
 
-	} )().compute( width * height, [ 64 ] );
+	} )().compute( rowGuides + 2 * height, [ 64 ] );
 
-	return [ rowTotals, mean, prefixSums, marginal, conditional ];
+	return [ rowTotals, mean, prefixSums, totals, exactRows, exactMarginal, guides ];
 
 }

package/src/TSL/ExtendKernel.js

@@ -3,8 +3,8 @@
  */
 
 import {
-	Fn, uint, int,
-	If,
+	Fn, uint, int, float,
+	If, dot, abs, select,
 	instanceIndex,
 	atomicLoad,
 	Return,
@@ -76,9 +76,14 @@ export function buildExtendKernel( params ) {
 			didHit: hitInfo.didHit, liftEnabled: shadowTerminatorOffset.greaterThan( 0.0 ),
 		} );
 
+		// origin + t · direction sits off a large triangle by t's own error, which grows with the triangle's size: the
+		// distance stored is moved along the ray onto the triangle's plane (not where it grazes the plane).
+		const cosToPlane = dot( direction, facet.faceN ).toVar();
+		const planeDst = hitInfo.dst.add( select( abs( cosToPlane ).greaterThan( 1e-3 ), facet.surfaceOffset.div( cosToPlane ), float( 0.0 ) ) );
+
 		writeHitPacked(
 			hitBufferRW, rayID,
-			hitInfo.dst,
+			planeDst,
 			uint( hitInfo.triangleIndex ),
 			hitInfo.uv.x, hitInfo.uv.y,
 			hitInfo.normal,

package/src/TSL/FinalWriteKernel.js

@@ -46,7 +46,7 @@ export function buildFinalWriteKernel( params ) {
 		visMode,
 		// Aux MRT (normalDepth + albedo) feeds only the denoiser/OIDN. Gated by a live uniform (1 = denoiser
 		// on): when off, skip the G-buffer decode, the prev-frame aux mix, and the two aux stores.
-		auxGBufferEnabled,
+		auxGBufferEnabled, gBuffer = true, // compiled in only when requested (PathTracer.requestOutput( 'gBuffer' ))
 		// Clean-aux normal (1 = temporally accumulate + renormalize the aux normal). On only for clean-aux
 		// OIDN models (calb_cnrm/high, alb_nrm/balanced); off for fast/ASVGF which want the bump normal.
 		cleanAuxNormalEnabled,
@@ -98,7 +98,7 @@ export function buildFinalWriteKernel( params ) {
 			const finalAlbedo = vec4( 0.0 ).xyz.toVar();
 			// Albedo .w carries the hit distance — OIDN reads albedo as 3 channels, so it is free.
 			const finalHitDist = float( 0.0 ).toVar();
-			If( auxOn, () => {
+			if ( gBuffer ) If( auxOn, () => {
 
 				const gbuf = readGBuffer( gBufferRO, rayID );
 				finalNormalDepth.assign( gbDecodeNormalDepth( gbuf ) );
@@ -118,7 +118,7 @@ export function buildFinalWriteKernel( params ) {
 
 				// Frozen pixels pass prev colour through unchanged (stale sample); active pixels accumulate.
 				finalColor.assign( select( wasFrozen, prevAccumSample.xyz, mix( prevAccumSample.xyz, sampleColor.xyz, accumulationAlpha ) ) );
-				If( auxOn.and( hasPreviousAux ), () => {
+				if ( gBuffer ) If( auxOn.and( hasPreviousAux ), () => {
 
 					// Albedo averages cleanly (it's a colour); so does the normalized hit distance in .w.
 					const prevAlbedoSample = texture( prevAlbedoTexture, prevUV, 0 ).toVar();
@@ -253,7 +253,7 @@ export function buildFinalWriteKernel( params ) {
 
 			const uintCoord = uvec2( uint( gx ), uint( gy ) );
 			textureStore( writeColorTex, uintCoord, vec4( finalColor, outputAlpha ) ).toWriteOnly();
-			If( auxOn, () => {
+			if ( gBuffer ) If( auxOn, () => {
 
 				textureStore( writeNDTex, uintCoord, finalNormalDepth ).toWriteOnly();
 				textureStore( writeAlbedoTex, uintCoord, vec4( finalAlbedo, finalHitDist ) ).toWriteOnly();

package/src/TSL/GenerateKernel.js

@@ -13,7 +13,7 @@
 import {
 	Fn, float, vec2, vec3, vec4, int, uint,
 	If, instanceIndex, atomicLoad,
-	localId, workgroupId,
+	localId, workgroupId, dot, max, select,
 } from 'three/tsl';
 
 import {
@@ -28,7 +28,7 @@ import { RAY_FLAG, COUNTER } from '../Processor/QueueManager.js';
 import {
 	writeRayOriginMeta, writeRayDirFlags, writeRayThroughputPdf,
 	writeRayRadiance, writeGBuffer,
-	writeMediumStack, writeFeatureThroughput, writeRngState,
+	writeMediumStack, writeFeatureThroughput, writeRngState, writeRngMis,
 } from '../Processor/PackedRayBuffer.js';
 
 const WG_SIZE = 16;
@@ -45,8 +45,10 @@ export function buildGenerateKernel( params ) {
 		chunkRowBase, chunkRows, // row band offset (global first row) + row count for this chunk
 		transmissiveBounces, // per-ray refraction budget (megakernel parity: PathTracerCore.js:606)
 		auxGBufferEnabled, // live uniform: 1 = init the per-pixel G-buffer (denoiser on), 0 = skip it
+		gBuffer = true, // compiled in only when requested (PathTracer.requestOutput( 'gBuffer' ))
 		// listDriven: 1D dispatch over the active-pixel list (activeIndicesRO[tid] = LOCAL slot) instead of 2D.
 		listDriven = false, activeIndicesRO = null, counters = null,
+		bidirectional: bdpt = null,
 	} = params;
 
 	const auxOn = auxGBufferEnabled.greaterThan( uint( 0 ) );
@@ -89,7 +91,7 @@ export function buildGenerateKernel( params ) {
 		// tell subject from background. Output is unaffected: FinalWrite forces alpha 1 when transparent-bg is off.
 		writeRayRadiance( rayBufferRW, rayID, vec4( vec3( 0.0 ), float( 1.0 ) ) );
 
-		If( auxOn, () => {
+		if ( gBuffer ) If( auxOn, () => {
 
 			// default: normal +Z, depth 1 (far), black albedo (background/miss). Per-CHUNK G-buffer → LOCAL slot.
 			writeGBuffer( gBufferRW, rayID, vec3( 0.0, 0.0, 1.0 ), float( 1.0 ), vec3( 0.0 ), float( 0.0 ) );
@@ -100,7 +102,19 @@ export function buildGenerateKernel( params ) {
 
 		writeMediumStack( rayBufferRW, rayID, uint( 0 ), uint( transmissiveBounces ), float( 1.0 ), float( 1.0 ), float( 1.0 ) );
 
-		writeRngState( hitBufferRW, rayID, seed );
+		if ( bdpt ) {
+
+			// Georgiev (31): light tracing's N_L samples over this ray's density 1 / (A_pixel cos³θ).
+			const cosCamera = max( dot( ray.direction, bdpt.cameraForward ), 1e-4 );
+			const dVCM = select( bdpt.lightTrace.greaterThan( uint( 0 ) ),
+				bdpt.lib.mis( float( bdpt.lightPaths ).mul( bdpt.pixelArea ).mul( cosCamera ).mul( cosCamera ).mul( cosCamera ) ), float( 0.0 ) );
+			writeRngMis( hitBufferRW, rayID, seed, dVCM, float( 0.0 ) );
+
+		} else {
+
+			writeRngState( hitBufferRW, rayID, seed );
+
+		}
 
 	};
 

package/src/TSL/HitFacet.js

@@ -15,18 +15,20 @@ import {
 	packHalf2x16, unpackHalf2x16,
 } from 'three/tsl';
 import {
-	unpackTriangleNormal, triangleRow, instanceRows, instanceFaceNormalToWorld,
+	unpackTriangleNormal, triangleRow, instanceRows, instanceFaceNormalToWorld, instancePointToWorld,
 } from './Common.js';
 import { shadowTerminatorLift } from './ShadowTerminator.js';
 
 /**
- * @returns {{ faceN: Node, liftScale: Node }} the facet normal on the viewer's side (the
- *   interpolated one for a degenerate triangle), and the terminator lift (0 unless `liftEnabled`)
+ * @returns {{ faceN: Node, liftScale: Node, surfaceOffset: Node }} the facet normal on the viewer's side (the
+ *   interpolated one for a degenerate triangle), the terminator lift (0 unless `liftEnabled`), and how far along
+ *   faceN `hitPoint` lies from the triangle's plane (ExtendKernel moves the stored distance onto it)
  */
 export function hitFacet( { triangleBuffer, bvhBuffer, triIdx, instanceLeaf, hitPoint, smoothNormal, viewDir, didHit, liftEnabled } ) {
 
 	const faceN = vec3( 0.0, 0.0, 1.0 ).toVar();
 	const liftScale = float( 0.0 ).toVar();
+	const surfaceOffset = float( 0.0 ).toVar();
 
 	If( didHit, () => {
 
@@ -47,9 +49,18 @@ export function hitFacet( { triangleBuffer, bvhBuffer, triIdx, instanceLeaf, hit
 
 		} );
 
-		const n = select( dot( face, face ).greaterThan( 0.0 ), normalize( face ), smoothNormal ).toVar();
+		const degenerate = dot( face, face ).lessThanEqual( 0.0 ).toVar();
+		const n = select( degenerate, smoothNormal, normalize( face ) ).toVar();
 		faceN.assign( select( dot( n, viewDir ).lessThan( 0.0 ), n.negate(), n ) );
 
+		const corner = V0.toVar();
+		If( instanced, () => {
+
+			corner.assign( instancePointToWorld( instanceRows( bvhBuffer, instanceLeaf ), V0 ) );
+
+		} );
+		surfaceOffset.assign( select( degenerate, float( 0.0 ), dot( corner.sub( hitPoint ), faceN ) ) );
+
 		If( liftEnabled, () => {
 
 			liftScale.assign( shadowTerminatorLift( {
@@ -62,7 +73,26 @@ export function hitFacet( { triangleBuffer, bvhBuffer, triIdx, instanceLeaf, hit
 
 	} );
 
-	return { faceN, liftScale };
+	return { faceN, liftScale, surfaceOffset };
+
+}
+
+/**
+ * The triangle's unit winding normal in world space: what the traversal's front/back test sees (a mirrored
+ * placement keeps its object-space sense). The interpolated normal can face the other way near a coarse mesh's
+ * silhouette. Unit length because sideAccepts has a threshold: a raw cross product of a small triangle is under it.
+ */
+export function windingNormal( triangleBuffer, bvhBuffer, triIdx, instanceLeaf ) {
+
+	const V0 = uintBitsToFloat( triangleRow( triangleBuffer, triIdx, 0 ).xyz ).toVar();
+	const local = cross( uintBitsToFloat( triangleRow( triangleBuffer, triIdx, 1 ).xyz ).sub( V0 ), uintBitsToFloat( triangleRow( triangleBuffer, triIdx, 2 ).xyz ).sub( V0 ) ).toVar();
+	const n = local.toVar();
+	If( instanceLeaf.greaterThanEqual( int( 0 ) ), () => {
+
+		n.assign( instanceFaceNormalToWorld( instanceRows( bvhBuffer, instanceLeaf ), local ) );
+
+	} );
+	return normalize( n );
 
 }
 

package/src/TSL/LightBVHSampling.js

@@ -18,11 +18,14 @@ import {
 	normalize,
 	cross,
 	length,
+	abs,
 } from 'three/tsl';
 import { MIN_PDF } from './Common.js';
+import { sideAccepts } from './BVHTraversal.js';
 import { getRandomSample1D, getRandomSample2D } from './Random.js';
 import {
 	EmissiveSample,
+	EmissiveSampleIndexed,
 	sampleTriangle,
 	interpolateNormal,
 	fetchTriangleData,
@@ -103,7 +106,7 @@ export const lbvhNodeImportance = Fn( ( [ nMin, power, nMax, coneAxis, cosThetaO
  *
  * Returns an EmissiveSample struct.
  */
-export const sampleLightBVHTriangle = Fn( ( [
+const makeSampleLightBVHTriangle = ( indexed ) => Fn( ( [
 	hitPoint, surfaceNormal,
 	rngState,
 	pixelCoord, resolution, frame, dimBase,
@@ -111,9 +114,11 @@ export const sampleLightBVHTriangle = Fn( ( [
 	emissiveTriangleBuffer,
 	emissiveVec4Offset,
 	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 ),
@@ -123,7 +128,10 @@ export const sampleLightBVHTriangle = 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();
 
 	// Accumulated selection PDF (product of per-level choice probabilities)
 	const selectionPdf = float( 1.0 ).toVar();
@@ -279,9 +287,9 @@ export const sampleLightBVHTriangle = 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( float( 0.0 ) ).and( emissiveFacing.greaterThan( float( 0.0 ) ) ), () => {
+				If( surfaceFacing.greaterThan( float( 0.0 ) ).or( throughSurface ).and( sideAccepts( triData.side, dot( dir, geoNormal ) ) ), () => {
 
 					// Interpolate normal at sampled point via barycentric coords
 					const barycentricCoords = barycentricFromPoint( samplePos, triData.v0, triData.v1, triData.v2 );
@@ -305,6 +313,12 @@ export const sampleLightBVHTriangle = Fn( ( [
 					result.area.assign( area );
 					result.cosThetaLight.assign( emissiveFacing );
 					result.valid.assign( true );
+					if ( indexed ) {
+
+						result.triangleIndex.assign( triangleIndex );
+						result.faceNormal.assign( geoNormal );
+
+					}
 
 				} );
 
@@ -322,9 +336,11 @@ export const sampleLightBVHTriangle = 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( float( 0.0 ) ).and( emissiveFacing.greaterThan( float( 0.0 ) ) ), () => {
+			// Edge-on (a two-sided emitter passes its side test there) the density is infinite and the light zero.
+			If( surfaceFacing.greaterThan( float( 0.0 ) ).or( throughSurface ).and( sideAccepts( triData.side, dot( dir, geoNormal ) ) ).and( emissiveFacing.greaterThan( float( 0.0 ) ) ), () => {
 
 				// PDF: selectionPdf / area, converted to solid angle: pdfArea * distSq / cosLight
 				const pdfArea = selectionPdf.div( max( area, float( 1e-10 ) ) );
@@ -339,6 +355,12 @@ export const sampleLightBVHTriangle = Fn( ( [
 				result.area.assign( area );
 				result.cosThetaLight.assign( emissiveFacing );
 				result.valid.assign( true );
+				if ( indexed ) {
+
+					result.triangleIndex.assign( triangleIndex );
+					result.faceNormal.assign( geoNormal );
+
+				}
 
 			} );
 
@@ -350,6 +372,9 @@ export const sampleLightBVHTriangle = Fn( ( [
 
 } );
 
+export const sampleLightBVHTriangle = /*@__PURE__*/ makeSampleLightBVHTriangle( false );
+export const sampleLightBVHTriangleIndexed = /*@__PURE__*/ makeSampleLightBVHTriangle( true );
+
 // ================================================================================
 // LIGHT-BVH MIS PDF (re-walk)
 // ================================================================================
@@ -482,6 +507,12 @@ export const calculateLightBVHPdf = Fn( ( [
 
 			// Convert selection pdf → solid-angle measure using the SAME heuristic as the sampler.
 			const triData = TriangleData.wrap( fetchTriangleData( triIdx, triangleBuffer, bvhBuffer, targetInstance ) );
+			// The sampler draws only the sides the triangle emits from (a unit normal: sideAccepts has a threshold).
+			If( sideAccepts( triData.side, dot( rayDir, normalize( cross( triData.v1.sub( triData.v0 ), triData.v2.sub( triData.v0 ) ) ) ) ).not(), () => {
+
+				selectionPdf.assign( float( 0.0 ) );
+
+			} );
 			If( useSphericalSampling( triData.v0, triData.v1, triData.v2, shadingPoint ), () => {
 
 				const solidAngle = sphericalTriangleSolidAngle( triData.v0, triData.v1, triData.v2, shadingPoint );
@@ -490,7 +521,7 @@ export const calculateLightBVHPdf = Fn( ( [
 			} ).Else( () => {
 
 				const geoNormal = normalize( cross( triData.v1.sub( triData.v0 ), triData.v2.sub( triData.v0 ) ) );
-				const cosLight = max( dot( rayDir.negate(), geoNormal ), float( 0.001 ) );
+				const cosLight = max( abs( dot( rayDir, geoNormal ) ), float( 0.001 ) );
 				const area = triangleArea( triData.v0, triData.v1, triData.v2 );
 				const distSq = hitDistance.mul( hitDistance );
 				const pdfArea = selectionPdf.div( max( area, float( 1e-10 ) ) );
@@ -502,6 +533,6 @@ export const calculateLightBVHPdf = Fn( ( [
 
 	} );
 
-	return max( result, MIN_PDF );
+	return select( result.greaterThan( 0.0 ), max( result, MIN_PDF ), float( 0.0 ) );
 
 } );