rayzee 7.20.2 → 7.21.0

package/src/TSL/LightBVHSampling.js

@@ -3,7 +3,6 @@
 
 import {
 	Fn,
-	vec2,
 	vec3,
 	float,
 	int,
@@ -21,7 +20,7 @@ import {
 	length,
 } from 'three/tsl';
 import { MIN_PDF } from './Common.js';
-import { RandomValue } from './Random.js';
+import { getRandomSample1D, getRandomSample2D } from './Random.js';
 import {
 	EmissiveSample,
 	sampleTriangle,
@@ -107,6 +106,7 @@ export const lbvhNodeImportance = Fn( ( [ nMin, power, nMax, coneAxis, cosThetaO
 export const sampleLightBVHTriangle = Fn( ( [
 	hitPoint, surfaceNormal,
 	rngState,
+	pixelCoord, resolution, frame, dimBase,
 	lbvhBuffer,
 	emissiveTriangleBuffer,
 	emissiveVec4Offset,
@@ -130,6 +130,13 @@ export const sampleLightBVHTriangle = Fn( ( [
 	const nodeIndex = int( 0 ).toVar();
 	const foundLeaf = tslBool( false ).toVar();
 
+	// Hierarchical sample warping: ONE variate recycled down the descent and into the leaf scan,
+	// rescaled to [0,1) after each choice. A per-level draw has no fixed dimension to key on
+	// (depth varies per pixel), so the descent — which dominates emissive-NEE variance — would
+	// otherwise stay white-noise however well the point-on-triangle pair is sampled. Unbiased:
+	// the rescaled value is uniform conditional on the branch taken; selectionPdf is unchanged.
+	const u = getRandomSample1D( pixelCoord, int( 0 ), dimBase.add( int( 1 ) ), rngState, resolution, frame ).toVar();
+
 	// Tree descent: at most MAX_LBVH_DEPTH iterations
 	Loop( MAX_LBVH_DEPTH, () => {
 
@@ -179,19 +186,19 @@ export const sampleLightBVHTriangle = Fn( ( [
 			// Probability of choosing left child
 			const pLeft = lImportance.div( totalImportance );
 
-			// Sample random value to pick child
-			const rand = RandomValue( rngState );
-
-			If( rand.lessThan( pLeft ), () => {
+			If( u.lessThan( pLeft ), () => {
 
 				// Choose left child
+				u.assign( clamp( u.div( max( pLeft, float( 1e-6 ) ) ), 0.0, 0.999999 ) );
 				selectionPdf.mulAssign( pLeft );
 				nodeIndex.assign( leftChildIdx );
 
 			} ).Else( () => {
 
 				// Choose right child
-				selectionPdf.mulAssign( float( 1.0 ).sub( pLeft ) );
+				const pRight = float( 1.0 ).sub( pLeft ).toVar();
+				u.assign( clamp( u.sub( pLeft ).div( max( pRight, float( 1e-6 ) ) ), 0.0, 0.999999 ) );
+				selectionPdf.mulAssign( pRight );
 				nodeIndex.assign( rightChildIdx );
 
 			} );
@@ -213,7 +220,7 @@ export const sampleLightBVHTriangle = Fn( ( [
 
 		// Sample one triangle proportional to power within the leaf
 		// Linear scan: pick random threshold against cumulative power sum
-		const randLeaf = RandomValue( rngState ).mul( leafTotalPower );
+		const randLeaf = u.mul( leafTotalPower );
 		const cumPower = float( 0.0 ).toVar();
 
 		// Default to last entry as fallback
@@ -253,10 +260,7 @@ export const sampleLightBVHTriangle = Fn( ( [
 		// Fetch triangle geometry
 		const triData = TriangleData.wrap( fetchTriangleData( triangleIndex, triangleBuffer ) );
 
-		// Generate random numbers for point sampling
-		const xi_r1 = RandomValue( rngState ).toVar();
-		const xi_r2 = RandomValue( rngState ).toVar();
-		const xi = vec2( xi_r1, xi_r2 );
+		const xi = getRandomSample2D( pixelCoord, int( 0 ), dimBase.add( int( 3 ) ), rngState, resolution, frame ).toVar();
 
 		const geoNormal = normalize( cross( triData.v1.sub( triData.v0 ), triData.v2.sub( triData.v0 ) ) );
 

package/src/TSL/LightsCore.js

@@ -83,13 +83,14 @@ export const LightSample = struct( {
 	distance: 'float',
 	lightType: 'int',
 	valid: 'bool',
+	// Reservoir denominator, carried out so the BSDF-hit MIS partner can rebuild the
+	// selection pdf without walking every light buffer a second time.
+	selectionTotalWeight: 'float',
 } );
 
 export const IndirectLightingResult = struct( {
 	direction: 'vec3', // Sampled direction for next bounce
 	throughput: 'vec3', // Light throughput along this path
-	misWeight: 'float', // MIS weight for this sample
-	pdf: 'float', // PDF of the selected strategy
 	combinedPdf: 'float', // Weighted sum of all strategy PDFs (for NEE↔implicit MIS pairing)
 } );
 

package/src/TSL/LightsDirect.js

@@ -74,7 +74,7 @@ export const traceShadowRay = Fn( ( [
 	const rayOrigin = origin.toVar();
 	const remainingDist = float( maxDist ).toVar();
 
-	const MAX_SHADOW_TRANSMISSIONS = 8;
+	const MAX_SHADOW_TRANSMISSIONS = 16;
 
 	Loop( { start: int( 0 ), end: int( MAX_SHADOW_TRANSMISSIONS ) }, () => {
 
@@ -160,7 +160,7 @@ export const traceShadowRay = Fn( ( [
 				const blendAlpha = clamp( shadowMaterial.color.a.mul( shadowMaterial.opacity ).mul( texAlpha ), 0.0, 1.0 );
 				transmittance.mulAssign( float( 1.0 ).sub( blendAlpha ) );
 
-				If( transmittance.lessThan( 0.005 ), () => {
+				If( transmittance.lessThan( 1e-4 ), () => {
 
 					transmittance.assign( 0.0 );
 					Break();
@@ -221,7 +221,7 @@ export const traceShadowRay = Fn( ( [
 			transmittance.mulAssign( matTransmittance );
 
 			// Early exit if almost no light passes through
-			If( transmittance.lessThan( 0.005 ), () => {
+			If( transmittance.lessThan( 1e-4 ), () => {
 
 				transmittance.assign( 0.0 );
 				Break();
@@ -237,7 +237,7 @@ export const traceShadowRay = Fn( ( [
 			// Handle transparent materials
 			transmittance.mulAssign( float( 1.0 ).sub( shadowMaterial.opacity ) );
 
-			If( transmittance.lessThan( 0.005 ), () => {
+			If( transmittance.lessThan( 1e-4 ), () => {
 
 				transmittance.assign( 0.0 );
 				Break();

package/src/TSL/LightsIndirect.js

@@ -7,398 +7,79 @@
  * strategy — it is handled via deterministic NEE in LightsSampling.js.
  *
  * Contains:
- *  - calculateTransmissionPDF  — transmission PDF for MIS
- *  - calculateClearcoatPDF     — clearcoat PDF for MIS
- *  - computeSamplingInfo       — compute importance weights for material strategies
- *  - selectSamplingStrategy    — CDF-based strategy selection (specular, diffuse, transmission, clearcoat)
  *  - calculateIndirectLighting — material multi-strategy MIS for bounce direction
  */
 
-import {
-	Fn,
-	float,
-	vec2,
-	vec3,
-	int,
-	bool as tslBool,
-	max,
-	abs,
-	sqrt,
-	dot,
-	If,
-	select,
-} from 'three/tsl';
+import { Fn, float, vec3, int, max, dot, If, select } from 'three/tsl';
 
-import {
-	IndirectLightingResult,
-} from './LightsCore.js';
-import {
-	SamplingStrategyWeights,
-} from './Struct.js';
-import {
-	PI_INV,
-	EPSILON,
-	MIN_PDF,
-} from './Common.js';
-import { DistributionGGX, calculateVNDFPDF, specularVNDFPDFForDir } from './MaterialProperties.js';
-import { evaluateMaterialResponse } from './MaterialEvaluation.js';
-import { RandomValue } from './Random.js';
-import { sampleMicrofacetTransmission, MicrofacetTransmissionResult } from './MaterialTransmission.js';
+import { IndirectLightingResult } from './LightsCore.js';
+import { MIN_PDF } from './Common.js';
+import { getRandomSample2D } from './Random.js';
 import { cosineWeightedSample } from './MaterialSampling.js';
 
-// =============================================================================
-// PDF Calculation Helpers
-// =============================================================================
-
-// Transmission PDF (Walter et al. 2007)
-export const calculateTransmissionPDF = Fn( ( [ V, L, N, ior, roughness, entering ] ) => {
-
-	// eta is the relative IOR: eta_transmitted / eta_incident
-	// When entering: air(1.0) -> material(ior), so eta = ior
-	// When exiting: material(ior) -> air(1.0), so eta = 1.0/ior
-	const eta = select( entering, ior, float( 1.0 ).div( ior ) ).toVar();
-
-	// Transmission half-vector formula
-	const H_raw = V.add( L.mul( eta ) ).toVar();
-	const lenSq = dot( H_raw, H_raw ).toVar();
-	const H = select( lenSq.greaterThan( EPSILON ), H_raw.div( sqrt( lenSq ) ), N ).toVar();
-
-	// Ensure H points into the correct hemisphere
-	If( dot( H, N ).lessThan( 0.0 ), () => {
-
-		H.assign( H.negate() );
-
-	} );
-
-	const VoH = abs( dot( V, H ) );
-	const LoH = abs( dot( L, H ) ).toVar();
-	const NoH = abs( dot( N, H ) ).toVar();
-
-	// GGX distribution
-	const D = DistributionGGX( NoH, roughness );
-
-	// Jacobian for transmission
-	const denom_inner = VoH.add( LoH.mul( eta ) ).toVar();
-	const denom = denom_inner.mul( denom_inner );
-	const jacobian = LoH.mul( eta ).mul( eta ).div( max( denom, EPSILON ) );
-
-	return D.mul( NoH ).mul( jacobian );
-
-} );
-
-// Clearcoat PDF
-export const calculateClearcoatPDF = Fn( ( [ V, L, N, clearcoatRoughness ] ) => {
-
-	const H_raw = V.add( L ).toVar();
-	const lenSq = dot( H_raw, H_raw ).toVar();
-	const H = select( lenSq.greaterThan( EPSILON ), H_raw.div( sqrt( lenSq ) ), N );
-
-	const NoH = max( dot( N, H ), 0.0 );
-	const NoV = max( dot( N, V ), 0.0 );
-
-	return calculateVNDFPDF( NoH, NoV, clearcoatRoughness );
-
-} );
-
-// =============================================================================
-// Sampling Strategy Computation
-// =============================================================================
-
-// Compute normalized strategy weights based on importance info
-export const computeSamplingInfo = Fn( ( [
-	samplingInfo,
-] ) => {
-
-	// Material-only strategies (env handled via deterministic NEE in direct lighting)
-	const specularW = samplingInfo.specularImportance.toVar();
-	const useSpecular = specularW.greaterThan( 0.001 ).toVar();
-
-	const diffuseW = samplingInfo.diffuseImportance.toVar();
-	const useDiffuse = diffuseW.greaterThan( 0.001 ).toVar();
-
-	const transmissionW = samplingInfo.transmissionImportance.toVar();
-	const useTransmission = transmissionW.greaterThan( 0.001 ).toVar();
-
-	const clearcoatW = samplingInfo.clearcoatImportance.toVar();
-	const useClearcoat = clearcoatW.greaterThan( 0.001 ).toVar();
-
-	const totalW = specularW.add( diffuseW ).add( transmissionW ).add( clearcoatW ).toVar();
-
-	If( totalW.lessThan( 0.001 ), () => {
-
-		specularW.assign( 0.0 );
-		diffuseW.assign( 1.0 );
-		transmissionW.assign( 0.0 );
-		clearcoatW.assign( 0.0 );
-		totalW.assign( 1.0 );
-		useSpecular.assign( tslBool( false ) );
-		useDiffuse.assign( tslBool( true ) );
-		useTransmission.assign( tslBool( false ) );
-		useClearcoat.assign( tslBool( false ) );
-
-	} ).Else( () => {
-
-		const invTotal = float( 1.0 ).div( totalW ).toVar();
-		specularW.mulAssign( invTotal );
-		diffuseW.mulAssign( invTotal );
-		transmissionW.mulAssign( invTotal );
-		clearcoatW.mulAssign( invTotal );
-		totalW.assign( 1.0 );
-
-	} );
-
-	return SamplingStrategyWeights( {
-		envWeight: float( 0.0 ),
-		specularWeight: specularW,
-		diffuseWeight: diffuseW,
-		transmissionWeight: transmissionW,
-		clearcoatWeight: clearcoatW,
-		totalWeight: totalW,
-		useEnv: tslBool( false ),
-		useSpecular,
-		useDiffuse,
-		useTransmission,
-		useClearcoat,
-	} );
-
-} );
-
-// =============================================================================
-// Strategy Selection via Cumulative Distribution
-// =============================================================================
-
-// Strategy IDs: 1=specular, 2=diffuse, 3=transmission, 4=clearcoat
-// (env removed — handled via deterministic NEE in direct lighting)
-export const selectSamplingStrategy = Fn( ( [ weights, randomValue ] ) => {
-
-	const selectedStrategy = int( 2 ).toVar(); // Default: diffuse
-
-	const cumulative = float( 0.0 ).toVar();
-	const found = tslBool( false ).toVar();
-
-	If( weights.useSpecular.and( found.not() ), () => {
-
-		cumulative.addAssign( weights.specularWeight );
-
-		If( randomValue.lessThan( cumulative ), () => {
-
-			selectedStrategy.assign( 1 );
-			found.assign( tslBool( true ) );
-
-		} );
-
-	} );
-
-	If( weights.useDiffuse.and( found.not() ), () => {
 
-		cumulative.addAssign( weights.diffuseWeight );
 
-		If( randomValue.lessThan( cumulative ), () => {
 
-			selectedStrategy.assign( 2 );
-			found.assign( tslBool( true ) );
 
-		} );
-
-	} );
-
-	If( weights.useTransmission.and( found.not() ), () => {
-
-		cumulative.addAssign( weights.transmissionWeight );
-
-		If( randomValue.lessThan( cumulative ), () => {
-
-			selectedStrategy.assign( 3 );
-			found.assign( tslBool( true ) );
-
-		} );
-
-	} );
-
-	If( weights.useClearcoat.and( found.not() ), () => {
-
-		selectedStrategy.assign( 4 );
-
-	} );
-
-	return selectedStrategy;
-
-} );
-
-// =============================================================================
-// Cosine Weighted PDF helper
-// =============================================================================
-
-const cosineWeightedPDF = Fn( ( [ NoL ] ) => {
-
-	return max( NoL, 0.0 ).mul( PI_INV );
-
-} );
 
 // =============================================================================
 // Indirect Lighting Calculation
 // =============================================================================
 
 export const calculateIndirectLighting = Fn( ( [
-	V, N, material,
+	N, material,
 	// brdfSample fields (DirectionSample)
 	brdfSampleDirection, brdfSamplePdf, brdfSampleValue,
+	// DirectionSample carries these so refraction throughput does not need a second sampler run.
+	isTransmission, brdfSampleColorWeight,
 	rngState,
-	samplingInfo,
+	pixelCoord, resolution, frame, dimBase,
 ] ) => {
 
 	// Initialize result
 	const r_direction = vec3( 0.0 ).toVar();
 	const r_throughput = vec3( 0.0 ).toVar();
-	const r_misWeight = float( 0.0 ).toVar();
-	const r_pdf = float( 0.0 ).toVar();
 	const r_combinedPdf = float( 0.0 ).toVar();
 
-	// Validate input sampling info
-	const validInput = samplingInfo.diffuseImportance.greaterThanEqual( 0.0 )
-		.and( samplingInfo.specularImportance.greaterThanEqual( 0.0 ) )
-		.and( samplingInfo.transmissionImportance.greaterThanEqual( 0.0 ) )
-		.and( samplingInfo.clearcoatImportance.greaterThanEqual( 0.0 ) );
+	// A non-finite pdf would poison the accumulation buffer permanently, so fall back to a
+	// cosine bounce rather than dividing by it.
+	If( brdfSamplePdf.greaterThan( 0.0 ).not(), () => {
 
-	If( validInput.not(), () => {
-
-		// Fallback to diffuse sampling
-		const r1_fb = RandomValue( rngState ).toVar();
-		const r2_fb = RandomValue( rngState ).toVar();
-		const sampleRand = vec2( r1_fb, r2_fb );
+		const sampleRand = getRandomSample2D( pixelCoord, int( 0 ), dimBase.add( int( 8 ) ), rngState, resolution, frame );
 		r_direction.assign( cosineWeightedSample( N, sampleRand ) );
 		r_throughput.assign( material.color.xyz );
-		r_misWeight.assign( 1.0 );
-		r_pdf.assign( 1.0 );
+		r_combinedPdf.assign( 1.0 );
 
 	} ).Else( () => {
 
-		// Use corrected sampling info
-		const weights = SamplingStrategyWeights.wrap( computeSamplingInfo(
-			samplingInfo,
-		).toVar() );
-
-		const selectionRand = RandomValue( rngState ).toVar();
-		const r1 = RandomValue( rngState ).toVar();
-		const r2 = RandomValue( rngState ).toVar();
-		const sampleRand = vec2( r1, r2 ).toVar();
-
-		// Strategy selection
-		const selectedStrategy = selectSamplingStrategy( weights, selectionRand ).toVar();
-
-		const sampleDir = vec3( 0.0 ).toVar();
-		const samplePdf = float( 0.0 ).toVar();
-		const sampleBrdfValue = vec3( 0.0 ).toVar();
-		// Transmission lobe uses this weight instead of a reflection-BRDF eval, which is
-		// invalid for the below-surface refraction direction.
-		const transColorWeight = vec3( 1.0 ).toVar();
-
-		// Execute selected strategy (chained If/ElseIf/Else for exclusive branches)
-		// Environment removed — handled via deterministic NEE in direct lighting
+		// generateSampledDirection IS the sampler — this used to re-select a strategy on top of
+		// it, and its strategies 1 and 4 both just returned brdfSampleDirection. So a sample that
+		// the inner selection had drawn from the diffuse or sheen lobe was reported to MIS as a
+		// specular-VNDF draw, making combinedPdf something no strategy actually sampled from.
+		// Since prevBouncePdf is that value, and the NEE sites evaluate a mixture, the two MIS
+		// strategies' weights stopped summing to 1.
+		//
+		// brdfSamplePdf is now the true mixture density (calculateBSDFSamplingPDF), so the
+		// estimator is just f·NoL/pdf and the MIS pairs share one function by construction.
+		const NoL = max( dot( N, brdfSampleDirection ), 0.0 ).toVar();
+		const pdf = max( brdfSamplePdf, MIN_PDF ).toVar();
+
+		r_direction.assign( brdfSampleDirection );
+		r_combinedPdf.assign( pdf );
+
+		// The reflection BRDF eval is invalid below the surface, so refraction carries the
+		// sampler's own tint (material.color × colorWeight), mirroring handleTransmission.
+		r_throughput.assign( select(
+			isTransmission,
+			material.color.xyz.mul( brdfSampleColorWeight ),
+			brdfSampleValue.mul( NoL ).div( pdf ),
+		) );
 
-		// Strategy 1: Specular
-		If( selectedStrategy.equal( int( 1 ) ), () => {
-
-			sampleDir.assign( brdfSampleDirection );
-			samplePdf.assign( brdfSamplePdf );
-			sampleBrdfValue.assign( brdfSampleValue );
-
-		} ).ElseIf( selectedStrategy.equal( int( 2 ) ), () => {
-
-			// Strategy 2: Diffuse
-			sampleDir.assign( cosineWeightedSample( N, sampleRand ) );
-			samplePdf.assign( cosineWeightedPDF( max( dot( N, sampleDir ), 0.0 ) ) );
-			sampleBrdfValue.assign( evaluateMaterialResponse( V, sampleDir, N, material ) );
-
-		} ).ElseIf( selectedStrategy.equal( int( 3 ) ), () => {
-
-			// Strategy 3: Transmission
-			const entering = dot( V, N ).greaterThan( 0.0 );
-			const mtResult = MicrofacetTransmissionResult.wrap( sampleMicrofacetTransmission(
-				V, N, material.ior, material.roughness, entering, material.dispersion, sampleRand, rngState, float( 0.0 )
-			).toVar() );
-			sampleDir.assign( mtResult.direction );
-			samplePdf.assign( mtResult.pdf );
-			// evaluateMaterialResponse is reflection-only and returns a non-physical value for
-			// the below-surface refraction direction (its dots are floored to 0.001). Carry the
-			// sampler's spectral tint and apply an energy-consistent transmission throughput
-			// below (mirrors handleTransmission's material.color × colorWeight convention).
-			transColorWeight.assign( mtResult.colorWeight );
-
-		} ).Else( () => {
-
-			// Strategy 4: Clearcoat (fallback)
-			sampleDir.assign( brdfSampleDirection );
-			samplePdf.assign( brdfSamplePdf );
-			sampleBrdfValue.assign( brdfSampleValue );
-
-		} );
-
-		const NoL = max( dot( N, sampleDir ), 0.0 ).toVar();
-
-		// Calculate combined PDF for MIS (material strategies only)
-		const combinedPdf = float( 0.0 ).toVar();
-
-		If( weights.useSpecular, () => {
-
-			// Evaluate specular PDF at sampleDir (not brdfSampleDirection which may differ);
-			// auto-selects iso/aniso to stay consistent with the BRDF sampler.
-			const specPdfAtSampleDir = specularVNDFPDFForDir( material, N, V, sampleDir );
-			combinedPdf.addAssign( weights.specularWeight.mul( specPdfAtSampleDir ) );
-
-		} );
-
-		If( weights.useDiffuse, () => {
-
-			combinedPdf.addAssign( weights.diffuseWeight.mul( cosineWeightedPDF( NoL ) ) );
-
-		} );
-
-		If( weights.useTransmission.and( material.transmission.greaterThan( 0.0 ) ), () => {
-
-			// Calculate transmission PDF for this direction
-			const entering = dot( V, N ).greaterThan( 0.0 );
-			combinedPdf.addAssign( weights.transmissionWeight.mul(
-				calculateTransmissionPDF( V, sampleDir, N, material.ior, material.roughness, entering )
-			) );
-
-		} );
-
-		If( weights.useClearcoat.and( material.clearcoat.greaterThan( 0.0 ) ), () => {
-
-			// Calculate clearcoat PDF for this direction
-			combinedPdf.addAssign( weights.clearcoatWeight.mul(
-				calculateClearcoatPDF( V, sampleDir, N, material.clearcoatRoughness )
-			) );
-
-		} );
-
-		// Ensure valid PDFs
-		samplePdf.assign( max( samplePdf, MIN_PDF ) );
-		combinedPdf.assign( max( combinedPdf, MIN_PDF ) );
-
-		// MIS weight calculation
-		const misWeight = samplePdf.div( combinedPdf ).toVar();
-
-		// Reflection lobes: f·NoL·mis/pdf. Transmission lobe: the sampler's energy-consistent
-		// weight (material tint × dispersion colorWeight × mis) — the reflection BRDF value is
-		// invalid below the surface, so it is not used for transmission.
-		const reflThroughput = sampleBrdfValue.mul( NoL ).mul( misWeight ).div( samplePdf );
-		const transThroughput = material.color.xyz.mul( transColorWeight ).mul( misWeight );
-
-		r_direction.assign( sampleDir );
-		r_throughput.assign( select( selectedStrategy.equal( int( 3 ) ), transThroughput, reflThroughput ) );
-		r_misWeight.assign( misWeight );
-		r_pdf.assign( samplePdf );
-		r_combinedPdf.assign( combinedPdf );
-
-	} ); // End validInput check
+	} );
 
 	return IndirectLightingResult( {
 		direction: r_direction,
 		throughput: r_throughput,
-		misWeight: r_misWeight,
-		pdf: r_pdf,
 		combinedPdf: r_combinedPdf,
 	} );