rayzee 9.3.1 → 9.3.3

package/src/Processor/SceneProcessor.js

@@ -2597,6 +2597,7 @@ export class SceneProcessor {
 	async refitBVH( newPositions, newNormals ) {
 
 		this._geometryVersion = ( this._geometryVersion ?? 0 ) + 1;
+		this._tlasLeafBoxesOf = null;
 
 		if ( ! this.bvh || ! this.triangles || ! this.instanceTable ) {
 
@@ -2648,13 +2649,19 @@ export class SceneProcessor {
 		// can be released as soon as it is read. Callers hand over world space; triangles are
 		// stored per instance, so each mesh comes back through its own inverse.
 		const table = this.instanceTable;
+		const FPT = TRIANGLE_DATA_LAYOUT.FLOATS_PER_TRIANGLE;
+		const triRanges = [];
+		const blasRanges = [];
+		let owners = 0;
 		for ( let i = 0; i < table.count; i ++ ) {
 
 			if ( ! table.isSet[ i ] || ! table.isOwner( i ) ) continue;
+			owners ++;
 
 			const p = positionsFor( i );
 			if ( ! p ) continue;
 			this._updateMeshTrianglePositions( i, p );
+			blasRanges.push( table.blasOffsetOf( i ), table.blasNodeCountOf( i ) );
 
 			// Smooth normals overwrite the face normals just computed, so they follow per mesh.
 			if ( normalsFor ) {
@@ -2664,8 +2671,18 @@ export class SceneProcessor {
 
 			}
 
+			const offset = table.triOffsetOf( i ) * FPT, count = table.triCountOf( i ) * FPT;
+			const last = triRanges.at( - 1 );
+			if ( last && last.offset + last.count === offset ) last.count += count;
+			else triRanges.push( { offset, count } );
+
 		}
 
+		const tlasNodeCount = table.tlasNodeCount;
+		const partial = tlasNodeCount > 0 && blasRanges.length / 2 < owners;
+		const bvhRanges = partial ? [ this.computeTLASDirtyRange() ] : null;
+		for ( let r = 0; partial && r < blasRanges.length; r += 2 ) bvhRanges.push( { offset: blasRanges[ r ] * 16, count: blasRanges[ r + 1 ] * 16 } );
+
 		return new Promise( ( resolve, reject ) => {
 
 			this._refitWorker.onmessage = ( e ) => {
@@ -2673,7 +2690,7 @@ export class SceneProcessor {
 				const msg = e.data;
 				if ( msg.type === 'refitComplete' ) {
 
-					resolve( { refitTimeMs: msg.refitTimeMs } );
+					resolve( { refitTimeMs: msg.refitTimeMs, triRanges, bvhRanges } );
 
 				} else if ( msg.type === 'error' ) {
 
@@ -2684,7 +2701,7 @@ export class SceneProcessor {
 			};
 
 			// Signal worker — no data transfer needed, everything is in shared memory
-			this._refitWorker.postMessage( { type: 'refit' } );
+			this._refitWorker.postMessage( { type: 'refit', blasRanges: partial ? blasRanges : null, tlasNodeCount } );
 
 		} );
 
@@ -2834,6 +2851,8 @@ export class SceneProcessor {
 		const start = performance.now();
 		const table = this.instanceTable;
 		const composed = this._transformScratch ??= new Float32Array( 16 );
+		if ( this._movedPlacements?.length !== table.count ) this._movedPlacements = new Uint8Array( table.count );
+		const movedMask = this._movedPlacements;
 		let moved = 0;
 
 		for ( const meshIndex of meshIndices ) {
@@ -2870,13 +2889,15 @@ export class SceneProcessor {
 				}
 
 				this._writeLeafMatrix( p );
+				movedMask[ p ] = 1;
 				moved ++;
 
 			}
 
 		}
 
-		this._refitTLAS();
+		this._refitTLAS( movedMask );
+		movedMask.fill( 0 );
 
 		return { refitTimeMs: performance.now() - start, placements: moved };
 
@@ -3357,6 +3378,8 @@ export class SceneProcessor {
 	/** Keep the chunked BVH and its u32 index view in step. @private */
 	_setBVHData( data ) {
 
+		this._tlasLeafBoxesOf = null;
+
 		const records = ! data ? null
 			: ( data instanceof ChunkedRecords
 				? data
@@ -3538,9 +3561,11 @@ export class SceneProcessor {
 	/**
 	 * Refit TLAS AABBs in-place without rebuilding the tree structure.
 	 * O(tlasNodeCount) bottom-up pass — much faster than full SAH rebuild.
+	 * @param {Uint8Array} [moved] - by placement: only these leaves' world boxes are recomputed, the
+	 *   rest kept from the last pass. Every leaf when omitted, or when nothing valid was kept.
 	 * @private
 	 */
-	_refitTLAS() {
+	_refitTLAS( moved = null ) {
 
 		const tlasNodeCount = this.instanceTable.tlasNodeCount;
 
@@ -3548,10 +3573,12 @@ export class SceneProcessor {
 		if ( ! this._tlasBounds || this._tlasBounds.length < tlasNodeCount * 6 ) {
 
 			this._tlasBounds = new Float32Array( tlasNodeCount * 6 );
+			this._tlasLeafBoxesOf = null;
 
 		}
 
 		const table = this.instanceTable;
+		const keep = moved && this._tlasLeafBoxesOf === table;
 
 		// Bottom-up pass: reverse iteration over TLAS nodes
 		for ( let i = tlasNodeCount - 1; i >= 0; i -- ) {
@@ -3567,7 +3594,7 @@ export class SceneProcessor {
 				// every placement of a shared geometry onto one box, so all but one copy sat
 				// outside its own bounds and rays walked straight past it.
 				const entryIndex = idxChunk[ o + 1 ] & TLAS_PLACEMENT_MASK;
-				if ( entryIndex < table.count ) {
+				if ( entryIndex < table.count && ! ( keep && ! moved[ entryIndex ] ) ) {
 
 					table.writeWorldAABB( entryIndex, this._tlasBounds, i * 6 );
 
@@ -3608,6 +3635,8 @@ export class SceneProcessor {
 
 		}
 
+		this._tlasLeafBoxesOf = table;
+
 	}
 
 	/**

package/src/Processor/ToneMapGPU.js

@@ -56,7 +56,39 @@ fn rayzee_source( x: u32, y: u32 ) -> vec4<f32> {
 }`,
 };
 
-const toneMapPassWGSL = ( transformWGSL, input ) => /* wgsl */ `
+// RGBA bytes for a picture, or four float planes (r, g, b, a) for a network that wants the curve
+// unquantized. The planes take a 2.2 power, not the sRGB curve: what the AI upscaler has always fed
+// its network, so its output does not move.
+const OUTPUTS = {
+	rgba8: /* wgsl */ `
+@group(0) @binding(1) var<storage, read_write> dst: array<u32>;
+
+fn rayzee_store( i: u32, linear: vec4<f32>, mapped: vec3<f32> ) {
+	let b8 = rayzee_to_u8( rayzee_encode( mapped, params.mode ) );
+	var a8 = 255u;
+	if ( params.alpha == 1u ) { a8 = rayzee_to_u8( vec3<f32>( linear.a ) ).x; }
+	dst[ i ] = b8.x | ( b8.y << 8u ) | ( b8.z << 16u ) | ( a8 << 24u );
+}`,
+	planar: /* wgsl */ `
+@group(0) @binding(1) var<storage, read_write> dst: array<f32>;
+
+fn rayzee_store( i: u32, linear: vec4<f32>, mapped: vec3<f32> ) {
+	var c = clamp( mapped, vec3<f32>( 0.0 ), vec3<f32>( 1.0 ) );
+	if ( ! rayzee_output_encoded( params.mode ) ) {
+		let m = max( mapped, vec3<f32>( 0.0 ) );
+		c = select( pow( m, vec3<f32>( 1.0 / 2.2 ) ), vec3<f32>( 0.0 ), m <= vec3<f32>( 0.0 ) );
+	}
+	let n = params.width * params.height;
+	dst[ i ] = c.r;
+	dst[ n + i ] = c.g;
+	dst[ 2u * n + i ] = c.b;
+	dst[ 3u * n + i ] = linear.a;
+}`,
+};
+
+const BYTES_PER_PIXEL = { rgba8: 4, planar: 16 };
+
+const toneMapPassWGSL = ( transformWGSL, input, output ) => /* wgsl */ `
 struct Params {
 	width: u32,
 	height: u32,
@@ -67,11 +99,11 @@ struct Params {
 	alpha: u32,
 };
 
-@group(0) @binding(1) var<storage, read_write> dst: array<u32>;
 @group(0) @binding(2) var<uniform> params: Params;
 ${SOURCES[ input ]}
 
 ${transformWGSL}
+${OUTPUTS[ output ]}
 
 @compute @workgroup_size(8, 8)
 fn main( @builtin(global_invocation_id) gid: vec3<u32> ) {
@@ -81,11 +113,7 @@ fn main( @builtin(global_invocation_id) gid: vec3<u32> ) {
 	if ( params.flipY == 1u ) { srcY = params.height - 1u - gid.y; }
 
 	let linear = rayzee_source( gid.x, srcY );
-	let mapped = rayzee_tone_map( linear.rgb, params.mode, params.exposure, params.saturation );
-	let b8 = rayzee_to_u8( rayzee_encode( mapped, params.mode ) );
-	var a8 = 255u;
-	if ( params.alpha == 1u ) { a8 = rayzee_to_u8( vec3<f32>( linear.a ) ).x; }
-	dst[ gid.y * params.width + gid.x ] = b8.x | ( b8.y << 8u ) | ( b8.z << 16u ) | ( a8 << 24u );
+	rayzee_store( gid.y * params.width + gid.x, linear, rayzee_tone_map( linear.rgb, params.mode, params.exposure, params.saturation ) );
 }
 `;
 
@@ -94,17 +122,18 @@ const PARAMS_BYTES = 32;
 
 /**
  * Tone-maps a tightly packed rgba16float buffer (two `u32` per pixel), or with `input: 'texture'` a
- * float texture read by pixel, into RGBA bytes.
+ * float texture read by pixel, into RGBA bytes — or with `output: 'planar'` into float planes.
  *
  * Bound to one device and one image size; `ensureSize()` reallocates when the size changes.
  */
 export class PackedToneMapper {
 
-	constructor( device, label = 'rayzee:tonemap', { input = 'packed' } = {} ) {
+	constructor( device, label = 'rayzee:tonemap', { input = 'packed', output = 'rgba8' } = {} ) {
 
 		this.device = device;
 		this.label = label;
 		this.input = input;
+		this.output = output;
 		this.width = 0;
 		this.height = 0;
 		this._pipeline = null;
@@ -139,7 +168,7 @@ export class PackedToneMapper {
 			label: this.label,
 			layout: 'auto',
 			compute: {
-				module: this.device.createShaderModule( { label: this.label, code: toneMapPassWGSL( wgsl, this.input ) } ),
+				module: this.device.createShaderModule( { label: this.label, code: toneMapPassWGSL( wgsl, this.input, this.output ) } ),
 				entryPoint: 'main',
 			},
 		} );
@@ -202,7 +231,7 @@ export class PackedToneMapper {
 
 		this._releaseBuffers();
 
-		const bytes = width * height * 4;
+		const bytes = width * height * BYTES_PER_PIXEL[ this.output ];
 		this._storage = this.device.createBuffer( {
 			label: `${this.label}-out`,
 			size: bytes,
@@ -235,7 +264,26 @@ export class PackedToneMapper {
 	 * @param {boolean} [tone.preserveAlpha=false] - the source's alpha, rounded as the CPU rounds it; else 255
 	 * @returns {Promise<Uint8ClampedArray>} RGBA bytes, `width * height * 4`
 	 */
-	async toRGBA8( src, { exposure = 1, toneMapping = 0, saturation = 1, flipY = false, preserveAlpha = false } = {} ) {
+	async toRGBA8( src, tone ) {
+
+		return new Uint8ClampedArray( await this._run( src, tone ) );
+
+	}
+
+	/**
+	 * The same tone map into four float planes — r, g, b, then the source's alpha — each `width * height`.
+	 * Needs `output: 'planar'`.
+	 * @param {GPUBuffer|GPUTexture} src - as for toRGBA8
+	 * @param {object} tone - as for toRGBA8; `preserveAlpha` does not apply
+	 * @returns {Promise<Float32Array>}
+	 */
+	async toPlanar( src, tone ) {
+
+		return new Float32Array( await this._run( src, tone ) );
+
+	}
+
+	async _run( src, { exposure = 1, toneMapping = 0, saturation = 1, flipY = false, preserveAlpha = false } = {} ) {
 
 		if ( this.disposed ) throw new Error( 'PackedToneMapper: disposed' );
 		if ( ! this._storage ) throw new Error( 'PackedToneMapper: call ensureSize() first' );
@@ -246,6 +294,7 @@ export class PackedToneMapper {
 		this._ensureTables();
 
 		const { width, height } = this;
+		const bytes = width * height * BYTES_PER_PIXEL[ this.output ];
 
 		this._paramU32[ 0 ] = width;
 		this._paramU32[ 1 ] = height;
@@ -275,13 +324,13 @@ export class PackedToneMapper {
 		pass.setBindGroup( 0, group );
 		pass.dispatchWorkgroups( Math.ceil( width / 8 ), Math.ceil( height / 8 ) );
 		pass.end();
-		encoder.copyBufferToBuffer( this._storage, 0, this._map, 0, width * height * 4 );
+		encoder.copyBufferToBuffer( this._storage, 0, this._map, 0, bytes );
 		this.device.queue.submit( [ encoder.finish() ] );
 
 		await this._map.mapAsync( GPUMapMode.READ );
-		const bytes = new Uint8ClampedArray( this._map.getMappedRange().slice( 0 ) );
+		const out = this._map.getMappedRange().slice( 0 );
 		this._map.unmap();
-		return bytes;
+		return out;
 
 	}
 

package/src/Processor/Workers/BVHRefitWorker.js

@@ -3,7 +3,8 @@
  *
  * Protocol:
  *   'init'  → receives the shared triangle and node buffers (once per scene)
- *   'refit' → recomputes every node's AABB from the triangles already written there
+ *   'refit' → recomputes every node's AABB from the triangles already written there, or with
+ *             `blasRanges` only those BLASes and the TLAS
  *
  * Positions never reach here: the main thread scatters each mesh into the shared triangle
  * records as it reads it, so no buffer the size of the scene exists on either side.
@@ -45,7 +46,9 @@ self.onmessage = function ( e ) {
 
 			const startTime = performance.now();
 
-			refitter.refit( bvhData, triData, nodeCount );
+			const { blasRanges, tlasNodeCount } = e.data;
+			if ( blasRanges ) refitter.refitPartial( bvhData, triData, blasRanges, tlasNodeCount );
+			else refitter.refit( bvhData, triData, nodeCount );
 
 			self.postMessage( {
 				type: 'refitComplete',

package/src/Stages/PathTracerStage.js

@@ -1088,26 +1088,48 @@ export class PathTracerStage extends RenderStage {
 
 	}
 
-	/** Re-uploads every triangle from the CPU records, adopting `triangleData` as them when given. */
-	updateTriangleData( triangleData ) {
+	/**
+	 * Re-uploads triangles from the CPU records, adopting `triangleData` as them when given.
+	 * @param {Object} [triangleData]
+	 * @param {Array<{offset:number,count:number}>} [ranges] - only these, in record lanes; every triangle when omitted
+	 */
+	updateTriangleData( triangleData, ranges ) {
 
 		if ( triangleData?.chunks?.length > 1 ) this._triangleRecords = triangleData;
 		else if ( triangleData ) this._triangleFlat = triangleData.chunks ? triangleData.chunks[ 0 ] : triangleData;
-		this._uploadTriangles( 0, this._triangleRecordCount );
+		if ( ranges ) this.updateBufferRanges( ranges, [] );
+		else this._uploadTriangles( 0, this._triangleRecordCount );
 
 	}
 
-	/** Update BVH node data in the existing GPU buffer (full). */
-	updateBVHData( bvhData ) {
+	/**
+	 * Update BVH node data in the existing GPU buffer.
+	 * @param {Object} [bvhData]
+	 * @param {Array<{offset:number,count:number}>} [ranges] - only these, in floats; every node when omitted
+	 */
+	updateBVHData( bvhData, ranges ) {
 
 		if ( this._bvhRecords ) {
 
-			uploadStorageChunks( this.renderer, this.bvhStorageAttr, this._bvhRecords.chunks );
+			if ( bvhData?.chunks?.length > 1 ) this._bvhRecords = bvhData;
+			if ( ranges ) this.updateBufferRanges( [], ranges );
+			else uploadStorageChunks( this.renderer, this.bvhStorageAttr, this._bvhRecords.chunks );
+			return;
+
+		}
+
+		const flat = bvhData?.chunks ? bvhData.chunks[ 0 ] : bvhData;
+		if ( ! ranges ) {
+
+			this._updateStorageBuffer( this.bvhStorageAttr, flat );
 			return;
 
 		}
 
-		this._updateStorageBuffer( this.bvhStorageAttr, bvhData?.chunks ? bvhData.chunks[ 0 ] : bvhData );
+		// The attribute keeps its own array once the refit has moved the nodes into shared memory.
+		const own = this.bvhStorageAttr?.array;
+		if ( flat && own && flat !== own ) for ( const r of ranges ) own.set( flat.subarray( r.offset, r.offset + r.count ), r.offset );
+		this.updateBufferRanges( [], ranges );
 
 	}
 

package/src/managers/AnimationManager.js

@@ -10,6 +10,23 @@
 import { AnimationMixer, EventDispatcher, Timer, Vector3, LoopRepeat, LoopOnce, PropertyBinding } from 'three';
 import { EngineEvents } from '../EngineEvents.js';
 
+/** The nodes of `nodes` with no ancestor in it, or null when updating each would cost more than one pass over `root`. */
+function subtreeRoots( nodes, root ) {
+
+	const roots = [ ...nodes ].filter( node => {
+
+		for ( let o = node.parent; o; o = o.parent ) if ( nodes.has( o ) ) return false;
+		return true;
+
+	} );
+
+	let total = 0, covered = 0;
+	root.traverse?.( () => total ++ );
+	for ( const node of roots ) node.traverse?.( () => covered ++ );
+	return covered + roots.length / 2 < total ? roots : null;
+
+}
+
 export class AnimationManager extends EventDispatcher {
 
 	constructor() {
@@ -39,6 +56,8 @@ export class AnimationManager extends EventDispatcher {
 		this._slotOf = null; // meshIndex -> row in the two caches below, or -1
 		this._lastWorld = null; // world matrix last handed to applyPoseCallback, 16 per row
 		this._lastVisible = null; // 0 / 1, or 2 before the first pose
+		this._lastMeshWorld = null; // deforming clips: world matrix at each mesh's last read, 16 per mesh
+		this._lastMorphWeights = null;
 
 		/** Injected by PathTracerApp — wakes the render loop after play/resume. */
 		this.wakeCallback = null;
@@ -135,6 +154,8 @@ export class AnimationManager extends EventDispatcher {
 		// 9 floats × every triangle — 1,030 MB at 30M, past what a renderer can allocate.
 		this._skinnedCache = [];
 		this._meshPositions = [];
+		this._lastMeshWorld = this._rigid ? null : new Float64Array( meshes.length * 16 ).fill( NaN );
+		this._lastMorphWeights = [];
 
 		const skinnedCount = meshes.filter( m => m.isSkinnedMesh ).length;
 		console.debug( `[AnimationManager] Init: ${animations.length} clips, ${meshes.length} meshes (${skinnedCount} skinned), ${offset} triangles, ${this._rigid ? 'rigid' : 'deforming'}` );
@@ -158,11 +179,19 @@ export class AnimationManager extends EventDispatcher {
 
 			const animated = new Set();
 			let visibility = false;
+			let unresolved = false;
 			for ( const track of clip.tracks ) {
 
 				const { nodeName, propertyName } = PropertyBinding.parseTrackName( track.name );
-				const node = byName.get( nodeName );
-				if ( ! node ) continue;
+				// As PropertyBinding.findNode: no node name binds the root itself.
+				const node = nodeName === '' || nodeName === '.' ? root : byName.get( nodeName );
+				if ( ! node ) {
+
+					unresolved = true;
+					continue;
+
+				}
+
 				animated.add( node );
 				if ( propertyName === 'visible' ) visibility = true;
 
@@ -187,7 +216,7 @@ export class AnimationManager extends EventDispatcher {
 			const cameras = new Set();
 			for ( const node of animated ) node.traverse( o => o.isCamera && cameras.add( o ) );
 
-			return { meshes: Int32Array.from( meshes ), visibility, cameras: [ ...cameras ] };
+			return { meshes: Int32Array.from( meshes ), visibility, cameras: [ ...cameras ], nodes: unresolved ? null : animated, roots: unresolved ? null : subtreeRoots( animated, root ) };
 
 		} );
 
@@ -214,15 +243,18 @@ export class AnimationManager extends EventDispatcher {
 
 			const meshes = new Set(), cameras = new Set();
 			let visibility = false;
+			let nodes = new Set();
 			for ( const plan of this._plans ) {
 
 				plan.meshes.forEach( m => meshes.add( m ) );
 				plan.cameras.forEach( c => cameras.add( c ) );
 				visibility ||= plan.visibility;
+				if ( nodes && plan.nodes ) plan.nodes.forEach( n => nodes.add( n ) );
+				else nodes = null;
 
 			}
 
-			this._allPlan = { meshes: Int32Array.from( meshes ), visibility, cameras: [ ...cameras ] };
+			this._allPlan = { meshes: Int32Array.from( meshes ), visibility, cameras: [ ...cameras ], nodes, roots: nodes ? subtreeRoots( nodes, this._mixerRoot ) : null };
 
 		}
 
@@ -487,7 +519,10 @@ export class AnimationManager extends EventDispatcher {
 
 		// Bones live outside mesh subtrees so per-mesh updateMatrixWorld() misses them. Doing it
 		// once here, on mixerRoot rather than the scene, keeps unrelated static objects out of it.
-		this._mixerRoot.updateMatrixWorld( true );
+		// A rigid clip moves only what its tracks name, so only those subtrees are updated.
+		const roots = this._rigid ? this._planFor( this._activeClip )?.roots : null;
+		if ( roots ) for ( const node of roots ) node.updateMatrixWorld( true );
+		else this._mixerRoot.updateMatrixWorld( true );
 
 		if ( this._rigid ) {
 
@@ -499,7 +534,52 @@ export class AnimationManager extends EventDispatcher {
 		const cameras = this._planFor( this._activeClip )?.cameras;
 		if ( cameras?.length ) this.applyPoseCallback?.( { meshIndices: [], visibilityChanged: false, cameras } );
 
-		return m => this._computeMeshPositions( m );
+		// Decided once per reader: an expanded instanced emitter asks for one mesh several times.
+		const moved = new Int8Array( this._meshes.length );
+		return m => {
+
+			if ( moved[ m ] === 0 ) moved[ m ] = this._meshes[ m ].isSkinnedMesh || this._poseChanged( m ) ? 1 : - 1;
+			return moved[ m ] > 0 ? this._computeMeshPositions( m ) : null;
+
+		};
+
+	}
+
+	/** Whether a mesh's world matrix or morph weights differ from when its positions were last read. @private */
+	_poseChanged( m ) {
+
+		const mesh = this._meshes[ m ];
+		const last = this._lastMeshWorld;
+		const e = mesh.matrixWorld.elements;
+		const o = m * 16;
+		let changed = false;
+
+		for ( let i = 0; i < 16; i ++ ) {
+
+			if ( last[ o + i ] !== e[ i ] ) {
+
+				for ( let j = 0; j < 16; j ++ ) last[ o + j ] = e[ j ];
+				changed = true;
+				break;
+
+			}
+
+		}
+
+		const weights = mesh.morphTargetInfluences;
+		if ( weights?.length ) {
+
+			const lastWeights = this._lastMorphWeights[ m ];
+			if ( ! lastWeights || lastWeights.length !== weights.length || lastWeights.some( ( w, i ) => w !== weights[ i ] ) ) {
+
+				this._lastMorphWeights[ m ] = Float64Array.from( weights );
+				changed = true;
+
+			}
+
+		}
+
+		return changed;
 
 	}
 
@@ -640,6 +720,8 @@ export class AnimationManager extends EventDispatcher {
 		this._slotOf = null;
 		this._lastWorld = null;
 		this._lastVisible = null;
+		this._lastMeshWorld = null;
+		this._lastMorphWeights = null;
 
 	}
 

package/src/managers/CameraManager.js

@@ -1,4 +1,4 @@
-import { EventDispatcher, MathUtils, OrthographicCamera, PerspectiveCamera, Quaternion, Vector3 } from 'three';
+import { EventDispatcher, MathUtils, Matrix4, OrthographicCamera, PerspectiveCamera, Quaternion, Vector3 } from 'three';
 import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
 import { EngineEvents, } from '../EngineEvents.js';
 import { AF_DEFAULTS, CAMERA_PROJECTION_IDS } from '../EngineDefaults.js';
@@ -62,6 +62,7 @@ export class CameraManager extends EventDispatcher {
 		this._smoothedFocusDistance = null;
 		this._afPointDirty = false;
 		this._afSuspended = false;
+		this._afPick = null;
 
 		// Saved state for default camera when switching to model cameras
 		this._defaultCameraState = null;
@@ -833,13 +834,12 @@ export class CameraManager extends EventDispatcher {
 			&& stage.frameCount > 0
 			&& ! stage.isComplete ) return;
 
-		// 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 );
+		const hitPoint = this._pickFocusPoint( stage.resetCount );
 
 		let rawDistance;
-		if ( validHit ) {
+		if ( hitPoint ) {
 
-			rawDistance = viewDepth( validHit.point, this.camera );
+			rawDistance = viewDepth( hitPoint, this.camera );
 			this._lastValidFocusDistance = rawDistance;
 
 		} else {
@@ -910,6 +910,32 @@ export class CameraManager extends EventDispatcher {
 
 	}
 
+	/** Picks again only on a new view or AF point, or a render reset, which every scene change makes. @private */
+	_pickFocusPoint( resetCount ) {
+
+		const camera = this.camera;
+		const { x, y } = this.afScreenPoint;
+		const last = this._afPick ??= { point: new Vector3(), hit: false, resetCount: NaN, x: NaN, y: NaN, view: new Matrix4(), projection: new Matrix4() };
+
+		if ( this._afPointDirty || resetCount !== last.resetCount || x !== last.x || y !== last.y
+			|| ! last.view.equals( camera.matrixWorld ) || ! last.projection.equals( camera.projectionMatrix ) ) {
+
+			// AF screen point (0 to 1, y down) to NDC.
+			const hit = this.interactionManager.pickSurface( x * 2 - 1, 1 - y * 2 );
+			last.hit = !! hit;
+			if ( hit ) last.point.copy( hit.point );
+			last.resetCount = resetCount;
+			last.x = x;
+			last.y = y;
+			last.view.copy( camera.matrixWorld );
+			last.projection.copy( camera.projectionMatrix );
+
+		}
+
+		return last.hit ? last.point : null;
+
+	}
+
 	/**
 	 * Deferred dependency injection — InteractionManager needs the camera
 	 * in its constructor, so it can't be passed during CameraManager creation.