rayzee 8.8.2 → 9.1.0

package/src/managers/CameraManager.js

@@ -1,14 +1,21 @@
-import { EventDispatcher, PerspectiveCamera, Vector3 } from 'three';
+import { EventDispatcher, MathUtils, OrthographicCamera, PerspectiveCamera, Quaternion, 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';
+import { toPortable, fromPortable } from '../SceneState/portable.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 +30,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 +38,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 +76,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 +97,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 +211,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 +234,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 +242,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 +319,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 +348,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 +479,255 @@ 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();
+
+	}
+
+	// ── Saved sessions ────────────────────────────────────────────
+
+	/**
+	 * The live view, every camera's own effects, the cameras the user added and which one is
+	 * active, as plain data. The active camera's effects are the render settings themselves.
+	 * @returns {Object}
+	 */
+	serialize() {
+
+		const camera = this.camera;
+		const saved = this._defaultCameraState;
+
+		return {
+			current: this.currentCameraIndex,
+			view: {
+				position: camera.position.toArray(),
+				quaternion: camera.quaternion.toArray(),
+				scale: camera.scale.toArray(),
+				fov: camera.fov,
+				near: camera.near,
+				far: camera.far,
+				zoom: camera.zoom,
+				orthographic: !! camera.orthographic,
+				orthoHalfHeight: camera.orthoHalfHeight,
+				target: this.controls.target.toArray(),
+			},
+			defaultView: saved ? {
+				position: saved.position.toArray(),
+				quaternion: saved.quaternion.toArray(),
+				scale: saved.scale.toArray(),
+				fov: saved.fov,
+				near: saved.near,
+				far: saved.far,
+				target: saved.target?.toArray() ?? null,
+			} : null,
+			navigationMode: this.navigationMode,
+			autoFocus: { mode: this.autoFocusMode, point: { ...this.afScreenPoint } },
+			cameras: this.cameras.map( ( cam, index ) => {
+
+				const entry = { index, name: cam.name ?? '', effects: toPortable( cam.userData?.__rayzeeEffects ) ?? null };
+				if ( index === 0 || ! cam.userData?.__rayzeeUserCamera ) return entry;
+
+				return {
+					...entry,
+					user: true,
+					orthographic: !! cam.isOrthographicCamera,
+					frustum: cam.isOrthographicCamera ? [ cam.left, cam.right, cam.top, cam.bottom ] : null,
+					fov: cam.fov ?? null,
+					aspect: cam.aspect ?? null,
+					near: cam.near,
+					far: cam.far,
+					zoom: cam.zoom,
+					position: cam.position.toArray(),
+					quaternion: cam.quaternion.toArray(),
+					scale: cam.scale.toArray(),
+					orbitTarget: cam.userData.__rayzeeOrbitTarget?.toArray() ?? null,
+				};
+
+			} ),
+		};
+
+	}
+
+	/**
+	 * Puts back what {@link serialize} recorded, against the cameras this load produced. A model
+	 * camera is matched by index and name; one that no longer matches keeps its own effects.
+	 * Restore render settings first: this sets the exact view after any projection change they made.
+	 * @param {Object} state
+	 * @returns {{mismatched: string[]}} model cameras whose saved effects were not applied
+	 */
+	restore( state ) {
+
+		const mismatched = [];
+		if ( ! state ) return { mismatched };
+
+		this.cameras = this.cameras.filter( cam => ! cam.userData?.__rayzeeUserCamera );
+		const indexMap = new Map();
+
+		for ( const entry of state.cameras ?? [] ) {
+
+			if ( entry.user ) {
+
+				const cam = entry.orthographic
+					? new OrthographicCamera( ...entry.frustum, entry.near, entry.far )
+					: new PerspectiveCamera( entry.fov, entry.aspect, entry.near, entry.far );
+				cam.name = entry.name;
+				cam.zoom = entry.zoom ?? 1;
+				cam.position.fromArray( entry.position );
+				cam.quaternion.fromArray( entry.quaternion );
+				cam.scale.fromArray( entry.scale );
+				cam.updateProjectionMatrix();
+				cam.updateMatrixWorld( true );
+				cam.userData.__rayzeeUserCamera = true;
+				cam.userData.__rayzeeEffects = fromPortable( entry.effects );
+				if ( entry.orbitTarget ) cam.userData.__rayzeeOrbitTarget = new Vector3().fromArray( entry.orbitTarget );
+				indexMap.set( entry.index, this.cameras.length );
+				this.cameras.push( cam );
+				continue;
+
+			}
+
+			const cam = this.cameras[ entry.index ];
+			if ( ! cam || ( entry.index > 0 && ( cam.name ?? '' ) !== entry.name ) ) {
+
+				mismatched.push( entry.name );
+				continue;
+
+			}
+
+			indexMap.set( entry.index, entry.index );
+			if ( entry.effects ) cam.userData.__rayzeeEffects = fromPortable( entry.effects );
+
+		}
+
+		this._userCameraCounter = this.cameras.filter( cam => cam.userData?.__rayzeeUserCamera ).length;
+		this.currentCameraIndex = indexMap.get( state.current ) ?? 0;
+
+		const d = state.defaultView;
+		this._defaultCameraState = d ? {
+			position: new Vector3().fromArray( d.position ),
+			quaternion: new Quaternion().fromArray( d.quaternion ),
+			scale: new Vector3().fromArray( d.scale ),
+			fov: d.fov,
+			near: d.near,
+			far: d.far,
+			target: d.target ? new Vector3().fromArray( d.target ) : null,
+		} : null;
+
+		if ( state.navigationMode ) this.setNavigationMode( state.navigationMode );
+
+		const v = state.view;
+		if ( v ) {
+
+			const camera = this.camera;
+			camera.position.fromArray( v.position );
+			camera.quaternion.fromArray( v.quaternion );
+			camera.scale.fromArray( v.scale );
+			camera.fov = v.fov;
+			camera.near = v.near;
+			camera.far = v.far;
+			this._setView( v.orthographic, v.orthoHalfHeight );
+			camera.zoom = v.zoom ?? 1;
+			camera.updateProjectionMatrix();
+			camera.updateMatrixWorld( true );
+			this.controls.target.fromArray( v.target );
+			this.controls.update();
+
+		}
+
+		if ( state.autoFocus ) {
+
+			this.setAutoFocusMode( state.autoFocus.mode );
+			this.setAFScreenPoint( state.autoFocus.point.x, state.autoFocus.point.y );
+
+		}
+
+		this.resetAutoFocus();
+		this._reportOrthoHeight();
+		this.dispatchEvent( {
+			type: 'CameraSwitched', cameraIndex: this.currentCameraIndex, effects: this._captureEffects(), fov: this.camera.fov,
+			cameraProjection: this._getSettings?.( 'cameraProjection' ),
+		} );
+
+		return { mismatched };
+
+	}
+
 	// ── Aliases (match Sub-API surface) ───────────────────────────
 
-	/** The active Three.js PerspectiveCamera. */
+	/** The active camera, a {@link ViewCamera}. */
 	get active() {
 
 		return this.camera;
@@ -393,6 +756,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 +792,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 +801,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 +833,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 +850,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 +892,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 +927,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 +952,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;
 
 	}