rayzee 8.4.1 → 8.6.0

package/src/RenderSettings.js

@@ -42,6 +42,7 @@ const SETTING_ROUTES = {
 	anamorphicRatio: { uniform: 'anamorphicRatio', reset: true },
 	samplingTechnique: { uniform: 'samplingTechnique', reset: true },
 	fireflyThreshold: { uniform: 'fireflyThreshold', reset: true },
+	shadowTerminatorOffset: { uniform: 'shadowTerminatorOffset', reset: true },
 	enableAlphaShadows: { uniform: 'enableAlphaShadows', reset: true },
 	// Adaptive sampling — whole-frame early-stop (useAdaptiveSampling) + per-pixel freeze (usePixelFreeze)
 	useAdaptiveSampling: { uniform: 'useAdaptiveSampling', reset: true },
@@ -63,6 +64,7 @@ const SETTING_ROUTES = {
 	panoramaLonRange: { handler: 'handlePanoramaLonRange', reset: true },
 	panoramaLatRange: { handler: 'handlePanoramaLatRange', reset: true },
 	interactionModeEnabled: { handler: 'handleInteractionModeEnabled', reset: false },
+	interactionRenderScale: { handler: 'handleInteractionRenderScale', reset: false },
 	maxSamples: { handler: 'handleMaxSamples', reset: false },
 	transparentBackground: { handler: 'handleTransparentBackground' },
 	backgroundColor: { handler: 'handleBackgroundColor', reset: true },
@@ -148,6 +150,7 @@ export class RenderSettings extends EventDispatcher {
 	 * @param {Function} [params.reconcileCompletion] - Called when completion limits change
 	 * @param {Object} [params.denoisingManager] - Needed to force ASVGF off under panorama
 	 * @param {Object} [params.cameraManager]    - Needed to force auto-focus manual under panorama
+	 * @param {Function} [params.onInteractionRenderScale] - Applies a new moving-camera render scale
 	 */
 	bind( params ) {
 
@@ -162,7 +165,7 @@ export class RenderSettings extends EventDispatcher {
 	 * Builds handler functions for multi-stage settings that can't
 	 * be routed with a simple uniform forward.
 	 */
-	_buildHandlers( { stages, renderer, resetCallback, reconcileCompletion, denoisingManager, cameraManager } ) {
+	_buildHandlers( { stages, renderer, resetCallback, reconcileCompletion, denoisingManager, cameraManager, onInteractionRenderScale } ) {
 
 		// UniformManager copies into the existing node, so one scratch vector serves every write.
 		const panoScratch = new Vector2();
@@ -279,6 +282,12 @@ export class RenderSettings extends EventDispatcher {
 
 			},
 
+			handleInteractionRenderScale: ( value ) => {
+
+				onInteractionRenderScale?.( value );
+
+			},
+
 		};
 
 	}

package/src/Stages/Compositor.js

@@ -66,8 +66,17 @@ export class Compositor extends RenderStage {
 	 */
 	_resolveSourceTexture( context ) {
 
-		return context.getTexture( 'bloom:output' )
-			|| context.getTexture( 'oidn:output' )
+		return context.getTexture( 'bloom:output' ) || this.resolveLightTexture( context );
+
+	}
+
+	/**
+	 * The newest scene-referred image the pipeline holds — denoised when a denoiser has run — without
+	 * bloom, which is a look added on top rather than light in the scene.
+	 */
+	resolveLightTexture( context ) {
+
+		return context.getTexture( 'oidn:output' )
 			|| context.getTexture( 'edgeFiltering:output' )
 			|| context.getTexture( 'bilateralFiltering:output' )
 			|| context.getTexture( 'asvgf:output' )

package/src/Stages/PathTracer.js

@@ -853,10 +853,25 @@ export class PathTracer extends PathTracerStage {
 		// (row-major active list → under-coverage of the lower rows → GI band). Force full coverage
 		// until the readback re-measures at the new size; bump the generation so any readback already
 		// in flight (carrying the old-resolution counts) is discarded when it resolves.
-		this._lastBounceCounts = null;
-		this._lastBounceEnergy = null;
-		this._lastBounceCountsBudget = - 1;
-		this._lastBounceCountsLoopBound = - 1;
+		// The early exit only compares energy against a per-pixel threshold, so the curve rescaled to the
+		// new pixel count keeps it working — nothing re-measures while the camera moves, and the moving-camera
+		// resolution drop would otherwise run every bounce slot. A multi-chunk curve holds only the last band.
+		if ( this._lastBounceCounts && this._numChunks <= 1 && oldW > 0 && oldH > 0 ) {
+
+			const ratio = ( newW * newH ) / ( oldW * oldH );
+			const rescale = ( v ) => Math.min( 0xFFFFFFFF, Math.round( v * ratio ) );
+			this._lastBounceCounts = this._lastBounceCounts.map( rescale );
+			this._lastBounceEnergy = this._lastBounceEnergy.map( rescale );
+
+		} else {
+
+			this._lastBounceCounts = null;
+			this._lastBounceEnergy = null;
+			this._lastBounceCountsBudget = - 1;
+			this._lastBounceCountsLoopBound = - 1;
+
+		}
+
 		this._curveSizingValid = false;
 		this._readbackFrameCounter = 0;
 		this._readbackGeneration ++;
@@ -1378,6 +1393,7 @@ export class PathTracer extends PathTracerStage {
 			activeIndicesRO: qm.getActiveReadRO(),
 			counters,
 			maxRayCount: this._wfMaxRayCount,
+			shadowTerminatorOffset: this.shadowTerminatorOffset,
 		} );
 		this._kernelManager.register( 'extend',
 			extFn().compute(
@@ -1476,6 +1492,7 @@ export class PathTracer extends PathTracerStage {
 			cameraProjectionMatrix: this.cameraProjectionMatrix,
 			cameraViewMatrix: this.cameraViewMatrix,
 			fireflyThreshold: this.fireflyThreshold,
+			shadowTerminatorOffset: this.shadowTerminatorOffset,
 			// RNG axis only (keys STBN via frame & 63).
 			frame: this.seedFrame,
 			accumFrame: this.frame,

package/src/Stages/PathTracerStage.js

@@ -298,18 +298,6 @@ export class PathTracerStage extends RenderStage {
 		const self = this;
 		const materialInterface = {
 			uniforms: {
-				maxBounceCount: {
-					get value() {
-
-						return self.maxBounces.value;
-
-					},
-					set value( v ) {
-
-						self.maxBounces.value = v;
-
-					}
-				},
 				enableAccumulation: {
 					get value() {
 
@@ -322,15 +310,15 @@ export class PathTracerStage extends RenderStage {
 
 					}
 				},
-				enableEmissiveTriangleSampling: {
+				fireflyThreshold: {
 					get value() {
 
-						return self.enableEmissiveTriangleSampling.value;
+						return self.fireflyThreshold.value;
 
 					},
 					set value( v ) {
 
-						self.enableEmissiveTriangleSampling.value = v;
+						self.fireflyThreshold.value = v;
 
 					}
 				},
@@ -351,11 +339,16 @@ export class PathTracerStage extends RenderStage {
 
 		this.cameraOptimizer = new CameraOptimizer( this.renderer, materialInterface, {
 			enabled: DEFAULT_STATE.interactionModeEnabled,
+			// Nothing that costs light: the app lowers the resolution instead (PathTracerApp._applyRenderScale).
+			// The firefly limit grows with sqrt(frame + 1), and every moving frame is frame 0, where it clipped
+			// ~10% of an emissive-lit interior's light. ×8 is the limit a still image reaches at 64 samples:
+			// lowest large-area error of the values measured, and half the extra grain of turning it off.
 			qualitySettings: {
-				maxBounceCount: 1,
 				enableAccumulation: false,
-				enableEmissiveTriangleSampling: false,
+				fireflyThreshold: ( threshold ) => threshold * 8,
 			},
+			onEnter: () => this.emit( 'pathtracer:interactionStart' ),
+			onExit: () => this.emit( 'pathtracer:interactionEnd' ),
 			onReset: () => {
 
 				this.reset();
@@ -487,7 +480,7 @@ export class PathTracerStage extends RenderStage {
 		this.setTriangleData( this.sdfs.triangleData, this.sdfs.triangleCount );
 		this.setBVHData( this.sdfs.bvhData );
 		this.setInstanceTable( this.sdfs.instanceTable );
-		this.materialData.setMaterialData( this.sdfs.materialData );
+		this.materialData.setMaterialData( this.sdfs.materialData, this.sdfs.materials?.map( m => m.sources ) );
 
 		// Material texture arrays
 		this.materialData.loadTexturesFromSdfs();

package/src/TSL/Common.js

@@ -8,6 +8,21 @@ import {
 	ShadowMaterial,
 } from './Struct.js';
 
+// Spawn point for a ray leaving a surface, Cycles' classic ray_offset: within 1 unit of the origin,
+// 1e-5 along n; beyond, 32 float ULPs per axis toward n. A fixed 1 mm let rays slip out of
+// sub-millimetre grooves — a 14 cm camera read up to 14 % bright in its crevices against Cycles.
+export const offsetRayOrigin = /*@__PURE__*/ wgslFn( `
+	fn offsetRayOrigin( p: vec3f, n: vec3f ) -> vec3f {
+		let step = select( vec3<i32>( 32 ), vec3<i32>( -32 ), ( p < vec3f( 0.0 ) ) != ( n < vec3f( 0.0 ) ) );
+		let far = bitcast<vec3f>( bitcast<vec3<i32>>( p ) + step );
+		return select( far, p + n * 1e-5, abs( p ) < vec3f( 1.0 ) );
+	}
+` );
+
+// Visibility rays stop this fraction short of the sampled light point: unit-free, and ≫ float
+// error, so an emitter coplanar with its fixture is never occluded by it.
+export const SHADOW_END = 1.0 - 1e-4;
+
 export const PI = 3.14159;
 export const PI_INV = 1.0 / PI;
 export const TWO_PI = 2.0 * PI;

package/src/TSL/Debugger.js

@@ -23,7 +23,7 @@ import {
 import { Ray, HitInfo, RayTracingMaterial, MaterialSamples } from './Struct.js';
 import { traverseBVHDebug as traverseBVH } from './BVHTraversal.js';
 import { sampleEnvironment } from './Environment.js';
-import { REC709_LUMINANCE_COEFFICIENTS, getMaterial } from './Common.js';
+import { REC709_LUMINANCE_COEFFICIENTS, getMaterial, offsetRayOrigin } from './Common.js';
 import { sampleAllMaterialTextures } from './TextureSampling.js';
 import { pcgHash, wang_hash, RandomValue } from './Random.js';
 import { cosineWeightedSample } from './MaterialSampling.js';
@@ -336,8 +336,7 @@ export const TraceDebugMode = Fn( ( [
 			const xi = vec2( xi_r1, xi_r2 );
 			const bounceDir = cosineWeightedSample( { N: normalA, xi } ).toVar();
 
-			// Trace secondary ray from the hit point (offset along normal to avoid self-intersection)
-			const bounceOrigin = hitInfo.hitPoint.add( normalA.mul( 0.001 ) );
+			const bounceOrigin = offsetRayOrigin( hitInfo.hitPoint, normalA );
 			const bounceRay = Ray( { origin: bounceOrigin, direction: bounceDir } );
 
 			const bounceHit = HitInfo.wrap( traverseBVH(

package/src/TSL/EmissiveSampling.js

@@ -30,7 +30,7 @@ import { struct } from './patches.js';
 import {
 	MIN_PDF, getDatafromStorageBuffer, powerHeuristic, MATERIAL_SLOTS, MATERIAL_SLOT,
 	computeDotProductsAniso, instanceRows, instanceNormalToWorld, instancePointToWorld,
-	unpackTriangleNormal, TRI_STRIDE
+	unpackTriangleNormal, TRI_STRIDE, SHADOW_END
 } from './Common.js';
 import { TRI_MATERIAL_MASK } from '../EngineDefaults.js';
 import { getRandomSample1D, getRandomSample2D } from './Random.js';
@@ -591,13 +591,11 @@ export const calculateEmissiveTriangleContributionDebug = Fn( ( [
 
 		If( NoL.greaterThan( 0.0 ).and( dot( emissiveSample.direction, geomNormal ).greaterThan( 0.0 ) ), () => {
 
-			// Calculate ray offset for shadow ray
-			const rayOffset = calculateRayOffsetFn( hitPoint, geomNormal, material );
-			const rayOrigin = hitPoint.add( rayOffset );
-
-			// Trace shadow ray
-			const shadowDist = emissiveSample.distance.sub( 0.001 );
-			const visibility = traceShadowRayFn( rayOrigin, emissiveSample.direction, shadowDist );
+			// Aimed at the sampled point and stopped a relative hair short, as for area lights.
+			const rayOrigin = hitPoint.add( calculateRayOffsetFn( hitPoint, geomNormal, emissiveSample.direction ) );
+			const toSample = emissiveSample.position.sub( rayOrigin ).toVar();
+			const shadowDist = length( toSample ).toVar();
+			const visibility = traceShadowRayFn( rayOrigin, toSample.div( shadowDist ), shadowDist.mul( SHADOW_END ) );
 
 			If( visibility.greaterThan( 0.0 ), () => {
 

package/src/TSL/ExtendKernel.js

@@ -17,6 +17,7 @@ import {
 	writeHitPacked,
 } from '../Processor/PackedRayBuffer.js';
 import { COUNTER, RAY_FLAG } from '../Processor/QueueManager.js';
+import { hitFacet, packHitFacet } from './HitFacet.js';
 
 const WG_SIZE = 256;
 
@@ -29,6 +30,7 @@ export function buildExtendKernel( params ) {
 		activeIndicesRO,
 		counters,
 		maxRayCount,
+		shadowTerminatorOffset,
 	} = params;
 
 	const computeFn = Fn( () => {
@@ -64,6 +66,12 @@ export function buildExtendKernel( params ) {
 			ray, bvhBuffer, triangleBuffer, insideMedium,
 		) ).toVar();
 
+		const facet = hitFacet( {
+			triangleBuffer, bvhBuffer, triIdx: hitInfo.triangleIndex, instanceLeaf: hitInfo.instanceLeaf,
+			hitPoint: hitInfo.hitPoint, smoothNormal: hitInfo.normal, viewDir: direction.negate(),
+			didHit: hitInfo.didHit, liftEnabled: shadowTerminatorOffset.greaterThan( 0.0 ),
+		} );
+
 		writeHitPacked(
 			hitBufferRW, rayID,
 			hitInfo.dst,
@@ -73,6 +81,7 @@ export function buildExtendKernel( params ) {
 			uint( hitInfo.materialIndex ),
 			// Biased by one: leaf 0 is real, so 0 has to mean "no instance".
 			uint( hitInfo.instanceLeaf.add( int( 1 ) ) ),
+			packHitFacet( facet.faceN, facet.liftScale ),
 		);
 
 	} );

package/src/TSL/Fresnel.js

@@ -1,4 +1,4 @@
-import { Fn, float, vec3, max, clamp, sqrt } from 'three/tsl';
+import { Fn, float, vec3, max, clamp, sqrt, select } from 'three/tsl';
 
 const EPSILON = 1e-6;
 
@@ -58,3 +58,25 @@ export const iorToFresnel0 = Fn( ( [ transmittedIor, incidentIor ] ) => {
 } );
 
 export const dielectricF0 = ( ior ) => vec3( iorToFresnel0( ior, float( 1.0 ) ) );
+
+// Unpolarised reflectance of a smooth dielectric interface, eta = n_transmitted / n_incident.
+// Returns 1 under total internal reflection. Schlick runs 16-23 % low at 45-65° for eta 1.5.
+export const fresnelDielectric = Fn( ( [ cosI, eta ] ) => {
+
+	const c = clamp( cosI, 0.0, 1.0 );
+	const g2 = eta.mul( eta ).sub( 1.0 ).add( c.mul( c ) );
+	const g = sqrt( max( g2, 0.0 ) );
+	const A = g.sub( c ).div( max( g.add( c ), EPSILON ) );
+	const B = c.mul( g.add( c ) ).sub( 1.0 ).div( max( c.mul( g.sub( c ) ).add( 1.0 ), EPSILON ) );
+	return select( g2.greaterThan( 0.0 ), clamp( A.mul( A ).mul( 0.5 ).mul( B.mul( B ).add( 1.0 ) ), 0.0, 1.0 ), float( 1.0 ) );
+
+} );
+
+// The exact curve rescaled to run 0 head-on to 1 at grazing, so F = mix( f0, f90, weight ) keeps
+// KHR_materials_specular's f0/f90 controls. With f0 = F0(eta) and f90 = 1 it is fresnelDielectric.
+export const dielectricFresnelWeight = Fn( ( [ cosI, eta ] ) => {
+
+	const F0 = iorToFresnel0( eta, float( 1.0 ) );
+	return clamp( fresnelDielectric( cosI, eta ).sub( F0 ).div( max( float( 1.0 ).sub( F0 ), EPSILON ) ), 0.0, 1.0 );
+
+} );

package/src/TSL/HitFacet.js

@@ -0,0 +1,102 @@
+/**
+ * The hit triangle's facet normal, packed into the hit record's spare lane by Extend.
+ *
+ * The hit record's `normal` is the interpolated vertex normal. Rays spawned from a surface must be
+ * offset along the facet itself — Cycles' ray_offset uses Ng — or a vertex normal bent away from its
+ * facet (foliage cards whose normals all point up) moves the origin within the card's own plane,
+ * and the continued ray hits the same card again. The lane also carries the shadow terminator lift.
+ *
+ * Layout: facet normal as an 11:11 octahedral pair (about 0.1°), then the lift's half float
+ * truncated to its top 10 bits (sign, exponent, 4 mantissa bits).
+ */
+
+import {
+	vec2, vec3, float, int, uint, max, abs, dot, cross, normalize, clamp, round, select, If, uintBitsToFloat,
+	packHalf2x16, unpackHalf2x16,
+} from 'three/tsl';
+import {
+	getDatafromStorageBuffer, unpackTriangleNormal, TRI_STRIDE, instanceRows, instanceFaceNormalToWorld,
+} from './Common.js';
+import { shadowTerminatorLift } from './ShadowTerminator.js';
+
+/**
+ * @returns {{ faceN: Node, liftScale: Node }} the facet normal on the viewer's side (the
+ *   interpolated one for a degenerate triangle), and the terminator lift (0 unless `liftEnabled`)
+ */
+export function hitFacet( { triangleBuffer, bvhBuffer, triIdx, instanceLeaf, hitPoint, smoothNormal, viewDir, didHit, liftEnabled } ) {
+
+	const faceN = vec3( 0.0, 0.0, 1.0 ).toVar();
+	const liftScale = float( 0.0 ).toVar();
+
+	If( didHit, () => {
+
+		const recA = getDatafromStorageBuffer( triangleBuffer, triIdx, int( 0 ), int( TRI_STRIDE ) ).toVar();
+		const recB = getDatafromStorageBuffer( triangleBuffer, triIdx, int( 1 ), int( TRI_STRIDE ) ).toVar();
+		const recC = getDatafromStorageBuffer( triangleBuffer, triIdx, int( 2 ), int( TRI_STRIDE ) ).toVar();
+		const V0 = uintBitsToFloat( recA.xyz ).toVar();
+		const V1 = uintBitsToFloat( recB.xyz ).toVar();
+		const V2 = uintBitsToFloat( recC.xyz ).toVar();
+
+		// Shared geometry is stored in object space.
+		const faceLocal = cross( V1.sub( V0 ), V2.sub( V0 ) ).toVar();
+		const face = faceLocal.toVar();
+		const instanced = instanceLeaf.greaterThanEqual( int( 0 ) );
+		If( instanced, () => {
+
+			face.assign( instanceFaceNormalToWorld( instanceRows( bvhBuffer, instanceLeaf ), faceLocal ) );
+
+		} );
+
+		const n = select( dot( face, face ).greaterThan( 0.0 ), normalize( face ), smoothNormal ).toVar();
+		faceN.assign( select( dot( n, viewDir ).lessThan( 0.0 ), n.negate(), n ) );
+
+		If( liftEnabled, () => {
+
+			liftScale.assign( shadowTerminatorLift( {
+				V0, V1, V2,
+				N0: unpackTriangleNormal( recA.w ), N1: unpackTriangleNormal( recB.w ), N2: unpackTriangleNormal( recC.w ),
+				hitPoint, instanced, bvhBuffer, instanceLeaf, faceN,
+			} ) );
+
+		} );
+
+	} );
+
+	return { faceN, liftScale };
+
+}
+
+// Per component: TSL's select() on a bvec is not component-wise.
+const signNotZero = v => vec2( select( v.x.greaterThanEqual( 0.0 ), 1.0, - 1.0 ), select( v.y.greaterThanEqual( 0.0 ), 1.0, - 1.0 ) );
+
+export function packHitFacet( faceN, liftScale ) {
+
+	const p = faceN.xy.div( max( abs( faceN.x ).add( abs( faceN.y ) ).add( abs( faceN.z ) ), 1e-20 ) ).toVar();
+	If( faceN.z.lessThan( 0.0 ), () => {
+
+		p.assign( vec2( 1.0 ).sub( abs( p.yx ) ).mul( signNotZero( p ) ) );
+
+	} );
+	const q = round( clamp( p, - 1.0, 1.0 ).mul( 0.5 ).add( 0.5 ).mul( 2047.0 ) );
+	const h = packHalf2x16( vec2( liftScale, 0.0 ) ).bitAnd( uint( 0xffff ) ).shiftRight( uint( 6 ) );
+	return uint( q.x ).bitOr( uint( q.y ).shiftLeft( uint( 11 ) ) ).bitOr( h.shiftLeft( uint( 22 ) ) );
+
+}
+
+/** @returns {{ faceN: Node, liftScale: Node }} */
+export function unpackHitFacet( bits ) {
+
+	const e = vec2(
+		float( bits.bitAnd( uint( 0x7ff ) ) ),
+		float( bits.shiftRight( uint( 11 ) ).bitAnd( uint( 0x7ff ) ) ),
+	).div( 2047.0 ).mul( 2.0 ).sub( 1.0 ).toVar();
+	const z = float( 1.0 ).sub( abs( e.x ) ).sub( abs( e.y ) ).toVar();
+	If( z.lessThan( 0.0 ), () => {
+
+		e.assign( vec2( 1.0 ).sub( abs( e.yx ) ).mul( signNotZero( e ) ) );
+
+	} );
+	const liftScale = unpackHalf2x16( bits.shiftRight( uint( 22 ) ).shiftLeft( uint( 6 ) ) ).x;
+	return { faceN: normalize( vec3( e, z ) ), liftScale };
+
+}

package/src/TSL/LightsDirect.js

@@ -28,9 +28,9 @@ import {
 import { Ray, ShadowMaterial, HitInfo } from './Struct.js';
 import {
 	REC709_LUMINANCE_COEFFICIENTS, getShadowMaterial, getDatafromStorageBuffer, instanceRows,
-	instanceFaceNormalToWorld, TRI_STRIDE, getAlphaShadowsUniform, shadowFlagsSettle
+	instanceFaceNormalToWorld, TRI_STRIDE, getAlphaShadowsUniform, shadowFlagsSettle, offsetRayOrigin,
 } from './Common.js';
-import { fresnelSchlickFloat, iorToFresnel0 } from './Fresnel.js';
+import { fresnelDielectric } from './Fresnel.js';
 import { calculateBeerLawAbsorption } from './MaterialTransmission.js';
 import { getTransformedUV, sampleBucket } from './TextureSampling.js';
 
@@ -212,11 +212,8 @@ export const traceShadowRay = Fn( ( [
 
 			} );
 
-			// Compute transmittance based on material properties
-			const fresnel = fresnelSchlickFloat(
-				abs( dot( dir, N ) ),
-				iorToFresnel0( shadowMaterial.ior, float( 1.0 ) ),
-			);
+			// Shadow rays go straight through, so both faces see the outside-in angle and eta.
+			const fresnel = fresnelDielectric( abs( dot( dir, N ) ), max( shadowMaterial.ior, 1.0 ) );
 
 			const matTransmittance = float( 1.0 ).sub( fresnel ).mul( shadowMaterial.transmission );
 			transmittance.mulAssign( matTransmittance );
@@ -230,8 +227,9 @@ export const traceShadowRay = Fn( ( [
 			} );
 
 			// Continue ray past transmissive surface
-			rayOrigin.assign( shadowHit.hitPoint.add( dir.mul( 0.001 ) ) );
-			remainingDist.subAssign( shadowHit.dst.add( 0.001 ) );
+			const passEps = max( float( 1e-5 ), length( shadowHit.hitPoint ).mul( 1e-6 ) );
+			rayOrigin.assign( shadowHit.hitPoint.add( dir.mul( passEps ) ) );
+			remainingDist.subAssign( shadowHit.dst.add( passEps ) );
 
 		} ).ElseIf( shadowMaterial.transparent, () => {
 
@@ -246,8 +244,9 @@ export const traceShadowRay = Fn( ( [
 			} );
 
 			// Continue ray past transparent surface
-			rayOrigin.assign( shadowHit.hitPoint.add( dir.mul( 0.001 ) ) );
-			remainingDist.subAssign( shadowHit.dst.add( 0.001 ) );
+			const passEps = max( float( 1e-5 ), length( shadowHit.hitPoint ).mul( 1e-6 ) );
+			rayOrigin.assign( shadowHit.hitPoint.add( dir.mul( passEps ) ) );
+			remainingDist.subAssign( shadowHit.dst.add( passEps ) );
 
 		} ).Else( () => {
 
@@ -267,28 +266,8 @@ export const traceShadowRay = Fn( ( [
 // RAY OFFSET CALCULATION
 // ================================================================================
 
-export const calculateRayOffset = Fn( ( [ hitPoint, normal, material ] ) => {
-
-	// Base epsilon scaled by scene size; adjusted by material properties below.
-	const materialEpsilon = max( float( 1e-4 ), length( hitPoint ).mul( 1e-6 ) ).toVar();
-
-	If( material.transmission.greaterThan( 0.0 ), () => {
-
-		// Transmissive materials need larger offsets
-		materialEpsilon.mulAssign( 2.0 );
-
-	} );
-
-	If( material.roughness.lessThan( 0.1 ), () => {
-
-		// Smooth materials are more sensitive to precision issues
-		materialEpsilon.mulAssign( 1.5 );
-
-	} );
-
-	return normal.mul( materialEpsilon );
-
-} );
+// Vector from hitPoint to its ray spawn point (offsetRayOrigin), for callers that add it themselves.
+export const calculateRayOffset = Fn( ( [ hitPoint, normal ] ) => offsetRayOrigin( hitPoint, normal ).sub( hitPoint ) );
 
 // ================================================================================
 // LIGHT IMPORTANCE ESTIMATION

package/src/TSL/LightsSampling.js

@@ -81,15 +81,15 @@ import {
 	powerHeuristic,
 	balanceHeuristic,
 	computeDotProductsAniso,
+	offsetRayOrigin,
+	SHADOW_END,
 } from './Common.js';
 import {
 	sampleEquirectProbability,
 } from './Environment.js';
+import { shadowTerminatorOrigin } from './ShadowTerminator.js';
 
 const TWO_PI = 2.0 * PI;
-// Visibility rays stop this fraction short of the sampled light point: unit-free, and ≫ float
-// error, so an emitter coplanar with its fixture is never occluded by it.
-const SHADOW_END = 1.0 - 1e-4;
 
 // =============================================================================
 // Light Sampling Functions
@@ -795,12 +795,19 @@ export const calculateDirectLightingUnified = Fn( ( [
 	// Shadow catcher: when true, also accumulate the unoccluded (visibility=1) reference
 	// at every light/env site so the caller can form a shadow ratio. Dead path otherwise.
 	wantUnoccluded,
+	// The facet on the viewer's side, which shadow rays are offset off, and the shadow terminator lift
+	// (ShadowTerminator.js) for the light and environment ones
+	terminatorLift, facetNormal, terminatorCutoff,
 ] ) => {
 
 	const totalContribution = vec3( 0.0 ).toVar();
 	// Unoccluded reference (visibility forced to 1) — only filled when wantUnoccluded.
 	const unoccludedContribution = vec3( 0.0 ).toVar();
-	const rayOrigin = hitPoint.add( geomNormal.mul( 0.001 ) ).toVar();
+	const rayOrigin = offsetRayOrigin( hitPoint, facetNormal ).toVar();
+	const lightShadowOrigin = L => shadowTerminatorOrigin( {
+		hitPoint, offsetNormal: facetNormal, lift: terminatorLift, faceN: facetNormal, smoothN: geomNormal, L,
+		cutoff: terminatorCutoff,
+	} );
 
 	// Binds BVH params so shadow-ray sites at varying call depths use a 3-arg call
 	const shadow = Fn( ( [ origin, dir, maxDist ] ) =>
@@ -845,9 +852,10 @@ export const calculateDirectLightingUnified = Fn( ( [
 
 				// Light geometry is measured from the hit point; only the visibility ray starts on the lifted
 				// origin, aimed at the sampled point and stopped a relative hair short of it.
-				const toSample = hitPoint.add( lightSample.direction.mul( lightSample.distance ) ).sub( rayOrigin ).toVar();
+				const lightOrigin = lightShadowOrigin( lightSample.direction ).toVar();
+				const toSample = hitPoint.add( lightSample.direction.mul( lightSample.distance ) ).sub( lightOrigin ).toVar();
 				const shadowDistance = length( toSample ).toVar();
-				const visibility = shadow( rayOrigin, toSample.div( shadowDistance ), shadowDistance.mul( SHADOW_END ) );
+				const visibility = shadow( lightOrigin, toSample.div( shadowDistance ), shadowDistance.mul( SHADOW_END ) );
 
 				If( visibility.greaterThan( 0.0 ).or( wantUnoccluded ), () => {
 
@@ -1004,7 +1012,7 @@ export const calculateDirectLightingUnified = Fn( ( [
 
 			If( NoL.greaterThan( 0.0 ).and( isDirectionValid( { direction: envDirection, surfaceNormal: geomNormal } ) ), () => {
 
-				const visibility = shadow( rayOrigin, envDirection, float( 1e20 ) );
+				const visibility = shadow( lightShadowOrigin( envDirection ), envDirection, float( 1e20 ) );
 
 				If( visibility.greaterThan( 0.0 ).or( wantUnoccluded ), () => {
 

package/src/TSL/MaterialEvaluation.js

@@ -3,12 +3,12 @@ import {
 	If, max, min, clamp, mix
 } from 'three/tsl';
 
-import { DotProducts, DFGResult } from './Struct.js';
+import { DotProducts, DFGResult, BaseFresnel } from './Struct.js';
 import { PI_INV, MIN_CLEARCOAT_ROUGHNESS, computeDotProductsAniso } from './Common.js';
-import { fresnelSchlick, fresnelSchlickFloat, dielectricF0 } from './Fresnel.js';
+import { fresnelSchlick, fresnelDielectric, dielectricFresnelWeight } from './Fresnel.js';
 import {
 	DistributionGGX, SheenDistribution, VisibilitySheen, VisibilityGGXSmithCorrelated,
-	sheenDirectionalAlbedo, evaluateDFG,
+	sheenDirectionalAlbedo, evaluateSpecularDFG, baseFresnelParams,
 	computeAnisoAlphas, DistributionGGXAniso, VisibilityGGXAniso,
 } from './MaterialProperties.js';
 import { evalIridescence } from './MaterialProperties.js';
@@ -43,12 +43,9 @@ export const evaluateMaterialResponseFromDots = Fn( ( [ material, dots ] ) => {
 
 	} ).Else( () => {
 
-		// Calculate base F0 with specular parameters, clamped to physically valid range
-		const F0 = clamp(
-			mix( dielectricF0( material.ior ).mul( material.specularColor ), material.color.rgb, material.metalness )
-				.mul( material.specularIntensity ),
-			vec3( 0.0 ), vec3( 1.0 )
-		).toVar();
+		const bf = BaseFresnel.wrap( baseFresnelParams( material, material.color.rgb ) ).toVar();
+		const F0 = bf.F0.toVar();
+		const iridF = vec3( 0.0 ).toVar();
 
 		// Modify material color for dispersive materials to enhance color separation
 		const materialColor = material.color.rgb.toVar();
@@ -72,13 +69,18 @@ export const evaluateMaterialResponseFromDots = Fn( ( [ material, dots ] ) => {
 
 			// Per glTF KHR_materials_iridescence spec: use max thickness when no texture
 			const thickness = material.iridescenceThicknessRange.y;
-			const iridescenceFresnel = evalIridescence( float( 1.0 ), material.iridescenceIOR, dots.VoH, thickness, F0 );
-			F0.assign( mix( F0, iridescenceFresnel, material.iridescence ) );
+			iridF.assign( evalIridescence( float( 1.0 ), material.iridescenceIOR, dots.VoH, thickness, F0 ) );
+			F0.assign( mix( F0, iridF, material.iridescence ) );
 
 		} );
 
-		// Precalculate shared terms
-		const F = fresnelSchlick( dots.VoH, F0 );
+		// Dielectric on the exact Fresnel curve, metal and iridescence on Schlick.
+		const Fd = mix( bf.f0, vec3( bf.f90 ), dielectricFresnelWeight( dots.VoH, bf.eta ) );
+		const F = mix(
+			mix( Fd, fresnelSchlick( dots.VoH, bf.F0m ), material.metalness ),
+			fresnelSchlick( dots.VoH, iridF ),
+			material.iridescence,
+		).toVar();
 
 		// Single-scatter specular BRDF (anisotropic when material.anisotropy > 0; the aniso
 		// visibility term already carries the 1/(4·NoV·NoL) denominator)
@@ -98,9 +100,11 @@ export const evaluateMaterialResponseFromDots = Fn( ( [ material, dots ] ) => {
 
 		} );
 
-		// Shared DFG evaluation — compensation factor and total directional albedo
-		// come from the same polynomial.
-		const dfg = DFGResult.wrap( evaluateDFG( F0, dots.NoV, material.roughness ) );
+		// Compensation factor and total directional albedo from the same table fetch.
+		const dfg = DFGResult.wrap( evaluateSpecularDFG(
+			bf.f0, bf.f90, bf.eta, bf.F0m, material.metalness, iridF, material.iridescence, F0,
+			dots.NoV, material.roughness,
+		) );
 		const specular = specularSS.mul( dfg.compensation );
 
 		// Diffuse energy budget from hemisphere-integrated specular albedo (includes multiscatter)
@@ -140,15 +144,18 @@ export const evaluateMaterialResponseFromDots = Fn( ( [ material, dots ] ) => {
 		If( material.clearcoat.greaterThan( 0.0 ), () => {
 
 			const ccRoughness = max( material.clearcoatRoughness, MIN_CLEARCOAT_ROUGHNESS );
-			const ccF0 = vec3( 0.04 );
+			const ccF0 = vec3( 0.04 ); // IOR 1.5
 
 			// A GGX lobe like any other, so same multiscatter treatment; its albedo is what the
 			// base underneath loses.
-			const ccDfg = DFGResult.wrap( evaluateDFG( ccF0, dots.NoV, ccRoughness ) );
+			const ccDfg = DFGResult.wrap( evaluateSpecularDFG(
+				ccF0, float( 1.0 ), float( 1.5 ), vec3( 0.0 ), float( 0.0 ), vec3( 0.0 ), float( 0.0 ), ccF0,
+				dots.NoV, ccRoughness,
+			) );
 
 			const ccD = DistributionGGX( dots.NoH, ccRoughness );
 			const ccVis = VisibilityGGXSmithCorrelated( dots.NoV, dots.NoL, ccRoughness );
-			const ccF = fresnelSchlickFloat( dots.VoH, float( 0.04 ) );
+			const ccF = fresnelDielectric( dots.VoH, float( 1.5 ) );
 			const ccLobe = vec3( ccD.mul( ccVis ).mul( ccF ) ).mul( ccDfg.compensation );