rayzee 7.22.6 → 7.22.8

package/package.json

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

package/src/EngineDefaults.js

@@ -604,7 +604,8 @@ export const PRODUCTION_RENDER_CONFIG = {
 	// so easy scenes finish well under it while hard GI scenes use the full budget.
 	maxSamples: 150, bounces: 20, transmissiveBounces: 8, maxSubsurfaceSteps: 64,
 	renderMode: 1, enableAlphaShadows: true,
-	enableOIDN: true, oidnQuality: 'balance',
+	// 'high' is the only tier that reaches OIDN's _large weights (calb_cnrm); ~2x denoise cost.
+	enableOIDN: true, oidnQuality: 'high',
 	interactionModeEnabled: false,
 	// 0.94 against the eroded count ≈ the old raw-count 0.98; erosion holds the fraction a few points lower.
 	useAdaptiveSampling: true,

package/src/Passes/OIDNDenoiser.js

@@ -52,20 +52,65 @@ import { getAssetConfig } from '../AssetConfig.js';
 const _tmOut = new Float32Array( 3 );
 
 const MODEL_CONFIG = {
-	// clean-aux models — first-hit albedo/normal are deterministic per pixel
+	// No cleanAux flag in oidn-web, so the blob is it — and must match what setCleanAuxNormal
+	// feeds: `fast` point-samples the normal (noisy aux), balance/high accumulate it. calb_cnrm
+	// is also the only model with a `_large` blob.
 	QUALITY_MODELS: {
 		fast: 'rt_hdr_alb_nrm_small',
-		balance: 'rt_hdr_alb_nrm',
+		balance: 'rt_hdr_calb_cnrm',
 		high: 'rt_hdr_calb_cnrm_large'
 	},
 	DEFAULT_OPTIONS: {
 		enableOIDN: true,
 		oidnQuality: 'fast',
 		debugGbufferMaps: true,
-		tileSize: 256
+		// Tiles run at tileSize + 2*overlap (96px, 112 for _large), so small tiles pay that padding
+		// every tile: 256 puts 3.06x the pixels through the UNet at 512². Measured 3.64x faster.
+		tileSize: 512
 	}
 };
 
+// Stands in for OIDN's inputScale, which oidn-web only applies on its CPU path — the GPUBuffer
+// path leaves the uniform at 1.0. Equivalent because oidn-web does PUForward(col*inputScale) in
+// and PUInverse(..)/inputScale out, so pre-multiplying here and dividing it back out of the
+// output exposure round-trips. Alpha is preserved for _cacheInputAlpha.
+const COLOR_SCALE_WGSL = /* wgsl */`
+@group(0) @binding(0) var<storage, read_write> col: array<vec4<f32>>;
+@group(0) @binding(1) var<uniform> scale: f32;
+
+@compute @workgroup_size(64)
+fn main( @builtin(global_invocation_id) gid: vec3<u32>,
+		 @builtin(num_workgroups) nwg: vec3<u32> ) {
+	let i = gid.y * nwg.x * 64u + gid.x;
+	if ( i >= arrayLength( &col ) ) { return; }
+	let c = col[ i ];
+	col[ i ] = vec4<f32>( c.xyz * scale, c.w );
+}
+`;
+
+const SCALE_WG_SIZE = 64;
+// 1D would exceed maxComputeWorkgroupsPerDimension (65535) past ~2048², so the dispatch is 2D.
+const SCALE_MAX_WG_X = 32768;
+
+// OIDN's autoexposure, mirroring oidn-web's avgLogLum. Whole-frame, so it cannot seam per tile.
+const OIDN_AUTOEXPOSURE_KEY = 0.18;
+
+function oidnInputScale( f32, pixelCount ) {
+
+	let logSum = 0;
+	for ( let i = 0; i < pixelCount; i ++ ) {
+
+		const o = i * 4;
+		const lum = 0.212671 * f32[ o ] + 0.71516 * f32[ o + 1 ] + 0.072169 * f32[ o + 2 ];
+		logSum += Math.log2( Math.max( lum, 0 ) + 0.0001 );
+
+	}
+
+	const scale = OIDN_AUTOEXPOSURE_KEY / Math.pow( 2, logSum / pixelCount );
+	return Number.isFinite( scale ) && scale > 0 ? scale : 1.0;
+
+}
+
 export class OIDNDenoiser extends EventDispatcher {
 
 	constructor( output, renderer, scene, camera, options = {} ) {
@@ -110,6 +155,11 @@ export class OIDNDenoiser extends EventDispatcher {
 		// order guarantees the overwrites are serialized).
 		this._gpuInputPadBuffer = null;
 		this._gpuInputPaddedRowBytes = 0;
+		// 1.0 until the first readback.
+		this._colorScalePipeline = null;
+		this._colorScaleBindGroup = null;
+		this._colorScaleUniform = null;
+		this._oidnInputScale = 1.0;
 		// Pooled MAP_READ staging buffer for _cacheInputAlpha. Only allocated
 		// when transparent-background readback is used, destroyed on resolution
 		// change or dispose. Same spirit as r184's ReadbackBuffer — we can't use
@@ -130,6 +180,8 @@ export class OIDNDenoiser extends EventDispatcher {
 		this.quality = this.config.oidnQuality;
 		this.debugGbufferMaps = this.config.debugGbufferMaps;
 		this.tileSize = this.config.tileSize;
+		// tileSize actually baked into the live UNet, so a runtime change forces a rebuild.
+		this._activeTileSize = 0;
 
 		// State management
 		this.state = {
@@ -212,8 +264,8 @@ export class OIDNDenoiser extends EventDispatcher {
 		this.state.isLoading = true;
 		const tzaUrl = this._generateTzaUrl();
 
-		// Skip setup if URL hasn't changed
-		if ( this.currentTZAUrl === tzaUrl && this.unet ) {
+		// maxTileSize is a constructor arg, so comparing the URL alone left tileSize changes inert.
+		if ( this.currentTZAUrl === tzaUrl && this._activeTileSize === this.tileSize && this.unet ) {
 
 			this.state.isLoading = false;
 			return;
@@ -251,6 +303,7 @@ export class OIDNDenoiser extends EventDispatcher {
 			} );
 
 			this.currentTZAUrl = tzaUrl;
+			this._activeTileSize = this.tileSize;
 			this.dispatchEvent( { type: 'loaded' } );
 			log.debug( 'UNet weights loaded:', tzaUrl );
 
@@ -477,21 +530,18 @@ export class OIDNDenoiser extends EventDispatcher {
 
 		copyTex( textures.color, this._gpuInputBuffers.color );
 		copyTex( textures.albedo, this._gpuInputBuffers.albedo );
+		// The normal stays [0,1]-encoded. This contradicts OIDN's API ("must be in the [-1,1]
+		// range") but is right for this port: OIDN's own getNormal (cpu_input_process.isph) does
+		// `value*0.5+0.5` before the network, and oidn-web omits that remap. Decoding to [-1,1]
+		// measured 0.878 -> 2.439 denoise ratio at 64 spp. Do not "fix" it.
 		copyTex( textures.normal, this._gpuInputBuffers.normal );
 
 		device.queue.submit( [ encoder.finish() ] );
 
-		// Cache alpha channel from input color buffer when transparent background is enabled.
-		// OIDN only processes RGB — the alpha channel is lost, so we read it before denoising.
-		if ( this.getTransparentBackground() ) {
-
-			await this._cacheInputAlpha( device, width, height );
-
-		} else {
-
-			this._cachedAlpha = null;
-
-		}
+		// One readback serves the autoexposure scale and the alpha OIDN discards. Must precede the scale.
+		await this._readbackColor( device, width, height );
+		if ( globalThis.__OIDN_NO_INPUT_SCALE ) this._oidnInputScale = 1.0;
+		this._applyColorScale( device, width * height );
 
 		// Draw the current noisy frame as the base — denoised tiles paint on top progressively
 		this.ctx.drawImage( this.input, 0, 0, width, height );
@@ -571,6 +621,10 @@ export class OIDNDenoiser extends EventDispatcher {
 
 		this._alphaReadbackBuffer?.destroy();
 		this._alphaReadbackMapped = false;
+		// Bind group holds the destroyed buffer; the pipeline is device-scoped and survives.
+		this._colorScaleBindGroup = null;
+		this._colorScaleUniform?.destroy();
+		this._colorScaleUniform = null;
 		this._gpuInputBuffers = { color: null, albedo: null, normal: null };
 		this._gpuInputPadBuffer = null;
 		this._gpuInputPaddedRowBytes = 0;
@@ -580,10 +634,10 @@ export class OIDNDenoiser extends EventDispatcher {
 	}
 
 	/**
-	 * Reads the alpha channel from the input color GPU buffer and caches it as a Uint8Array.
-	 * Called before OIDN denoising when transparent background is enabled.
+	 * Reads back the colour buffer for the autoexposure scale, plus alpha when transparent
+	 * background is on (OIDN discards alpha).
 	 */
-	async _cacheInputAlpha( device, width, height ) {
+	async _readbackColor( device, width, height ) {
 
 		const byteSize = width * height * 16; // rgba32float, tightly packed
 
@@ -620,13 +674,20 @@ export class OIDNDenoiser extends EventDispatcher {
 		}
 
 		const f32 = new Float32Array( staging.getMappedRange() );
-
-		// Extract alpha channel as uint8 (pre-multiplied is not needed — alpha is 0 or 1)
 		const pixelCount = width * height;
-		const alpha = new Uint8Array( pixelCount );
-		for ( let i = 0; i < pixelCount; i ++ ) {
 
-			alpha[ i ] = Math.min( Math.max( f32[ i * 4 + 3 ] * 255, 0 ), 255 ) | 0;
+		this._oidnInputScale = oidnInputScale( f32, pixelCount );
+
+		let alpha = null;
+		if ( this.getTransparentBackground() ) {
+
+			// Alpha as uint8; pre-multiplication is not needed — alpha is 0 or 1
+			alpha = new Uint8Array( pixelCount );
+			for ( let i = 0; i < pixelCount; i ++ ) {
+
+				alpha[ i ] = Math.min( Math.max( f32[ i * 4 + 3 ] * 255, 0 ), 255 ) | 0;
+
+			}
 
 		}
 
@@ -638,6 +699,81 @@ export class OIDNDenoiser extends EventDispatcher {
 
 	}
 
+	/** Display exposure with the input scale divided back out — output arrives pre-multiplied. */
+	_outputExposure() {
+
+		return this.getExposure() / this._oidnInputScale;
+
+	}
+
+	/** Pre-multiplies the colour buffer by the autoexposure scale. */
+	_applyColorScale( device, pixelCount ) {
+
+		const scale = this._oidnInputScale;
+		if ( ! this._ensureColorScalePipeline( device ) ) return;
+
+		device.queue.writeBuffer( this._colorScaleUniform, 0, new Float32Array( [ scale ] ) );
+
+		const wgTotal = Math.ceil( pixelCount / SCALE_WG_SIZE );
+		const wgX = Math.min( wgTotal, SCALE_MAX_WG_X );
+		const wgY = Math.ceil( wgTotal / wgX );
+
+		const encoder = device.createCommandEncoder( { label: 'oidn-color-scale' } );
+		const pass = encoder.beginComputePass( { label: 'oidn-color-scale' } );
+		pass.setPipeline( this._colorScalePipeline );
+		pass.setBindGroup( 0, this._colorScaleBindGroup );
+		pass.dispatchWorkgroups( wgX, wgY, 1 );
+		pass.end();
+		device.queue.submit( [ encoder.finish() ] );
+
+	}
+
+	/** @returns {GPUComputePipeline|null} */
+	_ensureColorScalePipeline( device ) {
+
+		const buffer = this._gpuInputBuffers.color;
+		if ( ! device || ! buffer ) return null;
+
+		if ( ! this._colorScalePipeline ) {
+
+			this._colorScalePipeline = device.createComputePipeline( {
+				label: 'oidn-color-scale',
+				layout: 'auto',
+				compute: {
+					module: device.createShaderModule( { label: 'oidn-color-scale', code: COLOR_SCALE_WGSL } ),
+					entryPoint: 'main'
+				}
+			} );
+
+		}
+
+		if ( ! this._colorScaleUniform ) {
+
+			this._colorScaleUniform = device.createBuffer( {
+				label: 'oidn-color-scale-uniform',
+				size: 16, // min uniform binding size
+				usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+			} );
+
+		}
+
+		if ( ! this._colorScaleBindGroup ) {
+
+			this._colorScaleBindGroup = device.createBindGroup( {
+				label: 'oidn-color-scale',
+				layout: this._colorScalePipeline.getBindGroupLayout( 0 ),
+				entries: [
+					{ binding: 0, resource: { buffer } },
+					{ binding: 1, resource: { buffer: this._colorScaleUniform } }
+				]
+			} );
+
+		}
+
+		return this._colorScalePipeline;
+
+	}
+
 	/**
 	 * Promise wrapper around tileExecute for the GPU path.
 	 * Outputs a GPUBuffer — copied to a staging buffer then converted to ImageData for the 2D canvas.
@@ -754,7 +890,7 @@ export class OIDNDenoiser extends EventDispatcher {
 
 						const f32 = new Float32Array( staging.getMappedRange() );
 						const tileImageData = new ImageData( clampedW, clampedH );
-						const exposure = this.getExposure();
+						const exposure = this._outputExposure();
 						const saturation = this.getSaturation();
 						const tmFn = TONE_MAP_FNS.get( this.getToneMapping() ) || TONE_MAP_FNS.get( ACESFilmicToneMapping );
 						const alpha = this._cachedAlpha;
@@ -856,7 +992,7 @@ export class OIDNDenoiser extends EventDispatcher {
 			const float32 = new Float32Array( stagingBuffer.getMappedRange() );
 
 			const imageData = new ImageData( width, height );
-			const exposure = this.getExposure();
+			const exposure = this._outputExposure();
 			const saturation = this.getSaturation();
 			const tmFn = TONE_MAP_FNS.get( this.getToneMapping() ) || TONE_MAP_FNS.get( ACESFilmicToneMapping );
 			const alpha = this._cachedAlpha;
@@ -962,6 +1098,7 @@ export class OIDNDenoiser extends EventDispatcher {
 		// TFJS tears down the cached backend's buffers/textures.
 		removeOidnTfjsBackend();
 		this._destroyGPUInputBuffers();
+		this._colorScalePipeline = null;
 
 		// Clean up DOM
 		if ( this.output?.parentNode ) {

package/src/PathTracerApp.js

@@ -442,16 +442,7 @@ export class PathTracerApp extends EventDispatcher {
 
 		}
 
-		// Abort post-processing and restore denoiser canvas resolution
-		this.denoisingManager?.abort( this.canvas );
-
-		if ( this.denoisingManager?.restoreBaseResolution() ) {
-
-			const w = this.denoisingManager._lastRenderWidth;
-			const h = this.denoisingManager._lastRenderHeight;
-			this.dispatchEvent( { type: 'resolution_changed', width: w, height: h } );
-
-		}
+		this._abortPostProcess();
 
 		this.completion.reset();
 		this.wake();
@@ -1524,6 +1515,37 @@ export class PathTracerApp extends EventDispatcher {
 
 	}
 
+	// Aborts any in-flight denoise/upscale and puts the denoiser canvas back at base resolution (the
+	// upscaler leaves it enlarged), so the live canvas is what's on screen again.
+	_abortPostProcess() {
+
+		this.denoisingManager?.abort( this.canvas );
+
+		if ( this.denoisingManager?.restoreBaseResolution() ) {
+
+			const w = this.denoisingManager._lastRenderWidth;
+			const h = this.denoisingManager._lastRenderHeight;
+			this.dispatchEvent( { type: 'resolution_changed', width: w, height: h } );
+
+		}
+
+	}
+
+	/**
+	 * Re-runs the post-process chain (OIDN → upscaler) against the accumulated image. The chain fires once,
+	 * on the frame the render completes, so a denoiser switched on afterwards would otherwise never run.
+	 */
+	requestPostProcessRefresh() {
+
+		if ( ! this.stages.pathTracer?.isReady || this._deviceLost ) return;
+
+		this._abortPostProcess();
+
+		this.completion.renderCompleteDispatched = false;
+		this.wake();
+
+	}
+
 	// ═══════════════════════════════════════════════════════════════
 	// Deterministic / headless control
 	// ═══════════════════════════════════════════════════════════════
@@ -2408,6 +2430,7 @@ export class PathTracerApp extends EventDispatcher {
 
 		this.denoisingManager.setOverlayManager( this.overlayManager );
 		this.denoisingManager.setResetCallback( () => this.reset() );
+		this.denoisingManager.setPostProcessRefreshCallback( () => this.requestPostProcessRefresh() );
 		this.denoisingManager.setSettings( this.settings );
 
 		// Expose environment manager (lives on pathTracer stage)

package/src/Stages/PathTracer.js

@@ -68,6 +68,10 @@ export class PathTracer extends PathTracerStage {
 		// of the point-sampled per-frame value that leaks noise. Off for fast/ASVGF (they want the bump normal).
 		this._cleanAuxNormalEnabled = false;
 		this._cleanAuxNormalUniform = uniform( 0, 'uint' );
+		// Aux MRT accumulates on an epoch of its own: enabling the denoiser at colour frame N must not leave
+		// the stale aux pinned by the colour's 1/(N+1) alpha.
+		this._auxSamples = 0;
+		this._auxSeedPending = false;
 
 		// CPU sizes per-bounce kernels from last frame's survivor curve; kernels bound on ENTERING_COUNT so over-sizing is safe. (indirect dispatch not viable — three.js doesn't sync compute-written indirect buffers across submissions)
 		this._useDynamicDispatch = true;
@@ -238,8 +242,17 @@ export class PathTracer extends PathTracerStage {
 
 		if ( this.isComplete || this.frameCount >= this.completionThreshold || this._isConvergedComplete() ) {
 
-			if ( ! this.isComplete ) this.isComplete = true;
-			return;
+			// Denoiser switched on after the render finished — spend one more frame to fill the aux MRT.
+			if ( this._auxSeedPending ) {
+
+				this.isComplete = false;
+
+			} else {
+
+				if ( ! this.isComplete ) this.isComplete = true;
+				return;
+
+			}
 
 		}
 
@@ -283,6 +296,7 @@ export class PathTracer extends PathTracerStage {
 		}
 
 		this._updateAccumulationUniforms( frameValue, renderMode );
+		const auxMixes = this._updateAuxAccumulationUniforms( frameValue );
 		this.frame.value = frameValue;
 		this.seedFrame.value = this._seedTick ++;
 
@@ -354,7 +368,8 @@ export class PathTracer extends PathTracerStage {
 
 			// Tier-2 bounce-0 grid size from the stale settled active-pixel count (single-chunk only; else full).
 			// Monotonic freeze ⇒ a stale count is a safe over-estimate; reset/camera-move → _curveSizingValid=false.
-			const adaptiveFreeze = this.usePixelFreeze.value > 0;
+			// An aux seed frame must trace every pixel: Generate/Shade skip the G-buffer for frozen ones.
+			const adaptiveFreeze = this.usePixelFreeze.value > 0 && ! this._auxSeedPending;
 			const activeBounce0 = ( singleChunk && adaptiveFreeze && this._curveSizingValid && this._lastActivePixelCount > 0 )
 				? this._lastActivePixelCount : maxRays;
 
@@ -488,6 +503,9 @@ export class PathTracer extends PathTracerStage {
 		// Don't count interaction-mode (1-SPP feedback) frames toward completion (megakernel parity Stages/PathTracer.js:1240) — else a continuous orbit "completes" on noise.
 		if ( ! this.cameraOptimizer?.isInInteractionMode() ) this.frameCount ++;
 
+		if ( this._auxGBufferEnabled ) this._auxSamples = auxMixes ? this._auxSamples + 1 : 1;
+		this._auxSeedPending = false;
+
 		if ( originalMaxBounces !== null ) this.maxBounces.value = originalMaxBounces;
 
 		this.performanceMonitor?.end();
@@ -518,6 +536,8 @@ export class PathTracer extends PathTracerStage {
 		this._convergedFraction = 0;
 		this._convergedGeometryFraction = 0;
 		this._lastActivePixelCount = 0;
+		this._auxSamples = 0;
+		this._auxSeedPending = false;
 
 	}
 
@@ -585,28 +605,62 @@ export class PathTracer extends PathTracerStage {
 	}
 
 	// Aux MRT (normalDepth/albedo) is needed only by the denoiser/OIDN; DenoisingManager calls this to
-	// turn the wavefront's aux writes on/off. It's a live uniform, so toggling is just a value flip +
-	// accumulation reset — no kernel rebuild, no UI freeze.
+	// turn the wavefront's aux writes on/off. It's a live uniform, so toggling is just a value flip —
+	// no kernel rebuild, no UI freeze.
 	setAuxGBufferEnabled( enabled ) {
 
 		enabled = !! enabled;
 		if ( this._auxGBufferEnabled === enabled ) return;
 		this._auxGBufferEnabled = enabled;
 		this._auxGBufferUniform.value = enabled ? 1 : 0;
-		this.reset();
+		this.restartAuxAccumulation();
 
 	}
 
 	// Clean-aux normal: when a clean-aux OIDN model is active (calb_cnrm/high, alb_nrm/balanced), FinalWrite
 	// temporally accumulates + renormalizes the aux normal so the model isn't fed per-frame point-sampled
-	// noise. DenoisingManager calls this on OIDN enable + quality change. Live uniform → value flip + reset.
+	// noise. DenoisingManager calls this on OIDN enable + quality change. The two modes write the normal in
+	// incompatible ways, so the aux buffer has to refill.
 	setCleanAuxNormal( enabled ) {
 
 		enabled = !! enabled;
 		if ( this._cleanAuxNormalEnabled === enabled ) return;
 		this._cleanAuxNormalEnabled = enabled;
 		this._cleanAuxNormalUniform.value = enabled ? 1 : 0;
-		this.reset();
+		this.restartAuxAccumulation();
+
+	}
+
+	/** Drops the aux MRT's history, leaving the colour's accumulation intact. */
+	restartAuxAccumulation() {
+
+		this._auxSamples = 0;
+		this._auxSeedPending = this._auxGBufferEnabled;
+
+	}
+
+	/**
+	 * @returns {boolean} whether FinalWrite will MIX the aux this frame rather than seed it.
+	 *
+	 * colorAccumulates mirrors FinalWrite's outer gate: when that gate is false the aux is written verbatim
+	 * regardless, which restarts the epoch. A mismatch costs aux quality only — the shader also reads
+	 * hasPreviousAux, so it can never mix against textures this epoch has not written.
+	 */
+	_updateAuxAccumulationUniforms( frameValue ) {
+
+		const colorAccumulates = this.accumulationEnabled
+			&& ! this.cameraIsMoving.value
+			&& frameValue > 0
+			&& this.hasPreviousAccumulated.value > 0
+			&& this.visMode.value !== 11;
+
+		const mixes = this._auxGBufferEnabled && colorAccumulates
+			&& ! this._auxSeedPending && this._auxSamples > 0;
+
+		this.hasPreviousAux.value = mixes ? 1 : 0;
+		this.auxAccumulationAlpha.value = mixes ? 1 / ( this._auxSamples + 1 ) : 1.0;
+
+		return mixes;
 
 	}
 
@@ -1483,6 +1537,8 @@ export class PathTracer extends PathTracerStage {
 			enableAccumulation: this.enableAccumulation,
 			hasPreviousAccumulated: this.hasPreviousAccumulated,
 			accumulationAlpha: this.accumulationAlpha,
+			hasPreviousAux: this.hasPreviousAux,
+			auxAccumulationAlpha: this.auxAccumulationAlpha,
 			cameraIsMoving: this.cameraIsMoving,
 			transparentBackground: this.transparentBackground,
 			prevAccumTexture: prevColor,

package/src/TSL/FinalWriteKernel.js

@@ -37,6 +37,8 @@ export function buildFinalWriteKernel( params ) {
 		writeColorTex, writeNDTex, writeAlbedoTex,
 		resolution, frame,
 		enableAccumulation, hasPreviousAccumulated, accumulationAlpha, cameraIsMoving,
+		// Aux MRT accumulates on its own epoch; hasPreviousAux=0 → write it verbatim instead of mixing.
+		hasPreviousAux, auxAccumulationAlpha,
 		transparentBackground,
 		prevAccumTexture, prevAlbedoTexture, prevNormalDepthTexture,
 		renderWidth,
@@ -113,10 +115,10 @@ export function buildFinalWriteKernel( params ) {
 
 				// Frozen pixels pass prev colour through unchanged (stale sample); active pixels accumulate.
 				finalColor.assign( select( wasFrozen, prevAccumSample.xyz, mix( prevAccumSample.xyz, sampleColor.xyz, accumulationAlpha ) ) );
-				If( auxOn, () => {
+				If( auxOn.and( hasPreviousAux ), () => {
 
 					// Albedo averages cleanly (it's a colour).
-					finalAlbedo.assign( mix( texture( prevAlbedoTexture, prevUV, 0 ).xyz, finalAlbedo, accumulationAlpha ) );
+					finalAlbedo.assign( mix( texture( prevAlbedoTexture, prevUV, 0 ).xyz, finalAlbedo, auxAccumulationAlpha ) );
 
 					// NORMAL: by default keep this frame's POINT-SAMPLED normal — it varies with the bump,
 					// which fast/ASVGF want to preserve edge detail. But a CLEAN-AUX OIDN model (calb_cnrm/high,
@@ -129,7 +131,7 @@ export function buildFinalWriteKernel( params ) {
 
 						const prevN = texture( prevNormalDepthTexture, prevUV, 0 ).xyz.mul( 2.0 ).sub( 1.0 );
 						const curN = finalNormalDepth.xyz.mul( 2.0 ).sub( 1.0 ).toVar();
-						const mixedN = mix( prevN, curN, accumulationAlpha ).toVar();
+						const mixedN = mix( prevN, curN, auxAccumulationAlpha ).toVar();
 						const len = length( mixedN );
 						const avgN = select( len.greaterThan( 1e-4 ), mixedN.div( len ), curN );
 						finalNormalDepth.assign( vec4( avgN.mul( 0.5 ).add( 0.5 ), finalNormalDepth.w ) );

package/src/managers/DenoisingManager.js

@@ -50,6 +50,9 @@ export class DenoisingManager extends EventDispatcher {
 		this.denoiser = null;
 		this.upscaler = null;
 
+		this._onReset = null;
+		this._onPostProcessRefresh = null;
+
 		// Resolution tracking — used for canvas restoration on reset
 		this._lastRenderWidth = 0;
 		this._lastRenderHeight = 0;
@@ -547,6 +550,13 @@ export class DenoisingManager extends EventDispatcher {
 
 	}
 
+	/** @param {Function} fn - () => void, re-runs the completion chain on the accumulated image */
+	setPostProcessRefreshCallback( fn ) {
+
+		this._onPostProcessRefresh = fn;
+
+	}
+
 	/** @param {import('../RenderSettings.js').RenderSettings} settings */
 	setSettings( settings ) {
 
@@ -620,6 +630,7 @@ export class DenoisingManager extends EventDispatcher {
 		if ( this.denoiser ) this.denoiser.enabled = enabled;
 		// OIDN reads the PathTracer aux MRT; re-sync so the wavefront produces it while OIDN is on.
 		this._syncGBufferStages();
+		this._onPostProcessRefresh?.();
 
 	}
 
@@ -629,6 +640,7 @@ export class DenoisingManager extends EventDispatcher {
 		this.denoiser?.updateQuality( quality );
 		// Clean-aux normal follows the model: balanced/high (clean-aux models) → accumulate; fast → keep bump.
 		this._stages.pathTracer?.setCleanAuxNormal?.( !! this.denoiser?.enabled && quality !== 'fast' );
+		this._onPostProcessRefresh?.();
 
 	}
 

package/src/managers/UniformManager.js

@@ -196,6 +196,10 @@ export class UniformManager {
 		ub( 'cameraIsMoving', false );
 		ub( 'hasPreviousAccumulated', false );
 
+		// Aux MRT epoch, separate from the colour's so the denoiser can be enabled mid-render.
+		u( 'auxAccumulationAlpha', 1.0, 'float' );
+		ub( 'hasPreviousAux', false );
+
 		// Environment
 		u( 'environmentIntensity', DEFAULT_STATE.environmentIntensity, 'float' );
 		u( 'backgroundIntensity', DEFAULT_STATE.backgroundIntensity, 'float' );