rayzee 8.8.2 → 9.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rayzee",
-  "version": "8.8.2",
+  "version": "9.0.0",
   "type": "module",
   "description": "Real-time WebGPU path tracing engine built on Three.js",
   "main": "dist/rayzee.umd.js",

package/src/EngineDefaults.js

@@ -14,6 +14,7 @@ export const RENDER_PROFILES = Object.freeze( {
 		environmentRotation: 0.0, // degrees — the HDRI as authored, as Blender shows it
 		toneMapping: 6, // AgXToneMapping
 		saturation: 1.0, // no grade
+		dofMode: 'look', // depth of field set by how blurry it looks, not by a lens — right at any scene scale
 	} ),
 	physical: Object.freeze( {
 		areaLightIntensityScale: 1.0,
@@ -22,6 +23,7 @@ export const RENDER_PROFILES = Object.freeze( {
 		// engine's own corpus (shade 1.48 vs AgX 3.01 from identical radiance).
 		toneMapping: 6,
 		saturation: 1.0, // no grade
+		dofMode: 'physical',
 	} ),
 } );
 
@@ -101,7 +103,7 @@ export const ENGINE_DEFAULTS = {
 	skyMieAnisotropy: 0.76,
 	skyPreset: 'clearMorning',
 
-	// Camera projection — 'perspective' | 'equirectangular'. Panorama ranges are UI-facing degrees.
+	// Camera projection — 'perspective' | 'orthographic' | 'equirectangular'. Panorama ranges are UI-facing degrees.
 	cameraProjection: 'perspective',
 	panoramaLonRange: [ - 180, 180 ],
 	panoramaLatRange: [ - 90, 90 ],
@@ -114,6 +116,9 @@ export const ENGINE_DEFAULTS = {
 	focalLength: 50,
 	apertureScale: 1.0,
 	anamorphicRatio: 1.0,
+	unitsPerMetre: 1, // scene units per real metre; the lens is specified in mm
+	dofMode: RENDER_PROFILES.viewer.dofMode, // 'look' | 'physical'
+	dofBlur: 0.05, // look mode: a far background's blur, as a fraction of the image height
 
 	// Auto-focus
 	autoFocusMode: 'auto', // 'manual' | 'auto'
@@ -252,6 +257,9 @@ export const ENGINE_DEFAULTS = {
 	autoExposureAdaptSpeedDark: 0.5,
 };
 
+/** The `cameraProjection` uniform's value for each setting value. */
+export const CAMERA_PROJECTION_IDS = Object.freeze( { perspective: 0, equirectangular: 1, orthographic: 2 } );
+
 // Ray distance NormalDepth writes on a miss. Max finite half-float, so miss−miss diffs stay 0
 // rather than Inf−Inf=NaN.
 export const GBUFFER_MISS_DEPTH = 65504.0;
@@ -474,44 +482,39 @@ export const CAMERA_PRESETS = {
 	portrait: {
 		name: "Portrait",
 		description: "Shallow depth of field, background blur",
-		fov: 45,
-		focusDistance: 1.5,
+		dofBlur: 0.10,
 		aperture: 1.4,
 		focalLength: 135,
-		apertureScale: 1.5
+		apertureScale: 1.0
 	},
 	landscape: {
 		name: "Landscape",
 		description: "Maximum depth of field, everything in focus",
-		fov: 65,
-		focusDistance: 10.0,
+		dofBlur: 0.001,
 		aperture: 16.0,
 		focalLength: 24,
 		apertureScale: 0.5
 	},
 	macro: {
 		name: "Macro",
-		description: "Extreme close-up with thin focus plane",
-		fov: 40,
-		focusDistance: 0.3,
-		aperture: 2.0,
+		description: "Very thin focus plane for close-ups",
+		dofBlur: 0.14,
+		aperture: 1.4,
 		focalLength: 100,
 		apertureScale: 2.0
 	},
 	product: {
 		name: "Product",
 		description: "Sharp detail with subtle background separation",
-		fov: 50,
-		focusDistance: 0.8,
+		dofBlur: 0.013,
 		aperture: 2.8,
 		focalLength: 85,
-		apertureScale: 1.0
+		apertureScale: 0.4
 	},
 	architectural: {
 		name: "Architectural",
-		description: "Wide view with deep focus",
-		fov: 75,
-		focusDistance: 5.0,
+		description: "Deep focus for rooms and buildings",
+		dofBlur: 0.001,
 		aperture: 11.0,
 		focalLength: 16,
 		apertureScale: 0.5
@@ -519,11 +522,10 @@ export const CAMERA_PRESETS = {
 	cinematic: {
 		name: "Cinematic",
 		description: "Dramatic depth separation with anamorphic bokeh",
-		fov: 35,
-		focusDistance: 3.0,
+		dofBlur: 0.13,
 		aperture: 1.4,
 		focalLength: 200,
-		apertureScale: 1.8,
+		apertureScale: 1.0,
 		anamorphicRatio: 1.5
 	}
 };

package/src/EngineEvents.js

@@ -36,6 +36,7 @@ export const EngineEvents = {
 
 	// Camera
 	AUTO_FOCUS_UPDATED: 'engine:autoFocusUpdated',
+	ORTHO_HEIGHT_UPDATED: 'engine:orthoHeightUpdated',
 	AUTO_EXPOSURE_UPDATED: 'engine:autoExposureUpdated',
 	AF_POINT_PLACED: 'engine:afPointPlaced',
 
@@ -48,6 +49,9 @@ export const EngineEvents = {
 	ANIMATION_STOPPED: 'engine:animationStopped',
 	ANIMATION_FINISHED: 'engine:animationFinished',
 
+	// Timeline (authored keyframes)
+	TIMELINE_CHANGED: 'engine:timelineChanged',
+
 	// Video rendering
 	VIDEO_RENDER_PROGRESS: 'engine:videoRenderProgress',
 	VIDEO_RENDER_COMPLETE: 'engine:videoRenderComplete',

package/src/Passes/OIDNTemporalHistory.js

@@ -22,10 +22,11 @@ export const HISTORY_DEFAULTS = Object.freeze( {
 } );
 
 const WG = 8;
-const PARAMS_BYTES = 288;
+const PARAMS_BYTES = 304;
 const MIN_MOVED_CAPACITY = 16;
 const FLAG_CLEAN_AUX = 1;
 const FLAG_SPLIT_COPIES = 2;
+const FLAG_ORTHOGRAPHIC = 4;
 const PICK_MOVED = 0x40000000;
 
 const COMMON_WGSL = /* wgsl */`
@@ -47,6 +48,7 @@ struct Params {
 	prevCamPos: vec4<f32>,
 	moved: vec4<u32>,
 	movedLength: f32,
+	prevCamDir: vec4<f32>,
 };
 
 @group(0) @binding(0) var<uniform> P: Params;
@@ -104,9 +106,19 @@ fn main( @builtin(global_invocation_id) gid: vec3<u32> ) {
 
 		let size = vec2<f32>( P.size );
 		let uv = ( vec2<f32>( gid.xy ) + 0.5 ) / size;
-		let rc = P.projInv * vec4<f32>( uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0, 1.0, 1.0 );
-		let dir = normalize( ( P.camWorld * vec4<f32>( rc.xyz / rc.w, 0.0 ) ).xyz );
-		var wp = P.camWorld[ 3 ].xyz + dir * g.w;
+		// Depth is along the ray: from the camera, or from its image plane when orthographic.
+		let ortho = ( P.flags & ${ FLAG_ORTHOGRAPHIC }u ) != 0u;
+		let ndc = vec2<f32>( uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0 );
+		var origin = P.camWorld[ 3 ].xyz;
+		var dir: vec3<f32>;
+		if ( ortho ) {
+			origin = ( P.camWorld * vec4<f32>( ( P.projInv * vec4<f32>( ndc, 0.0, 1.0 ) ).xy, 0.0, 1.0 ) ).xyz;
+			dir = - normalize( P.camWorld[ 2 ].xyz );
+		} else {
+			let rc = P.projInv * vec4<f32>( ndc, 1.0, 1.0 );
+			dir = normalize( ( P.camWorld * vec4<f32>( rc.xyz / rc.w, 0.0 ) ).xyz );
+		}
+		var wp = origin + dir * g.w;
 		var n = g.xyz * 2.0 - 1.0;
 
 		// A moved object's surface is looked for where the object was.
@@ -132,7 +144,7 @@ fn main( @builtin(global_invocation_id) gid: vec3<u32> ) {
 			let pos = vec2<f32>( clip.x / clip.w * 0.5 + 0.5, 0.5 - clip.y / clip.w * 0.5 ) * size - 0.5;
 			let base = vec2<i32>( floor( pos ) );
 			let f = fract( pos );
-			let expected = length( wp - P.prevCamPos.xyz );
+			let expected = select( length( wp - P.prevCamPos.xyz ), dot( wp - P.prevCamPos.xyz, P.prevCamDir.xyz ), ortho );
 
 			for ( var j = 0; j < 2; j++ ) {
 				for ( var i = 0; i < 2; i++ ) {
@@ -306,6 +318,7 @@ export class OIDNTemporalHistory {
 		this._paramF32 = new Float32Array( this._paramData );
 		this._prevViewProj = new Float32Array( 16 );
 		this._prevCamPos = new Float32Array( 4 );
+		this._prevCamDir = new Float32Array( 4 );
 
 	}
 
@@ -325,7 +338,7 @@ export class OIDNTemporalHistory {
 	/**
 	 * Blends the frame just traced (a restart: one sample) into the reprojected history.
 	 * @param {Object} src - GPUTextures { color, albedo, normal, geo, geoPrev, shading, leaf } and { width, height }
-	 * @param {{ world: Float32Array, projInv: Float32Array, viewProj: Float32Array }} camera - of that frame
+	 * @param {{ world: Float32Array, projInv: Float32Array, viewProj: Float32Array, orthographic: boolean }} camera - of that frame
 	 * @param {?{ count: number, leaves: Uint32Array, toPrev: Float32Array }} [moved] - TLAS leaves
 	 *   (ascending) that moved since the last frame, with each one's current→previous world matrix
 	 */
@@ -524,7 +537,7 @@ export class OIDNTemporalHistory {
 		u[ 0 ] = this.width;
 		u[ 1 ] = this.height;
 		u[ 2 ] = reset ? 1 : 0;
-		u[ 3 ] = ( s.cleanAux ? FLAG_CLEAN_AUX : 0 ) | ( s.splitCopies ? FLAG_SPLIT_COPIES : 0 );
+		u[ 3 ] = ( s.cleanAux ? FLAG_CLEAN_AUX : 0 ) | ( s.splitCopies ? FLAG_SPLIT_COPIES : 0 ) | ( camera.orthographic ? FLAG_ORTHOGRAPHIC : 0 );
 		f[ 4 ] = s.maxLength;
 		f[ 5 ] = s.smoothLength;
 		f[ 6 ] = s.depthTolerance;
@@ -539,6 +552,7 @@ export class OIDNTemporalHistory {
 		f.set( this._prevCamPos, 60 );
 		u[ 64 ] = this._movedCount;
 		f[ 68 ] = s.movedLength;
+		f.set( this._prevCamDir, 72 );
 		this.device.queue.writeBuffer( this._paramsBuffer, 0, this._paramData );
 
 	}
@@ -549,6 +563,10 @@ export class OIDNTemporalHistory {
 		this._prevCamPos[ 0 ] = camera.world[ 12 ];
 		this._prevCamPos[ 1 ] = camera.world[ 13 ];
 		this._prevCamPos[ 2 ] = camera.world[ 14 ];
+		const back = Math.hypot( camera.world[ 8 ], camera.world[ 9 ], camera.world[ 10 ] );
+		this._prevCamDir[ 0 ] = - camera.world[ 8 ] / back;
+		this._prevCamDir[ 1 ] = - camera.world[ 9 ] / back;
+		this._prevCamDir[ 2 ] = - camera.world[ 10 ] / back;
 
 	}
 

package/src/PathTracerApp.js

@@ -35,6 +35,7 @@ import { SceneProcessor } from './Processor/SceneProcessor.js';
 // Managers
 import { RenderSettings } from './RenderSettings.js';
 import { CameraManager } from './managers/CameraManager.js';
+import { TimelineManager } from './managers/timeline/TimelineManager.js';
 import { LightManager } from './managers/LightManager.js';
 import { GoboManager } from './managers/GoboManager.js';
 import { IESManager } from './managers/IESManager.js';
@@ -181,6 +182,7 @@ export class PathTracerApp extends EventDispatcher {
 				...DEFAULT_STATE,
 				environmentRotation: this._profile.environmentRotation,
 				saturation: this._profile.saturation,
+				dofMode: this._profile.dofMode,
 			},
 			{ issues: this._issues }
 		);
@@ -214,6 +216,8 @@ export class PathTracerApp extends EventDispatcher {
 		// ── Managers (direct public access) ──
 		/** @type {CameraManager} */
 		this.cameraManager = null;
+		/** @type {TimelineManager} Authored animation: keyframed tracks. */
+		this.timeline = null;
 		/** @type {LightManager} */
 		this.lightManager = null;
 		/** @type {GoboManager} */
@@ -359,7 +363,8 @@ export class PathTracerApp extends EventDispatcher {
 
 		}
 
-		if ( this.cameraManager.controls ) this.cameraManager.controls.update();
+		this.timeline.update();
+		this.cameraManager.updateControls();
 
 		this._applyPendingRenderScale();
 
@@ -638,6 +643,7 @@ export class PathTracerApp extends EventDispatcher {
 		this.iesManager?.dispose();
 		this.denoisingManager?.dispose();
 		this.interactionManager?.dispose();
+		this.timeline?.dispose();
 		this.cameraManager?.dispose();
 
 		this.pipeline?.dispose();
@@ -2088,6 +2094,7 @@ export class PathTracerApp extends EventDispatcher {
 		// refresh landing in the middle of that raced the renderer's own output pass.
 		this.denoisingManager?.setCadenceSuspended( isProduction );
 
+		this.timeline.stop();
 		this.cameraManager.controls.enabled = ! isProduction;
 
 		// Anything with a SETTING_ROUTES entry must go through settings, not setUniform: set() early-returns on
@@ -3390,6 +3397,7 @@ export class PathTracerApp extends EventDispatcher {
 	_initCameraManager() {
 
 		this.cameraManager = new CameraManager( this.canvas );
+		this.timeline = new TimelineManager( { cameraManager: this.cameraManager, onReset: () => this.reset() } );
 
 	}
 
@@ -3415,14 +3423,19 @@ export class PathTracerApp extends EventDispatcher {
 		this.assetLoader.setRenderer( this.renderer );
 		this.assetLoader.createFloorPlane();
 
-		this._addTrackedListener( this.cameraManager.controls, 'change', () => {
+		const onCameraMoved = () => {
 
 			this.needsReset = true;
 			// Here rather than in render(), so the first frame of the move is already at the lower resolution.
 			this.stages.pathTracer?.enterInteractionMode();
 			this.wake();
 
-		} );
+		};
+
+		this._addTrackedListener( this.cameraManager.controls, 'change', onCameraMoved );
+		this._addTrackedListener( this.cameraManager.walkControls, 'change', onCameraMoved );
+		// A held key moves the camera from the frame loop, which may be asleep.
+		this._addTrackedListener( this.cameraManager.walkControls, 'start', () => this.wake() );
 
 	}
 
@@ -3526,6 +3539,8 @@ export class PathTracerApp extends EventDispatcher {
 		// Forward manager events → app events
 		this._addTrackedListener( this.cameraManager, 'CameraSwitched', ( e ) => this.dispatchEvent( e ) );
 		this._addTrackedListener( this.cameraManager, EngineEvents.AUTO_FOCUS_UPDATED, ( e ) => this.dispatchEvent( e ) );
+		this._addTrackedListener( this.cameraManager, EngineEvents.ORTHO_HEIGHT_UPDATED, ( e ) => this.dispatchEvent( e ) );
+		this._addTrackedListener( this.timeline, EngineEvents.TIMELINE_CHANGED, ( e ) => this.dispatchEvent( e ) );
 
 		this._forwardEvents( this.denoisingManager, [
 			EngineEvents.DENOISING_START, EngineEvents.DENOISING_END,
@@ -3566,9 +3581,7 @@ export class PathTracerApp extends EventDispatcher {
 
 		// Auto-focus context — CameraManager stores it, reads it each frame
 		this.cameraManager.initAutoFocus( {
-			meshScene: this.meshScene,
 			assetLoader: this.assetLoader,
-			floorPlane: this.assetLoader.floorPlane,
 			pathTracer: this.stages.pathTracer,
 			settings: this.settings,
 			softReset: () => this.reset( true ),
@@ -3582,12 +3595,12 @@ export class PathTracerApp extends EventDispatcher {
 			resetCallback: () => this.reset(),
 			reconcileCompletion: () => this._reconcileCompletion(),
 			denoisingManager: this.denoisingManager,
-			cameraManager: this.cameraManager,
 			onInteractionRenderScale: () => {
 
 				if ( this.stages.pathTracer?.interactionMode ) this._requestRenderScale( this._interactionRenderScale() );
 
 			},
+			onCameraProjection: ( value ) => this.cameraManager.applyProjection( value ),
 		} );
 
 		this.renderer.toneMappingExposure = this.settings.get( 'exposure' ) ?? 1.0;
@@ -3643,6 +3656,8 @@ export class PathTracerApp extends EventDispatcher {
 
 			const cameras = [ this.cameraManager.camera, ...( event.cameras || [] ) ];
 			this.cameraManager.setCameras( cameras );
+			// Keys are poses in the scene being replaced, like the cameras saved in it.
+			this.timeline.clear();
 
 			if ( this.interactionManager ) {
 
@@ -3821,8 +3836,10 @@ export class PathTracerApp extends EventDispatcher {
 
 	_syncControlsAfterLoad() {
 
+		this.cameraManager.fitOrthographic();
 		this.cameraManager.controls.saveState();
 		this.cameraManager.controls.update();
+		this.cameraManager.walkControls.fitSpeed( this.assetLoader.getSceneScale() );
 
 	}
 

package/src/Processor/AssetLoader.js

@@ -97,6 +97,7 @@ export class AssetLoader extends EventDispatcher {
 		this.targetModel = null;
 		this.floorPlane = null;
 		this.sceneScale = 1.0;
+		this.sceneSize = new Vector3( 1, 1, 1 );
 		this.loaderCache = {};
 		this.uploadedFileInfo = null;
 		this.animations = [];
@@ -2000,6 +2001,7 @@ export class AssetLoader extends EventDispatcher {
 
 		// Calculate scene scale factor based on model size
 		const sceneScale = maxDim;
+		this.sceneSize.copy( size );
 
 		// Rebuild path tracing
 		buildTimer.start( 'setupPathTracing' );
@@ -2216,6 +2218,13 @@ export class AssetLoader extends EventDispatcher {
 
 	}
 
+	/** The loaded model's bounding-box size along x, y and z, in scene units. */
+	getSceneSize() {
+
+		return this.sceneSize.clone();
+
+	}
+
 	getTargetModel() {
 
 		return this.targetModel;

package/src/Processor/PBRT/PBRTSceneBuilder.js

@@ -3,7 +3,7 @@
  *
  * Output: { group, camera, environment, animations, warnings }
  *   - group:       THREE.Group of meshes (fed to PathTracerApp.loadObject3D)
- *   - camera:      PerspectiveCamera matching the pbrt Camera/LookAt, parented
+ *   - camera:      Perspective- or OrthographicCamera matching the pbrt Camera/LookAt, parented
  *                  into the group so AssetLoader.extractCamerasFromModel finds it
  *   - environment: { texture } | null — set by the caller as scene.environment
  *   - animations:  [ AnimationClip ] when the IR carries motion (see PBRTAnimation.js), else []
@@ -15,7 +15,7 @@
  */
 
 import {
-	Group, Mesh, InstancedMesh, PerspectiveCamera, Matrix4, Vector3, Quaternion,
+	Group, Mesh, InstancedMesh, PerspectiveCamera, OrthographicCamera, Matrix4, Vector3, Quaternion,
 	BufferGeometry, Float32BufferAttribute, Uint32BufferAttribute, SphereGeometry,
 	DataTexture, FloatType, RGBAFormat, LinearFilter, EquirectangularReflectionMapping,
 	SRGBColorSpace, AnimationClip, VectorKeyframeTrack, QuaternionKeyframeTrack,
@@ -184,7 +184,7 @@ export class PBRTSceneBuilder {
 
 	/**
 	 * @param {object} ir - output of PBRTParser
-	 * @returns {Promise<{group:Group, camera:PerspectiveCamera|null, environment:object|null, warnings:string[]}>}
+	 * @returns {Promise<{group:Group, camera:PerspectiveCamera|OrthographicCamera|null, environment:object|null, warnings:string[]}>}
 	 */
 	async build( ir ) {
 
@@ -494,7 +494,7 @@ export class PBRTSceneBuilder {
 
 			} );
 
-			if ( camMotion.fov ) {
+			if ( camMotion.fov && camera.isPerspectiveCamera ) {
 
 				const fovs = Array.from( camMotion.fov, f => this._verticalFov( { fov: { type: 'float', value: [ f ] } }, camera.aspect ) );
 				tracks.push( new NumberKeyframeTrack( `${camera.name}.fov`, camMotion.times.slice(), fovs ) );
@@ -1175,9 +1175,21 @@ export class PBRTSceneBuilder {
 	_buildCamera( cam, film ) {
 
 		const aspect = film && film.yresolution ? film.xresolution / film.yresolution : 16 / 9;
-		const fov = this._verticalFov( cam.params, aspect );
 
-		const camera = new PerspectiveCamera( fov, aspect, 0.01, 10000 );
+		let camera;
+		if ( cam.type === 'orthographic' ) {
+
+			// pbrt's default screen window spans [-1, 1] along the shorter image axis.
+			const window = cam.params?.screenwindow?.value;
+			const half = window?.length === 4 ? ( window[ 3 ] - window[ 2 ] ) / 2 : Math.max( 1, 1 / aspect );
+			camera = new OrthographicCamera( - half * aspect, half * aspect, half, - half, 0.01, 10000 );
+
+		} else {
+
+			camera = new PerspectiveCamera( this._verticalFov( cam.params, aspect ), aspect, 0.01, 10000 );
+
+		}
+
 		camera.name = 'PBRT Camera';
 		this._poseCamera( camera, cam.cameraToWorld );
 		camera.updateMatrixWorld( true );

package/src/RenderSettings.js

@@ -1,5 +1,5 @@
 import { EventDispatcher, Color, Vector2, MathUtils } from 'three';
-import { ENGINE_DEFAULTS } from './EngineDefaults.js';
+import { ENGINE_DEFAULTS, CAMERA_PROJECTION_IDS } from './EngineDefaults.js';
 import { EngineEvents } from './EngineEvents.js';
 import { ISSUE_CODES } from './EngineIssues.js';
 
@@ -40,6 +40,9 @@ const SETTING_ROUTES = {
 	aperture: { uniform: 'aperture', reset: true },
 	apertureScale: { uniform: 'apertureScale', reset: true },
 	anamorphicRatio: { uniform: 'anamorphicRatio', reset: true },
+	unitsPerMetre: { uniform: 'unitsPerMetre', reset: true },
+	dofMode: { handler: 'handleDofMode', reset: true },
+	dofBlur: { uniform: 'dofBlur', reset: true },
 	samplingTechnique: { uniform: 'samplingTechnique', reset: true },
 	fireflyThreshold: { uniform: 'fireflyThreshold', reset: true },
 	shadowTerminatorOffset: { uniform: 'shadowTerminatorOffset', reset: true },
@@ -149,8 +152,8 @@ export class RenderSettings extends EventDispatcher {
 	 * @param {Function} params.resetCallback   - Called to reset accumulation
 	 * @param {Function} [params.reconcileCompletion] - Called when completion limits change
 	 * @param {Object} [params.denoisingManager] - Needed to force ASVGF off under panorama
-	 * @param {Object} [params.cameraManager]    - Needed to force auto-focus manual under panorama
 	 * @param {Function} [params.onInteractionRenderScale] - Applies a new moving-camera render scale
+	 * @param {Function} [params.onCameraProjection] - The camera's side of a `cameraProjection` change
 	 */
 	bind( params ) {
 
@@ -165,7 +168,7 @@ export class RenderSettings extends EventDispatcher {
 	 * Builds handler functions for multi-stage settings that can't
 	 * be routed with a simple uniform forward.
 	 */
-	_buildHandlers( { stages, renderer, resetCallback, reconcileCompletion, denoisingManager, cameraManager, onInteractionRenderScale } ) {
+	_buildHandlers( { stages, renderer, resetCallback, reconcileCompletion, denoisingManager, onInteractionRenderScale, onCameraProjection } ) {
 
 		// UniformManager copies into the existing node, so one scratch vector serves every write.
 		const panoScratch = new Vector2();
@@ -180,20 +183,20 @@ export class RenderSettings extends EventDispatcher {
 
 			handleCameraProjection: ( value ) => {
 
-				const isPanorama = value === 'equirectangular';
-				stages.pathTracer?.setUniform( 'cameraProjection', isPanorama ? 1 : 0 );
+				stages.pathTracer?.setUniform( 'cameraProjection', CAMERA_PROJECTION_IDS[ value ] ?? CAMERA_PROJECTION_IDS.perspective );
+				onCameraProjection?.( value );
 
-				if ( ! isPanorama ) return;
+				if ( value !== 'equirectangular' ) return;
 
 				// MotionVector unprojects through projectionMatrixInverse, which is meaningless once
 				// every pixel is its own direction. Fall back to the spatial-only denoiser rather
 				// than leaving no strategy.
 				if ( denoisingManager?.requiresMotionVectors ) denoisingManager.setDenoiserStrategy( 'edgeaware' );
-				// Auto-focus raycasts via Raycaster.setFromCamera, which only knows the frustum.
-				cameraManager?.setAutoFocusMode( 'manual' );
 
 			},
 
+			handleDofMode: ( value ) => stages.pathTracer?.setUniform( 'dofMode', value === 'look' ? 1 : 0 ),
+
 			handlePanoramaLonRange: ( value ) => setPanoRange( 'panoLonRange', value ),
 
 			handlePanoramaLatRange: ( value ) => setPanoRange( 'panoLatRange', value ),

package/src/Stages/MotionVector.js

@@ -1,9 +1,10 @@
-import { Fn, vec2, vec3, vec4, float, int, uint, ivec2, uvec2, uniform, If, normalize, mat3,
+import { Fn, vec2, vec3, vec4, float, int, uint, ivec2, uvec2, uniform, If,
 	textureLoad, textureStore, workgroupId, localId } from 'three/tsl';
 import { RenderTarget, TextureNode, StorageTexture } from 'three/webgpu';
 import { HalfFloatType, RGBAFormat, NearestFilter, Matrix4, Box2, Vector2 } from 'three';
 import { RenderStage, StageExecutionMode } from '../Pipeline/RenderStage.js';
 import { MAX_STORAGE_TEXTURE_SIZE } from '../EngineDefaults.js';
+import { cameraRayPoint, cameraRayUniforms } from '../TSL/CameraRay.js';
 
 /**
  * WebGPU Motion Vector Stage (Compute Shader)
@@ -20,8 +21,8 @@ import { MAX_STORAGE_TEXTURE_SIZE } from '../EngineDefaults.js';
  *
  * Algorithm:
  *   1. Read normalDepth from NormalDepth (linear depth in alpha)
- *   2. Reconstruct camera ray from pixel coords via inverse projection
- *   3. World position = cameraPos + normalize(rayDir) * linearDepth
+ *   2. Reconstruct the camera ray NormalDepth traced for the pixel
+ *   3. World position = rayOrigin + rayDir * linearDepth
  *   4. Project to previous frame:  prevVP * worldPos
  *   5. Motion = currentUV - prevUV
  *
@@ -78,6 +79,7 @@ export class MotionVector extends RenderStage {
 		// Synced from PathTracer each frame (same source as NormalDepth)
 		this.cameraWorldMatrix = uniform( new Matrix4(), 'mat4' );
 		this.cameraProjectionMatrixInverse = uniform( new Matrix4(), 'mat4' );
+		this.cameraRay = cameraRayUniforms();
 		this.prevVP = uniform( new Matrix4(), 'mat4' );
 		this.isFirstFrameU = uniform( 1.0 ); // 1.0 = true, 0.0 = false
 		this.deltaTime = uniform( 1.0 / 60.0 );
@@ -175,29 +177,7 @@ export class MotionVector extends RenderStage {
 				// Sky / background (depth >= 65504 sentinel) — no motion
 				If( linearDepth.lessThan( float( 6e4 ) ), () => {
 
-					// Pixel coordinate → NDC
-					// Negate Y to match PathTracer convention
-					const ndcX = float( gx ).add( 0.5 ).div( resW ).mul( 2.0 ).sub( 1.0 );
-					const ndcY = float( gy ).add( 0.5 ).div( resH ).mul( 2.0 ).sub( 1.0 ).negate();
-					const ndcPos = vec3( ndcX, ndcY, 1.0 );
-
-					// Camera-space ray direction via inverse projection
-					const rayDirCS = cpi.mul( vec4( ndcPos, 1.0 ) );
-
-					// Transform to world space (rotation only, via mat3 of world matrix)
-					const rayDirWorld = normalize(
-						mat3(
-							cwm[ 0 ].xyz,
-							cwm[ 1 ].xyz,
-							cwm[ 2 ].xyz
-						).mul( rayDirCS.xyz.div( rayDirCS.w ) )
-					);
-
-					// Camera position (translation column of world matrix)
-					const camPos = vec3( cwm[ 3 ] );
-
-					// World position = camera origin + ray direction * linear depth
-					const worldPos = camPos.add( rayDirWorld.mul( linearDepth ) );
+					const worldPos = cameraRayPoint( currentUV, linearDepth, cwm, cpi, this.cameraRay );
 
 					// Project to previous frame
 					const prevClip = prevVP.mul( vec4( worldPos, 1.0 ) );
@@ -278,27 +258,12 @@ export class MotionVector extends RenderStage {
 				// Skip first frame and sky (depth >= 65504 sentinel)
 				If( isFirstFrameU.lessThan( 0.5 ).and( linearDepth.lessThan( float( 6e4 ) ) ), () => {
 
-					// Pixel coordinate → NDC
-					// Negate Y to match PathTracer convention
-					const ndcX = float( gx ).add( 0.5 ).div( resW ).mul( 2.0 ).sub( 1.0 );
-					const ndcY = float( gy ).add( 0.5 ).div( resH ).mul( 2.0 ).sub( 1.0 ).negate();
-					const ndcPos = vec3( ndcX, ndcY, 1.0 );
-					const rayDirCS = cpi.mul( vec4( ndcPos, 1.0 ) );
-					const rayDirWorld = normalize(
-						mat3(
-							cwm[ 0 ].xyz,
-							cwm[ 1 ].xyz,
-							cwm[ 2 ].xyz
-						).mul( rayDirCS.xyz.div( rayDirCS.w ) )
-					);
-					const camPos = vec3( cwm[ 3 ] );
-					const worldPos = camPos.add( rayDirWorld.mul( linearDepth ) );
-
 					// Current pixel UV
 					const currentUV = vec2(
 						float( gx ).add( 0.5 ).div( resW ),
 						float( gy ).add( 0.5 ).div( resH )
 					);
+					const worldPos = cameraRayPoint( currentUV, linearDepth, cwm, cpi, this.cameraRay );
 
 					// Project to previous frame
 					const prevClip = prevVP.mul( vec4( worldPos, 1.0 ) );
@@ -370,6 +335,7 @@ export class MotionVector extends RenderStage {
 		if ( pt && pt.uniforms ) {
 
 			// Sync from PathTracer (same source as NormalDepth)
+			this.cameraRay.sync( pt.uniforms );
 			worldMatrix = pt.uniforms.get( 'cameraWorldMatrix' ).value;
 			viewMatrix = pt.uniforms.get( 'cameraViewMatrix' ).value;
 			projMatrix = pt.uniforms.get( 'cameraProjectionMatrix' ).value;