rayzee 7.20.2 → 7.20.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rayzee",
-  "version": "7.20.2",
+  "version": "7.20.3",
   "type": "module",
   "description": "Real-time WebGPU path tracing engine built on Three.js",
   "main": "dist/rayzee.umd.js",

package/src/EngineDefaults.js

@@ -97,7 +97,7 @@ export const ENGINE_DEFAULTS = {
 	pixelFreezeThreshold: 0.02, // per-pixel noise below which a pixel becomes a freeze candidate
 	pixelFreezeStability: 8, // consecutive candidate frames before a pixel freezes
 
-	samplingTechnique: 3,
+	samplingTechnique: 2,
 	enableEmissiveTriangleSampling: false,
 	emissiveBoost: 1.0,
 

package/src/TSL/Clearcoat.js

@@ -1,7 +1,7 @@
 import {
 	Fn,
 	vec3,
-	float,
+	int,
 	dot,
 	normalize,
 	reflect,
@@ -11,12 +11,14 @@ import {
 
 import { struct } from './patches.js';
 
-import { AnisoFrame, DotProducts } from './Struct.js';
-import { PI, MIN_CLEARCOAT_ROUGHNESS, computeDotProductsAniso, anisoTangentFrame } from './Common.js';
-import { DistributionGGX, computeAnisoAlphas, calculateVNDFPDFAniso } from './MaterialProperties.js';
-import { ImportanceSampleGGX, ImportanceSampleCosine, sampleGGXVNDFAniso } from './MaterialSampling.js';
-import { evaluateLayeredBRDF } from './MaterialEvaluation.js';
-import { RandomValue } from './Random.js';
+import { AnisoFrame, DotProducts,
+	BRDFWeights,
+} from './Struct.js';
+import { MIN_CLEARCOAT_ROUGHNESS, computeDotProductsAniso, anisoTangentFrame, constructTBN } from './Common.js';
+import { computeAnisoAlphas, calculateBRDFWeightsFromMaterial, calculateBSDFSamplingPDF } from './MaterialProperties.js';
+import { ImportanceSampleCosine, sampleGGXVNDF, sampleGGXVNDFAniso } from './MaterialSampling.js';
+import { evaluateMaterialResponseFromDots } from './MaterialEvaluation.js';
+import { getRandomSample1D } from './Random.js';
 
 export const ClearcoatResult = struct( {
 	brdf: 'vec3',
@@ -29,6 +31,7 @@ export const ClearcoatResult = struct( {
 // L (light direction) is returned via the out pattern as a separate return
 export const sampleClearcoat = Fn( ( [
 	ray, hitInfo, material, randomSample, rngState,
+	pixelCoord, resolution, frame, dimBase,
 ] ) => {
 
 	const N = hitInfo.normal;
@@ -38,27 +41,26 @@ export const sampleClearcoat = Fn( ( [
 	const clearcoatRoughness = max( material.clearcoatRoughness, MIN_CLEARCOAT_ROUGHNESS );
 	const baseRoughness = max( material.roughness, MIN_CLEARCOAT_ROUGHNESS );
 
-	// Calculate sampling weights based on material properties
-	const specularWeight = float( 1.0 ).sub( baseRoughness ).mul( float( 0.5 ).add( float( 0.5 ).mul( material.metalness ) ) ).toVar();
-	const clearcoatWeight = material.clearcoat.mul( float( 1.0 ).sub( clearcoatRoughness ) ).toVar();
-	const diffuseWeight = float( 1.0 ).sub( specularWeight ).mul( float( 1.0 ).sub( material.metalness ) ).toVar();
-
-	// Normalize weights
-	const total = specularWeight.add( clearcoatWeight ).add( diffuseWeight );
-	specularWeight.divAssign( total );
-	clearcoatWeight.divAssign( total );
-	diffuseWeight.divAssign( total );
+	// The shared selection probabilities, NOT a fourth private scheme. This function used to
+	// derive its own specular/clearcoat/diffuse split, so a clearcoat material was sampled with
+	// one set of probabilities while every MIS site evaluated the density of another — the white
+	// furnace read the resulting mismatch as an energy error that flipped sign once the other
+	// sites were unified.
+	const weights = BRDFWeights.wrap( calculateBRDFWeightsFromMaterial( material ) ).toVar();
+	const clearcoatWeight = weights.clearcoat.toVar();
+	const specularWeight = weights.specular.toVar();
 
 	// Choose which layer to sample
-	const rand = RandomValue( rngState );
+	const rand = getRandomSample1D( pixelCoord, int( 0 ), dimBase.add( int( 13 ) ), rngState, resolution, frame );
 
 	const L = vec3( 0.0 ).toVar();
 	const H = vec3( 0.0 ).toVar();
 
 	If( rand.lessThan( clearcoatWeight ), () => {
 
-		// Sample clearcoat layer
-		H.assign( ImportanceSampleGGX( { N, roughness: clearcoatRoughness, Xi: randomSample } ) );
+		// Sample clearcoat layer (VNDF — see the base-specular note below)
+		const ccTBN = constructTBN( { N } );
+		H.assign( ccTBN.mul( sampleGGXVNDF( { V: ccTBN.transpose().mul( V ), roughness: clearcoatRoughness, Xi: randomSample } ) ) );
 		L.assign( reflect( V.negate(), H ) );
 
 	} ).ElseIf( rand.lessThan( clearcoatWeight.add( specularWeight ) ), () => {
@@ -74,7 +76,9 @@ export const sampleClearcoat = Fn( ( [
 
 		} ).Else( () => {
 
-			H.assign( ImportanceSampleGGX( { N, roughness: baseRoughness, Xi: randomSample } ) );
+			// VNDF to match the density the MIS sites evaluate for this lobe.
+			const tbn = constructTBN( { N } );
+			H.assign( tbn.mul( sampleGGXVNDF( { V: tbn.transpose().mul( V ), roughness: baseRoughness, Xi: randomSample } ) ) );
 
 		} );
 		L.assign( reflect( V.negate(), H ) );
@@ -90,27 +94,12 @@ export const sampleClearcoat = Fn( ( [
 	// Calculate dot products (aniso-aware: also projects onto the anisotropy frame)
 	const dots = DotProducts.wrap( computeDotProductsAniso( N, V, L, material ) );
 
-	// Calculate individual PDFs. Clearcoat layer is always isotropic; the base specular
-	// matches its sampler — VNDF-aniso when anisotropy>0, else the half-vector GGX pdf.
-	const clearcoatPDF = DistributionGGX( dots.NoH, clearcoatRoughness ).mul( dots.NoH ).div( float( 4.0 ).mul( dots.VoH ) ).mul( clearcoatWeight );
-	const specularPDF = float( 0.0 ).toVar();
-	If( material.anisotropy.greaterThan( 0.0 ), () => {
-
-		const a = computeAnisoAlphas( material.roughness, material.anisotropy );
-		specularPDF.assign( calculateVNDFPDFAniso( a.x, a.y, dots.NoH, dots.ToH, dots.BoH, dots.NoV, dots.ToV, dots.BoV ).mul( specularWeight ) );
-
-	} ).Else( () => {
-
-		specularPDF.assign( DistributionGGX( dots.NoH, baseRoughness ).mul( dots.NoH ).div( float( 4.0 ).mul( dots.VoH ) ).mul( specularWeight ) );
-
-	} );
-	const diffusePDF = dots.NoL.div( PI ).mul( diffuseWeight );
-
-	// Combined PDF using MIS
-	const pdf = max( clearcoatPDF.add( specularPDF ).add( diffusePDF ), 0.001 );
+	// One density for every MIS site — see calculateBSDFSamplingPDF.
+	const pdf = max( calculateBSDFSamplingPDF( material, weights, dots ), 0.001 );
 
 	// Evaluate complete BRDF
-	const brdf = evaluateLayeredBRDF( dots, material );
+	// The same BRDF every other site evaluates — see the clearcoat note in MaterialEvaluation.
+	const brdf = evaluateMaterialResponseFromDots( material, dots );
 
 	// Return brdf, L direction, and pdf packed together
 	// Caller needs L and pdf - return as struct-like output

package/src/TSL/EmissiveSampling.js

@@ -3,7 +3,6 @@
 
 import {
 	Fn,
-	vec2,
 	vec3,
 	float,
 	int,
@@ -27,7 +26,7 @@ import {
 
 import { struct } from './patches.js';
 import { MIN_PDF, getDatafromStorageBuffer, powerHeuristic, MATERIAL_SLOTS, MATERIAL_SLOT, computeDotProductsAniso } from './Common.js';
-import { RandomValue } from './Random.js';
+import { getRandomSample1D, getRandomSample2D } from './Random.js';
 import { calculateMaterialPDFFromDots } from './LightsSampling.js';
 import { evaluateMaterialResponseFromDots } from './MaterialEvaluation.js';
 import { DotProducts } from './Struct.js';
@@ -390,6 +389,7 @@ const binarySearchCDF = Fn( ( [ emissiveTriangleBuffer, emissiveOffset, emissive
 export const sampleEmissiveTriangle = Fn( ( [
 	hitPoint, surfaceNormal,
 	rngState,
+	pixelCoord, resolution, frame, dimBase,
 	emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower,
 	triangleBuffer,
 ] ) => {
@@ -410,7 +410,7 @@ export const sampleEmissiveTriangle = Fn( ( [
 	If( emissiveTriangleCount.greaterThan( int( 0 ) ), () => {
 
 		// CDF importance-weighted triangle selection (brighter triangles sampled more)
-		const randEmissive = RandomValue( rngState );
+		const randEmissive = getRandomSample1D( pixelCoord, int( 0 ), dimBase.add( int( 1 ) ), rngState, resolution, frame );
 		const emissiveIndex = binarySearchCDF( emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, randEmissive ).toVar();
 
 		// Fetch emissive triangle data from packed light buffer (2 vec4s per entry)
@@ -427,10 +427,7 @@ export const sampleEmissiveTriangle = Fn( ( [
 		// Fetch triangle geometry
 		const triData = TriangleData.wrap( fetchTriangleData( triangleIndex, triangleBuffer ) );
 
-		// Generate random numbers for 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 ) ) );
 
@@ -532,6 +529,7 @@ export const sampleEmissiveTriangle = Fn( ( [
 export const calculateEmissiveTriangleContributionDebug = Fn( ( [
 	hitPoint, normal, viewDir, material,
 	bounceIndex, rngState,
+	pixelCoord, resolution, frame, dimBase,
 	emissiveBoost,
 	emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower,
 	triangleBuffer,
@@ -555,6 +553,7 @@ export const calculateEmissiveTriangleContributionDebug = Fn( ( [
 		// Sample emissive triangle (CDF importance-weighted)
 		const emissiveSample = EmissiveSample.wrap( sampleEmissiveTriangle(
 			hitPoint, normal, rngState,
+			pixelCoord, resolution, frame, dimBase,
 			emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower,
 			triangleBuffer,
 		) );
@@ -616,6 +615,7 @@ export const calculateEmissiveTriangleContributionDebug = Fn( ( [
 export const calculateEmissiveTriangleContribution = Fn( ( [
 	hitPoint, normal, viewDir, material,
 	bounceIndex, rngState,
+	pixelCoord, resolution, frame, dimBase,
 	emissiveBoost,
 	emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower,
 	triangleBuffer,
@@ -626,6 +626,7 @@ export const calculateEmissiveTriangleContribution = Fn( ( [
 	const result = EmissiveContributionResult.wrap( calculateEmissiveTriangleContributionDebug(
 		hitPoint, normal, viewDir, material,
 		bounceIndex, rngState,
+		pixelCoord, resolution, frame, dimBase,
 		emissiveBoost,
 		emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower,
 		triangleBuffer,

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

@@ -88,8 +88,6 @@ export const LightSample = struct( {
 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)
 } );