rayzee 9.0.0 → 9.1.1

package/src/TSL/Common.js

@@ -329,8 +329,17 @@ export const getDatafromStorageBuffer = Fn( ( [ buffer, stride, sampleIndex, dat
 
 } );
 
-/** uvec4 lanes per triangle record — see TRIANGLE_DATA_LAYOUT. */
-export const TRI_STRIDE = 5;
+/**
+ * The five uvec4 rows of a triangle record (TRIANGLE_DATA_LAYOUT) live in two GPU buffers: rows
+ * 0–2, positions with their packed normals, in `tris.geo`; rows 3–4, UVs, flags and mesh index,
+ * in `tris.shade`. One buffer of 80 B a triangle hit the 4 GB storage-buffer limit at 53.6M.
+ */
+export const TRI_GEO_ROWS = 3;
+export const TRI_SHADE_ROWS = 2;
+
+export const triangleRow = ( tris, triIndex, row ) => row < TRI_GEO_ROWS
+	? getDatafromStorageBuffer( tris.geo, triIndex, int( row ), int( TRI_GEO_ROWS ) )
+	: getDatafromStorageBuffer( tris.shade, triIndex, int( row - TRI_GEO_ROWS ), int( TRI_SHADE_ROWS ) );
 
 // Unit normal to an octahedral snorm16 pair; GPU twin of packNormalOct in EngineDefaults.
 export const packNormalOct = /*@__PURE__*/ wgslFn( `

package/src/TSL/Displacement.js

@@ -1,7 +1,7 @@
 import { Fn, float, vec2, int, If, Loop, abs, normalize, dot, max, uintBitsToFloat } from 'three/tsl';
 
 import { struct } from './patches.js';
-import { getDatafromStorageBuffer, TRI_STRIDE, instanceRows, instanceDirToWorld } from './Common.js';
+import { triangleRow, instanceRows, instanceDirToWorld } from './Common.js';
 import { sampleDisplacementMap, bucketTexelSize, getLinearBucketTextures } from './TextureSampling.js';
 
 // Ray-displacement intersection configuration
@@ -42,12 +42,12 @@ export const refineDisplacedIntersection = Fn( ( [
 	// Fetch triangle vertex data
 	const triIdx = hitInfo.triangleIndex;
 
-	const pA = uintBitsToFloat( getDatafromStorageBuffer( triangleBuffer, triIdx, int( 0 ), int( TRI_STRIDE ) ).xyz ).toVar();
-	const pB = uintBitsToFloat( getDatafromStorageBuffer( triangleBuffer, triIdx, int( 1 ), int( TRI_STRIDE ) ).xyz );
-	const pC = uintBitsToFloat( getDatafromStorageBuffer( triangleBuffer, triIdx, int( 2 ), int( TRI_STRIDE ) ).xyz );
+	const pA = uintBitsToFloat( triangleRow( triangleBuffer, triIdx, 0 ).xyz ).toVar();
+	const pB = uintBitsToFloat( triangleRow( triangleBuffer, triIdx, 1 ).xyz );
+	const pC = uintBitsToFloat( triangleRow( triangleBuffer, triIdx, 2 ).xyz );
 
-	const uvData1 = uintBitsToFloat( getDatafromStorageBuffer( triangleBuffer, triIdx, int( 3 ), int( TRI_STRIDE ) ) ).toVar();
-	const uvData2 = uintBitsToFloat( getDatafromStorageBuffer( triangleBuffer, triIdx, int( 4 ), int( TRI_STRIDE ) ).xy );
+	const uvData1 = uintBitsToFloat( triangleRow( triangleBuffer, triIdx, 3 ) ).toVar();
+	const uvData2 = uintBitsToFloat( triangleRow( triangleBuffer, triIdx, 4 ).xy );
 
 	const uvA = uvData1.xy.toVar();
 	const uvB = uvData1.zw;

package/src/TSL/EmissiveSampling.js

@@ -30,7 +30,7 @@ import { struct } from './patches.js';
 import {
 	MIN_PDF, getDatafromStorageBuffer, powerHeuristic, MATERIAL_SLOTS, MATERIAL_SLOT,
 	computeDotProductsAniso, instanceRows, instanceNormalToWorld, instancePointToWorld,
-	unpackTriangleNormal, TRI_STRIDE, SHADOW_END
+	unpackTriangleNormal, triangleRow, SHADOW_END
 } from './Common.js';
 import { TRI_MATERIAL_MASK } from '../EngineDefaults.js';
 import { getRandomSample1D, getRandomSample2D } from './Random.js';
@@ -298,11 +298,11 @@ export const TriangleData = struct( {
 export const fetchTriangleData = Fn( ( [ triangleIndex, triangleBuffer, bvhBuffer, instanceLeaf ] ) => {
 
 	// Positions carry their packed normal in .w
-	const pos0 = getDatafromStorageBuffer( triangleBuffer, triangleIndex, int( 0 ), int( TRI_STRIDE ) ).toVar();
-	const pos1 = getDatafromStorageBuffer( triangleBuffer, triangleIndex, int( 1 ), int( TRI_STRIDE ) ).toVar();
-	const pos2 = getDatafromStorageBuffer( triangleBuffer, triangleIndex, int( 2 ), int( TRI_STRIDE ) ).toVar();
+	const pos0 = triangleRow( triangleBuffer, triangleIndex, 0 ).toVar();
+	const pos1 = triangleRow( triangleBuffer, triangleIndex, 1 ).toVar();
+	const pos2 = triangleRow( triangleBuffer, triangleIndex, 2 ).toVar();
 
-	const uvMat = getDatafromStorageBuffer( triangleBuffer, triangleIndex, int( 4 ), int( TRI_STRIDE ) );
+	const uvMat = triangleRow( triangleBuffer, triangleIndex, 4 );
 
 	const v0 = uintBitsToFloat( pos0.xyz ).toVar(), v1 = uintBitsToFloat( pos1.xyz ).toVar(), v2 = uintBitsToFloat( pos2.xyz ).toVar();
 	const n0 = unpackTriangleNormal( pos0.w ).toVar(), n1 = unpackTriangleNormal( pos1.w ).toVar(), n2 = unpackTriangleNormal( pos2.w ).toVar();

package/src/TSL/EnvironmentCDF.js

@@ -0,0 +1,176 @@
+import { Fn, float, int, uint, vec2, vec4, If, Loop, Return, instanceIndex, max, sin, dot, select } from 'three/tsl';
+
+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;
+
+// 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 ) {
+
+	const lo = int( 0 ).toVar();
+	const hi = int( n - 1 ).toVar();
+	Loop( { start: int( 0 ), end: int( Math.ceil( Math.log2( n ) ) + 1 ), type: 'int', condition: '<', name: 'step' }, () => {
+
+		If( lo.lessThan( hi ), () => {
+
+			const mid = lo.add( hi ).div( 2 ).toVar();
+			If( valueAt( mid ).lessThan( target ), () => {
+
+				lo.assign( mid.add( 1 ) );
+
+			} ).Else( () => {
+
+				hi.assign( mid );
+
+			} );
+
+		} );
+
+	} );
+	return lo;
+
+}
+
+// select(), never mix(): a + t·(b − a) is not b at t = 1, and the search compares a prefix sum
+// 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 ).
+ * @returns {Array} kernels, dispatched in order
+ */
+export function buildEnvironmentCDFKernels( { pixels, rows, prefix, stats, cdf, width, height } ) {
+
+	const stride = cdfRowStride( width );
+	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 ) ), () => {
+
+		Return();
+
+	} );
+
+	const rowTotals = Fn( () => {
+
+		const y = instanceIndex;
+		If( y.greaterThanEqual( uint( height ) ), () => {
+
+			Return();
+
+		} );
+
+		const sinT = sinTheta( y ).toVar();
+		const total = float( 0 ).toVar();
+		Loop( { start: int( 0 ), end: int( width ), type: 'int', condition: '<' }, ( { i } ) => {
+
+			total.addAssign( weight( y, uint( i ), sinT ) );
+
+		} );
+		rows.element( y ).assign( vec4( total, 0, 0, 0 ) );
+
+	} )().compute( height, [ 64 ] );
+
+	const mean = Fn( () => {
+
+		firstThreadOnly();
+		const total = float( 0 ).toVar();
+		Loop( { start: int( 0 ), end: int( height ), type: 'int', condition: '<' }, ( { i } ) => {
+
+			total.addAssign( rows.element( i ).x );
+
+		} );
+		stats.element( 0 ).assign( vec4( total, total.div( width * height ), 0, 0 ) );
+
+	} )().compute( 1, [ 1 ] );
+
+	const prefixSums = Fn( () => {
+
+		const y = instanceIndex;
+		If( y.greaterThanEqual( uint( height ) ), () => {
+
+			Return();
+
+		} );
+
+		const sinT = sinTheta( y ).toVar();
+		const delta = stats.element( 0 ).y.toVar();
+		const raw = float( 0 ).toVar();
+		const compensated = float( 0 ).toVar();
+		Loop( { start: int( 0 ), end: int( width ), type: 'int', condition: '<' }, ( { i } ) => {
+
+			const w = weight( y, uint( i ), sinT ).toVar();
+			raw.addAssign( w );
+			compensated.addAssign( max( w.sub( delta ), 0 ) );
+			prefix.element( y.mul( width ).add( uint( i ) ) ).assign( vec2( raw, compensated ) );
+
+		} );
+		rows.element( y ).assign( vec4( raw, compensated, 0, 0 ) );
+
+	} )().compute( height, [ 64 ] );
+
+	const marginal = Fn( () => {
+
+		firstThreadOnly();
+		const compensatedTotal = float( 0 ).toVar();
+		Loop( { start: int( 0 ), end: int( height ), type: 'int', condition: '<' }, ( { i } ) => {
+
+			compensatedTotal.addAssign( rows.element( i ).y );
+
+		} );
+		const useCompensated = compensatedTotal.greaterThan( 0 ).toVar();
+
+		const cumulative = float( 0 ).toVar();
+		Loop( { start: int( 0 ), end: int( height ), type: 'int', condition: '<' }, ( { i } ) => {
+
+			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 s = stats.element( 0 ).toVar();
+		stats.element( 1 ).assign( select( useCompensated, vec4( compensatedTotal, s.y, 1, 0 ), vec4( s.x, 0, 0, 0 ) ) );
+
+		Loop( { start: int( 0 ), end: int( height ), type: 'int', condition: '<', name: 'row' }, ( { row } ) => {
+
+			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 ) );
+
+		} );
+
+	} )().compute( 1, [ 1 ] );
+
+	const conditional = Fn( () => {
+
+		const idx = instanceIndex;
+		If( idx.greaterThanEqual( uint( width * 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 => {
+
+			const p = prefix.element( base.add( uint( j ) ) );
+			return select( useCompensated, p.y, p.x );
+
+		}, 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 ) );
+
+	} )().compute( width * height, [ 64 ] );
+
+	return [ rowTotals, mean, prefixSums, marginal, conditional ];
+
+}

package/src/TSL/GenerateKernel.js

@@ -28,7 +28,7 @@ import { RAY_FLAG, COUNTER } from '../Processor/QueueManager.js';
 import {
 	writeRayOriginMeta, writeRayDirFlags, writeRayThroughputPdf,
 	writeRayRadiance, writeGBuffer,
-	writeMediumStack, writeFeatureThroughput,
+	writeMediumStack, writeFeatureThroughput, writeRngState,
 } from '../Processor/PackedRayBuffer.js';
 
 const WG_SIZE = 16;
@@ -36,7 +36,7 @@ const WG_SIZE = 16;
 export function buildGenerateKernel( params ) {
 
 	const {
-		rayBufferRW, rngBufferRW, gBufferRW,
+		rayBufferRW, hitBufferRW, gBufferRW,
 		resolution, frame,
 		cameraWorldMatrix, cameraProjectionMatrixInverse,
 		cameraProjection, panoLonRange, panoLatRange, panoLevelHorizon,
@@ -104,7 +104,7 @@ export function buildGenerateKernel( params ) {
 
 		writeMediumStack( rayBufferRW, rayID, uint( 0 ), uint( transmissiveBounces ), float( 1.0 ), float( 1.0 ), float( 1.0 ) );
 
-		rngBufferRW.element( rayID ).assign( seed );
+		writeRngState( hitBufferRW, rayID, seed );
 
 	};
 

package/src/TSL/HitFacet.js

@@ -15,7 +15,7 @@ import {
 	packHalf2x16, unpackHalf2x16,
 } from 'three/tsl';
 import {
-	getDatafromStorageBuffer, unpackTriangleNormal, TRI_STRIDE, instanceRows, instanceFaceNormalToWorld,
+	unpackTriangleNormal, triangleRow, instanceRows, instanceFaceNormalToWorld,
 } from './Common.js';
 import { shadowTerminatorLift } from './ShadowTerminator.js';
 
@@ -30,9 +30,9 @@ export function hitFacet( { triangleBuffer, bvhBuffer, triIdx, instanceLeaf, hit
 
 	If( didHit, () => {
 
-		const recA = getDatafromStorageBuffer( triangleBuffer, triIdx, int( 0 ), int( TRI_STRIDE ) ).toVar();
-		const recB = getDatafromStorageBuffer( triangleBuffer, triIdx, int( 1 ), int( TRI_STRIDE ) ).toVar();
-		const recC = getDatafromStorageBuffer( triangleBuffer, triIdx, int( 2 ), int( TRI_STRIDE ) ).toVar();
+		const recA = triangleRow( triangleBuffer, triIdx, 0 ).toVar();
+		const recB = triangleRow( triangleBuffer, triIdx, 1 ).toVar();
+		const recC = triangleRow( triangleBuffer, triIdx, 2 ).toVar();
 		const V0 = uintBitsToFloat( recA.xyz ).toVar();
 		const V1 = uintBitsToFloat( recB.xyz ).toVar();
 		const V2 = uintBitsToFloat( recC.xyz ).toVar();

package/src/TSL/LightsDirect.js

@@ -27,8 +27,8 @@ import {
 
 import { Ray, ShadowMaterial, HitInfo } from './Struct.js';
 import {
-	REC709_LUMINANCE_COEFFICIENTS, getShadowMaterial, getDatafromStorageBuffer, instanceRows,
-	instanceFaceNormalToWorld, TRI_STRIDE, getAlphaShadowsUniform, shadowFlagsSettle, offsetRayOrigin,
+	REC709_LUMINANCE_COEFFICIENTS, getShadowMaterial, instanceRows,
+	instanceFaceNormalToWorld, triangleRow, getAlphaShadowsUniform, shadowFlagsSettle, offsetRayOrigin,
 } from './Common.js';
 import { fresnelDielectric } from './Fresnel.js';
 import { calculateBeerLawAbsorption } from './MaterialTransmission.js';
@@ -92,7 +92,7 @@ export const traceShadowRay = Fn( ( [
 		// Opaque fast-path: check the per-triangle blocker bit, set at extraction time when
 		// alphaMode/transparent/transmission/opacity all indicate a fully opaque surface.
 		// Short-circuits the 7-slot getShadowMaterial fetch and the whole alpha decision tree.
-		const flags = getDatafromStorageBuffer( triangleBuffer, shadowHit.triangleIndex, int( 4 ), int( TRI_STRIDE ) ).z;
+		const flags = triangleRow( triangleBuffer, shadowHit.triangleIndex, 4 ).z;
 		If( shadowFlagsSettle( flags ), () => {
 
 			transmittance.assign( 0.0 );
@@ -125,8 +125,8 @@ export const traceShadowRay = Fn( ( [
 					const baryU = shadowHit.uv.x;
 					const baryV = shadowHit.uv.y;
 					const baryW = float( 1.0 ).sub( baryU ).sub( baryV );
-					const uvData1 = uintBitsToFloat( getDatafromStorageBuffer( triangleBuffer, shadowHit.triangleIndex, int( 3 ), int( TRI_STRIDE ) ) );
-					const uvData2 = uintBitsToFloat( getDatafromStorageBuffer( triangleBuffer, shadowHit.triangleIndex, int( 4 ), int( TRI_STRIDE ) ).xy );
+					const uvData1 = uintBitsToFloat( triangleRow( triangleBuffer, shadowHit.triangleIndex, 3 ) );
+					const uvData2 = uintBitsToFloat( triangleRow( triangleBuffer, shadowHit.triangleIndex, 4 ).xy );
 					const hitUV = uvData1.xy.mul( baryW ).add( uvData1.zw.mul( baryU ) ).add( uvData2.mul( baryV ) );
 					const albedoUV = getTransformedUV( { uv: hitUV, transform: shadowMaterial.albedoTransform } );
 					texAlpha.assign( sampleBucket( _shadowAlbedoMaps, shadowMaterial.albedoMapIndex, albedoUV ).a );
@@ -181,9 +181,9 @@ export const traceShadowRay = Fn( ( [
 			// Deferred geometric-normal compute — refetch triangle positions and
 			// derive the normal here so opaque/alpha-cutout shadow hits don't pay
 			// the cross+normalize cost in BVH traversal.
-			const pA = uintBitsToFloat( getDatafromStorageBuffer( triangleBuffer, shadowHit.triangleIndex, int( 0 ), int( TRI_STRIDE ) ).xyz );
-			const pB = uintBitsToFloat( getDatafromStorageBuffer( triangleBuffer, shadowHit.triangleIndex, int( 1 ), int( TRI_STRIDE ) ).xyz );
-			const pC = uintBitsToFloat( getDatafromStorageBuffer( triangleBuffer, shadowHit.triangleIndex, int( 2 ), int( TRI_STRIDE ) ).xyz );
+			const pA = uintBitsToFloat( triangleRow( triangleBuffer, shadowHit.triangleIndex, 0 ).xyz );
+			const pB = uintBitsToFloat( triangleRow( triangleBuffer, shadowHit.triangleIndex, 1 ).xyz );
+			const pC = uintBitsToFloat( triangleRow( triangleBuffer, shadowHit.triangleIndex, 2 ).xyz );
 			// Positions are in the blocker's object space; the cross product is a normal, so
 			// it rides the inverse-transpose back out rather than the forward matrix.
 			const objNormal = normalize( cross( pB.sub( pA ), pC.sub( pA ) ) ).toVar();

package/src/TSL/LightsSampling.js

@@ -88,6 +88,7 @@ import {
 	sampleEquirectProbability,
 } from './Environment.js';
 import { shadowTerminatorOrigin } from './ShadowTerminator.js';
+import { sunRadianceToward, sampleSunDisc } from './Sun.js';
 
 const TWO_PI = 2.0 * PI;
 
@@ -798,6 +799,8 @@ export const calculateDirectLightingUnified = Fn( ( [
 	// The facet on the viewer's side, which shadow rays are offset off, and the shadow terminator lift
 	// (ShadowTerminator.js) for the light and environment ones
 	terminatorLift, facetNormal, terminatorCutoff,
+	// The physical sky's sun (Sun.js); its BSDF-sampled partner is the miss branch in ShadeKernel.
+	hasSun, sunDirection, sunRadiance, sunParams,
 ] ) => {
 
 	const totalContribution = vec3( 0.0 ).toVar();
@@ -987,55 +990,71 @@ export const calculateDirectLightingUnified = Fn( ( [
 
 	} );
 	// =====================================================================
-	// DETERMINISTIC ENVIRONMENT NEE
-	// Always runs (not stochastic) — forms a two-strategy Veach MIS
-	// estimator together with the implicit miss check in the main loop.
+	// DETERMINISTIC ENVIRONMENT NEE — the map, then the physical sky's sun, each MIS'd with its
+	// partner at the miss. One loop, so the shadow ray and BSDF evaluation are emitted once.
 	// =====================================================================
 
 	If( enableEnvironmentLight, () => {
 
-		const envRandom = getRandomSample2D( pixelCoord, int( 0 ), dimBase.add( int( 1 ) ), rngState, resolution, frame ).toVar();
-		const envColor = vec3( 0.0 ).toVar();
+		const passes = select( hasSun.greaterThan( int( 0 ) ), int( 2 ), int( 1 ) );
+		Loop( { start: int( 0 ), end: passes, type: 'int', condition: '<', name: 'envPass' }, ( { envPass } ) => {
 
-		// Sample direction + PDF + color from importance-sampled environment
-		const envSampleResult = sampleEquirectProbability(
-			envTexture, envCDFTexture,
-			envMatrix, environmentIntensity, envTotalSum, envCompensationDelta, envResolution, envRandom, envColor
-		).toVar();
+			const isSun = envPass.equal( int( 1 ) ).toVar();
+			const radiance = vec3( 0.0 ).toVar();
+			const direction = vec3( 0.0, 1.0, 0.0 ).toVar();
+			const lightPdf = float( 0.0 ).toVar();
 
-		const envDirection = envSampleResult.xyz.toVar();
-		const envPdf = envSampleResult.w.toVar();
+			If( isSun, () => {
 
-		If( envPdf.greaterThan( 0.0 ), () => {
+				const sunXi = getRandomSample2D( pixelCoord, int( 0 ), dimBase.add( int( 9 ) ), rngState, resolution, frame );
+				direction.assign( sampleSunDisc( sunDirection, sunParams, sunXi ) );
+				radiance.assign( sunRadianceToward( direction, sunDirection, sunRadiance, sunParams ).mul( environmentIntensity ) );
+				lightPdf.assign( select( radiance.x.add( radiance.y ).add( radiance.z ).greaterThan( 0.0 ), float( 1.0 ).div( sunParams.y ), float( 0.0 ) ) );
 
-			const NoL = max( float( 0.0 ), dot( hitNormal, envDirection ) ).toVar();
+			} ).Else( () => {
 
-			If( NoL.greaterThan( 0.0 ).and( isDirectionValid( { direction: envDirection, surfaceNormal: geomNormal } ) ), () => {
+				const envRandom = getRandomSample2D( pixelCoord, int( 0 ), dimBase.add( int( 1 ) ), rngState, resolution, frame ).toVar();
+				const envColor = vec3( 0.0 ).toVar();
+				const envSampleResult = sampleEquirectProbability(
+					envTexture, envCDFTexture,
+					envMatrix, environmentIntensity, envTotalSum, envCompensationDelta, envResolution, envRandom, envColor
+				).toVar();
+				direction.assign( envSampleResult.xyz );
+				radiance.assign( envColor );
+				lightPdf.assign( envSampleResult.w );
 
-				const visibility = shadow( lightShadowOrigin( envDirection ), envDirection, float( 1e20 ) );
+			} );
 
-				If( visibility.greaterThan( 0.0 ).or( wantUnoccluded ), () => {
+			If( lightPdf.greaterThan( 0.0 ), () => {
 
-					// Share H + dots between env BRDF/PDF — same redundancy fix as the
-					// discrete-light path above.
-					const envDots = DotProducts.wrap( computeDotProductsAniso( hitNormal, viewDir, envDirection, material ) );
-					const brdfValue = evaluateMaterialResponseFromDots( material, envDots );
-					const bPdf = calculateMaterialPDFFromDots( material, envDots ).toVar();
-
-					// Balance heuristic for env MIS — optimal for MIS-compensated PDFs (Karlík et al. 2019).
-					// The implicit path uses material combinedPdf as prevBouncePdf at the miss check.
-					const misW = select(
-						bPdf.greaterThan( 0.0 ),
-						balanceHeuristic( { pdf1: envPdf, pdf2: bPdf } ),
-						float( 1.0 )
-					).toVar();
-
-					// Base contribution WITHOUT visibility (deterministic estimator; no stochastic scaling).
-					const baseContribution = envColor.mul( brdfValue ).mul( NoL ).mul( misW ).div( max( envPdf, 1e-10 ) );
-					totalContribution.addAssign( baseContribution.mul( visibility ) );
-					If( wantUnoccluded, () => {
+				const NoL = max( float( 0.0 ), dot( hitNormal, direction ) ).toVar();
 
-						unoccludedContribution.addAssign( baseContribution );
+				If( NoL.greaterThan( 0.0 ).and( isDirectionValid( { direction, surfaceNormal: geomNormal } ) ), () => {
+
+					const visibility = shadow( lightShadowOrigin( direction ), direction, float( 1e20 ) );
+
+					If( visibility.greaterThan( 0.0 ).or( wantUnoccluded ), () => {
+
+						const envDots = DotProducts.wrap( computeDotProductsAniso( hitNormal, viewDir, direction, material ) );
+						const brdfValue = evaluateMaterialResponseFromDots( material, envDots );
+						const bPdf = calculateMaterialPDFFromDots( material, envDots ).toVar();
+
+						// The map pairs with the balance heuristic — optimal for its MIS-compensated pdf
+						// (Karlík et al. 2019); the sun, a small bright source, with the power heuristic.
+						const misW = select(
+							bPdf.greaterThan( 0.0 ),
+							select( isSun, powerHeuristic( { pdf1: lightPdf, pdf2: bPdf } ), balanceHeuristic( { pdf1: lightPdf, pdf2: bPdf } ) ),
+							float( 1.0 )
+						).toVar();
+
+						// Base contribution WITHOUT visibility (deterministic estimator; no stochastic scaling).
+						const baseContribution = radiance.mul( brdfValue ).mul( NoL ).mul( misW ).div( max( lightPdf, 1e-10 ) );
+						totalContribution.addAssign( baseContribution.mul( visibility ) );
+						If( wantUnoccluded, () => {
+
+							unoccludedContribution.addAssign( baseContribution );
+
+						} );
 
 					} );
 
@@ -1047,7 +1066,6 @@ export const calculateDirectLightingUnified = Fn( ( [
 
 	} );
 
-
 	// EMISSIVE TRIANGLE DIRECT LIGHTING
 	// NOTE: Emissive triangle sampling is handled separately in pathtracer_core.fs
 	// to bypass firefly suppression. Do not add it here to avoid double-counting.

package/src/TSL/Random.js

@@ -132,6 +132,7 @@ export const RandomPointInCircle = ( rngState ) => {
 //       +6  subsurface HG scatter dir    (ShadeKernel)
 //       +7  ground-catcher cosine BSDF   (ShadeKernel)
 //       +8  indirect-strategy direction  (LightsIndirect)
+//       +9  physical-sky sun disc        (LightsSampling)
 //   1D  +0  (free — was the {lights,BRDF} stochastic strategy pick)
 //       +1  emissive-triangle pick       (EmissiveSampling / LightBVHSampling)
 //       +2  BSDF lobe selection          (ShadeKernel)