rayzee 7.30.2 → 7.31.0

package/src/PathTracerApp.js

@@ -404,6 +404,7 @@ export class PathTracerApp extends EventDispatcher {
 			if ( ! this.stages.pathTracer.isComplete ) {
 
 				this.completion.updateTime();
+				this.denoisingManager?.tickContinuousDenoise( this.stages.pathTracer.frameCount );
 
 			}
 
@@ -1797,8 +1798,11 @@ export class PathTracerApp extends EventDispatcher {
 		if ( denoiser ) {
 
 			denoiser.abort();
-			denoiser.enabled = config.enableOIDN;
-			denoiser.updateQuality( config.oidnQuality );
+			// Through the manager both times: `denoiser.enabled` is the union of its two jobs and
+			// `denoiser.quality` dips to a cheaper model between refreshes, so neither is the
+			// record of what the host asked for.
+			this.denoisingManager.applyOIDNEnabled( config.enableOIDN );
+			this.denoisingManager.applyOIDNQuality( config.oidnQuality );
 
 		}
 
@@ -1933,6 +1937,7 @@ export class PathTracerApp extends EventDispatcher {
 					dynamicDispatch: stage._useDynamicDispatch,
 					autoFocusMode: this.cameraManager?.autoFocusMode,
 					autoExposure: this.stages.autoExposure?.enabled,
+					continuousDenoise: this.denoisingManager?.continuousDenoise,
 				};
 
 			}
@@ -1966,6 +1971,8 @@ export class PathTracerApp extends EventDispatcher {
 
 			this.cameraManager?.setAutoFocusMode( 'manual' );
 			if ( this.stages.autoExposure ) this.stages.autoExposure.enabled = false;
+			// Cadence denoising is wall-clock driven, so which frame it lands on is not reproducible.
+			this.denoisingManager?.setContinuousDenoise( false );
 
 			// The seed axis free-runs across accumulation resets so a camera drag gets fresh
 			// sequences; offline rendering needs the opposite. Pinning it makes seedFrame track
@@ -1990,6 +1997,12 @@ export class PathTracerApp extends EventDispatcher {
 
 			}
 
+			if ( prev.continuousDenoise !== undefined ) {
+
+				this.denoisingManager?.setContinuousDenoise( prev.continuousDenoise );
+
+			}
+
 			stage._pinSeedToFrame = false;
 
 			this._deterministicRestore = null;

package/src/Processor/ToneMapWGSL.js

@@ -0,0 +1,162 @@
+/**
+ * WGSL tone mapping, a transcription of ToneMapCPU.js.
+ *
+ * The two must stay identical: the same image is produced on the CPU by `toneMapToRGBA8`
+ * (renderToBuffer, upscaler) and on the GPU by this (the OIDN output pack). Order is part of
+ * the contract — exposure, saturation, clamp-negative, curve, sRGB OETF — and moving any step
+ * shifts every mid-tone.
+ */
+import {
+	NoToneMapping, LinearToneMapping, ReinhardToneMapping,
+	CineonToneMapping, ACESFilmicToneMapping, AgXToneMapping, NeutralToneMapping
+} from 'three';
+
+const SUPPORTED = new Set( [
+	NoToneMapping, LinearToneMapping, ReinhardToneMapping,
+	CineonToneMapping, ACESFilmicToneMapping, AgXToneMapping, NeutralToneMapping
+] );
+
+/**
+ * Three.js ToneMapping constant → shader mode. Anything unsupported falls back to ACES,
+ * matching `TONE_MAP_FNS.get( x ) || TONE_MAP_FNS.get( ACESFilmicToneMapping )`.
+ * @param {number} toneMapping
+ * @returns {number}
+ */
+export function toneMapMode( toneMapping ) {
+
+	return SUPPORTED.has( toneMapping ) ? toneMapping : ACESFilmicToneMapping;
+
+}
+
+/**
+ * Prelude defining `toneMapPixel( linear, gain, saturation, mode ) -> vec3f` (sRGB, [0,1]).
+ * Concatenate ahead of a kernel that wants it.
+ */
+export const TONE_MAP_WGSL = /* wgsl */`
+fn tmSaturation( c: vec3f, saturation: f32 ) -> vec3f {
+	if ( saturation == 1.0 ) { return c; }
+	let luma = dot( c, vec3f( 0.2126, 0.7152, 0.0722 ) );
+	return vec3f( luma ) + ( c - vec3f( luma ) ) * saturation;
+}
+
+fn tmSrgb1( c: f32 ) -> f32 {
+	if ( c <= 0.0031308 ) { return 12.92 * c; }
+	return 1.055 * pow( c, 1.0 / 2.4 ) - 0.055;
+}
+
+fn tmSrgb( c: vec3f ) -> vec3f {
+	return vec3f( tmSrgb1( c.r ), tmSrgb1( c.g ), tmSrgb1( c.b ) );
+}
+
+fn tmReinhard( c: vec3f ) -> vec3f {
+	return clamp( c / ( c + vec3f( 1.0 ) ), vec3f( 0.0 ), vec3f( 1.0 ) );
+}
+
+fn tmCineon1( x: f32 ) -> f32 {
+	let c = max( x - 0.004, 0.0 );
+	return pow( ( c * ( 6.2 * c + 0.5 ) ) / ( c * ( 6.2 * c + 1.7 ) + 0.06 ), 2.2 );
+}
+
+fn tmCineon( c: vec3f ) -> vec3f {
+	return vec3f( tmCineon1( c.r ), tmCineon1( c.g ), tmCineon1( c.b ) );
+}
+
+fn tmAcesFit( c: f32 ) -> f32 {
+	return ( c * ( c + 0.0245786 ) - 0.000090537 ) / ( c * ( 0.983729 * c + 0.4329510 ) + 0.238081 );
+}
+
+fn tmAces( cIn: vec3f ) -> vec3f {
+	let c = cIn / 0.6;
+	var i = vec3f(
+		0.59719 * c.r + 0.35458 * c.g + 0.04823 * c.b,
+		0.07600 * c.r + 0.90834 * c.g + 0.01566 * c.b,
+		0.02840 * c.r + 0.13383 * c.g + 0.83777 * c.b
+	);
+	i = vec3f( tmAcesFit( i.r ), tmAcesFit( i.g ), tmAcesFit( i.b ) );
+	let o = vec3f(
+		 1.60475 * i.r - 0.53108 * i.g - 0.07367 * i.b,
+		-0.10208 * i.r + 1.10813 * i.g - 0.00605 * i.b,
+		-0.00327 * i.r - 0.07276 * i.g + 1.07602 * i.b
+	);
+	return clamp( o, vec3f( 0.0 ), vec3f( 1.0 ) );
+}
+
+fn tmAgxApprox( x: f32 ) -> f32 {
+	let x2 = x * x;
+	let x4 = x2 * x2;
+	return 15.5 * x4 * x2 - 40.14 * x4 * x + 31.96 * x4 - 6.868 * x2 * x + 0.4298 * x2 + 0.1191 * x - 0.00232;
+}
+
+fn tmAgx( r: vec3f ) -> vec3f {
+	let c = vec3f(
+		0.6274 * r.r + 0.3293 * r.g + 0.0433 * r.b,
+		0.0691 * r.r + 0.9195 * r.g + 0.0113 * r.b,
+		0.0164 * r.r + 0.0880 * r.g + 0.8956 * r.b
+	);
+	var a = vec3f(
+		0.856627153315983 * c.r + 0.0951212405381588 * c.g + 0.0482516061458583 * c.b,
+		0.137318972929847 * c.r + 0.761241990602591  * c.g + 0.101439036467562  * c.b,
+		0.11189821299995  * c.r + 0.0767994186031903 * c.g + 0.811302368396859  * c.b
+	);
+
+	let agxMinEv = -12.47393;
+	let agxMaxEv = 4.026069;
+	let range = agxMaxEv - agxMinEv;
+	a = clamp( ( log2( max( a, vec3f( 1e-10 ) ) ) - vec3f( agxMinEv ) ) / range, vec3f( 0.0 ), vec3f( 1.0 ) );
+	a = vec3f( tmAgxApprox( a.r ), tmAgxApprox( a.g ), tmAgxApprox( a.b ) );
+
+	var o = vec3f(
+		 1.1271005818144368  * a.r - 0.11060664309660323 * a.g - 0.016493938717834573 * a.b,
+		-0.1413297634984383  * a.r + 1.157823702216272   * a.g - 0.016493938717834257 * a.b,
+		-0.14132976349843826 * a.r - 0.11060664309660294 * a.g + 1.2519364065950405   * a.b
+	);
+	o = pow( max( o, vec3f( 0.0 ) ), vec3f( 2.2 ) );
+
+	return clamp( vec3f(
+		 1.6605 * o.r - 0.5876 * o.g - 0.0728 * o.b,
+		-0.1246 * o.r + 1.1329 * o.g - 0.0083 * o.b,
+		-0.0182 * o.r - 0.1006 * o.g + 1.1187 * o.b
+	), vec3f( 0.0 ), vec3f( 1.0 ) );
+}
+
+fn tmNeutral( cIn: vec3f ) -> vec3f {
+	let startCompression = 0.8 - 0.04;
+	let desaturation = 0.15;
+
+	let x = min( cIn.r, min( cIn.g, cIn.b ) );
+	var offset = 0.04;
+	if ( x < 0.08 ) { offset = x - 6.25 * x * x; }
+
+	var c = cIn - vec3f( offset );
+	let peak = max( c.r, max( c.g, c.b ) );
+	if ( peak < startCompression ) { return c; }
+
+	let d = 1.0 - startCompression;
+	let newPeak = 1.0 - d * d / ( peak + d - startCompression );
+	c = c * ( newPeak / peak );
+	let gFactor = 1.0 - 1.0 / ( desaturation * ( peak - newPeak ) + 1.0 );
+
+	return c + ( vec3f( newPeak ) - c ) * gFactor;
+}
+
+fn tmCurve( cIn: vec3f, mode: u32 ) -> vec3f {
+	// Three.js clamps the fragment output before tone mapping ("force unsigned floats"), and
+	// AgX/Neutral mix negatives across channels rather than clipping them.
+	let c = max( cIn, vec3f( 0.0 ) );
+	switch mode {
+		case 0u, 1u: { return clamp( c, vec3f( 0.0 ), vec3f( 1.0 ) ); }
+		case 2u: { return tmReinhard( c ); }
+		case 3u: { return tmCineon( c ); }
+		case 6u: { return tmAgx( c ); }
+		case 7u: { return tmNeutral( c ); }
+		default: { return tmAces( c ); }
+	}
+}
+
+fn toneMapPixel( linear: vec3f, gain: f32, saturation: f32, mode: u32 ) -> vec3f {
+	var c = linear * gain;
+	c = tmSaturation( c, saturation );
+	c = tmCurve( c, mode );
+	return tmSrgb( c );
+}
+`;

package/src/managers/DenoisingManager.js

@@ -4,6 +4,29 @@ import { AIUpscaler } from '../Passes/AIUpscaler.js';
 import { EngineEvents } from '../EngineEvents.js';
 import { ENGINE_DEFAULTS as DEFAULT_STATE, ASVGF_QUALITY_PRESETS, NRD_DEFAULTS, NRD_QUALITY_PRESETS, NRD_PRESET_KEYS } 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:
+// at 512² every tier is under budget, at 1024² only `high` trips it.
+//
+// This replaced a second, time-based trigger ("downgrade once the render passes 2 s"), which
+// measured identically at 1024² for balance and high because the cost rule had already tripped —
+// but which also downgraded tiers that were affordable, on machines fast enough to run them.
+const CADENCE_COST_BUDGET_MS = 120;
+
+// Start-to-start gap as a multiple of what the last denoise actually cost. This is the whole
+// throttle: it spends half the wall clock on denoising at most, at any resolution, on any GPU.
+// A fixed millisecond floor cannot do that — the same tier measures 14 ms at 512², 48 ms at
+// 1024² and 800 ms at 2048².
+//
+// It replaced a sample-growth rule (refresh only once the sample count had grown 1.4x), which
+// was written when a denoise cost 100-330 ms. Measured after the denoise got cheap, that rule
+// only ever cost refreshes: 512² 2/s -> 32/s and 1024² 2/s -> 8.6/s, both at unchanged sample
+// rate, while 1536²/2048² did not move at all because this floor already bound there.
+//
+// 3x measured 97 % of the sample rate at 1536² against 89 % for 2x, but at a quarter of the
+// refreshes — 2x is the better trade while a person is watching the image resolve.
+const CADENCE_DENOISE_PERIODS = 2;
+
 /**
  * Orchestrates all denoising, post-processing, and AI upscaling:
  *   - Real-time denoiser strategy switching (ASVGF / NRD / EdgeAware / None)
@@ -50,6 +73,19 @@ export class DenoisingManager extends EventDispatcher {
 		this.denoiser = null;
 		this.upscaler = null;
 
+		// The tier the finished image uses. The loaded tier is not always this one: while the
+		// image is still accumulating we run a cheaper model (see previewQuality).
+		this._finalQuality = DEFAULT_STATE.oidnQuality;
+		// Two independent decisions. `finalDenoise` is the OIDN pass on the finished image;
+		// `continuousDenoise` is OIDN as the live-view denoiser. `denoiser.enabled` means only
+		// "OIDN is in use at all", which is what the aux G-buffer wiring needs.
+		this.finalDenoise = DEFAULT_STATE.enableOIDN;
+		this.continuousDenoise = DEFAULT_STATE.continuousDenoise;
+		this.continuousDenoiseInterval = DEFAULT_STATE.continuousDenoiseInterval;
+		// -Infinity, not 0: 0 reads as "denoised at time zero", which blocks the first cadence
+		// denoise while performance.now() is still below the interval.
+		this._lastCadenceAt = - Infinity;
+		this._lastCadenceSamples = 0;
 		this._onReset = null;
 		this._onPostProcessRefresh = null;
 
@@ -57,8 +93,9 @@ export class DenoisingManager extends EventDispatcher {
 		this._lastRenderWidth = 0;
 		this._lastRenderHeight = 0;
 
-		// Track the current completion-chain listener so it can be removed on re-trigger
+		// Track the current completion-chain listeners so they can be removed on re-trigger
 		this._pendingStartUpscaler = null;
+		this._pendingCloseDenoise = null;
 
 		// Bound event forwarding handlers (stored for removal on re-setup / dispose)
 		this._denoiserStartHandler = null;
@@ -97,6 +134,11 @@ export class DenoisingManager extends EventDispatcher {
 
 		this._lastRenderWidth = width;
 		this._lastRenderHeight = height;
+		// Sticky across resets: the device does not get faster between camera moves, and
+		// re-deciding per accumulation cost one slow denoise every time the camera stopped.
+		// Cleared only when the tier or the resolution changes — a denoise costs 14 ms at 512²
+		// and 800 ms at 2048², so the affordability verdict does not survive a resize.
+		this._cadenceDowngraded = false;
 		this.denoiser?.setSize( width, height );
 		this.upscaler?.setBaseSize( width, height );
 
@@ -162,16 +204,15 @@ export class DenoisingManager extends EventDispatcher {
 			getToneMapping: () => this._getToneMapping(),
 			getSaturation: () => this._getSaturation(),
 			getTransparentBackground: () => this._getTransparentBg(),
-			getMRTRenderTarget: () => pt?.storageTextures?.readTarget ?? null,
 		} );
 
-		this.denoiser.enabled = DEFAULT_STATE.enableOIDN;
+		this._syncOIDNInUse();
 
 		// Forward lifecycle events (store refs for removal on re-setup / dispose)
-		this._denoiserStartHandler = () =>
-			this.dispatchEvent( { type: EngineEvents.DENOISING_START } );
-		this._denoiserEndHandler = () =>
-			this.dispatchEvent( { type: EngineEvents.DENOISING_END } );
+		this._denoiserStartHandler = e =>
+			this.dispatchEvent( { type: EngineEvents.DENOISING_START, continuous: !! e.continuous } );
+		this._denoiserEndHandler = e =>
+			this.dispatchEvent( { type: EngineEvents.DENOISING_END, continuous: !! e.continuous } );
 		this.denoiser.addEventListener( 'start', this._denoiserStartHandler );
 		this.denoiser.addEventListener( 'end', this._denoiserEndHandler );
 
@@ -244,6 +285,10 @@ export class DenoisingManager extends EventDispatcher {
 	 */
 	get denoiserStrategy() {
 
+		// OIDN refreshing the accumulating image is a live-view denoiser like the others, so it
+		// belongs in the same one-of-N choice. Two of these running at once would mean paying for
+		// a per-frame denoise whose result the OIDN overlay then covers.
+		if ( this.continuousDenoise ) return 'oidn';
 		if ( this._stages.asvgf?.enabled ) return 'asvgf';
 		if ( this._stages.nrd?.enabled ) return 'nrd';
 		if ( this._stages.edgeFilter?.enabled ) return 'edgeaware';
@@ -269,6 +314,10 @@ export class DenoisingManager extends EventDispatcher {
 
 		this._clearDenoiserTextures();
 
+		// Which denoiser owns the live view. Deliberately says nothing about the finished image:
+		// wanting OIDN on the viewport is not the same as opting into a final pass.
+		this.setContinuousDenoise( strategy === 'oidn' );
+
 		switch ( strategy ) {
 
 			case 'asvgf':
@@ -422,7 +471,11 @@ export class DenoisingManager extends EventDispatcher {
 
 		// Clean-aux normal: temporally accumulate the aux normal only for OIDN clean-aux models
 		// (balanced/high). 'fast' and the real-time denoisers keep the point-sampled bump normal.
-		s.pathTracer?.setCleanAuxNormal?.( !! this.denoiser?.enabled && this.denoiser?.quality !== 'fast' );
+		// Keyed on the chosen tier, not the loaded one — the loaded tier dips to a cheaper model
+		// during refreshes, and following that would restart the aux accumulation mid-render.
+		s.pathTracer?.setCleanAuxNormal?.(
+			!! this.denoiser?.enabled && !! this.denoiser?.expectsCleanAux( this._finalQuality )
+		);
 
 		// Reclaim VRAM: free the big 2048² StorageTextures of any denoiser/G-buffer stage that ended up
 		// disabled (lazily re-created on the next dispatch after re-enable). Every strategy/denoiser
@@ -449,13 +502,99 @@ export class DenoisingManager extends EventDispatcher {
 	 */
 	_cleanupCompletionListener() {
 
-		if ( this._pendingStartUpscaler && this.denoiser ) {
+		if ( this.denoiser ) {
 
-			this.denoiser.removeEventListener( 'end', this._pendingStartUpscaler );
+			if ( this._pendingStartUpscaler ) this.denoiser.removeEventListener( 'end', this._pendingStartUpscaler );
+			if ( this._pendingCloseDenoise ) this.denoiser.removeEventListener( 'end', this._pendingCloseDenoise );
 
 		}
 
 		this._pendingStartUpscaler = null;
+		this._pendingCloseDenoise = null;
+
+	}
+
+	/**
+	 * Denoises the accumulating mean on a cadence, so a preview shows a clean image while it
+	 * refines instead of only once it finishes. Driven from the render loop; call every frame.
+	 *
+	 * @param {number} sampleCount - accumulated samples (PathTracer.frameCount)
+	 * @returns {boolean} whether a denoise was started this call
+	 */
+	tickContinuousDenoise( sampleCount ) {
+
+		const dn = this.denoiser;
+		if ( ! this.continuousDenoise || ! dn ) return false;
+		if ( dn.state.isDenoising || dn.state.isLoading ) return false;
+
+		// While the camera moves, reset() hides the output every frame and a denoise would paint
+		// a view that is already stale. Denoise once the motion stops.
+		if ( this._stages.pathTracer?.interactionMode ) return false;
+
+		// Nothing new has landed since the last refresh, so it would repaint the same image.
+		if ( sampleCount <= this._lastCadenceSamples ) return false;
+
+		const now = performance.now();
+		// `continuousDenoiseInterval` is only the floor's lower bound: on a cheap denoise it is
+		// what binds, and past ~1024² the denoise's own cost is.
+		const minGap = Math.max( this.continuousDenoiseInterval, dn.lastDenoiseMs * CADENCE_DENOISE_PERIODS );
+		if ( now - this._lastCadenceAt < minGap ) return false;
+
+		this._lastCadenceAt = now;
+		this._lastCadenceSamples = sampleCount;
+
+		// A tier too slow to be a live view refreshes with a cheaper model and is put back for the
+		// finished image. One-way: letting it flip back would reload weights on every tick.
+		if ( dn.lastDenoiseMs > CADENCE_COST_BUDGET_MS ) this._cadenceDowngraded = true;
+
+		// updateQuality flags the load synchronously, and start() below defers itself until the
+		// weights land.
+		const want = this._cadenceDowngraded ? this.previewQuality() : this._finalQuality;
+		if ( dn.quality !== want ) dn.updateQuality( want );
+
+		dn.start( { continuous: true } );
+		return true;
+
+	}
+
+	/**
+	 * The tier used for refreshes while the image is still accumulating: the cheapest model that
+	 * reads the same kind of aux buffer as the final one.
+	 *
+	 * Matching the aux kind is not optional. `setCleanAuxNormal()` throws away the accumulated
+	 * albedo/normal, so if the refreshes and the final denoise disagreed about it, the final
+	 * denoise would run against an aux buffer one sample deep.
+	 */
+	previewQuality() {
+
+		return this.denoiser?.expectsCleanAux( this._finalQuality ) ? 'fast-clean' : 'fast';
+
+	}
+
+	setContinuousDenoise( enabled ) {
+
+		this.continuousDenoise = !! enabled;
+		this._syncOIDNInUse();
+		this._lastCadenceAt = - Infinity;
+		this._resetCadence();
+
+	}
+
+	// Puts the finished image back on the tier the user asked for, after the refreshes ran a
+	// cheaper one. A no-op when they match, which is the common case in preview.
+	_useFinalQuality() {
+
+		const dn = this.denoiser;
+		if ( dn && dn.quality !== this._finalQuality ) dn.updateQuality( this._finalQuality );
+
+	}
+
+	// Only the sample gate resets, so a fresh accumulation denoises promptly. The clock is
+	// deliberately kept: reset() runs every frame of a camera drag, and rearming it there
+	// would spend a denoise per frame on views that are already stale.
+	_resetCadence() {
+
+		this._lastCadenceSamples = 0;
 
 	}
 
@@ -464,9 +603,16 @@ export class DenoisingManager extends EventDispatcher {
 		// Remove any stale completion-chain listener from a previous render cycle
 		this._cleanupCompletionListener();
 
-		// Chain: denoise first (if enabled), then upscale (if enabled)
+		// What closes the render, if anything. A full pass at the chosen tier when that switch is
+		// on; otherwise, if OIDN owns the live view, one last cheap refresh — the cadence's last
+		// tick lands a few samples short, and the picture should match the render that finished.
+		const closing = this.finalDenoise ? 'final' : this.continuousDenoise ? 'refresh' : null;
+
+		// Registered only once the closing denoise has been launched, so the next 'end' is
+		// unambiguously that one — a cadence run's end can look identical otherwise.
 		const startUpscaler = () => {
 
+			this.denoiser?.removeEventListener( 'end', startUpscaler );
 			this._pendingStartUpscaler = null;
 
 			if ( ! isStillComplete() ) return;
@@ -479,15 +625,58 @@ export class DenoisingManager extends EventDispatcher {
 
 		};
 
-		if ( this.denoiser?.enabled ) {
+		if ( ! closing ) {
+
+			startUpscaler();
+			return;
+
+		}
+
+		const launchClosing = () => {
+
+			if ( ! isStillComplete() ) return;
 
 			this._pendingStartUpscaler = startUpscaler;
-			this.denoiser.addEventListener( 'end', startUpscaler, { once: true } );
-			this.denoiser.start();
+			this.denoiser.addEventListener( 'end', startUpscaler );
+
+			if ( closing === 'final' ) {
+
+				this._useFinalQuality();
+				this.denoiser.start();
+
+			} else {
+
+				// Whatever model the refreshes have been using — no reload for a picture the user
+				// never asked to be denoised at full quality.
+				this.denoiser.start( { continuous: true } );
+
+			}
+
+		};
+
+		this._resetCadence();
+
+		if ( this.denoiser.state.isDenoising ) {
+
+			// A cadence run is mid-flight against a lower sample count. Let it finish first —
+			// start() would be refused right now.
+			// three.js EventDispatcher.addEventListener takes (type, listener) and silently
+			// ignores an options object, so a listener that restarts the denoiser MUST remove
+			// itself: `{ once: true }` here re-fired on its own end, forever.
+			const onCadenceEnd = () => {
+
+				this.denoiser?.removeEventListener( 'end', onCadenceEnd );
+				if ( this._pendingCloseDenoise === onCadenceEnd ) this._pendingCloseDenoise = null;
+				launchClosing();
+
+			};
+
+			this._pendingCloseDenoise = onCadenceEnd;
+			this.denoiser.addEventListener( 'end', onCadenceEnd );
 
 		} else {
 
-			startUpscaler();
+			launchClosing();
 
 		}
 
@@ -510,9 +699,12 @@ export class DenoisingManager extends EventDispatcher {
 
 			if ( this.denoiser.enabled ) this.denoiser.abort();
 			if ( this.denoiser.output ) this.denoiser.output.style.display = 'none';
+			this.denoiser.invalidateLatch();
 
 		}
 
+		this._resetCadence();
+
 	}
 
 	dispose() {
@@ -647,23 +839,60 @@ export class DenoisingManager extends EventDispatcher {
 	// ── OIDN ─────────────────────────────────────────────────────
 
 	/** Enables or disables Intel OIDN denoiser. */
+	/**
+	 * Records the final-pass decision and syncs `enabled`. No host refresh — for callers like
+	 * configureForMode that drive the whole change themselves.
+	 */
+	applyOIDNEnabled( enabled ) {
+
+		this.finalDenoise = !! enabled;
+		this._syncOIDNInUse();
+
+	}
+
+	/** The tier the finished image uses — not `denoiser.quality`, which dips during refreshes. */
+	get oidnQuality() {
+
+		return this._finalQuality;
+
+	}
+
+	/** Denoise the finished image with OIDN. Independent of which denoiser owns the live view. */
 	setOIDNEnabled( enabled ) {
 
-		if ( this.denoiser ) this.denoiser.enabled = enabled;
+		this.applyOIDNEnabled( enabled );
 		// OIDN reads the PathTracer aux MRT; re-sync so the wavefront produces it while OIDN is on.
 		this._syncGBufferStages();
 		this._onPostProcessRefresh?.();
 
 	}
 
-	/** Sets OIDN denoiser quality. */
-	setOIDNQuality( quality ) {
+	// `enabled` on the denoiser is the union of its two jobs — everything downstream (the aux MRT,
+	// VRAM retention) only needs to know whether OIDN runs at all.
+	_syncOIDNInUse() {
+
+		if ( this.denoiser ) this.denoiser.enabled = this.finalDenoise || this.continuousDenoise;
+
+	}
 
+	/**
+	 * Records the tier the finished image should use, and loads it. No host refresh — for callers
+	 * like configureForMode that drive the whole tier change themselves.
+	 */
+	applyOIDNQuality( quality ) {
+
+		this._finalQuality = quality;
+		this._cadenceDowngraded = false;
 		this.denoiser?.updateQuality( quality );
-		// Clean-aux normal follows the model, not the tier name — see OIDNDenoiser.QUALITY_MODELS.
-		this._stages.pathTracer?.setCleanAuxNormal?.(
-			!! this.denoiser?.enabled && !! this.denoiser?.expectsCleanAux( quality )
-		);
+
+	}
+
+	setOIDNQuality( quality ) {
+
+		this.applyOIDNQuality( quality );
+		// _syncGBufferStages owns the clean-aux decision (it follows the model, not the tier name —
+		// see OIDNDenoiser.QUALITY_MODELS). Inlining a second copy here let the two disagree.
+		this._syncGBufferStages();
 		this._onPostProcessRefresh?.();
 
 	}

package/src/managers/OverlayManager.js

@@ -179,6 +179,10 @@ export class OverlayManager {
 
 			source.addEventListener( 'tileProgress', ( e ) => {
 
+				// A cadence denoise of the still-accumulating preview runs many times a second and
+				// is a single tile — showing the border for those just strobes it.
+				if ( e.continuous ) return;
+
 				if ( e.tile ) {
 
 					tileHelper.setRenderSize( e.imageWidth, e.imageHeight );

package/src/managers/VideoRenderManager.js

@@ -123,7 +123,7 @@ export class VideoRenderManager {
 				if ( this._cancelled ) break;
 
 				// 4. Denoise if enabled
-				if ( enableOIDN && app.denoisingManager?.denoiser?.enabled ) {
+				if ( enableOIDN && app.denoisingManager?.finalDenoise ) {
 
 					await this._waitForDenoise( app );
 
@@ -280,8 +280,8 @@ export class VideoRenderManager {
 			transmissiveBounces: app.settings.get( 'transmissiveBounces' ),
 			renderMode: app.stages.pathTracer?.renderMode?.value,
 			controlsEnabled: app.cameraManager.controls?.enabled,
-			oidnEnabled: app.denoisingManager?.denoiser?.enabled,
-			oidnQuality: app.denoisingManager?.denoiser?.quality,
+			oidnEnabled: app.denoisingManager?.finalDenoise,
+			oidnQuality: app.denoisingManager?.oidnQuality,
 			wasPlaying: app.animationManager?.isPlaying,
 			pauseRendering: app.pauseRendering,
 		};
@@ -314,8 +314,8 @@ export class VideoRenderManager {
 
 		if ( app.denoisingManager?.denoiser ) {
 
-			app.denoisingManager.denoiser.enabled = state.oidnEnabled ?? false;
-			if ( state.oidnQuality ) app.denoisingManager.denoiser.updateQuality( state.oidnQuality );
+			app.denoisingManager.applyOIDNEnabled( state.oidnEnabled ?? false );
+			if ( state.oidnQuality ) app.denoisingManager.applyOIDNQuality( state.oidnQuality );
 
 		}