rayzee 6.0.0 → 6.1.0

package/src/TSL/PathTracerCore.js

@@ -7,8 +7,7 @@
  * Contains:
  *  - getOrCreateMaterialClassification — cached material classification
  *  - generateSampledDirection          — BRDF direction sampling with multi-lobe CDF
- *  - estimatePathContribution          — path importance estimation
- *  - handleRussianRoulette             — adaptive path termination
+ *  - handleRussianRoulette             — adaptive path termination (inlines path importance)
  *  - sampleBackgroundLighting          — environment background sampling
  *  - regularizePathContribution        — firefly suppression
  *  - Trace                             — main path tracing loop
@@ -26,6 +25,7 @@ import {
 	max,
 	min,
 	exp,
+	log,
 	clamp,
 	mix,
 	dot,
@@ -57,6 +57,7 @@ import {
 	getMaterial,
 	powerHeuristic,
 	balanceHeuristic,
+	computeDotProducts,
 } from './Common.js';
 import {
 	DirectionSample,
@@ -68,10 +69,11 @@ import {
 	MaterialSamples,
 	RayTracingMaterial,
 	ImportanceSamplingInfo,
+	DotProducts,
 } from './Struct.js';
 import { RandomValue, getRandomSample } from './Random.js';
 import { traverseBVH } from './BVHTraversal.js';
-import { sampleEnvironment, sampleEquirect } from './Environment.js';
+import { sampleEnvironment, sampleEquirect, getGroundProjectedDirection } from './Environment.js';
 import { sampleAllMaterialTextures } from './TextureSampling.js';
 import { refineDisplacedIntersection, DisplacementResult } from './Displacement.js';
 import { handleMaterialTransparency, MaterialInteractionResult, sampleMicrofacetTransmission, MicrofacetTransmissionResult } from './MaterialTransmission.js';
@@ -82,7 +84,7 @@ import {
 	createMaterialCache,
 	getImportanceSamplingInfo,
 } from './MaterialProperties.js';
-import { evaluateMaterialResponse } from './MaterialEvaluation.js';
+import { evaluateMaterialResponse, evaluateMaterialResponseFromDots } from './MaterialEvaluation.js';
 import { dielectricF0 } from './Fresnel.js';
 import {
 	ImportanceSampleCosine,
@@ -90,7 +92,7 @@ import {
 	sampleGGXVNDF,
 } from './MaterialSampling.js';
 import { sampleClearcoat, ClearcoatResult } from './Clearcoat.js';
-import { calculateDirectLightingUnified, calculateMaterialPDF } from './LightsSampling.js';
+import { calculateDirectLightingUnified, calculateMaterialPDFFromDots } from './LightsSampling.js';
 import { calculateIndirectLighting } from './LightsIndirect.js';
 import { IndirectLightingResult } from './LightsCore.js';
 import { calculateEmissiveTriangleContribution, calculateEmissiveLightPdf, EmissiveSample } from './EmissiveSampling.js';
@@ -152,9 +154,11 @@ export const getOrCreateMaterialClassification = Fn( ( [
 // =============================================================================
 
 export const generateSampledDirection = Fn( ( [
-	V, N, material, materialIndex, xi, rngState,
-	// PathState cache fields
-	classificationCached, lastMaterialIndex, cachedClassification,
+	V, N, material, xi, rngState,
+	// Caller-resolved material classification (avoids redundant classifyMaterial —
+	// TSL Fn can't write back to caller variables, so the caller is responsible
+	// for keeping psCachedClassification current and passes it in here).
+	mc,
 	weightsComputed, cachedBrdfWeights,
 	materialCacheCached, cachedMaterialCache,
 ] ) => {
@@ -163,12 +167,6 @@ export const generateSampledDirection = Fn( ( [
 	const resultValue = vec3( 0.0 ).toVar();
 	const resultPdf = float( 0.0 ).toVar();
 
-	// Get material classification (cached or computed)
-	const mc = MaterialClassification.wrap( getOrCreateMaterialClassification(
-		material, materialIndex,
-		classificationCached, lastMaterialIndex, cachedClassification,
-	) ).toVar();
-
 	// Compute BRDF weights
 	const weights = cachedBrdfWeights.toVar();
 
@@ -291,8 +289,9 @@ export const generateSampledDirection = Fn( ( [
 	If( sampled.not(), () => {
 
 		const entering = dot( V, N ).greaterThan( 0.0 ).toVar();
+		// pathWavelength=0 — only direction/PDF are consumed here, throughput goes via handleTransmission
 		const mtResult = MicrofacetTransmissionResult.wrap( sampleMicrofacetTransmission(
-			V, N, material.ior, material.roughness, entering, material.dispersion, xi, rngState,
+			V, N, material.ior, material.roughness, entering, material.dispersion, xi, rngState, float( 0.0 ),
 		) );
 		resultDirection.assign( mtResult.direction );
 		resultPdf.assign( max( mtResult.pdf, MIN_PDF ) );
@@ -311,63 +310,6 @@ export const generateSampledDirection = Fn( ( [
 
 } );
 
-// =============================================================================
-// Path Contribution Estimation
-// =============================================================================
-
-export const estimatePathContribution = Fn( ( [
-	throughput, direction, material, materialIndex,
-	classificationCached, lastMaterialIndex, cachedClassification,
-	enableEnvironmentLight, useEnvMapIS,
-] ) => {
-
-	const throughputStrength = max( maxComponent( { v: throughput } ), 0.0 ).toVar();
-
-	// Use cached material classification
-	const mc = MaterialClassification.wrap( getOrCreateMaterialClassification(
-		material, materialIndex,
-		classificationCached, lastMaterialIndex, cachedClassification,
-	) ).toVar();
-
-	// Enhanced material importance with interaction bonuses
-	const materialImportance = mc.complexityScore.toVar();
-
-	// Interaction complexity bonuses
-	If( mc.isMetallic.and( mc.isSmooth ), () => {
-
-		materialImportance.addAssign( 0.15 );
-
-	} );
-	If( mc.isTransmissive.and( mc.hasClearcoat ), () => {
-
-		materialImportance.addAssign( 0.12 );
-
-	} );
-	If( mc.isEmissive, () => {
-
-		materialImportance.addAssign( 0.1 );
-
-	} );
-	materialImportance.assign( clamp( materialImportance, 0.0, 1.0 ) );
-
-	// Direction importance calculation
-	const directionImportance = float( 0.5 ).toVar();
-
-	If( enableEnvironmentLight.and( useEnvMapIS ).and( throughputStrength.greaterThan( 0.01 ) ), () => {
-
-		const cosTheta = clamp( direction.y, 0.0, 1.0 );
-		directionImportance.assign( mix( float( 0.3 ), float( 0.8 ), cosTheta.mul( cosTheta ) ) );
-
-	} );
-
-	// Enhanced weighting
-	const throughputWeight = smoothstep( float( 0.001 ), float( 0.1 ), throughputStrength );
-	return throughputStrength.mul(
-		mix( materialImportance.mul( 0.7 ), directionImportance, 0.3 ),
-	).mul( throughputWeight );
-
-} );
-
 // =============================================================================
 // Russian Roulette Path Termination
 // =============================================================================
@@ -375,7 +317,6 @@ export const estimatePathContribution = Fn( ( [
 export const handleRussianRoulette = Fn( ( [
 	depth, throughput, material, materialIndex, rayDirection, rngState,
 	classificationCached, lastMaterialIndex, cachedClassification,
-	weightsComputed, pathImportance,
 	enableEnvironmentLight, useEnvMapIS,
 ] ) => {
 
@@ -443,22 +384,37 @@ export const handleRussianRoulette = Fn( ( [
 
 			} ).Else( () => {
 
-				// Path importance — used across all depth ranges
-				const pathContribution = float( 0.0 ).toVar();
+				// Path contribution estimate — reuses throughputStrength + mc from outer scope.
+				const estMaterialImportance = mc.complexityScore.toVar();
+				If( mc.isMetallic.and( mc.isSmooth ), () => {
 
-				If( classificationCached.and( weightsComputed ), () => {
+					estMaterialImportance.addAssign( 0.15 );
 
-					pathContribution.assign( pathImportance );
+				} );
+				If( mc.isTransmissive.and( mc.hasClearcoat ), () => {
 
-				} ).Else( () => {
+					estMaterialImportance.addAssign( 0.12 );
 
-					pathContribution.assign( estimatePathContribution(
-						throughput, rayDirection, material, materialIndex,
-						classificationCached, lastMaterialIndex, cachedClassification,
-						enableEnvironmentLight, useEnvMapIS,
-					) );
+				} );
+				If( mc.isEmissive, () => {
+
+					estMaterialImportance.addAssign( 0.1 );
 
 				} );
+				estMaterialImportance.assign( clamp( estMaterialImportance, 0.0, 1.0 ) );
+
+				const directionImportance = float( 0.5 ).toVar();
+				If( enableEnvironmentLight.and( useEnvMapIS ).and( throughputStrength.greaterThan( 0.01 ) ), () => {
+
+					const cosTheta = clamp( rayDirection.y, 0.0, 1.0 );
+					directionImportance.assign( mix( float( 0.3 ), float( 0.8 ), cosTheta.mul( cosTheta ) ) );
+
+				} );
+
+				const throughputWeight = smoothstep( float( 0.001 ), float( 0.1 ), throughputStrength );
+				const pathContribution = throughputStrength.mul(
+					mix( estMaterialImportance.mul( 0.7 ), directionImportance, 0.3 ),
+				).mul( throughputWeight ).toVar();
 
 				// Smooth adaptive continuation probability (no discrete depth brackets)
 				// Early behavior: throughput + material driven, generous
@@ -515,9 +471,10 @@ export const handleRussianRoulette = Fn( ( [
 // =============================================================================
 
 export const sampleBackgroundLighting = Fn( ( [
-	isPrimaryRay, direction,
+	isPrimaryRay, rayOrigin, direction,
 	envTexture, envMatrix, environmentIntensity, enableEnvironmentLight,
 	showBackground, backgroundIntensity,
+	groundProjectionEnabled, groundProjectionRadius, groundProjectionHeight,
 ] ) => {
 
 	// Only hide background for primary camera rays when showBackground is false
@@ -530,8 +487,18 @@ export const sampleBackgroundLighting = Fn( ( [
 
 	} ).Else( () => {
 
+		// Primary-ray only: indirect bounces must see the raw envmap so shading stays physically correct.
+		const effectiveDir = direction.toVar();
+		If( isPrimaryRay.and( groundProjectionEnabled ), () => {
+
+			effectiveDir.assign( getGroundProjectedDirection(
+				rayOrigin, direction, groundProjectionRadius, groundProjectionHeight,
+			) );
+
+		} );
+
 		const sampled = sampleEnvironment( {
-			tex: envTexture, samp: sampler( envTexture ), direction, environmentMatrix: envMatrix, environmentIntensity, enableEnvironmentLight,
+			tex: envTexture, samp: sampler( envTexture ), direction: effectiveDir, environmentMatrix: envMatrix, environmentIntensity, enableEnvironmentLight,
 		} );
 
 		If( isPrimaryRay, () => {
@@ -566,7 +533,7 @@ export const regularizePathContribution = /*@__PURE__*/ wgslFn( `
 // =============================================================================
 
 export const Trace = Fn( ( [
-	ray, rngState, rayIndex, pixelIndex,
+	ray, rngState, rayIndex,
 	// BVH / Scene
 	bvhBuffer,
 	triangleBuffer,
@@ -585,11 +552,12 @@ export const Trace = Fn( ( [
 	envCDFBuffer,
 	envTotalSum, envCompensationDelta, envResolution,
 	enableEnvironmentLight, useEnvMapIS,
+	groundProjectionEnabled, groundProjectionRadius, groundProjectionHeight,
 	// Rendering parameters
 	maxBounceCount, transmissiveBounces,
 	backgroundIntensity, showBackground, transparentBackground,
 	fireflyThreshold, globalIlluminationIntensity,
-	totalTriangleCount, enableEmissiveTriangleSampling,
+	enableEmissiveTriangleSampling,
 	emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower, emissiveBoost,
 	lightBVHBuffer, lightBVHNodeCount,
 	// Per-pixel info
@@ -613,11 +581,29 @@ export const Trace = Fn( ( [
 	// behind glass), not the glass surface itself.
 	const auxLocked = tslBool( false ).toVar();
 
-	// Medium stack for transmission (per-slot IOR, slots 1-3 for nested media, depth 0 = air)
+	// Medium stack for transmission (slots 1-3 for nested media, depth 0 = air).
+	// Each slot tracks IOR plus KHR_materials_volume attenuation (color + distance)
+	// so per-bounce in-volume absorption uses the actual ray path length.
 	const mediumStackDepth = int( 0 ).toVar();
 	const mediumStack_ior_1 = float( 1.0 ).toVar();
 	const mediumStack_ior_2 = float( 1.0 ).toVar();
 	const mediumStack_ior_3 = float( 1.0 ).toVar();
+	const mediumStack_attColor_1 = vec3( 1.0 ).toVar();
+	const mediumStack_attColor_2 = vec3( 1.0 ).toVar();
+	const mediumStack_attColor_3 = vec3( 1.0 ).toVar();
+	const mediumStack_attDist_1 = float( 0.0 ).toVar();
+	const mediumStack_attDist_2 = float( 0.0 ).toVar();
+	const mediumStack_attDist_3 = float( 0.0 ).toVar();
+	// Precomputed Beer-Lambert absorption coefficient sigma_a = -log(attColor)/attDist.
+	// Stored at push time so per-bounce absorption inside a medium becomes a single
+	// exp(-sigma_a * thickness) instead of a log + div + exp every bounce.
+	const mediumStack_sigmaA_1 = vec3( 0.0 ).toVar();
+	const mediumStack_sigmaA_2 = vec3( 0.0 ).toVar();
+	const mediumStack_sigmaA_3 = vec3( 0.0 ).toVar();
+
+	// Locked at the first dispersive transmission; reused for subsequent transmissions on
+	// the path so multi-bounce dispersion doesn't collapse under repeated colorWeight ×.
+	const pathWavelength = float( 0.0 ).toVar();
 
 	// Render state
 	const stateTraversals = maxBounceCount.toVar();
@@ -630,8 +616,6 @@ export const Trace = Fn( ( [
 	const psWeightsComputed = tslBool( false ).toVar();
 	const psClassificationCached = tslBool( false ).toVar();
 	const psMaterialCacheCached = tslBool( false ).toVar();
-	const psTexturesLoaded = tslBool( false ).toVar();
-	const psPathImportance = float( 0.0 ).toVar();
 	const psLastMaterialIndex = int( - 1 ).toVar();
 
 	// Cached classification
@@ -688,16 +672,41 @@ export const Trace = Fn( ( [
 			currentRay,
 			bvhBuffer,
 			triangleBuffer,
-			materialBuffer,
 		) ).toVar();
 
+		// KHR_materials_volume: apply Beer's law over the actual distance the ray
+		// traveled inside the current medium. Top-of-stack holds the medium the ray
+		// is currently in — depth==0 means air (no absorption). sigma_a was
+		// precomputed at push time, so this collapses to a single exp().
+		If( hitInfo.didHit.and( mediumStackDepth.greaterThan( int( 0 ) ) ), () => {
+
+			const mSigmaA = vec3( 0.0 ).toVar();
+			If( mediumStackDepth.equal( int( 1 ) ), () => {
+
+				mSigmaA.assign( mediumStack_sigmaA_1 );
+
+			} ).ElseIf( mediumStackDepth.equal( int( 2 ) ), () => {
+
+				mSigmaA.assign( mediumStack_sigmaA_2 );
+
+			} ).ElseIf( mediumStackDepth.equal( int( 3 ) ), () => {
+
+				mSigmaA.assign( mediumStack_sigmaA_3 );
+
+			} );
+
+			throughput.mulAssign( exp( mSigmaA.mul( hitInfo.dst ).negate() ) );
+
+		} );
+
 		If( hitInfo.didHit.not(), () => {
 
 			// ENVIRONMENT LIGHTING
 			const envColor = sampleBackgroundLighting(
-				stateIsPrimaryRay, rayDirection,
+				stateIsPrimaryRay, rayOrigin, rayDirection,
 				envTexture, envMatrix, environmentIntensity, enableEnvironmentLight,
 				showBackground, backgroundIntensity,
+				groundProjectionEnabled, groundProjectionRadius, groundProjectionHeight,
 			);
 
 			// MIS weight for implicit environment hit — prevents double-counting with NEE.
@@ -799,10 +808,12 @@ export const Trace = Fn( ( [
 
 		// Handle transparent materials
 		const interaction = MaterialInteractionResult.wrap( handleMaterialTransparency(
-			currentRay, hitInfo.hitPoint, N, material, rngState,
+			currentRay, N, material, rngState,
 			stateTransmissiveTraversals,
 			currentMediumIOR, previousMediumIOR,
+			pathWavelength,
 		) ).toVar();
+		pathWavelength.assign( interaction.pathWavelength );
 
 		If( interaction.continueRay, () => {
 
@@ -819,22 +830,39 @@ export const Trace = Fn( ( [
 
 					If( interaction.entering, () => {
 
-						// Push new medium onto stack
+						// Push new medium onto stack (IOR + KHR_materials_volume attenuation)
 						If( mediumStackDepth.lessThan( int( 3 ) ), () => {
 
 							mediumStackDepth.addAssign( 1 );
 
+							// Precompute sigma_a = -log(attColor)/attDist once at push time.
+							// attDist==0 means "no absorption" — store sigma_a=0 so exp() returns 1.
+							const mSigmaA = select(
+								material.attenuationDistance.greaterThan( 0.0 ),
+								log( max( material.attenuationColor, vec3( 0.001 ) ) ).negate().div( material.attenuationDistance ),
+								vec3( 0.0 )
+							).toVar();
+
 							If( mediumStackDepth.equal( int( 1 ) ), () => {
 
 								mediumStack_ior_1.assign( material.ior );
+								mediumStack_attColor_1.assign( material.attenuationColor );
+								mediumStack_attDist_1.assign( material.attenuationDistance );
+								mediumStack_sigmaA_1.assign( mSigmaA );
 
 							} ).ElseIf( mediumStackDepth.equal( int( 2 ) ), () => {
 
 								mediumStack_ior_2.assign( material.ior );
+								mediumStack_attColor_2.assign( material.attenuationColor );
+								mediumStack_attDist_2.assign( material.attenuationDistance );
+								mediumStack_sigmaA_2.assign( mSigmaA );
 
 							} ).ElseIf( mediumStackDepth.equal( int( 3 ) ), () => {
 
 								mediumStack_ior_3.assign( material.ior );
+								mediumStack_attColor_3.assign( material.attenuationColor );
+								mediumStack_attDist_3.assign( material.attenuationDistance );
+								mediumStack_sigmaA_3.assign( mSigmaA );
 
 							} );
 
@@ -908,6 +936,19 @@ export const Trace = Fn( ( [
 		const V = rayDirection.negate().toVar();
 		material.sheenRoughness.assign( clamp( material.sheenRoughness, MIN_ROUGHNESS, MAX_ROUGHNESS ) );
 
+		// Sync material classification cache up front — the materialCache, BRDF
+		// sample, importance sampling, and Russian roulette all consume it.
+		// getOrCreateMaterialClassification is a cache hit when materialIndex
+		// matches the previous bounce; otherwise it runs classifyMaterial once.
+		// Doing this here eliminates a redundant classifyMaterial that previously
+		// fired after generateSampledDirection to "sync" the caller's variable.
+		psCachedClassification.assign( MaterialClassification.wrap( getOrCreateMaterialClassification(
+			material, hitInfo.materialIndex,
+			psClassificationCached, psLastMaterialIndex, psCachedClassification,
+		) ) );
+		psClassificationCached.assign( tslBool( true ) );
+		psLastMaterialIndex.assign( hitInfo.materialIndex );
+
 		// Create material cache if needed
 		If( psMaterialCacheCached.not(), () => {
 
@@ -933,9 +974,12 @@ export const Trace = Fn( ( [
 
 		} ).Else( () => {
 
+			// Classification was already synced at the top of the bounce — pass
+			// psCachedClassification directly so generateSampledDirection doesn't
+			// have to call classifyMaterial again internally.
 			const brdfSample = DirectionSample.wrap( generateSampledDirection(
-				V, N, material, hitInfo.materialIndex, randomSample, rngState,
-				psClassificationCached, psLastMaterialIndex, psCachedClassification,
+				V, N, material, randomSample, rngState,
+				psCachedClassification,
 				psWeightsComputed, psCachedBrdfWeights,
 				psMaterialCacheCached, psCachedMaterialCache,
 			) );
@@ -943,22 +987,6 @@ export const Trace = Fn( ( [
 			brdfValue.assign( brdfSample.value );
 			brdfPdf.assign( brdfSample.pdf );
 
-			// Sync psCachedClassification for downstream consumers (importance sampling, Russian roulette).
-			// generateSampledDirection computed the correct classification internally via materialIndex
-			// guard, but TSL Fn can't write back to the caller's variable — update it here.
-			If( psLastMaterialIndex.notEqual( hitInfo.materialIndex ).or( psClassificationCached.not() ), () => {
-
-				psCachedClassification.assign( classifyMaterial(
-					material.metalness, material.roughness,
-					material.transmission, material.clearcoat,
-					material.emissive,
-				) );
-
-			} );
-
-			// Update cache state after generateSampledDirection
-			psClassificationCached.assign( tslBool( true ) );
-			psLastMaterialIndex.assign( hitInfo.materialIndex );
 			psWeightsComputed.assign( tslBool( true ) );
 
 		} );
@@ -996,7 +1024,7 @@ export const Trace = Fn( ( [
 			hitInfo.hitPoint, N, material,
 			V,
 			brdfDir, brdfPdf, brdfValue,
-			rayIndex, bounceIndex, rngState,
+			bounceIndex, rngState,
 			directionalLightsBuffer, numDirectionalLights,
 			areaLightsBuffer, numAreaLights,
 			pointLightsBuffer, numPointLights,
@@ -1017,10 +1045,9 @@ export const Trace = Fn( ( [
 		// 2b. EMISSIVE TRIANGLE DIRECT LIGHTING
 		If( enableEmissiveTriangleSampling.equal( int( 1 ) ).and( emissiveTriangleCount.greaterThan( int( 0 ) ) ), () => {
 
-			// Wrapper binding BVH params (EmissiveSampling expects 4-param callback)
-			const traceShadowRayWrapped = Fn( ( [ origin, dir, maxDist, rs ] ) => {
+			const traceShadowRayWrapped = Fn( ( [ origin, dir, maxDist ] ) => {
 
-				return traceShadowRay( origin, dir, maxDist, rs, traverseBVHShadow, bvhBuffer, triangleBuffer, materialBuffer );
+				return traceShadowRay( origin, dir, maxDist, traverseBVHShadow, bvhBuffer, triangleBuffer, materialBuffer );
 
 			} );
 
@@ -1050,12 +1077,14 @@ export const Trace = Fn( ( [
 						const rayOffset = calculateRayOffset( hitInfo.hitPoint, N, material );
 						const rayOrigin = hitInfo.hitPoint.add( rayOffset );
 						const shadowDist = emissiveSample.distance.sub( 0.001 );
-						const visibility = traceShadowRayWrapped( rayOrigin, emissiveSample.direction, shadowDist, rngState );
+						const visibility = traceShadowRayWrapped( rayOrigin, emissiveSample.direction, shadowDist );
 
 						If( visibility.greaterThan( 0.0 ), () => {
 
-							const brdfValue = evaluateMaterialResponse( V, emissiveSample.direction, N, material );
-							const brdfPdf = calculateMaterialPDF( V, emissiveSample.direction, N, material );
+							// Share H + dot products between BRDF eval and PDF eval.
+							const emisDots = DotProducts.wrap( computeDotProducts( N, V, emissiveSample.direction ) );
+							const brdfValue = evaluateMaterialResponseFromDots( material, emisDots );
+							const brdfPdf = calculateMaterialPDFFromDots( material, emisDots );
 							const misWeight = select(
 								brdfPdf.greaterThan( 0.0 ),
 								powerHeuristic( { pdf1: emissiveSample.pdf, pdf2: brdfPdf } ),
@@ -1082,12 +1111,11 @@ export const Trace = Fn( ( [
 				// Fallback: flat CDF importance sampling
 				const emissiveLight = calculateEmissiveTriangleContribution(
 					hitInfo.hitPoint, N, V, material,
-					totalTriangleCount, bounceIndex, rngState,
+					bounceIndex, rngState,
 					emissiveBoost,
 					emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower,
 					triangleBuffer,
 					traceShadowRayWrapped,
-					evaluateMaterialResponse,
 					calculateRayOffset,
 				);
 
@@ -1099,34 +1127,19 @@ export const Trace = Fn( ( [
 
 		} );
 
-		// Get importance sampling info with caching
-		If( psWeightsComputed.not().or( bounceIndex.equal( int( 0 ) ) ), () => {
-
-			// Update classification first
-			psCachedClassification.assign( MaterialClassification.wrap( getOrCreateMaterialClassification(
-				material, hitInfo.materialIndex,
-				psClassificationCached, psLastMaterialIndex, psCachedClassification,
-			) ) );
-			psClassificationCached.assign( tslBool( true ) );
-			psLastMaterialIndex.assign( hitInfo.materialIndex );
-
-		} );
-
+		// Classification was already synced at the top of the bounce loop, so
+		// psCachedClassification is current here regardless of which BRDF sample
+		// path ran above.
 		const samplingInfo = ImportanceSamplingInfo.wrap( getImportanceSamplingInfo(
 			material, bounceIndex, psCachedClassification,
-			environmentIntensity, useEnvMapIS, enableEnvironmentLight,
 		) );
 
 		// 3. INDIRECT LIGHTING
 		const indirectResult = IndirectLightingResult.wrap( calculateIndirectLighting(
 			V, N, material,
 			brdfDir, brdfPdf, brdfValue,
-			rayIndex, bounceIndex,
 			rngState,
 			samplingInfo,
-			envTexture, environmentIntensity, envMatrix,
-			envTotalSum, envCompensationDelta, envResolution,
-			enableEnvironmentLight, useEnvMapIS,
 		) );
 		throughput.mulAssign( indirectResult.throughput );
 
@@ -1185,7 +1198,6 @@ export const Trace = Fn( ( [
 			bounceIndex, throughput, material, hitInfo.materialIndex,
 			rayDirection, rngState,
 			psClassificationCached, psLastMaterialIndex, psCachedClassification,
-			psWeightsComputed, psPathImportance,
 			enableEnvironmentLight, useEnvMapIS,
 		);
 		If( rrSurvivalProb.lessThanEqual( 0.0 ), () => {

package/src/TSL/Struct.js

@@ -127,7 +127,6 @@ export const ImportanceSamplingInfo = struct( {
 	specularImportance: 'float',
 	transmissionImportance: 'float',
 	clearcoatImportance: 'float',
-	envmapImportance: 'float',
 } );
 
 export const DotProducts = struct( {
@@ -138,6 +137,13 @@ export const DotProducts = struct( {
 	LoH: 'float', // Light • Half
 } );
 
+// Kulla-Conty DFG approximation outputs (computed once, consumed by both
+// the multiscatter compensation factor and the total directional albedo).
+export const DFGResult = struct( {
+	compensation: 'vec3', // 1 + F0 * (1/Ew - 1)
+	E_total: 'vec3', // clamp(E_ss * compensation, 0, 1)
+} );
+
 export const MaterialSamples = struct( {
 	albedo: 'vec4',
 	emissive: 'vec3',

package/src/TSL/TextureSampling.js

@@ -307,7 +307,7 @@ export const processBump = Fn( ( [ bumpMaps, currentNormal, material, uvCache ]
 
 } );
 
-export const processEmissive = Fn( ( [ emissiveMaps, material, albedoColor, uvCache ] ) => {
+export const processEmissive = Fn( ( [ emissiveMaps, material, uvCache ] ) => {
 
 	const emissionBase = material.emissive.mul( material.emissiveIntensity ).toVar();
 
@@ -361,7 +361,7 @@ export const sampleAllMaterialTextures = Fn( ( [
 		const currentNormal = processNormal( normalMaps, geometryNormal, material, uvCache ).toVar();
 		normal.assign( processBump( bumpMaps, currentNormal, material, uvCache ) );
 
-		emissive.assign( processEmissive( emissiveMaps, material, albedo, uvCache ) );
+		emissive.assign( processEmissive( emissiveMaps, material, uvCache ) );
 
 	} );
 

package/src/index.js

@@ -39,6 +39,8 @@ export {
 export { RenderSettings } from './RenderSettings.js';
 export { CameraManager } from './managers/CameraManager.js';
 export { LightManager } from './managers/LightManager.js';
+export { GoboManager } from './managers/GoboManager.js';
+export { IESManager } from './managers/IESManager.js';
 export { DenoisingManager } from './managers/DenoisingManager.js';
 export { OverlayManager } from './managers/OverlayManager.js';
 

package/src/managers/AnimationManager.js

@@ -27,7 +27,6 @@ export class AnimationManager extends EventDispatcher {
 		this._posBuffer = null; // Float32Array(triCount * 9) — reused each frame
 		this._tempVec = new Vector3();
 		this._skinnedCache = null; // per-mesh Float32Array for skinned vertex positions
-		this._totalTriangleCount = 0;
 		this._clipsCache = null;
 		this._savedTimeScale = 1;
 		this.onFinished = null; // callback when a non-looping clip ends
@@ -45,9 +44,8 @@ export class AnimationManager extends EventDispatcher {
 	 * @param {Object3D} mixerRoot - GLTF model root (for animation track name resolution)
 	 * @param {Mesh[]} meshes - SceneProcessor.meshes (extraction order)
 	 * @param {AnimationClip[]} animations - GLTF animation clips
-	 * @param {number} triangleCount - Total triangle count
 	 */
-	init( scene, mixerRoot, meshes, animations, triangleCount ) {
+	init( scene, mixerRoot, meshes, animations ) {
 
 		this.dispose();
 
@@ -56,7 +54,6 @@ export class AnimationManager extends EventDispatcher {
 		this._scene = scene;
 		this._mixerRoot = mixerRoot;
 		this._meshes = meshes;
-		this._totalTriangleCount = triangleCount;
 
 		// Try mixerRoot (GLTF model root) first for track resolution.
 		// Fall back to scene if no tracks bind successfully.
@@ -121,10 +118,10 @@ export class AnimationManager extends EventDispatcher {
 		}
 
 		// Allocate reusable output buffer
-		this._posBuffer = new Float32Array( triangleCount * 9 );
+		this._posBuffer = new Float32Array( offset * 9 );
 
 		const skinnedCount = meshes.filter( m => m.isSkinnedMesh ).length;
-		console.debug( `[AnimationManager] Init: ${animations.length} clips, ${meshes.length} meshes (${skinnedCount} skinned), ${triangleCount} triangles` );
+		console.debug( `[AnimationManager] Init: ${animations.length} clips, ${meshes.length} meshes (${skinnedCount} skinned), ${offset} triangles` );
 
 	}
 

package/src/managers/DenoisingManager.js

@@ -575,7 +575,7 @@ export class DenoisingManager extends EventDispatcher {
 	 */
 	setAdaptiveSamplingParams( params ) {
 
-		if ( params.min !== undefined ) this._stages.pathTracer?.setAdaptiveSamplingMin( params.min );
+		if ( params.min !== undefined ) this._stages.pathTracer?.setUniform( 'adaptiveSamplingMin', params.min );
 		if ( params.adaptiveSamplingMax !== undefined ) this._settings?.set( 'adaptiveSamplingMax', params.adaptiveSamplingMax );
 		this._stages.adaptiveSampling?.setAdaptiveSamplingParameters( params );