rayzee 9.4.2 → 9.5.0

package/src/TSL/Environment.js

@@ -1,6 +1,6 @@
-import { Fn, wgslFn, vec2, vec3, vec4, ivec2, float, int, If, texture, dot, sin, sqrt, floor, fract, min, max, mix, clamp } from 'three/tsl';
+import { Fn, wgslFn, vec2, vec3, ivec2, float, int, If, Loop, sin, sqrt, min, max, clamp, select } from 'three/tsl';
 
-import { REC709_LUMINANCE_COEFFICIENTS } from './Common.js';
+import { EXACT_TABLE_MAX_WIDTH, GUIDES_PER_ENTRY } from '../Processor/EnvironmentExactTable.js';
 
 // Convert direction to UV coordinates for equirectangular map
 // Exact implementation from three-gpu-pathtracer
@@ -28,125 +28,96 @@ export const equirectUvToDirection = /*@__PURE__*/ wgslFn( `
 	}
 ` );
 
-// Evaluate PDF for a given direction (for MIS)
-// Returns vec4(color.rgb, pdf) since TSL cannot use inout params
-// Uses MIS-compensated PDF (Karlík et al. 2019): max(0, lum - delta) / compensatedTotalSum
-export const sampleEquirect = Fn( ( [ environment, direction, environmentMatrix, envTotalSum, envCompensationDelta, envResolution ] ) => {
+// The table (EnvironmentExactTable.js packExactTable): texel ( x, y ) is row y's entry x — its running sum, the one
+// below it, and the guides of steps 2x and 2x + 1 — and texel ( w, y ) the rows' entry y likewise. Sizes as exactTableSize.
+const exactTable = ( cdfTexture, envResolution ) => {
 
-	const result = vec4( 0.0 ).toVar();
+	const W = int( envResolution.x );
+	const H = int( envResolution.y );
+	const k = max( W.add( int( EXACT_TABLE_MAX_WIDTH - 1 ) ).div( int( EXACT_TABLE_MAX_WIDTH ) ), int( 1 ) );
+	const w = W.add( k ).sub( int( 1 ) ).div( k ).toVar();
+	const h = H.add( k ).sub( int( 1 ) ).div( k ).toVar();
+	return { w, h, entry: ( x, y ) => cdfTexture.load( ivec2( x, y ) ) };
 
-	If( envTotalSum.equal( 0.0 ), () => {
+};
 
-		// Exclude black environments from MIS
-		result.assign( vec4( 0.0 ) );
+// The first of `count` entries whose running sum is above target: the guide of target's step names it at once unless
+// the step holds more than one entry boundary, or f32 rounding of target × steps picked the step beside it; then a
+// search from one entry below the guide to the guide two steps on. Returns the entry with its sum and the one below.
+const invert = ( count, entryAt, target ) => {
 
-	} ).Else( () => {
+	const steps = count.mul( int( GUIDES_PER_ENTRY ) ).toVar();
+	const step = clamp( int( target.mul( float( steps ) ) ), int( 0 ), steps.sub( int( 1 ) ) ).toVar();
+	const odd = step.bitAnd( int( 1 ) ).equal( int( 1 ) ).toVar();
+	const guides = entryAt( step.shiftRight( int( 1 ) ) ).toVar();
+	const index = int( select( odd, guides.w, guides.z ) ).toVar();
+	const e = entryAt( index ).toVar();
+	If( target.lessThan( e.y ).or( target.greaterThanEqual( e.x ).and( index.lessThan( count.sub( int( 1 ) ) ) ) ), () => {
 
-		const uv = equirectDirectionToUv( { direction, environmentMatrix } ).toVar();
-		const color = texture( environment, uv, 0 ).rgb.toVar();
+		const lo = max( index.sub( int( 1 ) ), int( 0 ) ).toVar();
+		const ahead = entryAt( step.shiftRight( int( 1 ) ).add( int( 1 ) ) );
+		const hi = select( step.add( int( 2 ) ).lessThan( steps ), int( select( odd, ahead.w, ahead.z ) ), count.sub( int( 1 ) ) ).toVar();
+		Loop( lo.lessThan( hi ), () => {
 
-		// sin(theta) matches the CDF's solid-angle weighting (lum * sinTheta)
-		const sinTheta = sin( uv.y.mul( Math.PI ) ).toVar();
-		const lum = dot( color, REC709_LUMINANCE_COEFFICIENTS );
-		const weightedLum = lum.mul( sinTheta );
-		// MIS Compensation: subtract delta to match the sharpened CDF
-		const compensatedWeight = max( float( 0.0 ), weightedLum.sub( envCompensationDelta ) );
-		const pdf = compensatedWeight.div( envTotalSum );
+			const mid = lo.add( hi ).div( 2 ).toVar();
+			If( entryAt( mid ).x.lessThanEqual( target ), () => {
 
-		// Inline equirectDirectionPdf using the uv + sinTheta already in scope —
-		// the helper would otherwise re-derive uv via atan2+acos and recompute sin.
-		const dirPdf = sinTheta.greaterThan( 0.0 ).select(
-			float( 1.0 ).div( float( 2.0 * Math.PI * Math.PI ).mul( sinTheta ) ),
-			float( 0.0 )
-		);
-		const finalPdf = float( envResolution.x ).mul( float( envResolution.y ) ).mul( pdf ).mul( dirPdf );
+				lo.assign( mid.add( 1 ) );
 
-		result.assign( vec4( color, finalPdf ) );
+			} ).Else( () => {
+
+				hi.assign( mid );
+
+			} );
+
+		} );
+		index.assign( lo );
+		e.assign( entryAt( lo ) );
 
 	} );
+	return { index, top: e.x, bottom: e.y };
 
-	return result;
+};
 
-} );
+// Cell density over uv, per steradian at v.
+const cellPdf = ( share, w, h, v ) => {
 
-// Sample environment map using importance sampling
-// Returns vec4(direction.xyz, pdf). Optionally writes sampled color to colorOutput.
-// Exact implementation from three-gpu-pathtracer
-export const sampleEquirectProbability = Fn( ( [
-	environment,
-	envCDFTexture,
-	environmentMatrix,
-	environmentIntensity,
-	envTotalSum,
-	envCompensationDelta,
-	envResolution,
-	r,
-	colorOutput
-] ) => {
-
-	// CDF texture layout: (W+1)×H R32F — conditional[cy*W+cx] at texel (cx,cy); marginal[cy] at column W.
-	const cdfMarginalCol = int( envResolution.x ).toVar();
-
-	// Sample marginal CDF for V coordinate (1D, linear interpolation)
-	const marginalSize = envResolution.y;
-	const mIdx = clamp( r.x.mul( marginalSize.sub( 1.0 ) ), 0.0, marginalSize.sub( 1.0 ) );
-	const mI0 = int( floor( mIdx ) );
-	const mI1 = min( mI0.add( 1 ), int( marginalSize ).sub( 1 ) );
-	const mFrac = fract( mIdx );
-	const v = mix(
-		envCDFTexture.load( ivec2( cdfMarginalCol, mI0 ) ).x,
-		envCDFTexture.load( ivec2( cdfMarginalCol, mI1 ) ).x,
-		mFrac,
-	).toVar();
-
-	// Sample conditional CDF for U coordinate (2D grid, bilinear interpolation)
-	const condW = envResolution.x;
-	const condH = envResolution.y;
-	const cxf = clamp( r.y.mul( condW.sub( 1.0 ) ), 0.0, condW.sub( 1.0 ) );
-	const cyf = clamp( v.mul( condH.sub( 1.0 ) ), 0.0, condH.sub( 1.0 ) );
-	const cx0 = int( floor( cxf ) );
-	const cy0 = int( floor( cyf ) );
-	const cx1 = min( cx0.add( 1 ), int( condW ).sub( 1 ) );
-	const cy1 = min( cy0.add( 1 ), int( condH ).sub( 1 ) );
-	const fx = fract( cxf );
-	const fy = fract( cyf );
-	const v00 = envCDFTexture.load( ivec2( cx0, cy0 ) ).x;
-	const v10 = envCDFTexture.load( ivec2( cx1, cy0 ) ).x;
-	const v01 = envCDFTexture.load( ivec2( cx0, cy1 ) ).x;
-	const v11 = envCDFTexture.load( ivec2( cx1, cy1 ) ).x;
-	const u = mix( mix( v00, v10, fx ), mix( v01, v11, fx ), fy ).toVar();
-
-	const uv = vec2( u, v ).toVar();
-
-	// Convert UV to direction
-	const direction = equirectUvToDirection( { uv, environmentMatrix } ).toVar();
-
-	// Sample color
-	const color = texture( environment, uv, 0 ).rgb.mul( environmentIntensity ).toVar();
-
-	// Write color to output parameter (avoids redundant CDF texture lookups)
-	colorOutput.assign( color );
-
-	// Calculate PDF — sin(theta) weighting + MIS Compensation (Karlík et al. 2019)
-	const sinTheta = sin( uv.y.mul( Math.PI ) ).toVar();
-	const lum = dot( color.div( environmentIntensity ), REC709_LUMINANCE_COEFFICIENTS );
-	const weightedLum = lum.mul( sinTheta );
-	const compensatedWeight = max( float( 0.0 ), weightedLum.sub( envCompensationDelta ) );
-	const pdf = compensatedWeight.div( envTotalSum );
-
-	// Inline equirectDirectionPdf — uv + sinTheta are already in scope, so we
-	// skip the helper's redundant uv-from-direction + sin recompute.
-	const dirPdf = sinTheta.greaterThan( 0.0 ).select(
-		float( 1.0 ).div( float( 2.0 * Math.PI * Math.PI ).mul( sinTheta ) ),
-		float( 0.0 )
-	);
-	const finalPdf = float( envResolution.x ).mul( float( envResolution.y ) ).mul( pdf ).mul( dirPdf );
-
-	return vec4( direction, finalPdf );
+	const sinTheta = sin( v.mul( Math.PI ) );
+	return select( sinTheta.greaterThan( 0.0 ).and( share.greaterThan( 0.0 ) ),
+		share.mul( float( w ) ).mul( float( h ) ).div( max( sinTheta.mul( 2 * Math.PI * Math.PI ), 1e-30 ) ), float( 0.0 ) );
 
-} );
+};
+
+/** A direction drawn exactly from the table, and its density per steradian. */
+export function sampleEnvironmentExact( cdfTexture, environmentMatrix, envResolution, xi ) {
+
+	const { w, h, entry } = exactTable( cdfTexture, envResolution );
+	const row = invert( h, ( i ) => entry( w, i ), xi.y );
+	const y = row.index.toVar();
+	const cell = invert( w, ( i ) => entry( i, y ), xi.x );
+	const pRow = row.top.sub( row.bottom ).toVar();
+	const pCell = cell.top.sub( cell.bottom ).toVar();
+
+	const fv = clamp( xi.y.sub( row.bottom ).div( max( pRow, 1e-30 ) ), 0.0, 0.99999994 );
+	const fu = clamp( xi.x.sub( cell.bottom ).div( max( pCell, 1e-30 ) ), 0.0, 0.99999994 );
+	const uv = vec2( float( cell.index ).add( fu ).div( float( w ) ), float( y ).add( fv ).div( float( h ) ) ).toVar();
+
+	return { direction: equirectUvToDirection( { uv, environmentMatrix } ), pdf: cellPdf( pRow.mul( pCell ), w, h, uv.y ) };
+
+}
+
+/** sampleEnvironmentExact's density per steradian for `direction`. */
+export function environmentPdfExact( cdfTexture, environmentMatrix, envResolution, direction ) {
+
+	const { w, h, entry } = exactTable( cdfTexture, envResolution );
+	const uv = equirectDirectionToUv( { direction, environmentMatrix } ).toVar();
+	const x = clamp( int( uv.x.mul( float( w ) ) ), int( 0 ), w.sub( int( 1 ) ) ).toVar();
+	const y = clamp( int( uv.y.mul( float( h ) ) ), int( 0 ), h.sub( int( 1 ) ) ).toVar();
+	const rowEntry = entry( w, y ).toVar();
+	const cellEntry = entry( x, y ).toVar();
+	return cellPdf( rowEntry.x.sub( rowEntry.y ).mul( cellEntry.x.sub( cellEntry.y ) ), w, h, uv.y );
 
-// Note: powerHeuristic() is defined in Common.js
+}
 
 // Simple environment lookup (no importance sampling) — native WGSL
 export const sampleEnvironment = /*@__PURE__*/ wgslFn( `

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