rayzee 7.21.0 → 7.22.1

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 = {} ) {
@@ -350,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' );
@@ -402,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 );
 
 				}
 
@@ -935,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 = {
@@ -948,6 +944,10 @@ export class PathTracer extends PathTracerStage {
 			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,
@@ -977,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 ) );
 
 			} );
 
@@ -1050,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( () => {
@@ -1073,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;
@@ -1108,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(),
@@ -1292,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( {
@@ -1324,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,
@@ -1351,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,
@@ -1396,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 );
 
 	}
 
@@ -1416,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/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/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,
 			) );
 

package/src/TSL/ExtendKernel.js

@@ -13,17 +13,17 @@ import {
 import { traverseBVH } from './BVHTraversal.js';
 import { Ray, HitInfo } from './Struct.js';
 import {
-	readRayOrigin, readRayDirection, readMediumStack,
+	readRayOrigin, readRayDirection, readRayBounceFlags, readMediumStack,
 	writeHitPacked,
 } from '../Processor/PackedRayBuffer.js';
-import { COUNTER } from '../Processor/QueueManager.js';
+import { COUNTER, RAY_FLAG } from '../Processor/QueueManager.js';
 
 const WG_SIZE = 256;
 
 export function buildExtendKernel( params ) {
 
 	const {
-		bvhBuffer, triangleBuffer, materialBuffer,
+		bvhBuffer, triangleBuffer,
 		rayBufferRO,
 		hitBufferRW,
 		activeIndicesRO,
@@ -45,6 +45,14 @@ export function buildExtendKernel( params ) {
 
 		const rayID = activeIndicesRO.element( threadIdx );
 
+		// Parity with Shade's guard. Free — the flags share DIR_FLAGS.w with the direction read below.
+		// Only culls work on the pinned-dispatch path, whose identity list still holds dead rays.
+		If( readRayBounceFlags( rayBufferRO, rayID ).bitAnd( uint( RAY_FLAG.ACTIVE ) ).equal( uint( 0 ) ), () => {
+
+			Return();
+
+		} );
+
 		const origin = readRayOrigin( rayBufferRO, rayID ).toVar();
 		const direction = readRayDirection( rayBufferRO, rayID ).toVar();
 

package/src/TSL/FinalWriteKernel.js

@@ -54,7 +54,7 @@ export function buildFinalWriteKernel( params ) {
 
 		// Tier-2 per-pixel freeze: streakBufferRW = per-pixel freeze-candidate streak (stamped here);
 		// frozenMaskRO = dilated frozen mask from buildActivePixels (pass-through gates on it, not streak).
-		usePixelFreeze, pixelFreezeThreshold, pixelFreezeStability, streakBufferRW, frozenMaskRO,
+		usePixelFreeze, pixelFreezeThreshold, streakBufferRW, frozenMaskRO,
 	} = params;
 
 	const auxOn = auxGBufferEnabled.greaterThan( uint( 0 ) );
@@ -184,25 +184,12 @@ export function buildFinalWriteKernel( params ) {
 
 					} );
 
-					If( wasFrozen, () => {
-
-						// Already frozen (passed through above) — count it.
-						atomicAdd( counters.element( uint( COUNTER.FROZEN_COUNT ) ), uint( 1 ) );
-
-					} );
-
 					If( wasFrozen.not().and( frame.greaterThan( uint( 0 ) ) ), () => {
 
 						const freezeCandidate = frame.greaterThanEqual( uint( adaptiveMinSamples ) )
 							.and( relErr.lessThan( pixelFreezeThreshold ) );
 						const newStreak = select( freezeCandidate, streakBufferRW.element( pixelId ).add( uint( 1 ) ), uint( 0 ) ).toVar();
 						streakBufferRW.element( pixelId ).assign( newStreak );
-						// Just reached K → frozen next frame; count it now so the frozen population is current.
-						If( newStreak.greaterThanEqual( uint( pixelFreezeStability ) ), () => {
-
-							atomicAdd( counters.element( uint( COUNTER.FROZEN_COUNT ) ), uint( 1 ) );
-
-						} );
 
 					} );
 

package/src/TSL/GenerateKernel.js

@@ -22,7 +22,7 @@ import {
 	getStratifiedSample,
 } from './Random.js';
 
-import { generateRayFromCamera } from './BVHTraversal.js';
+import { generateRayFromCamera } from './CameraRay.js';
 import { Ray } from './Struct.js';
 import { RAY_FLAG, COUNTER } from '../Processor/QueueManager.js';
 import {
@@ -39,6 +39,7 @@ export function buildGenerateKernel( params ) {
 		rayBufferRW, rngBufferRW, gBufferRW,
 		resolution, frame,
 		cameraWorldMatrix, cameraProjectionMatrixInverse,
+		cameraProjection, panoLonRange, panoLatRange, panoLevelHorizon,
 		enableDOF, focalLength, aperture, focusDistance, sceneScale, apertureScale, anamorphicRatio,
 		renderWidth,
 		chunkRowBase, chunkRows, // row band offset (global first row) + row count for this chunk
@@ -56,9 +57,6 @@ export function buildGenerateKernel( params ) {
 
 		const pixelCoord = vec2( float( gx ).add( 0.5 ), float( gy ).add( 0.5 ) );
 
-		const screenPosition = pixelCoord.div( resolution ).mul( 2.0 ).sub( 1.0 ).toVar();
-		screenPosition.y.assign( screenPosition.y.negate() );
-
 		const baseSeed = getDecorrelatedSeed( { pixelCoord, rayIndex: int( 0 ), frame } ).toVar();
 		const seed = pcgHash( { state: baseSeed } ).toVar();
 
@@ -68,13 +66,18 @@ export function buildGenerateKernel( params ) {
 		// position from the first scatter direction (they were reading the identical cell).
 		const stratifiedJitter = getStratifiedSample( pixelCoord, int( 1 ), int( 1 ), seed, resolution, frame ).toVar();
 
-		const jitterScale = vec2( 2.0 ).div( resolution );
-		const jitter = stratifiedJitter.sub( 0.5 ).mul( jitterScale );
-		const jitteredScreenPosition = screenPosition.add( jitter );
+		// Y is subtracted because uv.y grows downward while the NDC this used to build grew upward —
+		// keeps the sub-pixel sample sequence bit-identical to the pre-panorama ray gen.
+		const jitterOffset = stratifiedJitter.sub( 0.5 );
+		const jitteredUV = vec2(
+			pixelCoord.x.add( jitterOffset.x ),
+			pixelCoord.y.sub( jitterOffset.y )
+		).div( resolution );
 
 		const ray = Ray.wrap( generateRayFromCamera(
-			jitteredScreenPosition, seed,
+			jitteredUV, seed,
 			cameraWorldMatrix, cameraProjectionMatrixInverse,
+			cameraProjection, panoLonRange, panoLatRange, panoLevelHorizon,
 			enableDOF, focalLength, aperture, focusDistance, sceneScale, apertureScale, anamorphicRatio,
 		) );
 

package/src/TSL/SortGlobalKernels.js

@@ -111,20 +111,65 @@ export function buildGlobalPrefixKernel( { sortGlobalHistogram, bins = SORT_GLOB
 
 }
 
-// Pass 4 — scatter: atomicAdd on the prefix-summed histogram gives each ray its global slot
-// within its material's contiguous region.
+// Pass 4 — scatter: each ray lands in a unique slot inside its material's contiguous region.
+//
+// Global atomics are reduced from O(rays) to O(workgroups × bins touched) by reserving one block
+// per bin per workgroup, the same aggregation Pass 2 already applies to the histogram. `local`
+// changes meaning across the barriers: first a per-workgroup count, then the workgroup's global
+// base cursor for that bin, which the lanes then bump to claim their own slot.
+//
+// Slot order WITHIN a bin changes versus the per-ray version, but it was never deterministic —
+// the old path raced on the same global atomicAdd. The output is still an exact permutation of the
+// entering set, and Shade reads each ray independently.
 export function buildGlobalScatterKernel( { hitBufferRO, activeIndicesReadRO, sortedIndicesRW, sortGlobalHistogram, counters, bins = SORT_GLOBAL_MAX_BINS } ) {
 
 	return Fn( () => {
 
 		const tid = instanceIndex;
+		const lid = localId.x;
+		const local = workgroupAtomicArray( 'uint', bins );
+
+		If( lid.lessThan( uint( bins ) ), () => {
+
+			atomicStore( local.element( lid ), uint( 0 ) );
+
+		} );
+		workgroupBarrier();
+
+		// Read once and reuse: recomputing the bin after the barriers would re-fetch the hit buffer.
 		const entering = atomicLoad( counters.element( uint( COUNTER.ENTERING_COUNT ) ) );
-		If( tid.lessThan( entering ), () => {
+		const inRange = tid.lessThan( entering );
+		const rayID = uint( 0 ).toVar();
+		const bin = uint( 0 ).toVar();
 
-			const rayID = activeIndicesReadRO.element( tid );
-			const bin = uint( readHitMaterialIndex( hitBufferRO, rayID ) ).clamp( uint( 0 ), uint( bins - 1 ) );
-			const pos = atomicAdd( sortGlobalHistogram.element( bin ), uint( 1 ) );
-			sortedIndicesRW.element( pos ).assign( rayID );
+		If( inRange, () => {
+
+			rayID.assign( activeIndicesReadRO.element( tid ) );
+			bin.assign( uint( readHitMaterialIndex( hitBufferRO, rayID ) ).clamp( uint( 0 ), uint( bins - 1 ) ) );
+			atomicAdd( local.element( bin ), uint( 1 ) );
+
+		} );
+		workgroupBarrier();
+
+		// One global atomic per bin per workgroup reserves that block; the returned base replaces the
+		// count in place. Bins this workgroup never touched are skipped — no lane will read them.
+		If( lid.lessThan( uint( bins ) ), () => {
+
+			const slot = local.element( lid );
+			const c = atomicLoad( slot );
+			If( c.greaterThan( uint( 0 ) ), () => {
+
+				atomicStore( slot, atomicAdd( sortGlobalHistogram.element( lid ), c ) );
+
+			} );
+
+		} );
+		workgroupBarrier();
+
+		If( inRange, () => {
+
+			// Workgroup-local atomic: gives this lane its rank inside the block reserved above.
+			sortedIndicesRW.element( atomicAdd( local.element( bin ), uint( 1 ) ) ).assign( rayID );
 
 		} );
 

package/src/managers/DenoisingManager.js

@@ -225,6 +225,19 @@ export class DenoisingManager extends EventDispatcher {
 	 * @param {string} strategy   - 'none' | 'asvgf' | 'edgeaware'
 	 * @param {string} [asvgfPreset] - ASVGF quality preset when strategy is 'asvgf'
 	 */
+	/**
+	 * Active real-time denoiser, derived from stage state so it can't drift from
+	 * setDenoiserStrategy / setASVGFEnabled.
+	 * @returns {'asvgf'|'edgeaware'|'none'}
+	 */
+	get denoiserStrategy() {
+
+		if ( this._stages.asvgf?.enabled ) return 'asvgf';
+		if ( this._stages.edgeFilter?.enabled ) return 'edgeaware';
+		return 'none';
+
+	}
+
 	setDenoiserStrategy( strategy, asvgfPreset ) {
 
 		const s = this._stages;

package/src/managers/EnvironmentManager.js

@@ -8,7 +8,7 @@
  */
 
 import {
-	RGBAFormat, RedFormat, FloatType, Vector2, Vector3, Color, Matrix4, DataTexture,
+	RGBAFormat, RedFormat, FloatType, LinearFilter, Vector2, Vector3, Color, Matrix4, DataTexture,
 } from 'three';
 import { EquirectHDRInfo } from '../Processor/EquirectHDRInfo.js';
 import { ProceduralSky } from '../Processor/ProceduralSky.js';
@@ -36,9 +36,12 @@ export class EnvironmentManager {
 		this.proceduralSkyRenderer = null;
 		this.simpleSkyRenderer = null;
 
-		// Environment texture — 1×1 black placeholder for shader compilation
+		// Environment texture — 1×1 black placeholder for shader compilation. Filters must be
+		// Linear: DataTexture defaults to Nearest, which is unfilterable, and WGSLNodeBuilder then
+		// omits the `_sampler` binding that sampleEnvironment() takes as an explicit wgslFn arg.
 		this._envPlaceholder = new DataTexture(
-			new Float32Array( [ 0, 0, 0, 1 ] ), 1, 1, RGBAFormat, FloatType
+			new Float32Array( [ 0, 0, 0, 1 ] ), 1, 1, RGBAFormat, FloatType,
+			undefined, undefined, undefined, LinearFilter, LinearFilter
 		);
 		this._envPlaceholder.needsUpdate = true;
 		this.environmentTexture = this._envPlaceholder;