rayzee 7.20.3 → 7.22.0

package/src/Stages/PathTracer.js

@@ -31,6 +31,13 @@ import {
 
 const log = createLogger( 'wavefront' );
 
+// Shared by the 1D index-list kernels built inline below.
+const LIST_WG_SIZE = 256;
+
+// Resized per bounce iteration, each from its own registered workgroup size. Unregistered entries
+// (the sort passes when _sortMaterials is off) are skipped by setDispatchForCount.
+const BOUNCE_KERNELS = [ 'extend', 'shade', 'globalHist', 'globalScatter', 'compact', 'compactCopyback' ];
+
 export class PathTracer extends PathTracerStage {
 
 	constructor( renderer, scene, camera, options = {} ) {
@@ -272,6 +279,7 @@ export class PathTracer extends PathTracerStage {
 
 		this._updateAccumulationUniforms( frameValue, renderMode );
 		this.frame.value = frameValue;
+		this.seedFrame.value = this._seedTick ++;
 
 		this._setWfDispatch();
 
@@ -349,7 +357,7 @@ export class PathTracer extends PathTracerStage {
 
 				// reset counters → compact non-frozen pixel IDs → publish count → list-driven 1D generate.
 				const genSized = Math.min( maxRays, Math.ceil( activeBounce0 * 1.5 ) + 1024 );
-				km.setDispatchCount( 'generateList', [ Math.ceil( genSized / 256 ), 1, 1 ] );
+				km.setDispatchForCount( 'generateList', genSized );
 				km.dispatch( 'resetFrameCounters' );
 				km.dispatch( 'buildActivePixels' );
 				km.dispatch( 'seedEnter' );
@@ -401,23 +409,12 @@ export class PathTracer extends PathTracerStage {
 					}
 
 					const sized = Math.min( maxRays, Math.ceil( entering * 1.5 ) + 1024 );
-					const wg = [ Math.ceil( sized / 256 ), 1, 1 ];
-					km.setDispatchCount( 'extend', wg );
-					km.setDispatchCount( 'shade', wg );
-					km.setDispatchCount( 'globalHist', wg );
-					km.setDispatchCount( 'globalScatter', wg );
-					km.setDispatchCount( 'compact', wg );
-					km.setDispatchCount( 'compactCopyback', wg );
+					for ( const k of BOUNCE_KERNELS ) km.setDispatchForCount( k, sized );
 
 				} else {
 
 					km.dispatch( 'enterFull' );
-					const full = [ Math.ceil( maxRays / 256 ), 1, 1 ];
-					km.setDispatchCount( 'extend', full );
-					km.setDispatchCount( 'shade', full );
-					km.setDispatchCount( 'compact', full );
-					km.setDispatchCount( 'globalHist', full );
-					km.setDispatchCount( 'globalScatter', full );
+					for ( const k of BOUNCE_KERNELS ) km.setDispatchForCount( k, maxRays );
 
 				}
 
@@ -934,7 +931,7 @@ export class PathTracer extends PathTracerStage {
 
 		} );
 		this._kernelManager.register( 'initActiveIndices',
-			initFn().compute( [ Math.ceil( ( this._chunkRows * w ) / 256 ), 1, 1 ], [ 256, 1, 1 ] )
+			initFn().compute( [ Math.ceil( ( this._chunkRows * w ) / LIST_WG_SIZE ), 1, 1 ], [ LIST_WG_SIZE, 1, 1 ] )
 		);
 
 		const genParams = {
@@ -942,9 +939,15 @@ export class PathTracer extends PathTracerStage {
 			rngBufferRW: pb.rngBuffer.rw,
 			gBufferRW,
 			resolution: this.resolution,
-			frame: this.frame,
+			// RNG axis only (baseSeed + stratified jitter) — takes the seed counter, not the
+			// accumulation index. FinalWrite keeps `frame`.
+			frame: this.seedFrame,
 			cameraWorldMatrix: this.cameraWorldMatrix,
 			cameraProjectionMatrixInverse: this.cameraProjectionMatrixInverse,
+			cameraProjection: this.cameraProjection,
+			panoLonRange: this.panoLonRange,
+			panoLatRange: this.panoLatRange,
+			panoLevelHorizon: this.panoLevelHorizon,
 			enableDOF: this.enableDOF,
 			focalLength: this.focalLength,
 			aperture: this.aperture,
@@ -974,13 +977,12 @@ export class PathTracer extends PathTracerStage {
 		const freezeK = this.pixelFreezeStability;
 		const resetFrameFn = Fn( () => {
 
-			// ACTIVE is per-chunk (zeroed before every chunk's scatter). CONVERGED/FROZEN are per-FRAME counters
-			// summed across chunks in FinalWrite → zero them only on the first chunk of the frame.
+			// ACTIVE is per-chunk (zeroed before every chunk's scatter). CONVERGED is a per-FRAME counter
+			// summed across chunks in FinalWrite → zero it only on the first chunk of the frame.
 			atomicStore( counters.element( uint( COUNTER.ACTIVE_RAY_COUNT ) ), uint( 0 ) );
 			If( this._wfIsFirstChunk.greaterThan( uint( 0 ) ), () => {
 
 				atomicStore( counters.element( uint( COUNTER.CONVERGED_COUNT ) ), uint( 0 ) );
-				atomicStore( counters.element( uint( COUNTER.FROZEN_COUNT ) ), uint( 0 ) );
 
 			} );
 
@@ -1047,7 +1049,7 @@ export class PathTracer extends PathTracerStage {
 
 		} );
 		this._kernelManager.register( 'buildActivePixels',
-			buildActiveFn().compute( [ Math.ceil( ( this._chunkRows * w ) / 256 ), 1, 1 ], [ 256, 1, 1 ] )
+			buildActiveFn().compute( [ Math.ceil( ( this._chunkRows * w ) / LIST_WG_SIZE ), 1, 1 ], [ LIST_WG_SIZE, 1, 1 ] )
 		);
 
 		const seedEnterFn = Fn( () => {
@@ -1070,7 +1072,7 @@ export class PathTracer extends PathTracerStage {
 			counters,
 		} );
 		this._kernelManager.register( 'generateList',
-			genListFn().compute( [ Math.ceil( maxRays / 256 ), 1, 1 ], [ 256, 1, 1 ] )
+			genListFn().compute( [ Math.ceil( maxRays / LIST_WG_SIZE ), 1, 1 ], [ LIST_WG_SIZE, 1, 1 ] )
 		);
 
 		const freshBvh = this.bvhStorageNode;
@@ -1105,7 +1107,6 @@ export class PathTracer extends PathTracerStage {
 		const extFn = buildExtendKernel( {
 			bvhBuffer: freshBvh,
 			triangleBuffer: freshTri,
-			materialBuffer: freshMat,
 			rayBufferRO: pb.rayBuffer.ro,
 			hitBufferRW: pb.hitBuffer.rw,
 			activeIndicesRO: qm.getActiveReadRO(),
@@ -1180,7 +1181,6 @@ export class PathTracer extends PathTracerStage {
 			environmentIntensity: this.environmentIntensity,
 			envMatrix: this.environmentMatrix,
 			enableEnvironmentLight: this.enableEnvironment,
-			useEnvMapIS: this.useEnvMapIS,
 			groundProjectionEnabled: this.groundProjectionEnabled,
 			groundProjectionRadius: this.groundProjectionRadius,
 			groundProjectionHeight: this.groundProjectionHeight,
@@ -1210,7 +1210,9 @@ export class PathTracer extends PathTracerStage {
 			cameraProjectionMatrix: this.cameraProjectionMatrix,
 			cameraViewMatrix: this.cameraViewMatrix,
 			fireflyThreshold: this.fireflyThreshold,
-			frame: this.frame,
+			// RNG axis only (keys STBN via frame & 63).
+			frame: this.seedFrame,
+			accumFrame: this.frame,
 			resolution: this.resolution,
 			emissiveTriangleCount: this.emissiveTriangleCount,
 			emissiveVec4Offset: this.emissiveVec4Offset,
@@ -1288,7 +1290,7 @@ export class PathTracer extends PathTracerStage {
 
 		} );
 		this._kernelManager.register( 'compactCopyback',
-			copyFn().compute( [ Math.ceil( maxRays / 256 ), 1, 1 ], [ 256, 1, 1 ] )
+			copyFn().compute( [ Math.ceil( maxRays / LIST_WG_SIZE ), 1, 1 ], [ LIST_WG_SIZE, 1, 1 ] )
 		);
 
 		const fwFn = buildFinalWriteKernel( {
@@ -1320,7 +1322,6 @@ export class PathTracer extends PathTracerStage {
 			// Tier-2 freeze (stamp + pass-through)
 			usePixelFreeze: this.usePixelFreeze,
 			pixelFreezeThreshold: this.pixelFreezeThreshold,
-			pixelFreezeStability: this.pixelFreezeStability,
 			streakBufferRW: streakRW,
 			frozenMaskRO, // dilated frozen mask (read-only; matches the active-list decision)
 			chunkRowBase: this._wfChunkRowBase,
@@ -1347,6 +1348,10 @@ export class PathTracer extends PathTracerStage {
 			cameraProjectionMatrixInverse: this.cameraProjectionMatrixInverse,
 			cameraProjectionMatrix: this.cameraProjectionMatrix,
 			cameraViewMatrix: this.cameraViewMatrix,
+			cameraProjection: this.cameraProjection,
+			panoLonRange: this.panoLonRange,
+			panoLatRange: this.panoLatRange,
+			panoLevelHorizon: this.panoLevelHorizon,
 			enableDOF: this.enableDOF,
 			focalLength: this.focalLength,
 			aperture: this.aperture,
@@ -1392,10 +1397,7 @@ export class PathTracer extends PathTracerStage {
 		const w = this._wfRenderWidth.value;
 		const h = this._wfRenderHeight.value;
 
-		this._kernelManager.setDispatchCount( 'debug', [
-			Math.ceil( w / DEBUG_WG_SIZE ),
-			Math.ceil( h / DEBUG_WG_SIZE ), 1
-		] );
+		this._kernelManager.setDispatchForGrid( 'debug', w, h );
 
 	}
 
@@ -1412,10 +1414,10 @@ export class PathTracer extends PathTracerStage {
 		this._wfMaxRayCount.value = chunkPixels;
 
 		const km = this._kernelManager;
-		km.setDispatchCount( 'generate', [ Math.ceil( w / GENERATE_WG_SIZE ), Math.ceil( rows / GENERATE_WG_SIZE ), 1 ] );
-		km.setDispatchCount( 'finalWrite', [ Math.ceil( w / FINALWRITE_WG_SIZE ), Math.ceil( rows / FINALWRITE_WG_SIZE ), 1 ] );
-		km.setDispatchCount( 'initActiveIndices', [ Math.ceil( chunkPixels / 256 ), 1, 1 ] );
-		km.setDispatchCount( 'buildActivePixels', [ Math.ceil( chunkPixels / 256 ), 1, 1 ] );
+		km.setDispatchForGrid( 'generate', w, rows );
+		km.setDispatchForGrid( 'finalWrite', w, rows );
+		km.setDispatchForCount( 'initActiveIndices', chunkPixels );
+		km.setDispatchForCount( 'buildActivePixels', chunkPixels );
 
 		return chunkPixels;
 

package/src/Stages/PathTracerStage.js

@@ -51,7 +51,6 @@ const BVH_VEC4_PER_NODE = 4;
  * - camera:moved - When camera position/orientation changes
  * - asvgf:reset - Request ASVGF to reset temporal data
  * - asvgf:updateParameters - Update ASVGF parameters
- * - asvgf:setTemporal - Enable/disable ASVGF temporal accumulation
  *
  * Textures published to context:
  * - pathtracer:color - Main color output
@@ -143,6 +142,11 @@ export class PathTracerStage extends RenderStage {
 		this.lastCameraMatrix = new Matrix4();
 		this.lastProjectionMatrix = new Matrix4();
 
+		// Sampler seed axis — advances per rendered frame, survives accumulation resets.
+		// Pinned back to the accumulation index in deterministic mode.
+		this._seedTick = 0;
+		this._pinSeedToFrame = false;
+
 		// Denoising management state
 		this.lastRenderMode = - 1;
 		this.renderModeChangeTimeout = null;
@@ -293,18 +297,6 @@ export class PathTracerStage extends RenderStage {
 
 					}
 				},
-				useEnvMapIS: {
-					get value() {
-
-						return self.useEnvMapIS.value;
-
-					},
-					set value( v ) {
-
-						self.useEnvMapIS.value = v;
-
-					}
-				},
 				enableAccumulation: {
 					get value() {
 
@@ -348,7 +340,6 @@ export class PathTracerStage extends RenderStage {
 			enabled: DEFAULT_STATE.interactionModeEnabled,
 			qualitySettings: {
 				maxBounceCount: 1,
-				useEnvMapIS: false,
 				enableAccumulation: false,
 				enableEmissiveTriangleSampling: false,
 			},
@@ -651,10 +642,14 @@ export class PathTracerStage extends RenderStage {
 		this.isComplete = false;
 		this.performanceMonitor?.reset();
 
-		this.lastRenderMode = - 1;
-
+		// lastRenderMode is deliberately NOT invalidated here — clearing it made
+		// manageASVGFForRenderMode see a phantom mode change 50 ms after every reset, wiping
+		// ASVGF's history. A real mode change is still caught by the renderMode comparison.
 		this.lastInteractionModeState = false;
 
+		// Only deterministic mode rewinds the seed axis; see _pinSeedToFrame.
+		if ( this._pinSeedToFrame ) this._seedTick = 0;
+
 	}
 
 	/**
@@ -1238,7 +1233,10 @@ export class PathTracerStage extends RenderStage {
 				if ( this.pendingRenderMode !== null && this.pendingRenderMode !== this.lastRenderMode ) {
 
 					this.lastRenderMode = this.pendingRenderMode;
-					this._onRenderModeChanged( this.pendingRenderMode );
+					// History from the previous mode is not comparable. temporalAlpha is NOT
+					// touched here — it is owned by ASVGF_QUALITY_PRESETS, and overwriting it
+					// with a hardcoded value meant `medium` and `high` never took effect.
+					this.emit( 'asvgf:reset' );
 
 				}
 
@@ -1249,35 +1247,6 @@ export class PathTracerStage extends RenderStage {
 
 		}
 
-		this._handleFullQuadASVGF();
-
-	}
-
-	_onRenderModeChanged( newMode ) {
-
-		if ( newMode === 1 ) {
-
-			this.emit( 'asvgf:updateParameters', {
-				enableDebug: false,
-				temporalAlpha: 0.15
-			} );
-
-		} else {
-
-			this.emit( 'asvgf:updateParameters', {
-				temporalAlpha: 0.1,
-			} );
-
-		}
-
-		this.emit( 'asvgf:reset' );
-
-	}
-
-	_handleFullQuadASVGF() {
-
-		this.emit( 'asvgf:setTemporal', { enabled: true } );
-
 	}
 
 	// ===== UNIFORM & DATA SETTERS =====

package/src/TSL/BVHTraversal.js

@@ -14,17 +14,14 @@ import {
 	min,
 	normalize,
 	mix,
-	vec4,
 	notEqual,
 	lessThan,
-	mat3,
 	array,
 	bool as tslBool,
 } from 'three/tsl';
 
-import { Ray, HitInfo } from './Struct.js';
+import { HitInfo } from './Struct.js';
 import { getDatafromStorageBuffer } from './Common.js';
-import { RandomPointInCircle } from './Random.js';
 
 const MAX_STACK_DEPTH = 32;
 const MAX_BVH_ITERATIONS = 512;
@@ -559,66 +556,3 @@ export const traverseBVHShadow = Fn( ( [
 	return closestHit;
 
 } );
-
-// ================================================================================
-// CAMERA RAY GENERATION
-// ================================================================================
-
-export const generateRayFromCamera = Fn( ( [
-	screenPosition, rngState,
-	cameraWorldMatrix, cameraProjectionMatrixInverse,
-	enableDOF, focalLength, aperture, focusDistance, sceneScale, apertureScale, anamorphicRatio
-] ) => {
-
-	// Convert screen position to NDC
-	const ndcPos = vec3( screenPosition.xy, 1.0 );
-
-	// Convert NDC to camera space
-	const rayDirCS = cameraProjectionMatrixInverse.mul( vec4( ndcPos, 1.0 ) );
-
-	// Convert to world space
-	const rayDirectionWorld = normalize( mat3(
-		cameraWorldMatrix[ 0 ].xyz,
-		cameraWorldMatrix[ 1 ].xyz,
-		cameraWorldMatrix[ 2 ].xyz
-	).mul( rayDirCS.xyz.div( rayDirCS.w ) ) ).toVar();
-
-	const rayOriginWorld = vec3( cameraWorldMatrix[ 3 ] ).toVar();
-
-	const resultOrigin = rayOriginWorld.toVar();
-	const resultDirection = rayDirectionWorld.toVar();
-
-	// Check if DOF is disabled or conditions make it ineffective
-	If( enableDOF.and( focalLength.greaterThan( 0.0 ) ).and( aperture.lessThan( 64.0 ) ).and( focusDistance.greaterThan( 0.001 ) ), () => {
-
-		// Physical aperture calculation
-		const effectiveAperture = focalLength.div( aperture );
-		// Apply scene scale to maintain correct physical aperture size
-		const apertureRadius = effectiveAperture.mul( 0.001 ).mul( sceneScale ).mul( apertureScale );
-
-		// Generate random point on aperture disk
-		const randomPoint = RandomPointInCircle( rngState );
-
-		// Apply anamorphic squeeze — stretch horizontally for oval bokeh
-		const lensX = randomPoint.x.mul( anamorphicRatio.max( 0.01 ) );
-		const lensY = randomPoint.y;
-
-		// Extract camera coordinate system directly from camera matrix
-		const cameraRight = normalize( vec3( cameraWorldMatrix[ 0 ] ) );
-		const cameraUp = normalize( vec3( cameraWorldMatrix[ 1 ] ) );
-
-		// Apply aperture offset using camera's actual coordinate system
-		const offset = cameraRight.mul( lensX ).add( cameraUp.mul( lensY ) ).mul( apertureRadius );
-
-		// Calculate new ray from offset origin to focal point
-		resultOrigin.assign( rayOriginWorld.add( offset ) );
-		resultDirection.assign( normalize( rayOriginWorld.add( rayDirectionWorld.mul( focusDistance ) ).sub( resultOrigin ) ) );
-
-	} );
-
-	return Ray( {
-		origin: resultOrigin,
-		direction: resultDirection,
-	} );
-
-} );

package/src/TSL/CameraRay.js

@@ -0,0 +1,141 @@
+/**
+ * CameraRay.js — primary camera ray generation.
+ *
+ * Two projections behind one `cameraProjection` uniform: 0 = pinhole (NDC through
+ * cameraProjectionMatrixInverse), 1 = equirectangular 360 panorama. Both branches live in the same
+ * kernel, so switching modes writes a uniform and resets accumulation — it never recompiles WGSL.
+ *
+ * Equirect mapping, for uv ∈ [0,1] with v = 0 at the top row:
+ *   lon = mix( lonMin, lonMax, u ),  lat = mix( latMax, latMin, v )
+ *   dirCam = ( sin(lon)·cos(lat), sin(lat), -cos(lon)·cos(lat) )
+ * so lon = lat = 0 is camera-forward (image centre), u = 0.75 is camera-right and v = 0 is the zenith.
+ */
+
+import {
+	Fn, vec3, vec4, float, int,
+	If, normalize, mat3, mix, sin, cos, cross, dot,
+} from 'three/tsl';
+
+import { Ray } from './Struct.js';
+import { constructTBN } from './Common.js';
+import { RandomPointInCircle } from './Random.js';
+
+/** World-space primary ray direction for pixel uv. Origin is always cameraWorldMatrix[3]. */
+export const cameraRayDirection = Fn( ( [
+	uv01, cameraWorldMatrix, cameraProjectionMatrixInverse,
+	cameraProjection, panoLonRange, panoLatRange, panoLevelHorizon
+] ) => {
+
+	const direction = vec3( 0.0 ).toVar();
+
+	If( cameraProjection.equal( int( 1 ) ), () => {
+
+		const lon = mix( panoLonRange.x, panoLonRange.y, uv01.x ).toVar();
+		const lat = mix( panoLatRange.y, panoLatRange.x, uv01.y ).toVar();
+		const cosLat = cos( lat ).toVar();
+
+		const right = vec3( 0.0 ).toVar();
+		const up = vec3( 0.0 ).toVar();
+		const back = vec3( 0.0 ).toVar();
+
+		If( panoLevelHorizon.equal( int( 1 ) ), () => {
+
+			// Yaw-only frame — orbit pitch/roll must not tilt the panorama. The flattened column
+			// is normalized below, so it needs no pre-normalize.
+			const flat = vec3( cameraWorldMatrix[ 2 ].x, 0.0, cameraWorldMatrix[ 2 ].z ).toVar();
+			// Straight up/down: the camera's own up vector is the horizontal one.
+			If( dot( flat, flat ).lessThan( float( 1e-8 ) ), () => {
+
+				flat.assign( vec3( cameraWorldMatrix[ 1 ].x, 0.0, cameraWorldMatrix[ 1 ].z ) );
+
+			} );
+
+			back.assign( normalize( flat ) );
+			up.assign( vec3( 0.0, 1.0, 0.0 ) );
+			right.assign( cross( up, back ) );
+
+		} ).Else( () => {
+
+			right.assign( normalize( vec3( cameraWorldMatrix[ 0 ] ) ) );
+			up.assign( normalize( vec3( cameraWorldMatrix[ 1 ] ) ) );
+			back.assign( normalize( vec3( cameraWorldMatrix[ 2 ] ) ) );
+
+		} );
+
+		direction.assign( normalize(
+			right.mul( sin( lon ).mul( cosLat ) )
+				.add( up.mul( sin( lat ) ) )
+				.sub( back.mul( cos( lon ).mul( cosLat ) ) )
+		) );
+
+	} ).Else( () => {
+
+		const ndcPos = vec3( uv01.x.mul( 2.0 ).sub( 1.0 ), float( 1.0 ).sub( uv01.y.mul( 2.0 ) ), 1.0 );
+		const rayDirCS = cameraProjectionMatrixInverse.mul( vec4( ndcPos, 1.0 ) );
+
+		direction.assign( normalize( mat3(
+			cameraWorldMatrix[ 0 ].xyz,
+			cameraWorldMatrix[ 1 ].xyz,
+			cameraWorldMatrix[ 2 ].xyz
+		).mul( rayDirCS.xyz.div( rayDirCS.w ) ) ) );
+
+	} );
+
+	return direction;
+
+} );
+
+export const generateRayFromCamera = Fn( ( [
+	uv01, rngState,
+	cameraWorldMatrix, cameraProjectionMatrixInverse,
+	cameraProjection, panoLonRange, panoLatRange, panoLevelHorizon,
+	enableDOF, focalLength, aperture, focusDistance, sceneScale, apertureScale, anamorphicRatio
+] ) => {
+
+	const rayOriginWorld = vec3( cameraWorldMatrix[ 3 ] ).toVar();
+	// .toVar() so the two reads below don't inline the whole projection graph twice.
+	const rayDirectionWorld = cameraRayDirection(
+		uv01, cameraWorldMatrix, cameraProjectionMatrixInverse,
+		cameraProjection, panoLonRange, panoLatRange, panoLevelHorizon
+	).toVar();
+
+	const resultOrigin = rayOriginWorld.toVar();
+	const resultDirection = rayDirectionWorld.toVar();
+
+	If( enableDOF.and( focalLength.greaterThan( 0.0 ) ).and( aperture.lessThan( 64.0 ) ).and( focusDistance.greaterThan( 0.001 ) ), () => {
+
+		const effectiveAperture = focalLength.div( aperture );
+		const apertureRadius = effectiveAperture.mul( 0.001 ).mul( sceneScale ).mul( apertureScale );
+
+		const randomPoint = RandomPointInCircle( rngState );
+		// Anamorphic squeeze — stretch horizontally for oval bokeh
+		const lensX = randomPoint.x.mul( anamorphicRatio.max( 0.01 ) );
+		const lensY = randomPoint.y;
+
+		const lensOffset = vec3( 0.0 ).toVar();
+
+		If( cameraProjection.equal( int( 1 ) ), () => {
+
+			// Every pixel points a different way, so the lens plane is built around the ray. The
+			// camera's right/up would skew bokeh into a slit away from the image centre.
+			lensOffset.assign( constructTBN( { N: rayDirectionWorld } ).mul( vec3( lensX, lensY, 0.0 ) ) );
+
+		} ).Else( () => {
+
+			const camRight = normalize( vec3( cameraWorldMatrix[ 0 ] ) );
+			const camUp = normalize( vec3( cameraWorldMatrix[ 1 ] ) );
+			lensOffset.assign( camRight.mul( lensX ).add( camUp.mul( lensY ) ) );
+
+		} );
+
+		resultOrigin.assign( rayOriginWorld.add( lensOffset.mul( apertureRadius ) ) );
+		resultDirection.assign( normalize( rayOriginWorld.add( rayDirectionWorld.mul( focusDistance ) ).sub( resultOrigin ) ) );
+
+	} );
+
+	return Ray( {
+		origin: resultOrigin,
+		direction: resultDirection,
+	} );
+
+} );

package/src/TSL/Common.js

@@ -1,10 +1,9 @@
-import { Fn, wgslFn, float, vec2, vec3, vec4, int, mat3, If, max, dot, clamp, bool as tslBool } from 'three/tsl';
+import { Fn, wgslFn, float, vec2, vec3, vec4, int, mat3, If, max, dot, clamp } from 'three/tsl';
 
 import {
 	AnisoFrame,
 	DotProducts,
 	MaterialClassification,
-	MISStrategy,
 	RayTracingMaterial,
 	ShadowMaterial,
 } from './Struct.js';
@@ -299,51 +298,6 @@ export const classifyMaterial = Fn( ( [ metalness, roughness, transmission, clea
 
 } );
 
-// Dynamic MIS strategy based on material properties
-export const selectOptimalMISStrategy = Fn( ( [ roughness, metalness, bounceIndex, throughput ] ) => {
-
-	const throughputStrength = maxComponent( { v: throughput } ).toVar();
-
-	// Environment is now handled via deterministic NEE — not part of stochastic selection.
-	// Only lights and BRDF are stochastically selected.
-	const brdfWeight = float( 0.5 ).toVar();
-	const lightWeight = float( 0.5 ).toVar();
-	const useBRDFSampling = tslBool( true );
-	const useLightSampling = throughputStrength.greaterThan( 0.01 );
-
-	If( roughness.lessThan( 0.1 ).and( metalness.greaterThan( 0.8 ) ), () => {
-
-		// Highly specular materials — favor BRDF
-		brdfWeight.assign( 0.7 );
-		lightWeight.assign( 0.3 );
-
-	} ).ElseIf( roughness.greaterThan( 0.7 ), () => {
-
-		// Diffuse materials — favor light sampling
-		brdfWeight.assign( 0.4 );
-		lightWeight.assign( 0.6 );
-
-	} );
-
-	// Gentle adjustment for very deep bounces — shift toward BRDF
-	If( bounceIndex.greaterThan( int( 5 ) ), () => {
-
-		brdfWeight.assign( 0.6 );
-		lightWeight.assign( 0.4 );
-
-	} );
-
-	return MISStrategy( {
-		brdfWeight,
-		lightWeight,
-		envWeight: float( 0.0 ),
-		useBRDFSampling,
-		useLightSampling,
-		useEnvSampling: tslBool( false ),
-	} );
-
-} );
-
 // Storage buffer access — flat 1D indexing (WebGPU native)
 // No 2D coordinate math needed: directly indexes into the buffer
 export const getDatafromStorageBuffer = Fn( ( [ buffer, stride, sampleIndex, dataOffset ] ) => {

package/src/TSL/DebugKernel.js

@@ -13,7 +13,7 @@ import {
 	localId, workgroupId,
 } from 'three/tsl';
 
-import { generateRayFromCamera } from './BVHTraversal.js';
+import { generateRayFromCamera } from './CameraRay.js';
 import { Ray } from './Struct.js';
 import { TraceDebugMode } from './Debugger.js';
 import { pcgHash, getStratifiedSample } from './Random.js';
@@ -26,6 +26,7 @@ export function buildDebugKernel( params ) {
 		writeColorTex, writeNDTex, writeAlbedoTex,
 		resolution, renderWidth, renderHeight,
 		cameraWorldMatrix, cameraProjectionMatrixInverse, cameraProjectionMatrix, cameraViewMatrix,
+		cameraProjection, panoLonRange, panoLatRange, panoLevelHorizon,
 		enableDOF, focalLength, aperture, focusDistance, sceneScale, apertureScale, anamorphicRatio,
 		bvhBuffer, triangleBuffer, materialBuffer,
 		envTexture, environmentMatrix, environmentIntensity, enableEnvironmentLight,
@@ -45,12 +46,10 @@ export function buildDebugKernel( params ) {
 			const seed = pcgHash( { state: uint( pixelIndex ).add( uint( 1 ) ) } ).toVar();
 
 			// Center-pixel primary ray (no AA jitter — debug viz wants a stable, sharp image).
-			const screenPosition = pixelCoord.div( resolution ).mul( 2.0 ).sub( 1.0 ).toVar();
-			screenPosition.y.assign( screenPosition.y.negate() );
-
 			const ray = Ray.wrap( generateRayFromCamera(
-				screenPosition, seed,
+				pixelCoord.div( resolution ), seed,
 				cameraWorldMatrix, cameraProjectionMatrixInverse,
+				cameraProjection, panoLonRange, panoLatRange, panoLevelHorizon,
 				enableDOF, focalLength, aperture, focusDistance, sceneScale, apertureScale, anamorphicRatio,
 			) );