rayzee 9.5.0 → 11.0.0

package/src/TSL/LightVisibility.js

@@ -0,0 +1,111 @@
+/**
+ * Where each kind of light gets through, learned from the shadow-ray pick's own rays (LightsSampling lightPick):
+ * tries and visible counts per cell of space and facing. Shade reads the learned half, which no kernel writes during
+ * a frame, so a render repeats; it adds to the fresh half, folded into the learned one after each frame.
+ */
+
+import { Fn, float, int, uint, If, Return, instanceIndex, abs, ceil, exp2, floor, length, log2, max, select, sqrt, atomicAdd, atomicLoad, atomicStore } from 'three/tsl';
+
+import { VISIBILITY_BASE, VISIBILITY_CELLS, VISIBILITY_KINDS, VISIBILITY_COUNTER_WORDS } from '../Processor/QueueManager.js';
+import { pcgHash } from './Random.js';
+
+export const VISIBILITY_KIND = { LAMPS: 0, ENVIRONMENT: 1, SUN: 2, EMITTERS: 3 };
+
+const LEARNED = VISIBILITY_BASE;
+const FRESH = VISIBILITY_BASE + VISIBILITY_COUNTER_WORDS;
+const SLOTS = VISIBILITY_CELLS * VISIBILITY_KINDS;
+// A cell is this share of its distance from the camera, rounded up to a power of two.
+const CELL_SHARE = 1 / 32;
+// Below it a kind is still picked now and then, so a light that comes into view is found again.
+const MIN_SHARE = 1 / 64;
+const HALVE_AT = 1 << 16;
+
+const hashIn = ( h, v ) => pcgHash( { state: h.bitXor( v ) } );
+
+/** The cell of a point and the side its surface faces. */
+export const visibilityCell = ( p, n, cameraPosition ) => {
+
+	const level = ceil( log2( max( length( p.sub( cameraPosition ) ).mul( CELL_SHARE ), 1e-6 ) ) ).toVar();
+	const c = floor( p.div( exp2( level ) ) ).toVar();
+	const a = abs( n );
+	const facing = select( a.x.greaterThan( max( a.y, a.z ) ), select( n.x.greaterThan( 0.0 ), uint( 0 ), uint( 1 ) ),
+		select( a.y.greaterThan( a.z ), select( n.y.greaterThan( 0.0 ), uint( 2 ), uint( 3 ) ), select( n.z.greaterThan( 0.0 ), uint( 4 ), uint( 5 ) ) ) );
+
+	let h = pcgHash( { state: uint( int( level ).add( 1024 ) ) } );
+	h = hashIn( h, uint( int( c.x ) ) );
+	h = hashIn( h, uint( int( c.y ) ) );
+	h = hashIn( h, uint( int( c.z ) ) );
+	h = hashIn( h, facing );
+	return h.bitAnd( uint( VISIBILITY_CELLS - 1 ) ).toVar();
+
+};
+
+const slot = ( cell, kind ) => cell.mul( uint( VISIBILITY_KINDS ) ).add( uint( kind ) ).mul( uint( 2 ) );
+
+/** √ of the share of rays that got through: the pick's best weight against a light that is on or off. */
+export const visibilityShare = ( counters, cell, kind ) => {
+
+	const at = uint( LEARNED ).add( slot( cell, kind ) ).toVar();
+	const tries = float( atomicLoad( counters.element( at ) ) );
+	const seen = float( atomicLoad( counters.element( at.add( uint( 1 ) ) ) ) );
+	return sqrt( max( seen.add( 0.5 ).div( tries.add( 1.0 ) ), MIN_SHARE ) );
+
+};
+
+export const recordVisibility = ( counters, cell, kind, visible ) => {
+
+	const at = uint( FRESH ).add( slot( cell, kind ) ).toVar();
+	atomicAdd( counters.element( at ), uint( 1 ) );
+	If( visible, () => {
+
+		atomicAdd( counters.element( at.add( uint( 1 ) ) ), uint( 1 ) );
+
+	} );
+
+};
+
+/** Adds the frame's counts to the learned ones, halving both past HALVE_AT so the table keeps up with a change. */
+export function buildVisibilityFoldKernel( { counters } ) {
+
+	return Fn( () => {
+
+		If( instanceIndex.greaterThanEqual( uint( SLOTS ) ), () => {
+
+			Return();
+
+		} );
+
+		const learned = uint( LEARNED ).add( instanceIndex.mul( uint( 2 ) ) ).toVar();
+		const fresh = uint( FRESH ).add( instanceIndex.mul( uint( 2 ) ) ).toVar();
+		const tries = atomicLoad( counters.element( learned ) ).add( atomicLoad( counters.element( fresh ) ) ).toVar();
+		const seen = atomicLoad( counters.element( learned.add( uint( 1 ) ) ) ).add( atomicLoad( counters.element( fresh.add( uint( 1 ) ) ) ) ).toVar();
+		If( tries.greaterThan( uint( HALVE_AT ) ), () => {
+
+			tries.assign( tries.shiftRight( uint( 1 ) ) );
+			seen.assign( seen.shiftRight( uint( 1 ) ) );
+
+		} );
+		atomicStore( counters.element( learned ), tries );
+		atomicStore( counters.element( learned.add( uint( 1 ) ) ), seen );
+		atomicStore( counters.element( fresh ), uint( 0 ) );
+		atomicStore( counters.element( fresh.add( uint( 1 ) ) ), uint( 0 ) );
+
+	} )().compute( SLOTS, [ 256 ] );
+
+}
+
+/** Forgets everything learned: a reset may have moved what blocks what. */
+export function buildVisibilityClearKernel( { counters } ) {
+
+	const words = 2 * VISIBILITY_COUNTER_WORDS;
+	return Fn( () => {
+
+		If( instanceIndex.lessThan( uint( words ) ), () => {
+
+			atomicStore( counters.element( uint( LEARNED ).add( instanceIndex ) ), uint( 0 ) );
+
+		} );
+
+	} )().compute( words, [ 256 ] );
+
+}

package/src/TSL/LightsSampling.js

@@ -35,6 +35,7 @@ import {
 	length,
 	mix,
 	select,
+	min,
 	If,
 	Loop,
 	sampler,
@@ -84,10 +85,12 @@ import {
 	computeDotProductsAniso,
 	offsetRayOrigin,
 	SHADOW_END,
+	REC709_LUMINANCE_COEFFICIENTS,
 } from './Common.js';
 import { sampleEnvironment, sampleEnvironmentExact } from './Environment.js';
 import { shadowTerminatorOrigin } from './ShadowTerminator.js';
 import { sunRadianceToward, sampleSunDisc } from './Sun.js';
+import { VISIBILITY_KIND, visibilityShare, recordVisibility } from './LightVisibility.js';
 
 const TWO_PI = 2.0 * PI;
 
@@ -773,13 +776,97 @@ export const calculateMaterialPDF = Fn( ( [ viewDir, lightDir, normal, material
 
 } );
 
+// Fewer shadow rays a hit (setting shadowRays). Each light kind offers its sample unshadowed; `variant`:
+//   'one' — keeps one with chance ∝ luminance × √(its kind's learned visibility), traced and divided by that chance;
+//   'two' — always traces the strongest as well, and picks one of the rest.
+const ONE_BELOW = 0.99999994;
+
+const slotOf = () => ( {
+	kind: int( 0 ).toVar(), weight: float( 0.0 ).toVar(), value: vec3( 0.0 ).toVar(),
+	origin: vec3( 0.0 ).toVar(), direction: vec3( 0.0, 1.0, 0.0 ).toVar(), distance: float( 0.0 ).toVar(),
+} );
+
+const FIELDS = [ 'kind', 'weight', 'value', 'origin', 'direction', 'distance' ];
+const assignSlot = ( slot, from ) => FIELDS.forEach( ( f ) => slot[ f ].assign( from[ f ] ) );
+
+// `learned` (LightVisibility.js) gives `share( kind )` and `record( kind, visible )`.
+export const lightPick = ( u0, learned = null, variant = 'one' ) => {
+
+	const u = float( u0 ).toVar();
+	const total = float( 0.0 ).toVar();
+	const kept = slotOf();
+	const best = variant === 'two' ? slotOf() : null;
+
+	const keep = ( c ) => {
+
+		If( c.weight.greaterThan( 0.0 ), () => {
+
+			total.addAssign( c.weight );
+			const p = c.weight.div( total ).toVar();
+			If( u.lessThan( p ), () => {
+
+				u.assign( min( u.div( p ), ONE_BELOW ) );
+				assignSlot( kept, c );
+
+			} ).Else( () => {
+
+				u.assign( min( u.sub( p ).div( float( 1.0 ).sub( p ) ), ONE_BELOW ) );
+
+			} );
+
+		} );
+
+	};
+
+	const offer = ( contribution, from, dir, maxDist, lightKind = 0 ) => {
+
+		const luminance = dot( contribution, REC709_LUMINANCE_COEFFICIENTS );
+		const c = {
+			kind: int( lightKind ), value: contribution, origin: from, direction: dir, distance: maxDist,
+			weight: ( learned ? luminance.mul( learned.share( lightKind ) ) : luminance ).toVar(),
+		};
+		if ( ! best ) return keep( c );
+
+		const better = c.weight.greaterThan( best.weight ).toVar();
+		const loser = Object.fromEntries( FIELDS.map( ( f ) => [ f, select( better, best[ f ], c[ f ] ).toVar() ] ) );
+		keep( loser );
+		If( better, () => assignSlot( best, c ) );
+
+	};
+
+	// The direct light, tracing what the variant keeps through `shadow( origin, direction, distance )`.
+	const trace = ( shadow ) => {
+
+		const result = vec3( 0.0 ).toVar();
+		Loop( { start: int( 0 ), end: int( best ? 2 : 1 ), type: 'int', condition: '<' }, ( { i } ) => {
+
+			const isBest = best ? i.equal( int( 0 ) ) : tslBool( false );
+			const pickOf = ( f ) => ( best ? select( isBest, best[ f ], kept[ f ] ) : kept[ f ] );
+			const weight = pickOf( 'weight' ).toVar();
+			If( weight.greaterThan( 0.0 ), () => {
+
+				const visibility = shadow( pickOf( 'origin' ), pickOf( 'direction' ), pickOf( 'distance' ) ).toVar();
+				if ( learned ) learned.record( pickOf( 'kind' ), visibility.greaterThan( 0.0 ) );
+				result.addAssign( pickOf( 'value' ).mul( visibility ).mul( select( isBest, float( 1.0 ), total.div( weight ) ) ) );
+
+			} );
+
+		} );
+		return result;
+
+	};
+
+	return { offer, total, trace };
+
+};
+
 // =============================================================================
 // Unified Direct Lighting System
 // =============================================================================
 
 // Optimized direct lighting function with importance-based sampling and better MIS. `throughSurfaces` (compile
 // time) adds light from behind a surface that passes it through diffusely; without it the code is exactly as before.
-const makeDirectLighting = ( throughSurfaces ) => Fn( ( [
+const makeDirectLighting = ( throughSurfaces, picked = null ) => Fn( ( [
 	// Surface hit data
 	hitPoint, hitNormal, geomNormal, material,
 	// View direction
@@ -813,6 +900,9 @@ const makeDirectLighting = ( throughSurfaces ) => Fn( ( [
 	terminatorLift, facetNormal, terminatorCutoff,
 	// The physical sky's sun (Sun.js); its BSDF-sampled partner is the miss branch in ShadeKernel.
 	hasSun, sunDirection, sunRadiance, sunParams,
+	// picked: the caller's emitter sample, unshadowed, and the learned visibility (LightVisibility.js) at this point
+	emissiveValue, emissiveOrigin, emissiveDirection, emissiveDistance,
+	visibilityCounters, visibilityCell,
 ] ) => {
 
 	const totalContribution = vec3( 0.0 ).toVar();
@@ -880,6 +970,13 @@ const makeDirectLighting = ( throughSurfaces ) => Fn( ( [
 	// rather than re-walking every light buffer to rebuild the same sum.
 	const neeTotalWeight = float( 0.0 ).toVar();
 
+	const learned = picked ? {
+		share: ( kind ) => visibilityShare( visibilityCounters, visibilityCell, kind ),
+		record: ( kind, visible ) => recordVisibility( visibilityCounters, visibilityCell, kind, visible ),
+	} : null;
+	const pick = picked ? lightPick( getRandomSample1D( pixelCoord, int( 0 ), dimBase, rngState, resolution, frame ), learned, picked ) : null;
+	if ( pick ) pick.offer( emissiveValue, emissiveOrigin, emissiveDirection, emissiveDistance, VISIBILITY_KIND.EMITTERS );
+
 	// =====================================================================
 	// LIGHT SAMPLING PATH
 	// =====================================================================
@@ -911,9 +1008,7 @@ const makeDirectLighting = ( throughSurfaces ) => Fn( ( [
 				const lightOrigin = originFor( back, lightShadowOrigin( lightSample.direction ) ).toVar();
 				const toSample = hitPoint.add( lightSample.direction.mul( lightSample.distance ) ).sub( lightOrigin ).toVar();
 				const shadowDistance = length( toSample ).toVar();
-				const visibility = shadow( lightOrigin, toSample.div( shadowDistance ), shadowDistance.mul( SHADOW_END ) );
-
-				If( visibility.greaterThan( 0.0 ).or( wantUnoccluded ), () => {
+				const lampLight = () => {
 
 					const { value: brdfValue, pdf: bPdf } = bsdfToward( lightSample.direction, back );
 
@@ -927,17 +1022,33 @@ const makeDirectLighting = ( throughSurfaces ) => Fn( ( [
 
 					} );
 
-					// Base contribution WITHOUT visibility; shadowed = base × visibility (identical to the
-					// pre-dual-sum math), unoccluded = base × 1 (shadow-catcher reference only).
-					const baseContribution = lightSample.emission.mul( brdfValue ).mul( NoL ).mul( misW ).div( max( lightSample.pdf, 1e-10 ) );
-					totalContribution.addAssign( baseContribution.mul( visibility ) );
-					If( wantUnoccluded, () => {
+					return lightSample.emission.mul( brdfValue ).mul( NoL ).mul( misW ).div( max( lightSample.pdf, 1e-10 ) );
+
+				};
+
+				if ( pick ) {
+
+					pick.offer( lampLight(), lightOrigin, toSample.div( shadowDistance ), shadowDistance.mul( SHADOW_END ), VISIBILITY_KIND.LAMPS );
+
+				} else {
+
+					const visibility = shadow( lightOrigin, toSample.div( shadowDistance ), shadowDistance.mul( SHADOW_END ) );
+
+					If( visibility.greaterThan( 0.0 ).or( wantUnoccluded ), () => {
+
+						// Base contribution WITHOUT visibility; shadowed = base × visibility (identical to the
+						// pre-dual-sum math), unoccluded = base × 1 (shadow-catcher reference only).
+						const baseContribution = lampLight();
+						totalContribution.addAssign( baseContribution.mul( visibility ) );
+						If( wantUnoccluded, () => {
+
+							unoccludedContribution.addAssign( baseContribution );
 
-						unoccludedContribution.addAssign( baseContribution );
+						} );
 
 					} );
 
-				} );
+				}
 
 			} );
 
@@ -1082,9 +1193,7 @@ const makeDirectLighting = ( throughSurfaces ) => Fn( ( [
 
 				If( reachesSurface( direction, back ), () => {
 
-					const visibility = shadow( originFor( back, lightShadowOrigin( direction ) ), direction, float( 1e20 ) );
-
-					If( visibility.greaterThan( 0.0 ).or( wantUnoccluded ), () => {
+					const skyLight = () => {
 
 						const { value: brdfValue, pdf: bPdf } = bsdfToward( direction, back );
 
@@ -1096,8 +1205,24 @@ const makeDirectLighting = ( throughSurfaces ) => Fn( ( [
 							float( 1.0 )
 						).toVar();
 
+						return radiance.mul( brdfValue ).mul( NoL ).mul( misW ).div( max( lightPdf, 1e-10 ) );
+
+					};
+
+					if ( pick ) {
+
+						pick.offer( skyLight(), originFor( back, lightShadowOrigin( direction ) ), direction, float( 1e20 ),
+							select( isSun, int( VISIBILITY_KIND.SUN ), int( VISIBILITY_KIND.ENVIRONMENT ) ) );
+						return;
+
+					}
+
+					const visibility = shadow( originFor( back, lightShadowOrigin( direction ) ), direction, float( 1e20 ) );
+
+					If( visibility.greaterThan( 0.0 ).or( wantUnoccluded ), () => {
+
 						// Base contribution WITHOUT visibility (deterministic estimator; no stochastic scaling).
-						const baseContribution = radiance.mul( brdfValue ).mul( NoL ).mul( misW ).div( max( lightPdf, 1e-10 ) );
+						const baseContribution = skyLight();
 						totalContribution.addAssign( baseContribution.mul( visibility ) );
 						If( wantUnoccluded, () => {
 
@@ -1115,6 +1240,8 @@ const makeDirectLighting = ( throughSurfaces ) => Fn( ( [
 
 	} );
 
+	if ( pick ) totalContribution.addAssign( pick.trace( shadow ) );
+
 	// EMISSIVE TRIANGLE DIRECT LIGHTING
 	// NOTE: Emissive triangle sampling is handled separately in pathtracer_core.fs
 	// to bypass firefly suppression. Do not add it here to avoid double-counting.
@@ -1125,3 +1252,12 @@ const makeDirectLighting = ( throughSurfaces ) => Fn( ( [
 
 export const calculateDirectLightingUnified = /*@__PURE__*/ makeDirectLighting( false );
 export const calculateDirectLightingThroughSurfaces = /*@__PURE__*/ makeDirectLighting( true );
+const pickedLighting = new Map();
+/** The direct light with fewer shadow rays a hit; `variant` as lightPick takes it. */
+export const calculateDirectLightingPicked = ( throughSurfaces, variant ) => {
+
+	const key = `${throughSurfaces}:${variant}`;
+	if ( ! pickedLighting.has( key ) ) pickedLighting.set( key, makeDirectLighting( throughSurfaces, variant ) );
+	return pickedLighting.get( key );
+
+};

package/src/TSL/Random.js

@@ -107,7 +107,7 @@ export const RandomPointInCircle = ( rngState ) => {
 //       +7  ground-catcher cosine BSDF   (ShadeKernel)
 //       +8  indirect-strategy direction  (LightsIndirect)
 //       +9  physical-sky sun disc        (LightsSampling)
-//   1D  +0  (free — was the {lights,BRDF} stochastic strategy pick)
+//   1D  +0  light kind for the picked shadow ray (LightsSampling lightPick, setting shadowRays)
 //       +1  emissive-triangle pick       (EmissiveSampling / LightBVHSampling)
 //       +2  BSDF lobe selection          (ShadeKernel)
 //       +3  Russian roulette             (PathTracerCore)

package/src/TSL/ShadeKernel.js

@@ -21,6 +21,7 @@ import { sampleAllMaterialTextures, processAnisotropyMap, applyExtensionMaps, ge
 import { evaluateMaterialResponse } from './MaterialEvaluation.js';
 import {
 	calculateDirectLightingUnified, calculateDirectLightingThroughSurfaces, calculateMaterialPDF,
+	calculateDirectLightingPicked,
 	sampleDirectionalLight, sampleRectAreaLight, samplePointLightWithAttenuation, sampleSpotLightWithRadius,
 	areaLightRadiance, areaLightSpreadAttenuation,
 } from './LightsSampling.js';
@@ -28,6 +29,7 @@ import { traceShadowRay, traceShadowRayRefractiveOpaque, estimateLightImportance
 import { shadowTerminatorOrigin } from './ShadowTerminator.js';
 import { hitFacet, unpackHitFacet, windingNormal } from './HitFacet.js';
 import { traverseBVHShadow, triangleSide, sideAccepts } from './BVHTraversal.js';
+import { visibilityCell } from './LightVisibility.js';
 import { handleMaterialTransparency, MaterialInteractionResult } from './MaterialTransmission.js';
 import { sampleChromaticCollision, sampleHenyeyGreenstein, subsurfaceCoefficients, CollisionSample, MediumCoeffs } from './Subsurface.js';
 import { ALL_MATERIAL_LAYERS } from './SceneResources.js';
@@ -44,7 +46,7 @@ import { sampleClearcoat, ClearcoatResult } from './Clearcoat.js';
 import { refineDisplacedIntersection, DisplacementResult } from './Displacement.js';
 import {
 	calculateEmissiveTriangleContribution, calculateEmissiveLightPdf, EmissiveSample, EmissiveSampleIndexed,
-	sampleEmissiveTriangleIndexed, fetchTriangleData, TriangleData,
+	sampleEmissiveTriangle, sampleEmissiveTriangleIndexed, fetchTriangleData, TriangleData,
 } from './EmissiveSampling.js';
 import { sampleLightBVHTriangle, sampleLightBVHTriangleIndexed, calculateLightBVHPdf } from './LightBVHSampling.js';
 import {
@@ -134,6 +136,9 @@ export function buildShadeKernel( params ) {
 		// The material layers some material uses (MaterialDataManager.materialLayers); the rest compile out. Bidirectional
 		// always leaves diffuse transmission out: its connections and light tracing do not cross surfaces yet.
 		materialLayers: layers = ALL_MATERIAL_LAYERS,
+		// Fewer shadow rays a hit, emitters included: null (one per light kind) or a lightPick variant; path tracing only.
+		shadowRays = null,
+		cameraWorldMatrix = null,
 	} = params;
 	const diffuseTransmission = layers.diffuseTransmission;
 
@@ -145,6 +150,7 @@ export function buildShadeKernel( params ) {
 	const auxOn = gBuffer ? auxGBufferEnabled.greaterThan( uint( 0 ) ) : null;
 
 	const useEmissiveNEE = lightBuffer !== undefined;
+	const picksLights = shadowRays && ! bdpt;
 	const lamps = {
 		directional: directionalLightsBuffer, numDirectional: numDirectionalLights, area: areaLightsBuffer, numArea: numAreaLights,
 		point: pointLightsBuffer, numPoint: numPointLights, spot: spotLightsBuffer, numSpot: numSpotLights,
@@ -1607,7 +1613,85 @@ export function buildShadeKernel( params ) {
 
 		} ).Else( sampleLobes );
 
-		const directLighting = () => DirectLightingDual.wrap( ( transmitting ? calculateDirectLightingThroughSurfaces : calculateDirectLightingUnified )(
+		const emitterCandidate = () => {
+
+			const value = vec3( 0.0 ).toVar();
+			const from = vec3( 0.0 ).toVar();
+			const dir = vec3( 0.0, 1.0, 0.0 ).toVar();
+			const dist = float( 0.0 ).toVar();
+			if ( ! useEmissiveNEE ) return [ value, from, dir, dist ];
+
+			If( enableEmissiveTriangleSampling.equal( int( 1 ) ).and( emissiveTriangleCount.greaterThan( int( 0 ) ) ), () => {
+
+				const position = vec3( 0.0 ).toVar();
+				const direction = vec3( 0.0, 1.0, 0.0 ).toVar();
+				const emission = vec3( 0.0 ).toVar();
+				const pdf = float( 0.0 ).toVar();
+				const valid = tslBool( false ).toVar();
+				const take = ( sample ) => {
+
+					const e = EmissiveSample.wrap( sample );
+					position.assign( e.position );
+					direction.assign( e.direction );
+					emission.assign( e.emission );
+					pdf.assign( e.pdf );
+					valid.assign( e.valid );
+
+				};
+
+				If( lightBVHNodeCount.greaterThan( int( 0 ) ), () => {
+
+					take( sampleLightBVHTriangle(
+						hitPoint, N, rngState, _pixelCoord, resolution, frame, dimBase,
+						lightBuffer, lightBuffer, emissiveVec4Offset, triangleBuffer, bvhBuffer, transmitsDiffusely,
+					) );
+
+				} ).Else( () => {
+
+					take( sampleEmissiveTriangle(
+						hitPoint, N, rngState, _pixelCoord, resolution, frame, dimBase,
+						lightBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower, triangleBuffer, bvhBuffer, transmitsDiffusely,
+					) );
+
+				} );
+
+				If( valid.and( pdf.greaterThan( 0.0 ) ), () => {
+
+					const back = throughSurface( direction ).toVar();
+					const NoL = transmitting ? abs( dot( N, direction ) ) : max( float( 0.0 ), dot( N, direction ) );
+					const inFront = NoL.greaterThan( 0.0 ).and( dot( N, direction ).greaterThan( 0.0 ) )
+						.and( dot( direction, NgeoFF ).greaterThan( 0.0 ) );
+
+					If( transmitting ? back.or( inFront ) : inFront, () => {
+
+						from.assign( originFor( direction, lightShadowOrigin( direction ) ) );
+						const toSample = position.sub( from ).toVar();
+						const span = length( toSample ).toVar();
+						dir.assign( toSample.div( span ) );
+						dist.assign( span.mul( SHADOW_END ) );
+
+						const bPdf = calculateMaterialPDF( V, direction, N, material );
+						const misW = select( bPdf.greaterThan( 0.0 ), powerHeuristic( { pdf1: pdf, pdf2: bPdf } ), float( 1.0 ) );
+						value.assign( emission.mul( evaluateMaterialResponse( V, direction, N, material ) ).mul( NoL )
+							.div( pdf ).mul( emissiveBoost ).mul( misW ) );
+
+					} );
+
+				} );
+
+			} );
+
+			return [ value, from, dir, dist ];
+
+		};
+
+		const pickArgs = picksLights
+			? [ ...emitterCandidate(), counters, visibilityCell( hitPoint, NgeoFF, vec3( cameraWorldMatrix[ 3 ] ) ) ]
+			: [];
+		const directLightingFn = picksLights
+			? calculateDirectLightingPicked( transmitting, shadowRays )
+			: ( transmitting ? calculateDirectLightingThroughSurfaces : calculateDirectLightingUnified );
+		const directLighting = () => DirectLightingDual.wrap( directLightingFn(
 			hitPoint, N, NgeoFF, material, V,
 			brdfDir, brdfPdf, brdfValue,
 			bounceIndex, rngState,
@@ -1624,6 +1708,7 @@ export function buildShadeKernel( params ) {
 			tslBool( false ), // wantUnoccluded: false on real surfaces — dead-codes the unoccluded sum
 			terminatorLift, facetN, shadowTerminatorOffset,
 			hasSun, sunDirection, sunRadiance, sunParams,
+			...pickArgs,
 		) ).shadowed;
 		// Bidirectional mode samples every light itself, below.
 		const directLight = bdpt ? null : directLighting().toVar();
@@ -1954,7 +2039,7 @@ export function buildShadeKernel( params ) {
 
 			} );
 
-		} else if ( useEmissiveNEE ) {
+		} else if ( useEmissiveNEE && ! picksLights ) {
 
 			If(
 				enableEmissiveTriangleSampling.equal( int( 1 ) )

package/src/TSL/TextureSampling.js

@@ -8,7 +8,7 @@ import {
 	ExtMapResult,
 } from './Struct.js';
 import { instanceRows, instanceDirToWorld, triangleRow } from './Common.js';
-import { TEXTURE_CONSTANTS } from '../EngineDefaults.js';
+import { TEXTURE_CONSTANTS } from '../Processor/TextureBuckets.js';
 
 // ================================================================================
 // CONSOLIDATED SHAPE-BUCKETED MATERIAL TEXTURES

package/src/core.js

@@ -21,15 +21,11 @@ export { RenderSettings, SETTING_SOURCE } from './RenderSettings.js';
 export { configureAssets, getAssetConfig } from './AssetConfig.js';
 export { configurePlatform, getPlatform } from './Platform.js';
 export { LightManager } from './managers/LightManager.js';
-export { listViewTransforms, getViewTransform, onRegistryChange } from './Color/ViewTransforms.js';
+export { listViewTransforms, getViewTransform, onRegistryChange, DEFAULT_VIEW } from './Color/ViewTransforms.js';
 export { ARCHIVE_FORMATS } from './Processor/archiveFormats.js';
-export {
-	ENGINE_DEFAULTS,
-	MATERIAL_DEFAULTS,
-	RENDER_PROFILES,
-	getRenderProfile,
-	MAX_RESERVABLE_RENDER_SIZE,
-	TRIANGLE_DATA_LAYOUT,
-} from './EngineDefaults.js';
+export { ENGINE_DEFAULTS, MATERIAL_DEFAULTS } from './EngineDefaults.js';
+export { SKY_DEFAULTS } from './managers/EnvironmentManager.js';
+export { MAX_RESERVABLE_RENDER_SIZE } from './Processor/StorageTexturePool.js';
+export { TRIANGLE_DATA_LAYOUT } from './Processor/BufferLayout.js';
 export { Logger, createLogger, fmt, LOG_LEVELS } from './utils/Logger.js';
 export { VERSION } from './version.js';

package/src/index.js

@@ -57,30 +57,19 @@ export { Logger, createLogger, fmt, LOG_LEVELS } from './utils/Logger.js';
 // Configuration defaults and presets
 export {
 	ENGINE_DEFAULTS,
-	ASVGF_QUALITY_PRESETS,
-	NRD_DEFAULTS,
-	NRD_QUALITY_PRESETS,
-	NRD_PRESET_KEYS,
-	NRD_HIT_DIST_A,
-	NRD_HIT_DIST_B,
-	CAMERA_PRESETS,
-	CAMERA_RANGES,
-	SKY_PRESETS,
-	DEFAULT_SUN_PATH,
-	AUTO_FOCUS_MODES,
-	AF_DEFAULTS,
-	TRIANGLE_DATA_LAYOUT,
-	BVH_LEAF_MARKERS,
-	TEXTURE_CONSTANTS,
-	DEFAULT_TEXTURE_MATRIX,
 	MATERIAL_DEFAULTS,
-	MEMORY_CONSTANTS,
 	PRODUCTION_RENDER_CONFIG,
 	INTERACTIVE_RENDER_CONFIG,
-	MAX_RESERVABLE_RENDER_SIZE,
-	RENDER_PROFILES,
-	getRenderProfile,
 } from './EngineDefaults.js';
+export { MAX_RESERVABLE_RENDER_SIZE } from './Processor/StorageTexturePool.js';
+export {
+	DENOISER_DEFAULTS, ASVGF_QUALITY_PRESETS, NRD_DEFAULTS, NRD_QUALITY_PRESETS, NRD_PRESET_KEYS, NRD_HIT_DIST_A,
+	NRD_HIT_DIST_B,
+} from './Stages/DenoiserSettings.js';
+export { SKY_DEFAULTS, DEFAULT_SUN_PATH } from './managers/EnvironmentManager.js';
+export { AUTO_EXPOSURE_DEFAULTS } from './Stages/AutoExposure.js';
+export { AUTO_FOCUS_DEFAULTS } from './managers/CameraManager.js';
+export { TRIANGLE_DATA_LAYOUT, BVH_LEAF_MARKERS } from './Processor/BufferLayout.js';
 export { sunPosition, timeForSunElevation, dayOfYearForMonth } from './Processor/SunPosition.js';
 
 // Settings & managers (for advanced consumers)
@@ -141,7 +130,7 @@ export { displayCanvasFit } from './Color/Displays.js';
 export {
 	VIEW_TRANSFORMS, listViewTransforms, getViewTransform, addViewTransform, removeViewTransform,
 	onRegistryChange, getRegistryVersion, buildToneMapWGSL,
-	OCIO_VIEW_BASE, MAX_TABLE_TRANSFORMS,
+	OCIO_VIEW_BASE, MAX_TABLE_TRANSFORMS, DEFAULT_VIEW,
 } from './Color/ViewTransforms.js';
 export {
 	buildOcioView, addOcioView, addAllOcioViews,

package/src/integrators/BidirectionalIntegrator.js

@@ -12,7 +12,8 @@ import { gpuOnlyStorageAttribute } from '../TSL/patches.js';
 import { LIGHT_FLOATS } from '../managers/UniformManager.js';
 import { HIT_STRIDE_BIDIRECTIONAL, LIGHT_VERTEX_STRIDE, freeStorageAttribute } from '../Processor/PackedRayBuffer.js';
 import { COUNTER, ENERGY_SCALE } from '../Processor/QueueManager.js';
-import { CAMERA_PROJECTION_IDS, BVH_MAX_INDEX } from '../EngineDefaults.js';
+import { CAMERA_PROJECTION_IDS } from '../EngineDefaults.js';
+import { BVH_MAX_INDEX } from '../Processor/BufferLayout.js';
 import { BOUNCE_KERNELS, LIST_WG_SIZE } from '../Stages/PathTracer.js';
 import { buildLightGenerateKernel, LIGHT_GENERATE_WG_SIZE } from '../TSL/LightGenerateKernel.js';
 import { buildGuideKernel, buildGuideClearKernel, guidedDiscPdf, recordEscape, GUIDE_BINS, GUIDE_ROW_STRIDE, GUIDE_TEXTURE_WIDTH } from '../TSL/LightGuide.js';

package/src/managers/CameraManager.js

@@ -1,12 +1,22 @@
 import { EventDispatcher, MathUtils, Matrix4, OrthographicCamera, PerspectiveCamera, Quaternion, Vector3 } from 'three';
 import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
 import { EngineEvents, } from '../EngineEvents.js';
-import { AF_DEFAULTS, CAMERA_PROJECTION_IDS } from '../EngineDefaults.js';
+import { CAMERA_PROJECTION_IDS } from '../EngineDefaults.js';
 import { viewDepth } from './InteractionManager.js';
 import { ViewCamera } from './ViewCamera.js';
 import { WalkControls } from './WalkControls.js';
 import { toPortable, fromPortable } from '../SceneState/portable.js';
 
+export const AUTO_FOCUS_DEFAULTS = {
+	autoFocusMode: 'auto', // 'manual' | 'auto'
+	afScreenPoint: { x: 0.5, y: 0.5 },
+	afSmoothingFactor: 0.15,
+};
+
+const AF_RESET_THRESHOLD = 0.05;
+const AF_FALLBACK_DISTANCE = 10.0;
+const AF_SNAP_THRESHOLD = 0.5;
+
 const DEFAULT_CAMERA_SCALE = Object.freeze( new Vector3( 1, 1, 1 ) );
 
 /** The height of an orthographic camera's view in world units, or null for any other camera. */
@@ -55,9 +65,9 @@ export class CameraManager extends EventDispatcher {
 		this._userCameraCounter = 0;
 
 		// Auto-focus state
-		this.autoFocusMode = AF_DEFAULTS.SMOOTHING_FACTOR ? 'auto' : 'manual';
-		this.afScreenPoint = { x: 0.5, y: 0.5 };
-		this.afSmoothingFactor = AF_DEFAULTS.SMOOTHING_FACTOR;
+		this.autoFocusMode = AUTO_FOCUS_DEFAULTS.autoFocusMode;
+		this.afScreenPoint = { ...AUTO_FOCUS_DEFAULTS.afScreenPoint };
+		this.afSmoothingFactor = AUTO_FOCUS_DEFAULTS.afSmoothingFactor;
 		this._lastValidFocusDistance = null;
 		this._smoothedFocusDistance = null;
 		this._afPointDirty = false;
@@ -873,7 +883,7 @@ export class CameraManager extends EventDispatcher {
 
 				// Nothing under the AF point on a fresh view: focus where the camera orbits.
 				const depth = this.controls ? viewDepth( this.controls.target, this.camera ) : 0;
-				rawDistance = depth > 0 ? depth : AF_DEFAULTS.FALLBACK_DISTANCE * ( assetLoader?.getSceneScale() || 1.0 );
+				rawDistance = depth > 0 ? depth : AF_FALLBACK_DISTANCE * ( assetLoader?.getSceneScale() || 1.0 );
 				this._lastValidFocusDistance = rawDistance;
 
 			}
@@ -893,7 +903,7 @@ export class CameraManager extends EventDispatcher {
 			const changeFraction = Math.abs( rawDistance - this._smoothedFocusDistance )
 				/ this._smoothedFocusDistance;
 
-			if ( changeFraction > AF_DEFAULTS.SNAP_THRESHOLD ) {
+			if ( changeFraction > AF_SNAP_THRESHOLD ) {
 
 				this._smoothedFocusDistance = rawDistance;
 
@@ -921,7 +931,7 @@ export class CameraManager extends EventDispatcher {
 
 				hardReset?.();
 
-			} else if ( changeRatio > AF_DEFAULTS.RESET_THRESHOLD ) {
+			} else if ( changeRatio > AF_RESET_THRESHOLD ) {
 
 				softReset?.();