rayzee 8.8.1 → 9.0.0

package/src/managers/CameraManager.js

@@ -1,14 +1,20 @@
-import { EventDispatcher, PerspectiveCamera, Vector3 } from 'three';
+import { EventDispatcher, MathUtils, OrthographicCamera, PerspectiveCamera, Vector3 } from 'three';
 import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
 import { EngineEvents, } from '../EngineEvents.js';
-import { AF_DEFAULTS } from '../EngineDefaults.js';
+import { AF_DEFAULTS, CAMERA_PROJECTION_IDS } from '../EngineDefaults.js';
+import { viewDepth } from './InteractionManager.js';
+import { ViewCamera } from './ViewCamera.js';
+import { WalkControls } from './WalkControls.js';
 
 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. */
+const orthoHeightOf = camera => camera?.isOrthographicCamera ? ( camera.top - camera.bottom ) / camera.zoom : null;
+
 /**
  * Manages camera creation, switching, auto-focus, and AF point placement.
  *
- * Owns the PerspectiveCamera and OrbitControls instances.
+ * Owns the {@link ViewCamera} and OrbitControls instances.
  * Dispatches events that PathTracerApp relays to external consumers.
  */
 export class CameraManager extends EventDispatcher {
@@ -23,7 +29,7 @@ export class CameraManager extends EventDispatcher {
 		const width = canvas.clientWidth;
 		const height = canvas.clientHeight;
 
-		this.camera = new PerspectiveCamera( 60, width / height || 1, 0.01, 1000 );
+		this.camera = new ViewCamera( 60, width / height || 1, 0.01, 1000 );
 		this.camera.position.set( 0, 0, 5 );
 
 		this.controls = new OrbitControls( this.camera, canvas );
@@ -31,9 +37,16 @@ export class CameraManager extends EventDispatcher {
 		this.controls.zoomToCursor = true;
 		this.controls.saveState();
 
+		// The wheel zooms an orthographic view: report its height.
+		this._reportedOrthoHeight = null;
+		this._reportOrthoHeight = this._reportOrthoHeight.bind( this );
+		this.controls.addEventListener( 'change', this._reportOrthoHeight );
+
+		this.walkControls = new WalkControls( this.camera, canvas, this.controls );
+
 		this.interactionManager = null;
 
-		/** @type {import('three').PerspectiveCamera[]} */
+		/** @type {import('three').Camera[]} */
 		this.cameras = [ this.camera ];
 		this.currentCameraIndex = 0;
 
@@ -62,19 +75,20 @@ export class CameraManager extends EventDispatcher {
 
 	/**
 	 * Sets the list of available cameras (default + extracted from model).
-	 * @param {import('three').PerspectiveCamera[]} cameras
+	 * @param {import('three').Camera[]} cameras - perspective or orthographic
 	 */
 	setCameras( cameras ) {
 
 		this.cameras = cameras;
 		this._userCameraCounter = 0;
+		this.resetAutoFocus();
 
 	}
 
 	/**
 	 * Adds a new user camera that snapshots the current render camera's pose,
-	 * FOV, clip planes, and orbit target. The snapshot is a standalone template
-	 * appended to the list; switching to it restores this exact framing.
+	 * FOV or orthographic size, clip planes, and orbit target. The snapshot is a standalone
+	 * template appended to the list; switching to it restores this exact framing.
 	 *
 	 * @param {string} [name] - Optional display name (auto-generated otherwise).
 	 * @returns {number} The index of the newly added camera.
@@ -82,7 +96,10 @@ export class CameraManager extends EventDispatcher {
 	addCameraFromView( name ) {
 
 		const src = this.camera;
-		const cam = new PerspectiveCamera( src.fov, src.aspect, src.near, src.far );
+		const cam = src.orthographic
+			? new OrthographicCamera( src.left, src.right, src.top, src.bottom, src.near, src.far )
+			: new PerspectiveCamera( src.fov, src.aspect, src.near, src.far );
+		cam.zoom = src.zoom;
 		cam.position.copy( src.position );
 		cam.quaternion.copy( src.quaternion );
 		cam.scale.copy( src.scale );
@@ -193,8 +210,10 @@ export class CameraManager extends EventDispatcher {
 			focalLength: get( 'focalLength' ),
 			apertureScale: get( 'apertureScale' ),
 			anamorphicRatio: get( 'anamorphicRatio' ),
+			dofBlur: get( 'dofBlur' ),
 			autoFocusMode: this.autoFocusMode,
 			afScreenPoint: { ...this.afScreenPoint },
+			orthoHeight: this.orthoHeight,
 		};
 
 	}
@@ -214,6 +233,7 @@ export class CameraManager extends EventDispatcher {
 			focalLength: eff.focalLength,
 			apertureScale: eff.apertureScale,
 			anamorphicRatio: eff.anamorphicRatio,
+			dofBlur: eff.dofBlur,
 		} );
 
 		if ( eff.autoFocusMode !== undefined ) this.setAutoFocusMode( eff.autoFocusMode );
@@ -221,13 +241,6 @@ export class CameraManager extends EventDispatcher {
 
 	}
 
-	/** Scene scale used to convert scaled focusDistance to UI-facing units. */
-	_getSceneScale() {
-
-		return this._afContext?.assetLoader?.getSceneScale?.() || 1;
-
-	}
-
 	/**
 	 * Switches the active camera by index.
 	 * Uses stored callbacks from initCallbacks() for resize/reset.
@@ -305,7 +318,7 @@ export class CameraManager extends EventDispatcher {
 			// quaternion can express — a pbrt scene's `Scale -1 1 1`, for one. Copying
 			// pose alone would silently un-mirror the view.
 			this.camera.scale.copy( sourceCamera.scale );
-			this.camera.fov = sourceCamera.fov;
+			if ( sourceCamera.isPerspectiveCamera ) this.camera.fov = sourceCamera.fov;
 			this.camera.near = sourceCamera.near;
 			this.camera.far = sourceCamera.far;
 			this.camera.updateProjectionMatrix();
@@ -334,18 +347,121 @@ export class CameraManager extends EventDispatcher {
 
 		}
 
+		this.resetAutoFocus();
+
+		// A camera left orthographic comes back orthographic; one never visited is what it was made as.
+		const incoming = this.cameras[ index ];
+		const saved = incoming?.userData?.__rayzeeEffects;
+		this._showOrthographic( saved ? saved.orthoHeight : orthoHeightOf( incoming ) );
+
 		// Restore the incoming camera's own DOF/focus effects (if it has any saved;
 		// otherwise it inherits the current global config).
-		this._applyEffects( this.cameras[ index ]?.userData?.__rayzeeEffects );
+		this._applyEffects( saved );
 
 		onResize?.();
 		onReset?.();
 
-		// Emit UI-facing effects: focusDistance unscaled (matching AUTO_FOCUS_UPDATED),
-		// so the adapter is a plain passthrough with no scene-scale awareness.
-		const effects = this._captureEffects();
-		if ( effects ) effects.focusDistance /= this._getSceneScale();
-		this.dispatchEvent( { type: 'CameraSwitched', cameraIndex: index, effects, fov: this.camera.fov } );
+		this.dispatchEvent( {
+			type: 'CameraSwitched', cameraIndex: index, effects: this._captureEffects(), fov: this.camera.fov,
+			cameraProjection: this._getSettings?.( 'cameraProjection' ),
+		} );
+
+	}
+
+	/**
+	 * Makes the camera orthographic at `height`, or perspective for null, then hands the `cameraProjection`
+	 * setting the outcome — after, so its handler finds the camera already there. A 360° panorama stays on
+	 * across perspective cameras.
+	 * @param {?number} height - in world units
+	 */
+	_showOrthographic( height ) {
+
+		if ( height > 0 ) this._setView( true, height / 2 );
+		else this._setView( false );
+
+		const current = this._getSettings?.( 'cameraProjection' );
+		const next = height > 0 ? 'orthographic' : current === 'orthographic' ? 'perspective' : current;
+		if ( next !== current ) this._applySettings?.( { cameraProjection: next } );
+
+	}
+
+	/**
+	 * The camera's side of the `cameraProjection` setting: set that, not this. Turning orthographic
+	 * keeps what the view shows at the orbit target, and turning back moves the camera to keep it.
+	 * @param {'perspective' | 'orthographic' | 'equirectangular'} projection
+	 */
+	applyProjection( projection ) {
+
+		const camera = this.camera;
+		const orthographic = projection === 'orthographic';
+		if ( camera.orthographic === orthographic ) return;
+
+		if ( orthographic ) {
+
+			this._setView( true, this._fittedHalfHeight() );
+
+		} else {
+
+			const target = this.controls.target;
+			const distance = this.orthoHeight / 2 / Math.tan( MathUtils.degToRad( camera.fov ) / 2 );
+			camera.position.sub( target ).setLength( distance ).add( target );
+			this._setView( false );
+
+		}
+
+		this.controls.update();
+
+	}
+
+	/** The height of the view in world units while orthographic, the wheel's zoom included; null otherwise. */
+	get orthoHeight() {
+
+		return orthoHeightOf( this.camera );
+
+	}
+
+	/** @param {number} height - the orthographic view's height, in world units */
+	setOrthoHeight( height ) {
+
+		if ( ! ( height > 0 ) ) return;
+		this._setView( this.camera.orthographic, height / 2 );
+		this._onReset?.();
+
+	}
+
+	/** Sizes an orthographic view to show what a perspective one would at the orbit target. */
+	fitOrthographic() {
+
+		if ( this.camera.orthographic ) this.setOrthoHeight( 2 * this._fittedHalfHeight() );
+
+	}
+
+	// The one writer of the camera's projection. The wheel's zoom starts over.
+	_setView( orthographic, halfHeight = this.camera.orthoHalfHeight ) {
+
+		const camera = this.camera;
+		camera.orthographic = orthographic;
+		camera.orthoHalfHeight = halfHeight;
+		camera.zoom = 1;
+		camera.updateProjectionMatrix();
+		this._reportOrthoHeight();
+
+	}
+
+	// Half of what a perspective view shows at the orbit target.
+	_fittedHalfHeight() {
+
+		return this.camera.position.distanceTo( this.controls.target ) * Math.tan( MathUtils.degToRad( this.camera.fov ) / 2 );
+
+	}
+
+	_reportOrthoHeight() {
+
+		if ( ! this.camera.orthographic ) return;
+		const height = this.orthoHeight;
+		if ( height === this._reportedOrthoHeight ) return;
+		this._reportedOrthoHeight = height;
+		this.dispatchEvent( { type: EngineEvents.ORTHO_HEIGHT_UPDATED, height } );
 
 	}
 
@@ -362,9 +478,88 @@ export class CameraManager extends EventDispatcher {
 
 	}
 
+	/**
+	 * Orbit around a target, or walk through the scene first-person (see {@link WalkControls}).
+	 * Leaving walk mode orbits around the surface at the centre of the view.
+	 * @param {'orbit' | 'walk'} mode
+	 */
+	setNavigationMode( mode ) {
+
+		const walk = mode === 'walk';
+		if ( this.walkControls.enabled === walk ) return;
+
+		const controls = this.controls;
+		controls.enableRotate = controls.enablePan = controls.enableZoom = ! walk;
+		this.walkControls.enabled = walk;
+		if ( walk ) return;
+
+		this.walkControls.release();
+		const hit = this.interactionManager?.pickSurface( 0, 0 );
+		if ( ! hit ) return;
+
+		const distance = MathUtils.clamp( hit.distance, controls.minDistance, controls.maxDistance );
+		controls.target.copy( this.camera.position ).addScaledVector( this.camera.getWorldDirection( new Vector3() ), distance );
+		controls.update();
+
+	}
+
+	/** @returns {'orbit' | 'walk'} */
+	get navigationMode() {
+
+		return this.walkControls.enabled ? 'walk' : 'orbit';
+
+	}
+
+	/** Per frame, before rendering. */
+	updateControls() {
+
+		this.walkControls.update();
+		this.controls.update();
+
+	}
+
+	/**
+	 * The current view as a pose: where the camera is, what it looks at, and how much it shows — the
+	 * height an orthographic view covers, or what a perspective one covers at its orbit target.
+	 * @returns {import('./timeline/CameraTrack.js').CameraPose}
+	 */
+	captureView() {
+
+		const camera = this.camera;
+		const orthoHeight = this.orthoHeight ?? 2 * this._fittedHalfHeight();
+		return { position: camera.position.clone(), target: this.controls.target.clone(), fov: camera.fov, orthoHeight };
+
+	}
+
+	/**
+	 * Puts the camera at a pose, looking at its target, sized for the projection in use.
+	 * @param {import('./timeline/CameraTrack.js').CameraPose} pose
+	 */
+	applyPose( pose ) {
+
+		const camera = this.camera;
+		camera.position.copy( pose.position );
+		camera.lookAt( pose.target );
+		this.controls.target.copy( pose.target );
+
+		if ( camera.orthographic ) {
+
+			this._setView( true, pose.orthoHeight / 2 );
+
+		} else {
+
+			camera.fov = pose.fov;
+			camera.updateProjectionMatrix();
+
+		}
+
+		camera.updateMatrixWorld();
+
+	}
+
 	// ── Aliases (match Sub-API surface) ───────────────────────────
 
-	/** The active Three.js PerspectiveCamera. */
+	/** The active camera, a {@link ViewCamera}. */
 	get active() {
 
 		return this.camera;
@@ -393,6 +588,15 @@ export class CameraManager extends EventDispatcher {
 
 	}
 
+	/** Forget what auto-focus last measured: it belonged to another model or viewpoint. */
+	resetAutoFocus() {
+
+		this._lastValidFocusDistance = null;
+		this._smoothedFocusDistance = null;
+		this._afPointDirty = true;
+
+	}
+
 	setAFScreenPoint( x, y ) {
 
 		this.afScreenPoint = { x, y };
@@ -420,9 +624,7 @@ export class CameraManager extends EventDispatcher {
 	 * Per-frame auto-focus update. Called in animate() before pipeline.render().
 	 *
 	 * @param {Object} params
-	 * @param {import('three').Scene} params.meshScene
 	 * @param {Object} params.assetLoader
-	 * @param {import('three').Mesh} params.floorPlane
 	 * @param {number} params.currentFocusDistance
 	 * @param {import('../Stages/PathTracer.js').PathTracer} params.pathTracer
 	 * @param {Function} params.setFocusDistance - Callback to update uniform + settings
@@ -431,16 +633,18 @@ export class CameraManager extends EventDispatcher {
 	 */
 	updateAutoFocus( ctx ) {
 
-		const { meshScene, assetLoader, floorPlane, currentFocusDistance, pathTracer, setFocusDistance, softReset, hardReset } = ctx || this._afContext || {};
-		if ( ! meshScene ) return;
+		const context = ctx || this._afContext;
+		if ( ! context || ! this.interactionManager ) return;
+		const { assetLoader, currentFocusDistance, pathTracer, setFocusDistance, softReset, hardReset } = context;
 
 		if ( this.autoFocusMode === 'manual' ) return;
 
 		// Depth-of-field is the only consumer of the auto-focus distance. With DOF
 		// off (the default) the per-frame scene raycast is pure waste, so skip it.
-		// Re-snap on the frame DOF turns back on so focus is correct immediately
+		// A panorama pauses it too: Raycaster.setFromCamera only knows a frustum.
+		// Re-snap on the frame it resumes so focus is correct immediately
 		// rather than racking from a stale smoothed value.
-		if ( ! pathTracer?.enableDOF?.value ) {
+		if ( ! pathTracer?.enableDOF?.value || pathTracer.cameraProjection?.value === CAMERA_PROJECTION_IDS.equirectangular ) {
 
 			this._afSuspended = true;
 			return;
@@ -461,27 +665,13 @@ export class CameraManager extends EventDispatcher {
 			&& stage.frameCount > 0
 			&& ! stage.isComplete ) return;
 
-		// Convert AF screen point (normalized 0-1) to NDC (-1 to 1)
-		const ndcX = this.afScreenPoint.x * 2 - 1;
-		const ndcY = - ( this.afScreenPoint.y * 2 - 1 );
-
-		const raycaster = this.interactionManager?.raycaster;
-		if ( ! raycaster ) return;
-
-		raycaster.setFromCamera( { x: ndcX, y: ndcY }, this.camera );
-		const intersects = raycaster.intersectObjects( meshScene.children, true );
-
-		const validHit = intersects.find( hit =>
-			hit.object !== this.interactionManager?.focusPointIndicator &&
-			hit.object !== floorPlane &&
-			! hit.object.name.includes( 'Helper' ) &&
-			hit.object.type === 'Mesh'
-		);
+		// AF screen point (0 to 1, y down) to NDC.
+		const validHit = this.interactionManager.pickSurface( this.afScreenPoint.x * 2 - 1, 1 - this.afScreenPoint.y * 2 );
 
 		let rawDistance;
 		if ( validHit ) {
 
-			rawDistance = validHit.distance;
+			rawDistance = viewDepth( validHit.point, this.camera );
 			this._lastValidFocusDistance = rawDistance;
 
 		} else {
@@ -492,8 +682,9 @@ export class CameraManager extends EventDispatcher {
 
 			} else {
 
-				const scale = assetLoader?.getSceneScale() || 1.0;
-				rawDistance = AF_DEFAULTS.FALLBACK_DISTANCE * scale;
+				// 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 );
 				this._lastValidFocusDistance = rawDistance;
 
 			}
@@ -533,9 +724,8 @@ export class CameraManager extends EventDispatcher {
 
 			setFocusDistance( newFocus );
 
-			// Update store for UI display (unscaled value)
 			const scale = assetLoader?.getSceneScale() || 1.0;
-			this.dispatchEvent( { type: EngineEvents.AUTO_FOCUS_UPDATED, distance: newFocus / scale } );
+			this.dispatchEvent( { type: EngineEvents.AUTO_FOCUS_UPDATED, distance: newFocus / scale, worldDistance: newFocus } );
 
 			const changeRatio = Math.abs( newFocus - prevFocus ) / Math.max( prevFocus, 0.001 );
 			if ( forceReset ) {
@@ -569,20 +759,16 @@ export class CameraManager extends EventDispatcher {
 	 * and `updateAutoFocus()` reads from it each frame — no per-frame allocation.
 	 *
 	 * @param {Object} deps
-	 * @param {import('three').Scene}           deps.meshScene
 	 * @param {import('../Processor/AssetLoader.js').AssetLoader} deps.assetLoader
-	 * @param {import('three').Mesh}            deps.floorPlane
 	 * @param {import('../Stages/PathTracer.js').PathTracer} deps.pathTracer
 	 * @param {import('../RenderSettings.js').RenderSettings} deps.settings
 	 * @param {Function}                        deps.softReset
 	 * @param {Function}                        deps.hardReset
 	 */
-	initAutoFocus( { meshScene, assetLoader, floorPlane, pathTracer, settings, softReset, hardReset } ) {
+	initAutoFocus( { assetLoader, pathTracer, settings, softReset, hardReset } ) {
 
 		this._afContext = {
-			meshScene,
 			assetLoader,
-			floorPlane,
 			pathTracer,
 			setFocusDistance: ( d ) => settings.set( 'focusDistance', d, { silent: true } ),
 			softReset,
@@ -598,6 +784,8 @@ export class CameraManager extends EventDispatcher {
 
 	dispose() {
 
+		this.walkControls?.dispose();
+		this.controls?.removeEventListener( 'change', this._reportOrthoHeight );
 		this.controls?.dispose();
 
 	}

package/src/managers/DenoisingManager.js

@@ -8,7 +8,7 @@ import { createLogger } from '../utils/Logger.js';
 // The neural passes live in `../neural/` but report through the manager that drives them, so they
 // share one namespace: `rayzee.log.only( 'neural' )` shows the whole chain.
 const neuralLog = createLogger( 'neural' );
-import { ENGINE_DEFAULTS as DEFAULT_STATE, ASVGF_QUALITY_PRESETS, NRD_DEFAULTS, NRD_QUALITY_PRESETS, NRD_PRESET_KEYS } from '../EngineDefaults.js';
+import { ENGINE_DEFAULTS as DEFAULT_STATE, ASVGF_QUALITY_PRESETS, NRD_DEFAULTS, NRD_QUALITY_PRESETS, NRD_PRESET_KEYS, CAMERA_PROJECTION_IDS } from '../EngineDefaults.js';
 
 // A refresh slower than this is a slideshow, not a live view, so the cadence swaps to a cheaper
 // model and puts the chosen one back for the finished image. Resolution-aware by construction:
@@ -164,7 +164,7 @@ export class DenoisingManager extends EventDispatcher {
 		this._knownResetCount = 0;
 		this._seenTracedFrames = 0;
 		this._viewProj = new Matrix4();
-		this._historyCamera = { world: null, projInv: null, viewProj: null };
+		this._historyCamera = { world: null, projInv: null, viewProj: null, orthographic: false };
 		// TLAS leaf → { world, offset, prev }: placements moved since the last traced frame.
 		this._movedPlacements = new Map();
 		this._movedUpload = { count: 0, leaves: new Uint32Array( 0 ), toPrev: new Float32Array( 0 ) };
@@ -870,7 +870,7 @@ export class DenoisingManager extends EventDispatcher {
 
 		const pt = this._stages.pathTracer;
 		return this.historyWanted && ! this._cadenceSuspended && !! this._stages.normalDepth?.enabled
-			&& ( pt?.uniforms?.get( 'cameraProjection' )?.value ?? 0 ) === 0
+			&& pt?.uniforms?.get( 'cameraProjection' )?.value !== CAMERA_PROJECTION_IDS.equirectangular
 			&& ! ( pt?.visMode?.value > 0 );
 
 	}
@@ -1043,6 +1043,7 @@ export class DenoisingManager extends EventDispatcher {
 		camera.world = pt.cameraWorldMatrix.value.elements;
 		camera.projInv = pt.cameraProjectionMatrixInverse.value.elements;
 		camera.viewProj = this._viewProj.elements;
+		camera.orthographic = pt.uniforms?.get( 'cameraProjection' )?.value === CAMERA_PROJECTION_IDS.orthographic;
 		return camera;
 
 	}

package/src/managers/InteractionManager.js

@@ -3,9 +3,28 @@ import {
 	Raycaster,
 	SphereGeometry,
 	Mesh,
-	MeshBasicMaterial
+	MeshBasicMaterial,
+	Vector3
 } from 'three';
 import { EngineEvents } from '../EngineEvents.js';
+import { CAMERA_PROJECTION_IDS } from '../EngineDefaults.js';
+
+const _viewAxis = new Vector3();
+const _toPoint = new Vector3();
+
+/** Depth of a point along the camera's view axis — the distance the flat focal plane is measured in. */
+export function viewDepth( point, camera ) {
+
+	return _toPoint.subVectors( point, camera.position ).dot( camera.getWorldDirection( _viewAxis ) );
+
+}
+
+/** The focus distance that puts a raycast hit in focus: a panorama focuses along each ray, not on a plane. */
+export function focusDistanceOfHit( hit, camera, panorama = false ) {
+
+	return panorama ? hit.distance : viewDepth( hit.point, camera );
+
+}
 
 /**
  * InteractionManager
@@ -207,7 +226,8 @@ export class InteractionManager extends EventDispatcher {
 		if ( intersects.length > 0 ) {
 
 			const intersection = intersects[ 0 ];
-			const distance = intersection.distance;
+			const panorama = this.pathTracer?.cameraProjection?.value === CAMERA_PROJECTION_IDS.equirectangular;
+			const distance = focusDistanceOfHit( intersection, this.camera, panorama );
 
 			// Show visual indicator at focus point
 			this.showFocusPoint( intersection.point );
@@ -675,6 +695,14 @@ export class InteractionManager extends EventDispatcher {
 
 	}
 
+	/** The nearest scene surface under an NDC point, skipping the floor and helpers. */
+	pickSurface( ndcX, ndcY ) {
+
+		this.raycaster.setFromCamera( { x: ndcX, y: ndcY }, this.camera );
+		return this.filterValidIntersects( this.raycaster.intersectObjects( this.scene.children, true ) )[ 0 ] ?? null;
+
+	}
+
 	/**
 	 * Filter intersections to exclude helper objects and floor plane
 	 * @private

package/src/managers/UniformManager.js

@@ -8,7 +8,7 @@
 import { uniform, uniformArray } from 'three/tsl';
 import { Vector2, Matrix4, Vector3, Color, MathUtils } from 'three';
 import { samplingTechniqueUniform } from '../TSL/Random.js';
-import { ENGINE_DEFAULTS as DEFAULT_STATE } from '../EngineDefaults.js';
+import { ENGINE_DEFAULTS as DEFAULT_STATE, CAMERA_PROJECTION_IDS } from '../EngineDefaults.js';
 
 /**
  * Map of uniform names to their WGSL shader names (where different).
@@ -278,9 +278,9 @@ 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).
+		// Projection: CAMERA_PROJECTION_IDS. 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( 'cameraProjection', CAMERA_PROJECTION_IDS[ DEFAULT_STATE.cameraProjection ], 'int' );
 		u( 'panoLonRange', radRange( DEFAULT_STATE.panoramaLonRange ), 'vec2' );
 		u( 'panoLatRange', radRange( DEFAULT_STATE.panoramaLatRange ), 'vec2' );
 		ub( 'panoLevelHorizon', DEFAULT_STATE.panoramaLevelHorizon );
@@ -292,7 +292,9 @@ export class UniformManager {
 		u( 'aperture', DEFAULT_STATE.aperture, 'float' );
 		u( 'apertureScale', 1.0, 'float' );
 		u( 'anamorphicRatio', DEFAULT_STATE.anamorphicRatio ?? 1.0, 'float' );
-		u( 'sceneScale', 1.0, 'float' );
+		u( 'unitsPerMetre', DEFAULT_STATE.unitsPerMetre, 'float' );
+		u( 'dofMode', DEFAULT_STATE.dofMode === 'look' ? 1 : 0, 'int' );
+		u( 'dofBlur', DEFAULT_STATE.dofBlur, 'float' );
 
 		// Sampling — use the module-level uniform from Random.js so TSL sees the same node
 		this._uniforms.set( 'samplingTechnique', samplingTechniqueUniform );