rayzee 7.1.0 → 7.2.1

package/src/TSL/LightBVHSampling.js

@@ -14,6 +14,8 @@ import {
 	dot,
 	sqrt,
 	max,
+	clamp,
+	select,
 	normalize,
 	cross,
 	length,
@@ -29,6 +31,8 @@ import {
 	sampleSphericalTriangle,
 	barycentricFromPoint,
 	useSphericalSampling,
+	sphericalTriangleSolidAngle,
+	triangleArea,
 	SphericalTriangleSampleResult,
 } from './EmissiveSampling.js';
 
@@ -37,6 +41,58 @@ const LBVH_STRIDE = 4; // 4 vec4s per node
 const EMISSIVE_STRIDE = 2; // 2 vec4s per emissive entry (matches EmissiveSampling.js)
 const MAX_LBVH_DEPTH = 32;
 
+// ================================================================================
+// LIGHT-BVH NODE IMPORTANCE (Conty-Estevez & Kulla 2018 / PBRT-v4 BVHLightSampler)
+// ================================================================================
+// cos((thetaA - thetaB) clamped to >= 0). cosA > cosB ⇒ thetaA < thetaB ⇒ diff clamped to 0.
+const cosSubClamped = Fn( ( [ sinThetaA, cosThetaA, sinThetaB, cosThetaB ] ) => {
+
+	return select( cosThetaA.greaterThan( cosThetaB ), float( 1.0 ), cosThetaA.mul( cosThetaB ).add( sinThetaA.mul( sinThetaB ) ) );
+
+} );
+
+// sin((thetaA - thetaB) clamped to >= 0).
+const sinSubClamped = Fn( ( [ sinThetaA, cosThetaA, sinThetaB, cosThetaB ] ) => {
+
+	return select( cosThetaA.greaterThan( cosThetaB ), float( 0.0 ), sinThetaA.mul( cosThetaB ).sub( cosThetaA.mul( sinThetaB ) ) );
+
+} );
+
+// Importance of a Light-BVH node for a shading point (power × orientation × inverse-square),
+// θ_e = π/2 (diffuse emitters). cosThetaO = -1 ⇒ whole-sphere cone (never culled by orientation).
+// SHARED by both the stochastic descent and the MIS pdf re-walk — they MUST stay byte-identical.
+export const lbvhNodeImportance = Fn( ( [ nMin, power, nMax, coneAxis, cosThetaO, hitPoint ] ) => {
+
+	const center = nMin.add( nMax ).mul( 0.5 );
+	const diagLen = length( nMax.sub( nMin ) );
+	const toCenter = hitPoint.sub( center );
+	const d2c = max( dot( toCenter, toCenter ), float( 1e-12 ) );
+	// PBRT distance clamp (note: clamps to diagLen/2, a length not a square — matches PBRT)
+	const d2 = max( d2c, diagLen.mul( 0.5 ) );
+
+	const wi = toCenter.div( sqrt( d2c ) ); // direction from cluster center to shading point
+	const cosThetaW = dot( coneAxis, wi );
+	const sinThetaW = sqrt( max( float( 1.0 ).sub( cosThetaW.mul( cosThetaW ) ), float( 0.0 ) ) );
+
+	// Half-angle subtended by the cluster's bounding sphere from the shading point.
+	const r2 = diagLen.mul( diagLen ).mul( 0.25 );
+	const sin2ThetaB = clamp( r2.div( d2c ), float( 0.0 ), float( 1.0 ) );
+	const cosThetaB = select( d2c.lessThan( r2 ), float( - 1.0 ), sqrt( max( float( 1.0 ).sub( sin2ThetaB ), float( 0.0 ) ) ) );
+	const sinThetaB = sqrt( max( float( 1.0 ).sub( cosThetaB.mul( cosThetaB ) ), float( 0.0 ) ) );
+
+	const sinThetaO = sqrt( max( float( 1.0 ).sub( cosThetaO.mul( cosThetaO ) ), float( 0.0 ) ) );
+
+	// cosThetap = cos( (theta_w - theta_o - theta_b) clamped >= 0 )
+	const cosThetaX = cosSubClamped( sinThetaW, cosThetaW, sinThetaO, cosThetaO );
+	const sinThetaX = sinSubClamped( sinThetaW, cosThetaW, sinThetaO, cosThetaO );
+	const cosThetap = cosSubClamped( sinThetaX, cosThetaX, sinThetaB, cosThetaB );
+
+	// θ_e = π/2 ⇒ cosThetaE = 0; cluster cannot illuminate the point when cosThetap <= 0.
+	const imp = select( cosThetap.greaterThan( float( 0.0 ) ), power.mul( cosThetap ).div( d2 ), float( 0.0 ) );
+	return max( imp, float( 0.0 ) );
+
+} );
+
 /**
  * Sample one emissive triangle using the Light BVH for spatially-aware importance sampling.
  *
@@ -105,31 +161,12 @@ export const sampleLightBVHTriangle = Fn( ( [
 		const rd0 = lbvhBuffer.element( rBase ); // [minX, minY, minZ, totalPower]
 		const rd1 = lbvhBuffer.element( rBase.add( int( 1 ) ) ); // [maxX, maxY, maxZ, isLeaf]
 
-		// Compute center of each child's AABB
-		const lCenter = vec3(
-			ld0.x.add( ld1.x ).mul( 0.5 ),
-			ld0.y.add( ld1.y ).mul( 0.5 ),
-			ld0.z.add( ld1.z ).mul( 0.5 )
-		);
-		const rCenter = vec3(
-			rd0.x.add( rd1.x ).mul( 0.5 ),
-			rd0.y.add( rd1.y ).mul( 0.5 ),
-			rd0.z.add( rd1.z ).mul( 0.5 )
-		);
-
-		// Compute squared distance from hitPoint to each child center
-		const lDiff = lCenter.sub( hitPoint );
-		const rDiff = rCenter.sub( hitPoint );
-		const lDistSq = max( dot( lDiff, lDiff ), float( 0.01 ) );
-		const rDistSq = max( dot( rDiff, rDiff ), float( 0.01 ) );
-
-		// Child power
-		const lPower = max( ld0.w, float( 0.0 ) );
-		const rPower = max( rd0.w, float( 0.0 ) );
-
-		// Importance = power / dist²
-		const lImportance = lPower.div( lDistSq );
-		const rImportance = rPower.div( rDistSq );
+		// Conty-Kulla importance: power × orientation-cone × inverse-square (shared with the MIS re-walk).
+		// d3 = [coneAxis, cosThetaO]; cosThetaO = -1 ⇒ whole-sphere cone (never culled by orientation).
+		const ld3 = lbvhBuffer.element( lBase.add( int( 3 ) ) );
+		const rd3 = lbvhBuffer.element( rBase.add( int( 3 ) ) );
+		const lImportance = lbvhNodeImportance( ld0.xyz, ld0.w, ld1.xyz, ld3.xyz, ld3.w, hitPoint );
+		const rImportance = lbvhNodeImportance( rd0.xyz, rd0.w, rd1.xyz, rd3.xyz, rd3.w, hitPoint );
 		const totalImportance = lImportance.add( rImportance );
 
 		If( totalImportance.lessThanEqual( float( 0.0 ) ), () => {
@@ -307,3 +344,157 @@ export const sampleLightBVHTriangle = Fn( ( [
 	return result;
 
 } );
+
+// ================================================================================
+// LIGHT-BVH MIS PDF (re-walk)
+// ================================================================================
+// Computes the solid-angle pdf that sampleLightBVHTriangle WOULD assign to a given emissive
+// triangle hit by a BSDF bounce, by re-walking the exact stochastic descent along the triangle's
+// stored bit-trail. Required so the bounce-hit MIS weight uses the SAME light pdf the NEE sampler
+// used — without this the MIS partition-of-unity breaks (a real bias).
+//
+// lightBuffer packs [ LBVH nodes | emissive entries | bit-trail map ]. The bit-trail map holds one
+// float per absolute triangleIndex (4 packed per vec4): the root→leaf left(0)/right(1) choices.
+export const calculateLightBVHPdf = Fn( ( [
+	triangleIndex, hitDistance, rayDir, shadingPoint,
+	lightBuffer, emissiveVec4Offset, reverseMapVec4Offset, triangleBuffer,
+] ) => {
+
+	const result = float( 0.0 ).toVar();
+
+	const triIdx = int( triangleIndex ).toVar();
+
+	// Fetch this triangle's bit-trail (4 packed per vec4). -1 ⇒ not in the BVH (shouldn't happen on
+	// an emissive hit) → leave pdf 0 (MIS falls back to BSDF-only).
+	const packed = lightBuffer.element( reverseMapVec4Offset.add( triIdx.shiftRight( int( 2 ) ) ) );
+	const lane = triIdx.bitAnd( int( 3 ) );
+	const trailF = select( lane.equal( int( 0 ) ), packed.x,
+		select( lane.equal( int( 1 ) ), packed.y,
+			select( lane.equal( int( 2 ) ), packed.z, packed.w ) ) ).toVar();
+
+	If( trailF.greaterThanEqual( float( 0.0 ) ), () => {
+
+		const trail = int( trailF ).toVar();
+		const selectionPdf = float( 1.0 ).toVar();
+		const nodeIndex = int( 0 ).toVar();
+		const depth = int( 0 ).toVar();
+		const foundLeaf = tslBool( false ).toVar();
+
+		Loop( MAX_LBVH_DEPTH, () => {
+
+			const base = nodeIndex.mul( int( LBVH_STRIDE ) );
+			const d1 = lightBuffer.element( base.add( int( 1 ) ) ); // [max, isLeaf]
+
+			If( d1.w.greaterThan( 0.5 ), () => {
+
+				foundLeaf.assign( tslBool( true ) );
+				Break();
+
+			} );
+
+			const d2 = lightBuffer.element( base.add( int( 2 ) ) ); // [left, right]
+			const leftChildIdx = int( d2.x );
+			const rightChildIdx = int( d2.y );
+
+			const lBase = leftChildIdx.mul( int( LBVH_STRIDE ) );
+			const ld0 = lightBuffer.element( lBase );
+			const ld1 = lightBuffer.element( lBase.add( int( 1 ) ) );
+			const ld3 = lightBuffer.element( lBase.add( int( 3 ) ) );
+			const rBase = rightChildIdx.mul( int( LBVH_STRIDE ) );
+			const rd0 = lightBuffer.element( rBase );
+			const rd1 = lightBuffer.element( rBase.add( int( 1 ) ) );
+			const rd3 = lightBuffer.element( rBase.add( int( 3 ) ) );
+
+			const lImp = lbvhNodeImportance( ld0.xyz, ld0.w, ld1.xyz, ld3.xyz, ld3.w, shadingPoint );
+			const rImp = lbvhNodeImportance( rd0.xyz, rd0.w, rd1.xyz, rd3.xyz, rd3.w, shadingPoint );
+			const totalImp = lImp.add( rImp );
+
+			// Trail bit at this depth: 0 → left, 1 → right. Mirror the descent's choice logic EXACTLY.
+			const goRight = trail.shiftRight( depth ).bitAnd( int( 1 ) ).equal( int( 1 ) );
+
+			If( totalImp.lessThanEqual( float( 0.0 ) ), () => {
+
+				// Descent forces left with no pdf update; if the trail goes right it is unreachable.
+				If( goRight, () => {
+
+					selectionPdf.assign( float( 0.0 ) );
+					nodeIndex.assign( rightChildIdx );
+
+				} ).Else( () => {
+
+					nodeIndex.assign( leftChildIdx );
+
+				} );
+
+			} ).Else( () => {
+
+				const pLeft = lImp.div( totalImp );
+				If( goRight, () => {
+
+					selectionPdf.mulAssign( float( 1.0 ).sub( pLeft ) );
+					nodeIndex.assign( rightChildIdx );
+
+				} ).Else( () => {
+
+					selectionPdf.mulAssign( pLeft );
+					nodeIndex.assign( leftChildIdx );
+
+				} );
+
+			} );
+
+			depth.addAssign( int( 1 ) );
+
+		} );
+
+		If( foundLeaf.and( selectionPdf.greaterThan( float( 0.0 ) ) ), () => {
+
+			// Leaf: power-weighted within-leaf selection prob for the target triangle (matches the sampler).
+			const base = nodeIndex.mul( int( LBVH_STRIDE ) );
+			const d0 = lightBuffer.element( base );
+			const d2 = lightBuffer.element( base.add( int( 2 ) ) );
+			const emissiveStart = int( d2.x );
+			const emissiveCount = int( d2.y );
+			const leafTotalPower = max( d0.w, float( 1e-10 ) );
+
+			const targetPower = float( 0.0 ).toVar();
+			Loop( { start: int( 0 ), end: emissiveCount }, ( { i } ) => {
+
+				const entryIdx = emissiveStart.add( i );
+				const emData0 = lightBuffer.element( emissiveVec4Offset.add( entryIdx.mul( int( EMISSIVE_STRIDE ) ) ) );
+				If( int( emData0.r ).equal( triIdx ), () => {
+
+					targetPower.assign( max( emData0.g, float( 0.0 ) ) );
+					Break();
+
+				} );
+
+			} );
+
+			selectionPdf.mulAssign( targetPower.div( leafTotalPower ) );
+
+			// Convert selection pdf → solid-angle measure using the SAME heuristic as the sampler.
+			const triData = TriangleData.wrap( fetchTriangleData( triIdx, triangleBuffer ) );
+			If( useSphericalSampling( triData.v0, triData.v1, triData.v2, shadingPoint ), () => {
+
+				const solidAngle = sphericalTriangleSolidAngle( triData.v0, triData.v1, triData.v2, shadingPoint );
+				result.assign( selectionPdf.div( max( solidAngle, float( 1e-10 ) ) ) );
+
+			} ).Else( () => {
+
+				const geoNormal = normalize( cross( triData.v1.sub( triData.v0 ), triData.v2.sub( triData.v0 ) ) );
+				const cosLight = max( dot( rayDir.negate(), geoNormal ), float( 0.001 ) );
+				const area = triangleArea( triData.v0, triData.v1, triData.v2 );
+				const distSq = hitDistance.mul( hitDistance );
+				const pdfArea = selectionPdf.div( max( area, float( 1e-10 ) ) );
+				result.assign( pdfArea.mul( distSq ).div( cosLight ) );
+
+			} );
+
+		} );
+
+	} );
+
+	return max( result, MIN_PDF );
+
+} );

package/src/TSL/ShadeKernel.js

@@ -29,7 +29,7 @@ import { getImportanceSamplingInfo } from './MaterialProperties.js';
 import { sampleClearcoat, ClearcoatResult } from './Clearcoat.js';
 import { refineDisplacedIntersection, DisplacementResult } from './Displacement.js';
 import { calculateEmissiveTriangleContribution, calculateEmissiveLightPdf, EmissiveSample } from './EmissiveSampling.js';
-import { sampleLightBVHTriangle } from './LightBVHSampling.js';
+import { sampleLightBVHTriangle, calculateLightBVHPdf } from './LightBVHSampling.js';
 import {
 	Ray,
 	HitInfo,
@@ -85,7 +85,7 @@ export function buildShadeKernel( params ) {
 		fireflyThreshold, frame, resolution,
 		emissiveTriangleCount, emissiveVec4Offset, emissiveTotalPower,
 		emissiveBoost, totalTriangleCount, enableEmissiveTriangleSampling,
-		lightBVHNodeCount,
+		lightBVHNodeCount, reverseMapVec4Offset,
 		maxRayCount,
 	} = params;
 
@@ -560,10 +560,25 @@ export function buildShadeKernel( params ) {
 					const prevBouncePdf = readRayPdf( rayBufferRW, rayID );
 					If( prevBouncePdf.greaterThan( 0.0 ), () => {
 
-						const lightPdf = calculateEmissiveLightPdf(
-							int( hitTriIdx ), hitDist, direction, origin,
-							triangleBuffer, materialBuffer, emissiveTotalPower,
-						);
+						// MIS partner pdf MUST match the actual NEE sampler: re-walk the Light BVH descent
+						// when it is active, else use the flat-CDF pdf. Mismatching them breaks MIS
+						// partition-of-unity → a real bias (see calculateLightBVHPdf).
+						const lightPdf = float( 0.0 ).toVar();
+						If( lightBVHNodeCount.greaterThan( int( 0 ) ), () => {
+
+							lightPdf.assign( calculateLightBVHPdf(
+								int( hitTriIdx ), hitDist, direction, origin,
+								lightBuffer, emissiveVec4Offset, reverseMapVec4Offset, triangleBuffer,
+							) );
+
+						} ).Else( () => {
+
+							lightPdf.assign( calculateEmissiveLightPdf(
+								int( hitTriIdx ), hitDist, direction, origin,
+								triangleBuffer, materialBuffer, emissiveTotalPower,
+							) );
+
+						} );
 						emissiveMISWeight.assign( powerHeuristic( { pdf1: prevBouncePdf, pdf2: lightPdf } ) );
 
 					} );

package/src/managers/CameraManager.js

@@ -42,6 +42,7 @@ export class CameraManager extends EventDispatcher {
 		this._lastValidFocusDistance = null;
 		this._smoothedFocusDistance = null;
 		this._afPointDirty = false;
+		this._afSuspended = false;
 
 		// Saved state for default camera when switching to model cameras
 		this._defaultCameraState = null;
@@ -273,6 +274,24 @@ export class CameraManager extends EventDispatcher {
 
 		if ( this.autoFocusMode === 'manual' ) return;
 
+		// Depth-of-field is the only consumer of the auto-focus distance. With DOF
+		// off (the default) the per-frame scene raycast is pure waste, so skip it.
+		// Re-snap on the frame DOF turns back on so focus is correct immediately
+		// rather than racking from a stale smoothed value.
+		if ( ! pathTracer?.enableDOF?.value ) {
+
+			this._afSuspended = true;
+			return;
+
+		}
+
+		if ( this._afSuspended ) {
+
+			this._afSuspended = false;
+			this._smoothedFocusDistance = null;
+
+		}
+
 		// Lock focus during active tiled final rendering
 		const stage = pathTracer;
 		if ( stage?.isReady

package/src/managers/UniformManager.js

@@ -242,6 +242,10 @@ export class UniformManager {
 		// Offset (in vec4 elements) within the packed light buffer where emissive
 		// triangle data starts. Equals lightBVHNodeCount * LBVH_STRIDE; computed on upload.
 		u( 'emissiveVec4Offset', 0, 'int' );
+		// Offset (in vec4 elements) within the packed light buffer where the per-triangle
+		// bit-trail map starts (4 trails packed per vec4); computed on upload. Used by the
+		// bounce-hit MIS path to re-walk the Light BVH descent pdf.
+		u( 'reverseMapVec4Offset', 0, 'int' );
 
 		// Render mode
 		u( 'renderMode', DEFAULT_STATE.renderMode, 'int' );