rayzee 7.21.0 → 7.22.0

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;

package/src/managers/UniformManager.js

@@ -6,7 +6,7 @@
  */
 
 import { uniform, uniformArray } from 'three/tsl';
-import { Vector2, Matrix4, Vector3, Color } from 'three';
+import { Vector2, Matrix4, Vector3, Color, MathUtils } from 'three';
 import { samplingTechniqueUniform } from '../TSL/Random.js';
 import { ENGINE_DEFAULTS as DEFAULT_STATE } from '../EngineDefaults.js';
 
@@ -241,6 +241,13 @@ export class UniformManager {
 		u( 'cameraViewMatrix', new Matrix4(), 'mat4' );
 		u( 'cameraProjectionMatrix', new Matrix4(), 'mat4' );
 
+		// Projection: 0 = pinhole, 1 = equirectangular panorama. Ranges are radians (UI carries degrees).
+		const radRange = ( [ min, max ] ) => new Vector2( min, max ).multiplyScalar( MathUtils.DEG2RAD );
+		u( 'cameraProjection', DEFAULT_STATE.cameraProjection === 'equirectangular' ? 1 : 0, 'int' );
+		u( 'panoLonRange', radRange( DEFAULT_STATE.panoramaLonRange ), 'vec2' );
+		u( 'panoLatRange', radRange( DEFAULT_STATE.panoramaLatRange ), 'vec2' );
+		ub( 'panoLevelHorizon', DEFAULT_STATE.panoramaLevelHorizon );
+
 		// DOF
 		ub( 'enableDOF', DEFAULT_STATE.enableDOF );
 		u( 'focusDistance', DEFAULT_STATE.focusDistance, 'float' );