rayzee 8.7.0 → 8.8.1

package/src/PathTracerApp.js

@@ -447,6 +447,7 @@ export class PathTracerApp extends EventDispatcher {
 			}
 
 			this.pipeline.render();
+			this.denoisingManager?.afterTrace();
 
 			if ( ! this.stages.pathTracer.isComplete ) {
 
@@ -567,8 +568,15 @@ export class PathTracerApp extends EventDispatcher {
 	/**
 	 * Resets the accumulation buffer.
 	 * @param {boolean} soft - When true, preserves ASVGF temporal history
+	 * @param {Object} [options]
+	 * @param {boolean} [options.motion] - only object placements or geometry moved; keeps the OIDN
+	 *   motion history, which rejects what moved per pixel
 	 */
-	reset( soft = false ) {
+	reset( soft = false, { motion = false } = {} ) {
+
+		// Objects moving is the view changing, as far as the live denoiser's refresh cadence goes.
+		if ( motion ) this.stages.pathTracer?.noteViewChanged();
+		this.denoisingManager?.beforeReset( { keepHistory: soft || motion } );
 
 		if ( this.pipeline ) {
 
@@ -582,6 +590,8 @@ export class PathTracerApp extends EventDispatcher {
 
 		}
 
+		this.denoisingManager?.afterReset();
+
 		// Whatever is on screen stays until its replacement is ready, including while the camera
 		// moves: the denoising manager decides, since only it knows something is coming.
 		this._abortPostProcess( { keepDisplay: true } );
@@ -1617,7 +1627,7 @@ export class PathTracerApp extends EventDispatcher {
 
 		this.stages.pathTracer.updateTriangleData( this._sdf.triangles );
 		this.stages.pathTracer.updateBVHData( this._sdf.bvh );
-		this.reset();
+		this.reset( false, { motion: true } );
 
 		return result;
 
@@ -1639,7 +1649,7 @@ export class PathTracerApp extends EventDispatcher {
 
 		const { triRanges, bvhRanges } = this._sdf.computeBLASDirtyRanges( affectedMeshIndices );
 		this.stages.pathTracer.updateBufferRanges( triRanges, bvhRanges );
-		this.reset();
+		this.reset( false, { motion: true } );
 
 		// Kick off background rebuild for optimal SAH quality
 		this._sdf.scheduleBackgroundRebuild( affectedMeshIndices, ( meshIndex ) => {
@@ -1648,7 +1658,7 @@ export class PathTracerApp extends EventDispatcher {
 			// re-upload here is gigabytes on a large scene, for one mesh's worth of change.
 			const dirty = this._sdf.computeBLASDirtyRanges( [ meshIndex ] );
 			this.stages.pathTracer.updateBufferRanges( dirty.triRanges, dirty.bvhRanges );
-			this.reset();
+			this.reset( false, { motion: true } );
 
 		} );
 
@@ -1664,6 +1674,7 @@ export class PathTracerApp extends EventDispatcher {
 
 		if ( meshIndices.length > 0 ) {
 
+			this._notePlacementsMoving( meshIndices );
 			this._sdf.updateMeshTransforms( meshIndices );
 			this.stages.pathTracer?.updateBufferRanges( [], [ this._sdf.computeTLASDirtyRange() ] );
 			if ( this._sdf.movesEmitters( meshIndices ) ) {
@@ -1689,7 +1700,24 @@ export class PathTracerApp extends EventDispatcher {
 
 		if ( cameras.length > 0 && this._followAnimatedCamera( cameras ) ) changed = true;
 
-		if ( changed ) this.reset();
+		if ( changed ) this.reset( false, { motion: true } );
+
+	}
+
+	/** @private */
+	_notePlacementsMoving( meshIndices ) {
+
+		const dm = this.denoisingManager;
+		const table = this._sdf?.instanceTable;
+		if ( ! dm?.historyActive || ! table ) return;
+
+		for ( const meshIndex of meshIndices ) {
+
+			const run = table.placementRunOf( meshIndex );
+			if ( ! run ) continue;
+			for ( let p = run.start; p < run.start + run.count; p ++ ) dm.notePlacementMoving( table.tlasLeafIndex[ p ], table.world, p * 16 );
+
+		}
 
 	}
 
@@ -1758,10 +1786,11 @@ export class PathTracerApp extends EventDispatcher {
 	 */
 	updateMeshTransforms( meshIndices ) {
 
+		this._notePlacementsMoving( meshIndices );
 		const result = this._sdf.updateMeshTransforms( meshIndices );
 
 		this.stages.pathTracer.updateBufferRanges( [], [ this._sdf.computeTLASDirtyRange() ] );
-		this.reset();
+		this.reset( false, { motion: true } );
 
 		return result;
 
@@ -3444,6 +3473,12 @@ export class PathTracerApp extends EventDispatcher {
 		this.cameraManager.setInteractionManager( this.interactionManager );
 		this.lightManager = new LightManager( this.scene, this._sceneHelpers, this.stages.pathTracer, {
 			onReset: () => this.reset(),
+			// The gizmo stays attached to a removed light and warns every frame it draws.
+			onLightRemoved: light => {
+
+				if ( this.interactionManager?.selectedObject === light ) this.interactionManager.deselect();
+
+			},
 		} );
 		this.goboManager = new GoboManager( this.stages.pathTracer, {
 			onReset: () => this.reset(),

package/src/Stages/NormalDepth.js

@@ -1,7 +1,7 @@
-import { Fn, vec2, vec3, vec4, float, int, uint, uvec2, uniform, min, storage, If,
+import { Fn, vec2, vec3, vec4, float, int, uint, uvec2, uvec4, uniform, min, storage, If,
 	textureStore, workgroupId, localId } from 'three/tsl';
 import { RenderTarget, StorageTexture } from 'three/webgpu';
-import { HalfFloatType, RGBAFormat, NearestFilter, Matrix4, Box2, Vector2 } from 'three';
+import { HalfFloatType, RGBAFormat, RedIntegerFormat, UnsignedIntType, NearestFilter, Matrix4, Box2, Vector2 } from 'three';
 import { RenderStage, StageExecutionMode } from '../Pipeline/RenderStage.js';
 import { MAX_STORAGE_TEXTURE_SIZE } from '../EngineDefaults.js';
 import { Ray, HitInfo, RayTracingMaterial, UVCache } from '../TSL/Struct.js';
@@ -32,7 +32,8 @@ import { computeUVCache, processNormal, processBump, processMetalnessRoughness,
  * Its .w is the sampled material roughness (NRD's normal+roughness guide).
  *
  * Publishes: pathtracer:normalDepth, pathtracer:prevNormalDepth,
- *            pathtracer:shadingNormal (rgb = shading normal·0.5+0.5, a = roughness)
+ *            pathtracer:shadingNormal (rgb = shading normal·0.5+0.5, a = roughness),
+ *            pathtracer:instanceLeaf (r32uint: the hit's transformed TLAS leaf + 1, 0 = none)
  */
 export class NormalDepth extends RenderStage {
 
@@ -85,6 +86,10 @@ export class NormalDepth extends RenderStage {
 			stencilBuffer: false
 		} );
 
+		// Created only while a consumer asks for it (setInstanceLeafOutput).
+		this._leafStorageTex = null;
+		this._leafRT = null;
+
 		this._srcRegion = new Box2( new Vector2( 0, 0 ), new Vector2( 0, 0 ) );
 
 		// Ping-pong RTs share format with the StorageTexture so copyTextureToTexture works.
@@ -215,6 +220,7 @@ export class NormalDepth extends RenderStage {
 		const resH = this.resolutionHeight;
 		const outputTex = this._outputStorageTex;
 		const shadingTex = this._shadingStorageTex;
+		const leafTex = this._leafStorageTex;
 
 		const WG_SIZE = 8;
 
@@ -256,6 +262,16 @@ export class NormalDepth extends RenderStage {
 					result
 				).toWriteOnly();
 
+				if ( leafTex ) {
+
+					textureStore(
+						leafTex,
+						uvec2( uint( gx ), uint( gy ) ),
+						uvec4( uint( hit.instanceLeaf.add( 1 ) ), 0, 0, 0 )
+					).toWriteOnly();
+
+				}
+
 				// Shading normal: perturb the geometric normal by the normal/bump map
 				// from the SAME hit (deterministic UV → jitter-free). Miss → geo default.
 				const shadingNormal = hit.normal.toVar();
@@ -339,6 +355,7 @@ export class NormalDepth extends RenderStage {
 			context.setTexture( 'pathtracer:normalDepth', currentRT.texture );
 			context.setTexture( 'pathtracer:prevNormalDepth', currentRT.texture );
 			context.setTexture( 'pathtracer:shadingNormal', this._shadingRT.texture );
+			this._publishLeaf( context );
 			return;
 
 		}
@@ -367,6 +384,7 @@ export class NormalDepth extends RenderStage {
 		this._srcRegion.max.set( writeRT.width, writeRT.height );
 		this.renderer.copyTextureToTexture( this._outputStorageTex, writeRT.texture, this._srcRegion );
 		this.renderer.copyTextureToTexture( this._shadingStorageTex, this._shadingRT.texture, this._srcRegion );
+		if ( this._leafRT ) this.renderer.copyTextureToTexture( this._leafStorageTex, this._leafRT.texture, this._srcRegion );
 
 		// First dispatch: seed prev from current so ASVGF doesn't see false
 		// disocclusion on frame 1.
@@ -380,6 +398,7 @@ export class NormalDepth extends RenderStage {
 		context.setTexture( 'pathtracer:normalDepth', writeRT.texture );
 		context.setTexture( 'pathtracer:prevNormalDepth', prevRT.texture );
 		context.setTexture( 'pathtracer:shadingNormal', this._shadingRT.texture );
+		this._publishLeaf( context );
 
 		this._dirty = false;
 
@@ -391,6 +410,7 @@ export class NormalDepth extends RenderStage {
 
 		this._outputStorageTex?.dispose();
 		this._shadingStorageTex?.dispose();
+		this._leafStorageTex?.dispose();
 		this.reset();
 		// The textures backing the ping-pong are gone, so the prev-frame G-buffer is too.
 		this._hasHistory = false;
@@ -417,6 +437,13 @@ export class NormalDepth extends RenderStage {
 		this._rtB.texture.needsUpdate = true;
 		this._shadingRT.setSize( width, height );
 		this._shadingRT.texture.needsUpdate = true;
+		if ( this._leafRT ) {
+
+			this._leafRT.setSize( width, height );
+			this._leafRT.texture.needsUpdate = true;
+
+		}
+
 		this._hasHistory = false;
 		this.resolutionWidth.value = width;
 		this.resolutionHeight.value = height;
@@ -451,7 +478,69 @@ export class NormalDepth extends RenderStage {
 
 		this._outputStorageTex = mk();
 		this._shadingStorageTex = mk();
+		if ( this._leafStorageTex ) {
+
+			this._leafStorageTex.dispose();
+			this._leafStorageTex = this._makeLeafStorage();
+
+		}
+
+		this._computeBuilt = false;
+
+	}
+
+	/**
+	 * Whether to write `pathtracer:instanceLeaf` (the hit's transformed TLAS leaf + 1, 0 = none).
+	 * Off by default: it costs a full-reserve texture, and changing it rebuilds the kernel.
+	 */
+	setInstanceLeafOutput( enabled ) {
+
+		enabled = !! enabled;
+		if ( enabled === !! this._leafStorageTex ) return;
+
+		this._computeNode?.dispose();
+		this._computeNode = null;
 		this._computeBuilt = false;
+		this._dirty = true;
+
+		if ( enabled ) {
+
+			this._leafStorageTex = this._makeLeafStorage();
+			this._leafRT = new RenderTarget( this._rtA.width, this._rtA.height, {
+				type: UnsignedIntType,
+				format: RedIntegerFormat,
+				minFilter: NearestFilter,
+				magFilter: NearestFilter,
+				depthBuffer: false,
+				stencilBuffer: false
+			} );
+
+		} else {
+
+			this._leafStorageTex.dispose();
+			this._leafRT.dispose();
+			this._leafStorageTex = null;
+			this._leafRT = null;
+
+		}
+
+	}
+
+	_publishLeaf( context ) {
+
+		if ( this._leafRT ) context.setTexture( 'pathtracer:instanceLeaf', this._leafRT.texture );
+		else if ( context.getTexture( 'pathtracer:instanceLeaf' ) ) context.removeTexture( 'pathtracer:instanceLeaf' );
+
+	}
+
+	_makeLeafStorage() {
+
+		const t = new StorageTexture( MAX_STORAGE_TEXTURE_SIZE, MAX_STORAGE_TEXTURE_SIZE );
+		t.type = UnsignedIntType;
+		t.format = RedIntegerFormat;
+		t.minFilter = NearestFilter;
+		t.magFilter = NearestFilter;
+		return t;
 
 	}
 
@@ -461,6 +550,8 @@ export class NormalDepth extends RenderStage {
 		this._outputStorageTex?.dispose();
 		this._shadingStorageTex?.dispose();
 		this._shadingRT?.dispose();
+		this._leafStorageTex?.dispose();
+		this._leafRT?.dispose();
 		this._rtA?.dispose();
 		this._rtB?.dispose();
 

package/src/Stages/PathTracer.js

@@ -303,6 +303,7 @@ export class PathTracer extends PathTracerStage {
 		const auxMixes = this._updateAuxAccumulationUniforms( frameValue );
 		this.frame.value = frameValue;
 		this.seedFrame.value = this._seedTick ++;
+		this.tracedFrames ++;
 
 		this._setWfDispatch();
 

package/src/Stages/PathTracerStage.js

@@ -155,6 +155,9 @@ export class PathTracerStage extends RenderStage {
 		// Pinned back to the accumulation index in deterministic mode.
 		this._seedTick = 0;
 		this._pinSeedToFrame = false;
+		// Monotonic, unlike the seed axis; let observers tell a traced frame and a reset apart.
+		this.tracedFrames = 0;
+		this.resetCount = 0;
 
 		// Denoising management state
 		this.lastRenderMode = - 1;
@@ -635,6 +638,7 @@ export class PathTracerStage extends RenderStage {
 	 */
 	reset() {
 
+		this.resetCount ++;
 		this.frameCount = 0;
 		this.frame.value = 0;
 		this.hasPreviousAccumulated.value = 0;

package/src/managers/DenoisingManager.js

@@ -1,5 +1,6 @@
-import { EventDispatcher } from 'three';
+import { EventDispatcher, Matrix4 } from 'three';
 import { OIDNDenoiser } from '../Passes/OIDNDenoiser.js';
+import { OIDNTemporalHistory } from '../Passes/OIDNTemporalHistory.js';
 import { AIUpscaler } from '../Passes/AIUpscaler.js';
 import { EngineEvents } from '../EngineEvents.js';
 import { createLogger } from '../utils/Logger.js';
@@ -73,6 +74,11 @@ const INTERACTION_HOPELESS_FACTOR = 3;
 // screen, so any clock would read a perfectly good frame as abandoned the moment it woke.
 const HELD_FRAME_MAX_FAILURES = 3;
 
+// Still samples after which the motion history no longer helps; it fades out linearly until then.
+const HISTORY_HANDOFF_SAMPLES = 16;
+
+const historyFade = ( samples ) => Math.max( 0, 1 - samples / HISTORY_HANDOFF_SAMPLES );
+
 /**
  * Orchestrates all denoising, post-processing, and AI upscaling:
  *   - Real-time denoiser strategy switching (ASVGF / NRD / EdgeAware / None)
@@ -151,6 +157,20 @@ export class DenoisingManager extends EventDispatcher {
 		this._onPostProcessRefresh = null;
 		this._onDisplayRefresh = null;
 
+		this.temporalHistory = DEFAULT_STATE.oidnTemporalHistory;
+		this._history = null;
+		// Stale after a scene-changing reset, or one the app did not announce (material/env edits).
+		this._historyDirty = true;
+		this._knownResetCount = 0;
+		this._seenTracedFrames = 0;
+		this._viewProj = new Matrix4();
+		this._historyCamera = { world: null, projInv: null, viewProj: null };
+		// 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 ) };
+		this._matA = new Matrix4();
+		this._matB = new Matrix4();
+
 		// Resolution tracking — used for canvas restoration on reset
 		this._lastRenderWidth = 0;
 		this._lastRenderHeight = 0;
@@ -211,6 +231,7 @@ export class DenoisingManager extends EventDispatcher {
 		this._holdWhileMoving = null;
 		this._movingDenoiseMs.length = 0;
 		this._movingHopeless = false;
+		this._historyDirty = true;
 		// A run in flight was sized for the old resolution and setSize rebuilds the network under
 		// it. Resets no longer cancel a run while its frame is on screen, so this has to.
 		this.denoiser?.abort();
@@ -229,6 +250,7 @@ export class DenoisingManager extends EventDispatcher {
 		}
 
 		this.upscaler?.setBaseSize( width, height );
+		this._syncGBufferStages();
 
 	}
 
@@ -273,9 +295,11 @@ export class DenoisingManager extends EventDispatcher {
 				adapterInfo: null
 			} ),
 
-			getGPUTextures: () => {
+			getGPUTextures: ( { continuous = false } = {} ) => {
 
 				if ( ! pt?.storageTextures?.readTarget ) return null;
+				const history = continuous ? this._historyTextures() : null;
+				if ( history ) return history;
 				const readTextures = pt.storageTextures.getReadTextures();
 				const { backend } = this.renderer;
 				return {
@@ -534,8 +558,9 @@ export class DenoisingManager extends EventDispatcher {
 		const mv = s.motionVector;
 
 		const motionNeeded = this.requiresMotionVectors;
-		// pathtracer:normalDepth consumed by ASVGF, NRD, EdgeFilter, BilateralFilter
-		const normalNeeded = motionNeeded || !! ( s.edgeFilter?.enabled || s.bilateralFilter?.enabled );
+		// pathtracer:normalDepth consumed by ASVGF, NRD, EdgeFilter, BilateralFilter, the OIDN history
+		const normalNeeded = motionNeeded || this.historyWanted || !! ( s.edgeFilter?.enabled || s.bilateralFilter?.enabled );
+		if ( ! this.historyWanted ) this._releaseHistory();
 
 		if ( nd ) {
 
@@ -543,6 +568,7 @@ export class DenoisingManager extends EventDispatcher {
 			// (not the stale static fast-path) and seeds prev = current.
 			if ( normalNeeded && ! nd.enabled ) nd.reset();
 			nd.enabled = normalNeeded;
+			nd.setInstanceLeafOutput?.( this.historyWanted );
 
 		}
 
@@ -630,7 +656,12 @@ export class DenoisingManager extends EventDispatcher {
 		const best = this.movingCostMs;
 		const seen = this._movingDenoiseMs.length;
 
-		if ( best > INTERACTION_HOLD_BUDGET_MS * INTERACTION_HOPELESS_FACTOR ) this._movingHopeless = true;
+		if ( best > INTERACTION_HOLD_BUDGET_MS * INTERACTION_HOPELESS_FACTOR ) {
+
+			this._movingHopeless = true;
+			this._syncGBufferStages();
+
+		}
 
 		// One reading is a warm-up; two that are both over budget are the answer.
 		const affordable = ! this._movingHopeless && ( seen < 2 || best <= INTERACTION_HOLD_BUDGET_MS );
@@ -781,6 +812,7 @@ export class DenoisingManager extends EventDispatcher {
 	setCadenceSuspended( suspended ) {
 
 		this._cadenceSuspended = !! suspended;
+		this._historyDirty = true;
 		if ( ! this._cadenceSuspended ) return;
 
 		// The accumulation is what a final render shows; a held preview frame would otherwise sit
@@ -817,6 +849,221 @@ export class DenoisingManager extends EventDispatcher {
 
 	}
 
+	// ── Motion history (OIDN live view) ──────────────────────────
+
+	/** Feeds OIDN the reprojected history of restarted frames while the view moves. */
+	setTemporalHistory( enabled ) {
+
+		this.temporalHistory = !! enabled;
+		this._syncGBufferStages();
+
+	}
+
+	// Not at a size proven too slow to denoise while moving: the raw render owns the view there.
+	get historyWanted() {
+
+		return this.temporalHistory && this.continuousDenoise && !! this.denoiser?.enabled && ! this._movingHopeless;
+
+	}
+
+	get historyActive() {
+
+		const pt = this._stages.pathTracer;
+		return this.historyWanted && ! this._cadenceSuspended && !! this._stages.normalDepth?.enabled
+			&& ( pt?.uniforms?.get( 'cameraProjection' )?.value ?? 0 ) === 0
+			&& ! ( pt?.visMode?.value > 0 );
+
+	}
+
+	/**
+	 * Called by the app before each of its resets, while the accumulation still exists.
+	 * @param {Object} [options]
+	 * @param {boolean} [options.keepHistory] - only the view or object placements changed
+	 */
+	beforeReset( { keepHistory = false } = {} ) {
+
+		const pt = this._stages.pathTracer;
+		if ( ! pt || ! this.historyActive ) return;
+
+		const unannounced = pt.resetCount !== this._knownResetCount;
+		if ( ! keepHistory || ( unannounced && pt.frameCount < 2 ) ) {
+
+			this._historyDirty = true;
+			return;
+
+		}
+
+		// A move that starts from a still image starts from that image, not from one sample.
+		if ( pt.frameCount < 2 ) return;
+		const src = this._historyInputs();
+		if ( ! src ) return;
+		this._ensureHistory().merge( src, pt.frameCount, this._historyCameraNow(), {
+			commit: true,
+			keepHistory: ! this._historyDirty && ! unannounced,
+			historyScale: historyFade( pt.frameCount ),
+		} );
+		this._historyDirty = false;
+
+	}
+
+	/** Called by the app right after its own resets, so they are not taken for unannounced ones. */
+	afterReset() {
+
+		this._knownResetCount = this._stages.pathTracer?.resetCount ?? 0;
+
+	}
+
+	/** Called after every render-loop tick that ran the pipeline. */
+	afterTrace() {
+
+		const pt = this._stages.pathTracer;
+		if ( ! pt || pt.tracedFrames === this._seenTracedFrames ) return;
+		this._seenTracedFrames = pt.tracedFrames;
+
+		if ( pt.resetCount !== this._knownResetCount ) {
+
+			this._historyDirty = true;
+			this._knownResetCount = pt.resetCount;
+
+		}
+
+		// Accumulating: the history holds still and is merged in when a refresh starts.
+		if ( ! this.historyActive || pt.frame.value !== 0 ) {
+
+			this._movedPlacements.clear();
+			return;
+
+		}
+
+		const src = this._historyInputs();
+		if ( ! src ) {
+
+			this._movedPlacements.clear();
+			this._historyDirty = true;
+			return;
+
+		}
+
+		const history = this._ensureHistory();
+		if ( this._historyDirty ) history.invalidate();
+		history.accumulate( src, this._historyCameraNow(), this._takeMovedPlacements() );
+		this._historyDirty = false;
+
+	}
+
+	/**
+	 * Records a placement's transform before it changes, so the history can follow the object.
+	 * @param {number} leaf - its TLAS leaf node
+	 * @param {Float32Array} world - the placement matrix pool
+	 * @param {number} offset - where this placement's matrix starts in it
+	 */
+	notePlacementMoving( leaf, world, offset ) {
+
+		if ( leaf < 0 || ! this.historyActive || this._movedPlacements.has( leaf ) ) return;
+		this._movedPlacements.set( leaf, { world, offset, prev: world.slice( offset, offset + 16 ) } );
+
+	}
+
+	// Leaves in ascending order, each with its current→previous world matrix.
+	_takeMovedPlacements() {
+
+		const moved = this._movedPlacements;
+		const upload = this._movedUpload;
+		upload.count = moved.size;
+		if ( ! moved.size ) return upload;
+
+		if ( upload.leaves.length < moved.size ) {
+
+			upload.leaves = new Uint32Array( moved.size * 2 );
+			upload.toPrev = new Float32Array( moved.size * 32 );
+
+		}
+
+		const leaves = [ ...moved.keys() ].sort( ( a, b ) => a - b );
+		for ( let i = 0; i < leaves.length; i ++ ) {
+
+			const { world, offset, prev } = moved.get( leaves[ i ] );
+			this._matB.fromArray( world, offset ).invert();
+			this._matA.fromArray( prev ).multiply( this._matB ).toArray( upload.toPrev, i * 16 );
+			upload.leaves[ i ] = leaves[ i ];
+
+		}
+
+		moved.clear();
+		return upload;
+
+	}
+
+	// What a live refresh denoises, or null for the plain accumulation.
+	_historyTextures() {
+
+		const pt = this._stages.pathTracer;
+		const history = this._history;
+		if ( ! history?.valid || this._historyDirty || ! this.historyActive || pt.isComplete ) return null;
+		if ( pt.resetCount !== this._knownResetCount ) return null;
+		if ( history.width !== this._lastRenderWidth || history.height !== this._lastRenderHeight ) return null;
+		if ( pt.frameCount <= 1 ) return history.textures;
+		if ( pt.frameCount >= HISTORY_HANDOFF_SAMPLES ) return null;
+
+		const src = this._historyInputs();
+		return src ? history.merge( src, pt.frameCount, this._historyCameraNow(), { historyScale: historyFade( pt.frameCount ) } ) : null;
+
+	}
+
+	_historyInputs() {
+
+		const pt = this._stages.pathTracer;
+		const ctx = this.pipeline?.context;
+		const backend = this.renderer?.backend;
+		if ( ! pt?.storageTextures?.readTarget || ! ctx || ! backend ) return null;
+
+		const read = pt.storageTextures.getReadTextures();
+		const gpu = ( texture ) => ( texture ? backend.get( texture )?.texture : null );
+		const src = {
+			color: gpu( read.color ),
+			albedo: gpu( read.albedo ),
+			normal: gpu( read.normalDepth ),
+			geo: gpu( ctx.getTexture( 'pathtracer:normalDepth' ) ),
+			geoPrev: gpu( ctx.getTexture( 'pathtracer:prevNormalDepth' ) ),
+			shading: gpu( ctx.getTexture( 'pathtracer:shadingNormal' ) ),
+			leaf: gpu( ctx.getTexture( 'pathtracer:instanceLeaf' ) ),
+			width: pt.width,
+			height: pt.height,
+		};
+		return src.color && src.albedo && src.normal && src.geo && src.geoPrev && src.shading && src.leaf ? src : null;
+
+	}
+
+	// The camera of the frame last traced: the path tracer's uniforms, not the live camera.
+	_historyCameraNow() {
+
+		const pt = this._stages.pathTracer;
+		this._viewProj.multiplyMatrices( pt.cameraProjectionMatrix.value, pt.cameraViewMatrix.value );
+		const camera = this._historyCamera;
+		camera.world = pt.cameraWorldMatrix.value.elements;
+		camera.projInv = pt.cameraProjectionMatrixInverse.value.elements;
+		camera.viewProj = this._viewProj.elements;
+		return camera;
+
+	}
+
+	_ensureHistory() {
+
+		this._history ??= new OIDNTemporalHistory( this.renderer.backend.device );
+		this._history.settings.cleanAux = !! this.denoiser?.expectsCleanAux( this._finalQuality );
+		return this._history;
+
+	}
+
+	_releaseHistory() {
+
+		this._history?.dispose();
+		this._history = null;
+		this._historyDirty = true;
+		this._movedPlacements.clear();
+
+	}
+
 	/**
 	 * Selects the AI upscaler's model. 'neural' is fixed at 2x and reads the denoised picture, so it
 	 * is a no-op without a denoiser — feeding it raw Monte-Carlo noise measurably loses to bilinear.
@@ -1190,6 +1437,7 @@ export class DenoisingManager extends EventDispatcher {
 
 		this._unpublishOutput();
 		this._restoreRenderDisplay();
+		this._historyDirty = true;
 
 	}
 
@@ -1203,6 +1451,7 @@ export class DenoisingManager extends EventDispatcher {
 
 		// Before the denoiser destroys the picture the Compositor would otherwise still sample.
 		this._unpublishOutput();
+		this._releaseHistory();
 
 		if ( this.denoiser ) {