rayzee 6.0.1 → 6.2.0

package/src/TSL/MaterialProperties.js

@@ -1,16 +1,16 @@
-import { Fn, float, vec3, vec4, int, If, dot, max, min, sqrt, cos, exp, mix, clamp, smoothstep } from 'three/tsl';
+import { Fn, float, vec3, int, If, dot, max, min, sqrt, cos, exp, mix, clamp, smoothstep } from 'three/tsl';
 
 import {
 	BRDFWeights,
-	MaterialClassification,
 	MaterialCache,
 	ImportanceSamplingInfo,
+	DFGResult,
 
 } from './Struct.js';
 
 import {
-	PI, TWO_PI, EPSILON, MIN_ROUGHNESS, REC709_LUMINANCE_COEFFICIENTS,
-	XYZ_TO_REC709, square, squareVec3, maxComponent,
+	PI, TWO_PI, EPSILON, MIN_ROUGHNESS,
+	XYZ_TO_REC709, square,
 } from './Common.js';
 
 import {
@@ -68,10 +68,14 @@ export const GeometrySmith = Fn( ( [ NoV, NoL, roughness ] ) => {
 // multiplicative factor for the specular BRDF that compensates for this loss.
 // Based on: Kulla & Conty 2017 + Karis 2014 analytical DFG approximation.
 
-export const multiscatterCompensation = Fn( ( [ F0, NoV, roughness ] ) => {
+// Single Karis DFG evaluation that returns both outputs the BRDF needs:
+//   compensation — multiscatter energy compensation factor for the specular lobe
+//   E_total      — total specular directional albedo (single-scatter × compensation)
+// Both share the same dfgScale/dfgBias/Ew polynomial, so computing them together
+// halves the polynomial work versus calling two separate functions.
+export const evaluateDFG = Fn( ( [ F0, NoV, roughness ] ) => {
 
 	// Analytical DFG approximation (Karis 2014)
-	// Computes scale and bias where E(F0) = F0 * scale + bias
 	const r0 = float( 1.0 ).sub( roughness );
 	const r1 = roughness.mul( - 0.0275 ).add( 0.0425 );
 	const r2 = roughness.mul( - 0.572 ).add( 1.04 );
@@ -87,35 +91,13 @@ export const multiscatterCompensation = Fn( ( [ F0, NoV, roughness ] ) => {
 	const Ew = max( dfgScale.add( dfgBias ), 0.1 );
 
 	// Energy compensation: 1 + F0 * (1/Ew - 1)
-	// At F0=1 (metals): fully compensates to 1/Ew
-	// At F0=0.04 (dielectrics): negligible correction
-	return vec3( 1.0 ).add( F0.mul( float( 1.0 ).div( Ew ).sub( 1.0 ) ) );
-
-} );
-
-// Compute the total specular directional albedo including multiscatter compensation.
-// Returns per-channel fraction of energy captured by specular reflection,
-// used for energy-conserving diffuse weight: kD = (1 - E_total) * (1 - metalness).
-export const specularDirectionalAlbedo = Fn( ( [ F0, NoV, roughness ] ) => {
-
-	// Analytical DFG approximation (same as multiscatterCompensation)
-	const r0 = float( 1.0 ).sub( roughness );
-	const r1 = roughness.mul( - 0.0275 ).add( 0.0425 );
-	const r2 = roughness.mul( - 0.572 ).add( 1.04 );
-	const r3 = roughness.mul( 0.022 ).sub( 0.04 );
-	const a004 = min( r0.mul( r0 ), exp( float( - 6.4308 ).mul( NoV ) ) ).mul( r0 ).add( r1 );
-	const dfgScale = float( - 1.04 ).mul( a004 ).add( r2 );
-	const dfgBias = float( 1.04 ).mul( a004 ).add( r3 );
+	const compensation = vec3( 1.0 ).add( F0.mul( float( 1.0 ).div( Ew ).sub( 1.0 ) ) );
 
-	// Single-scatter directional albedo per channel: E_ss = F0 * scale + bias
+	// Single-scatter directional albedo per channel, then total with compensation
 	const E_ss = max( F0.mul( dfgScale ).add( vec3( dfgBias ) ), vec3( 0.0 ) );
+	const E_total = clamp( E_ss.mul( compensation ), vec3( 0.0 ), vec3( 1.0 ) );
 
-	// Directional albedo at F0=1 (white furnace test)
-	const Ew = max( dfgScale.add( dfgBias ), 0.1 );
-
-	// Apply multiscatter compensation to get total specular albedo
-	const compensation = vec3( 1.0 ).add( F0.mul( float( 1.0 ).div( Ew ).sub( 1.0 ) ) );
-	return clamp( E_ss.mul( compensation ), vec3( 0.0 ), vec3( 1.0 ) );
+	return DFGResult( { compensation, E_total } );
 
 } );
 
@@ -329,7 +311,6 @@ export const calculateBRDFWeights = Fn( ( [ material, mc, cache ] ) => {
 
 export const getImportanceSamplingInfo = Fn( ( [
 	material, bounceIndex, mc,
-	environmentIntensity, useEnvMapIS, enableEnvironmentLight
 ] ) => {
 
 	// Base BRDF weights using temporary cache
@@ -418,7 +399,6 @@ export const getImportanceSamplingInfo = Fn( ( [
 		specularImportance,
 		transmissionImportance,
 		clearcoatImportance,
-		envmapImportance: float( 0.0 ),
 	} );
 
 } );

package/src/TSL/MaterialTransmission.js

@@ -6,30 +6,25 @@ import {
 	wgslFn,
 	vec2,
 	vec3,
-	vec4,
 	float,
 	int,
 	bool as tslBool,
-	uint,
 	If,
-	Loop,
 	select,
 	abs,
 	dot,
 	reflect,
 	refract,
 	max,
-	min,
 	mix,
 	clamp,
 	exp,
 } from 'three/tsl';
 
 import { struct } from './patches.js';
-import { Ray, RayTracingMaterial, RenderState, HitInfo, DotProducts, DirectionSample } from './Struct.js';
-import { PI, EPSILON, MIN_ROUGHNESS, MIN_CLEARCOAT_ROUGHNESS, computeDotProducts } from './Common.js';
+import { EPSILON, MIN_ROUGHNESS, MIN_PDF } from './Common.js';
 import { iorToFresnel0, fresnelSchlickFloat } from './Fresnel.js';
-import { DistributionGGX, calculateGGXPDF } from './MaterialProperties.js';
+import { DistributionGGX } from './MaterialProperties.js';
 import { ImportanceSampleGGX } from './MaterialSampling.js';
 import { RandomValue, pcgHash } from './Random.js';
 
@@ -78,9 +73,6 @@ export const MicrofacetTransmissionResult = struct( {
 	pathWavelength: 'float', // 0 if path is not yet spectral, else locked wavelength in nm
 } );
 
-// Maximum number of nested media
-const MAX_MEDIA_STACK = 4;
-
 // MediumStack as a struct with fixed-size slots
 export const MediumStack = struct( {
 	m0_ior: 'float',
@@ -305,8 +297,14 @@ export const sampleMicrofacetTransmission = Fn( ( [
 
 		} );
 
-		// Compute refracted direction using the sampled half-vector
-		const HoV = clamp( dot( H, V ), 0.001, 1.0 );
+		// Compute refracted direction using the sampled half-vector. HoV and NoH
+		// are needed by both the TIR and the transmission PDF branches below, so
+		// hoist them once here (VoH == HoV — same dot product). DistributionGGX D
+		// is also identical between the two branches (calculateGGXPDF builds the
+		// same D internally for the TIR branch), so share it too.
+		const HoV = clamp( dot( H, V ), 0.001, 1.0 ).toVar();
+		const NoH = clamp( dot( N, H ), 0.001, 1.0 ).toVar();
+		const D = DistributionGGX( NoH, transmissionRoughness ).toVar();
 		const refractDir = refract( V.negate(), H, etaRatio ).toVar();
 
 		// Check for total internal reflection
@@ -316,10 +314,8 @@ export const sampleMicrofacetTransmission = Fn( ( [
 			result.direction.assign( reflect( V.negate(), H ) );
 			result.didReflect.assign( true );
 
-			// Calculate PDF for reflection (standard GGX sampling)
-			const NoH = clamp( dot( N, H ), 0.001, 1.0 );
-			const VoH = clamp( dot( V, H ), 0.001, 1.0 );
-			result.pdf.assign( calculateGGXPDF( NoH, VoH, transmissionRoughness ) );
+			// Reflection PDF: D(H) * NoH / (4 * VoH) — reuses the hoisted D + dots.
+			result.pdf.assign( D.mul( NoH ).div( max( float( 4.0 ).mul( HoV ), MIN_PDF ) ) );
 
 		} ).Else( () => {
 
@@ -327,10 +323,7 @@ export const sampleMicrofacetTransmission = Fn( ( [
 			result.direction.assign( refractDir );
 			result.didReflect.assign( false );
 
-			// Calculate proper PDF for microfacet transmission
-			const NoH = clamp( dot( N, H ), 0.001, 1.0 );
 			const HoL = clamp( dot( H, refractDir ), 0.001, 1.0 );
-			const D = DistributionGGX( NoH, transmissionRoughness );
 
 			// Account for change of measure due to refraction (Jacobian)
 			const sqrtDenom = HoV.add( etaRatio.mul( HoL ) );
@@ -472,12 +465,9 @@ export const handleTransmission = Fn( ( [
 			// due to solid angle compression/expansion (cancels for round-trip enter+exit paths)
 			result.throughput.mulAssign( n1.mul( n1 ).div( max( n2.mul( n2 ), EPSILON ) ) );
 
-			// Apply Beer's law absorption when entering medium
-			If( entering.and( material.attenuationDistance.greaterThan( 0.0 ) ), () => {
-
-				result.throughput.mulAssign( calculateBeerLawAbsorption( { attenuationColor: material.attenuationColor, attenuationDistance: material.attenuationDistance, thickness: material.thickness } ) );
-
-			} );
+			// KHR_materials_volume absorption is applied per-bounce in PathTracerCore based
+			// on the actual ray path length inside the medium (driven by the medium stack).
+			// No entry-point thickness approximation here — that would double-count.
 
 			// Fresnel transmission factor with PDF compensation
 			result.throughput.mulAssign( float( 1.0 ).sub( Fr ).div( max( float( 1.0 ).sub( reflectProb ), 0.05 ) ) );
@@ -495,7 +485,7 @@ export const handleTransmission = Fn( ( [
 // ================================================================================
 
 export const handleMaterialTransparency = Fn( ( [
-	ray, hitPoint, normal, material, rngState,
+	ray, normal, material, rngState,
 	transmissiveTraversals,
 	currentMediumIOR, previousMediumIOR,
 	pathWavelength,
@@ -513,19 +503,13 @@ export const handleMaterialTransparency = Fn( ( [
 		pathWavelength: pathWavelength,
 	} ).toVar();
 
-	// -----------------------------------------------------------------
-	// Step 1: Fast path for completely opaque materials
-	// -----------------------------------------------------------------
-	// Quick early exit for fully opaque materials (most common case)
+	// Fast path for fully opaque materials (most common case)
 	If( material.alphaMode.equal( int( 0 ) ).and( material.transmission.lessThanEqual( 0.0 ) ), () => {
 
-		// Return default (no interaction needed)
+		// no interaction needed
 
 	} ).Else( () => {
 
-		// -----------------------------------------------------------------
-		// Step 2: Handle alpha modes according to glTF spec
-		// -----------------------------------------------------------------
 		const alphaRand = RandomValue( rngState );
 		const transmissionRand = RandomValue( rngState );
 		const transmissionSeed = pcgHash( { state: rngState } );
@@ -577,9 +561,6 @@ export const handleMaterialTransparency = Fn( ( [
 
 		} );
 
-		// -----------------------------------------------------------------
-		// Step 3: Handle transmission if present
-		// -----------------------------------------------------------------
 		If( handled.not().and( material.transmission.greaterThan( 0.0 ) ).and( transmissiveTraversals.greaterThan( int( 0 ) ) ), () => {
 
 			// Only apply transmission with probability equal to the transmission value

package/src/TSL/PathTracer.js

@@ -74,6 +74,16 @@ export const computeNDCDepth = /*@__PURE__*/ wgslFn( `
 	}
 ` );
 
+// NaN/Inf detector for debug mode 11. x != x catches NaN; the abs threshold catches Inf.
+const nanInfToRed = /*@__PURE__*/ wgslFn( `
+	fn nanInfToRed( c: vec3f ) -> vec3f {
+		let isNan = c.x != c.x || c.y != c.y || c.z != c.z;
+		let isInf = abs( c.x ) > 1e30f || abs( c.y ) > 1e30f || abs( c.z ) > 1e30f;
+		if ( isNan || isInf ) { return vec3f( 1.0f, 0.0f, 0.0f ); }
+		return vec3f( 0.0f );
+	}
+` );
+
 // Get required samples from adaptive sampling texture
 export const getRequiredSamples = Fn( ( [
 	pixelCoord, resolution,
@@ -140,10 +150,11 @@ export const pathTracerMain = ( params ) => {
 		envCDFBuffer,
 		envTotalSum, envCompensationDelta, envResolution,
 		enableEnvironmentLight, useEnvMapIS,
+		groundProjectionEnabled, groundProjectionRadius, groundProjectionHeight,
 		maxBounceCount, transmissiveBounces,
 		showBackground, transparentBackground, backgroundIntensity,
 		fireflyThreshold, globalIlluminationIntensity,
-		totalTriangleCount, enableEmissiveTriangleSampling,
+		enableEmissiveTriangleSampling,
 		emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower, emissiveBoost,
 		lightBVHBuffer, lightBVHNodeCount,
 		debugVisScale,
@@ -170,7 +181,6 @@ export const pathTracerMain = ( params ) => {
 	const pixelSamples = int( 0 ).toVar();
 
 	const baseSeed = getDecorrelatedSeed( { pixelCoord, rayIndex: int( 0 ), frame } ).toVar();
-	const pixelIndex = int( pixelCoord.y ).mul( int( resolution.x ) ).add( int( pixelCoord.x ) ).toVar();
 
 	// MRT data
 	const worldNormal = vec3( 0.0, 0.0, 1.0 ).toVar();
@@ -251,8 +261,8 @@ export const pathTracerMain = ( params ) => {
 
 		const sampleColor = vec4( 0.0 ).toVar();
 
-		// Debug or normal trace
-		If( visMode.greaterThan( int( 0 ) ), () => {
+		// Debug or normal trace (mode 11 runs the full path tracer so we can sniff NaN at the end)
+		If( visMode.greaterThan( int( 0 ) ).and( visMode.notEqual( int( 11 ) ) ), () => {
 
 			sampleColor.assign( TraceDebugMode(
 				ray.origin, ray.direction,
@@ -272,7 +282,7 @@ export const pathTracerMain = ( params ) => {
 
 			// Normal path tracing
 			const traceResult = TraceResult.wrap( Trace(
-				ray, seed, rayIndex, pixelIndex,
+				ray, seed, rayIndex,
 				bvhBuffer,
 				triangleBuffer,
 				materialBuffer,
@@ -287,10 +297,11 @@ export const pathTracerMain = ( params ) => {
 				envCDFBuffer,
 				envTotalSum, envCompensationDelta, envResolution,
 				enableEnvironmentLight, useEnvMapIS,
+				groundProjectionEnabled, groundProjectionRadius, groundProjectionHeight,
 				maxBounceCount, transmissiveBounces,
 				backgroundIntensity, showBackground, transparentBackground,
 				fireflyThreshold, globalIlluminationIntensity,
-				totalTriangleCount, enableEmissiveTriangleSampling,
+				enableEmissiveTriangleSampling,
 				emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower, emissiveBoost,
 				lightBVHBuffer, lightBVHNodeCount,
 				pixelCoord, resolution, frame,
@@ -343,7 +354,7 @@ export const pathTracerMain = ( params ) => {
 	// Output alpha: accumulated per-sample alpha when transparent, otherwise 1.0
 	const outputAlpha = select( transparentBackground, pixelAlpha, float( 1.0 ) ).toVar();
 
-	If( enableAccumulation.and( cameraIsMoving.not() ).and( frame.greaterThan( uint( 0 ) ) ).and( hasPreviousAccumulated ), () => {
+	If( enableAccumulation.and( cameraIsMoving.not() ).and( frame.greaterThan( uint( 0 ) ) ).and( hasPreviousAccumulated ).and( visMode.notEqual( int( 11 ) ) ), () => {
 
 		const prevAccumSample = texture( prevAccumTexture, prevUV, 0 ).toVar();
 
@@ -360,6 +371,13 @@ export const pathTracerMain = ( params ) => {
 
 	} );
 
+	// NaN/Inf debug: red where the path tracer output isn't finite, black otherwise.
+	If( visMode.equal( int( 11 ) ), () => {
+
+		finalColor.assign( nanInfToRed( finalColor ) );
+
+	} );
+
 	// Write outputs to StorageTextures
 	textureStore( writeColorTex, uintCoord, vec4( finalColor.xyz, outputAlpha ) ).toWriteOnly();
 	textureStore( writeNDTex, uintCoord, finalNormalDepth ).toWriteOnly();