rayzee 10.0.0 → 11.0.0

package/src/EngineEvents.js

@@ -8,6 +8,8 @@ export const EngineEvents = {
 	RENDER_COMPLETE: 'engine:renderComplete',
 	RENDER_RESET: 'engine:renderReset',
 	FRAME: 'engine:frame',
+	// The path tracer compiles its shaders in the background ({ compiling }); the canvas keeps its last frame meanwhile.
+	SHADERS_COMPILING: 'engine:shadersCompiling',
 
 	// Denoiser
 	DENOISING_START: 'engine:denoisingStart',

package/src/EngineIssues.js

@@ -32,7 +32,9 @@ export const ISSUE_CODES = Object.freeze( {
 	STORAGE_CACHE_MISMATCH: 'storage.cache_mismatch',
 	DENOISER_UNAVAILABLE: 'denoiser.unavailable',
 	OUTPUT_SOURCE_FALLBACK: 'output.source_fallback',
+	OUTPUT_TONEMAP_FALLBACK: 'output.tonemap_fallback',
 	LIGHT_PLACEHOLDER_SKIPPED: 'light.placeholder_skipped',
+	CAPABILITY_MISSING: 'capability.missing',
 } );
 
 /** Strict throws on ERROR only. */

package/src/Headless.js

@@ -1,6 +1,6 @@
 /**
  * The supported way to render without a person watching. Defaults are the batch renderer's —
- * strict, physical profile, deterministic — all reversible, none reversible by accident.
+ * strict, deterministic — all reversible, none reversible by accident.
  *
  * @example
  * const shot = await renderHeadless( { model: url, width: 1920, height: 1080, samples: 256 } );
@@ -20,11 +20,10 @@ import { PathTracerApp } from './PathTracerApp.js';
  * @param {number} [options.samples=64] - samples to accumulate
  * @param {'linear'|'srgb'} [options.colorSpace='srgb']
  * @param {boolean} [options.strict=true]
- * @param {string} [options.profile='physical'] - see RENDER_PROFILES
  * @param {boolean} [options.deterministic=true]
  * @param {boolean} [options.allowEarlyRetire=false] - needs `deterministic: false` to be reachable
  * @param {boolean} [options.denoise=false] - one final OIDN pass, read back instead of the raw accumulation
- * @param {Object} [options.settings] - applied after the model loads
+ * @param {Object} [options.settings] - applied before the model loads and again after it
  * @param {function(number): void} [options.onProgress] - running sample count
  * @returns {Promise<{data: Float32Array|Uint8ClampedArray, width: number, height: number,
  *   colorSpace: string, source: string, samples: number, retiredBy: string, issues: Object[], adapter: Object,
@@ -95,7 +94,6 @@ export async function openHeadless( {
 	width = 1920,
 	height = 1080,
 	strict = true,
-	profile = 'physical',
 	deterministic = true,
 	settings = null,
 	storage = false,
@@ -103,7 +101,7 @@ export async function openHeadless( {
 } = {} ) {
 
 	// Off unless asked for: cached state from an earlier run must not change what a batch renders.
-	const app = new PathTracerApp( canvas ?? null, { autoResize: false, strict, profile, storage, hostMemoryGB } );
+	const app = new PathTracerApp( canvas ?? null, { autoResize: false, strict, storage, hostMemoryGB } );
 
 	try {
 
@@ -114,7 +112,10 @@ export async function openHeadless( {
 		await app.init();
 		app.setCanvasSize( width, height );
 
+		// Before the load as well: some are read while a model loads (areaLightIntensityScale).
+		if ( settings ) app.settings.setMany( settings, { silent: true } );
 		if ( model ) await app.loadModel( model );
+		// Again after it, over anything the model's metadata set.
 		if ( settings ) app.settings.setMany( settings, { silent: true } );
 
 		// After the model: scene metadata can turn adaptive sampling back on.

package/src/Passes/AIUpscaler.js

@@ -1,15 +1,8 @@
 import { EventDispatcher, ACESFilmicToneMapping } from 'three';
-import { TONE_MAP_FNS, SRGB_GAMMA, applySaturation, effectiveExposure, isOutputEncoded } from '../Processor/ToneMapCPU.js';
+import { PackedToneMapper } from '../Processor/ToneMapGPU.js';
 import { getAssetConfig } from '../AssetConfig.js';
 import AIUpscalerWorker from '../Processor/Workers/AIUpscalerWorker.js?worker&inline';
 
-
-// An OCIO view already returned colour encoded for its display, so the gamma step below would
-// encode it twice. A built-in curve returns linear and does want it.
-const displayEncoder = toneMapping => isOutputEncoded( toneMapping )
-	? ( c => ( c > 1 ? 1 : c < 0 ? 0 : c ) )
-	: ( c => Math.pow( c, SRGB_GAMMA ) );
-
 // ─── Model Configuration ───────────────────────────────────────────────────────
 // Quality presets reference relative paths against asset-config `upscalerModelBaseUrl`.
 
@@ -140,13 +133,8 @@ export class AIUpscaler extends EventDispatcher {
 		this._baseWidth = output.width;
 		this._baseHeight = output.height;
 
-		// Pooled HDR readback staging buffer — reused across _captureSourceHDR calls.
-		// Rebuilt only when the source texture dimensions change (same spirit as
-		// r184's ReadbackBuffer; we can't use renderer.getArrayBufferAsync directly
-		// because our source is a raw GPUTexture, not a Three.js BufferAttribute).
-		this._hdrStagingBuffer = null;
-		this._hdrStagingWidth = 0;
-		this._hdrStagingHeight = 0;
+		// Tone-maps the HDR source on the card; its buffers are released after each capture.
+		this._toneMapper = null;
 
 	}
 
@@ -283,7 +271,7 @@ export class AIUpscaler extends EventDispatcher {
 		// so we must grab the pixels before awaiting model load.
 		if ( this.hdr && this.getGPUTextures ) {
 
-			// HDR path: read float32 from GPU texture, tonemap happens after upscale
+			// HDR path: float planes tone-mapped on the GPU, no 8-bit step before the network
 			this._capturedSource = await this._captureSourceHDR();
 
 		} else {
@@ -403,17 +391,6 @@ export class AIUpscaler extends EventDispatcher {
 		// The SR model outputs RGB only — alpha would be lost without this.
 		this._cacheUpscaledAlpha( sourceImageData, srcW * scale, srcH * scale );
 
-		// Cache HDR tonemapping state for tile extraction (avoids per-pixel lookups)
-		if ( sourceImageData.isHDR ) {
-
-			this._hdrToneMapFn = TONE_MAP_FNS.get( this.getToneMapping() ) || TONE_MAP_FNS.get( ACESFilmicToneMapping );
-			this._hdrEncode = displayEncoder( this.getToneMapping() );
-			this._hdrExposure = effectiveExposure( this.getExposure(), this.getToneMapping() );
-			this._hdrSaturation = this.getSaturation();
-			this._tmOut = new Float32Array( 3 );
-
-		}
-
 		// Tile-based inference
 		const overlap = MODEL_CONFIG.TILE_OVERLAP;
 		const tileSize = this.tileSize;
@@ -503,121 +480,72 @@ export class AIUpscaler extends EventDispatcher {
 	}
 
 	/**
-	 * HDR capture: reads float32 color data directly from the path tracer's GPU texture.
-	 * Returns an ImageData-like object with float32 RGBA data and dimensions.
+	 * HDR capture: tone-maps the path tracer's float colour on the card and reads back float
+	 * planes — r, g, b, a — so the network gets the curve without 8-bit quantization.
 	 */
 	async _captureSourceHDR() {
 
 		const gpuTextures = this.getGPUTextures();
 		if ( ! gpuTextures?.color ) throw new Error( 'No GPU color texture available for HDR capture' );
 
-		const device = this.renderer.backend.device;
 		const colorTexture = gpuTextures.color;
-		const width = colorTexture.width;
-		const height = colorTexture.height;
-
-		// GPU texture → pooled staging buffer → CPU readback.
-		// The staging buffer is kept alive between calls (unmap, don't destroy)
-		// and only re-created when texture dimensions change.
-		const bytesPerRow = Math.ceil( width * 16 / 256 ) * 256; // rgba32float=16 bytes, aligned to 256
-		const bufferSize = bytesPerRow * height;
-
-		if ( this._hdrStagingWidth !== width || this._hdrStagingHeight !== height ) {
-
-			this._hdrStagingBuffer?.destroy();
-			this._hdrStagingBuffer = device.createBuffer( {
-				label: 'aiupscaler-hdr-readback',
-				size: bufferSize,
-				usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
-			} );
-			this._hdrStagingWidth = width;
-			this._hdrStagingHeight = height;
-
-		}
-
-		const stagingBuffer = this._hdrStagingBuffer;
-
-		const encoder = device.createCommandEncoder();
-		encoder.copyTextureToBuffer(
-			{ texture: colorTexture },
-			{ buffer: stagingBuffer, bytesPerRow, rowsPerImage: height },
-			{ width, height, depthOrArrayLayers: 1 }
-		);
-		device.queue.submit( [ encoder.finish() ] );
-
-		await stagingBuffer.mapAsync( GPUMapMode.READ );
-		const mappedData = new Float32Array( stagingBuffer.getMappedRange() );
-
-		// Copy to ImageData-like structure (handle row alignment padding)
-		const pixelFloats = width * 4;
-		const rowFloats = bytesPerRow / 4;
-		const data = new Float32Array( width * height * 4 );
-
-		for ( let y = 0; y < height; y ++ ) {
-
-			const srcOffset = y * rowFloats;
-			const dstOffset = y * pixelFloats;
-			data.set( mappedData.subarray( srcOffset, srcOffset + pixelFloats ), dstOffset );
-
-		}
-
-		stagingBuffer.unmap();
+		const { width, height } = colorTexture;
+
+		this._toneMapper ??= new PackedToneMapper( this.renderer.backend.device, 'aiupscaler-tonemap', { input: 'texture', output: 'planar' } );
+		this._toneMapper.ensureSize( width, height );
+		const planes = await this._toneMapper.toPlanar( colorTexture, {
+			exposure: this.getExposure(),
+			toneMapping: this.getToneMapping() ?? ACESFilmicToneMapping,
+			saturation: this.getSaturation(),
+		} );
+		this._toneMapper.release();
 
-		// Mark as HDR so _extractTile and _tensorToImageData handle it correctly
-		return { data, width, height, isHDR: true };
+		return { planes, width, height, isHDR: true };
 
 	}
 
 	/**
 	 * Extracts a tile region from the source image.
 	 * Returns a Float32Array in NCHW format [1, 3, H, W] with values in [0, 1].
-	 * Handles both LDR (uint8 ImageData) and HDR (float32) sources.
+	 * Handles both LDR (uint8 ImageData) and HDR (tone-mapped float planes) sources.
 	 */
 	_extractTile( sourceImageData, x, y, w, h ) {
 
-		const { data, width } = sourceImageData;
-		const isHDR = sourceImageData.isHDR;
+		const { width } = sourceImageData;
 		const pixelCount = w * h;
 		const floats = new Float32Array( 3 * pixelCount );
 
-		for ( let row = 0; row < h; row ++ ) {
+		if ( sourceImageData.isHDR ) {
 
-			for ( let col = 0; col < w; col ++ ) {
+			const { planes } = sourceImageData;
+			const plane = width * sourceImageData.height;
+			for ( let c = 0; c < 3; c ++ ) {
 
-				const srcIdx = ( ( y + row ) * width + ( x + col ) ) * 4;
-				const dstIdx = row * w + col;
+				for ( let row = 0; row < h; row ++ ) {
 
-				if ( isHDR ) {
+					const from = c * plane + ( y + row ) * width + x;
+					floats.set( planes.subarray( from, from + w ), c * pixelCount + row * w );
 
-					// HDR: exposure + saturation + tonemap + gamma to sRGB [0,1] at float32 precision.
-					// The SR model expects sRGB-range input — we tonemap before the model
-					// but keep float32 precision (no uint8 quantization bottleneck).
-					const tmFn = this._hdrToneMapFn;
-					const exposure = this._hdrExposure;
-					const saturation = this._hdrSaturation;
-					let er = data[ srcIdx ] * exposure, eg = data[ srcIdx + 1 ] * exposure, eb = data[ srcIdx + 2 ] * exposure;
-					if ( saturation !== 1.0 ) {
+				}
 
-						this._tmOut[ 0 ] = er; this._tmOut[ 1 ] = eg; this._tmOut[ 2 ] = eb;
-						applySaturation( this._tmOut, saturation );
-						er = this._tmOut[ 0 ]; eg = this._tmOut[ 1 ]; eb = this._tmOut[ 2 ];
+			}
 
-					}
+			return floats;
+
+		}
 
-					tmFn( er, eg, eb, 1.0, this._tmOut );
-					const encode = this._hdrEncode;
-					floats[ dstIdx ] = encode( this._tmOut[ 0 ] );
-					floats[ pixelCount + dstIdx ] = encode( this._tmOut[ 1 ] );
-					floats[ 2 * pixelCount + dstIdx ] = encode( this._tmOut[ 2 ] );
+		const { data } = sourceImageData;
+		for ( let row = 0; row < h; row ++ ) {
 
-				} else {
+			for ( let col = 0; col < w; col ++ ) {
 
-					// LDR: normalize uint8 [0,255] to [0,1]
-					floats[ dstIdx ] = data[ srcIdx ] / 255;
-					floats[ pixelCount + dstIdx ] = data[ srcIdx + 1 ] / 255;
-					floats[ 2 * pixelCount + dstIdx ] = data[ srcIdx + 2 ] / 255;
+				const srcIdx = ( ( y + row ) * width + ( x + col ) ) * 4;
+				const dstIdx = row * w + col;
 
-				}
+				// LDR: normalize uint8 [0,255] to [0,1]
+				floats[ dstIdx ] = data[ srcIdx ] / 255;
+				floats[ pixelCount + dstIdx ] = data[ srcIdx + 1 ] / 255;
+				floats[ 2 * pixelCount + dstIdx ] = data[ srcIdx + 2 ] / 255;
 
 			}
 
@@ -715,14 +643,19 @@ export class AIUpscaler extends EventDispatcher {
 	 */
 	_cacheUpscaledAlpha( sourceImageData, outW, outH ) {
 
-		const { data, width, height } = sourceImageData;
+		const { width, height } = sourceImageData;
+		const count = width * height;
 
+		// HDR alpha is the fourth plane, LDR every fourth byte.
 		const isHDR = sourceImageData.isHDR;
+		const data = isHDR ? sourceImageData.planes.subarray( 3 * count ) : sourceImageData.data;
+		const stride = isHDR ? 1 : 4;
+		const offset = isHDR ? 0 : 3;
 		const opaqueVal = isHDR ? 1.0 : 255;
 
 		// Check if source has any non-opaque pixels
 		let hasAlpha = false;
-		for ( let i = 3; i < data.length; i += 4 ) {
+		for ( let i = offset; i < data.length; i += stride ) {
 
 			if ( data[ i ] < opaqueVal ) {
 
@@ -748,10 +681,10 @@ export class AIUpscaler extends EventDispatcher {
 		const srcCtx = srcCanvas.getContext( '2d' );
 		const alphaImage = srcCtx.createImageData( width, height );
 
-		for ( let i = 0, len = width * height; i < len; i ++ ) {
+		for ( let i = 0; i < count; i ++ ) {
 
 			const a = isHDR
-				? Math.min( Math.max( data[ i * 4 + 3 ] * 255, 0 ), 255 ) | 0
+				? Math.min( Math.max( data[ i ] * 255, 0 ), 255 ) | 0
 				: data[ i * 4 + 3 ];
 			alphaImage.data[ i * 4 ] = a;
 			alphaImage.data[ i * 4 + 1 ] = a;
@@ -797,32 +730,18 @@ export class AIUpscaler extends EventDispatcher {
 
 		if ( sourceImageData.isHDR ) {
 
-			// HDR source: tonemap to LDR for the backup canvas display
-			const { data, width, height } = sourceImageData;
+			// Already tone-mapped and encoded on the card; only quantized here.
+			const { planes, width, height } = sourceImageData;
+			const count = width * height;
 			const imageData = ctx.createImageData( width, height );
 			const pixels = imageData.data;
-			const tmFn = TONE_MAP_FNS.get( this.getToneMapping() ) || TONE_MAP_FNS.get( ACESFilmicToneMapping );
-			const exposure = effectiveExposure( this.getExposure(), this.getToneMapping() );
-			const encode = displayEncoder( this.getToneMapping() );
-			const saturation = this.getSaturation();
-			const out = new Float32Array( 3 );
 
-			for ( let i = 0, len = width * height; i < len; i ++ ) {
+			for ( let i = 0; i < count; i ++ ) {
 
 				const si = i * 4;
-				let er = data[ si ] * exposure, eg = data[ si + 1 ] * exposure, eb = data[ si + 2 ] * exposure;
-				if ( saturation !== 1.0 ) {
-
-					out[ 0 ] = er; out[ 1 ] = eg; out[ 2 ] = eb;
-					applySaturation( out, saturation );
-					er = out[ 0 ]; eg = out[ 1 ]; eb = out[ 2 ];
-
-				}
-
-				tmFn( er, eg, eb, 1.0, out );
-				pixels[ si ] = ( encode( out[ 0 ] ) * 255 + 0.5 ) | 0;
-				pixels[ si + 1 ] = ( encode( out[ 1 ] ) * 255 + 0.5 ) | 0;
-				pixels[ si + 2 ] = ( encode( out[ 2 ] ) * 255 + 0.5 ) | 0;
+				pixels[ si ] = ( planes[ i ] * 255 + 0.5 ) | 0;
+				pixels[ si + 1 ] = ( planes[ count + i ] * 255 + 0.5 ) | 0;
+				pixels[ si + 2 ] = ( planes[ 2 * count + i ] * 255 + 0.5 ) | 0;
 				pixels[ si + 3 ] = 255;
 
 			}
@@ -927,10 +846,8 @@ export class AIUpscaler extends EventDispatcher {
 		this._upscaledAlpha = null;
 		this.state.abortController = null;
 
-		this._hdrStagingBuffer?.destroy();
-		this._hdrStagingBuffer = null;
-		this._hdrStagingWidth = 0;
-		this._hdrStagingHeight = 0;
+		this._toneMapper?.dispose();
+		this._toneMapper = null;
 
 		console.log( 'AIUpscaler disposed' );
 

package/src/Passes/OIDNDenoiser.js

@@ -182,6 +182,20 @@ fn main( @builtin(global_invocation_id) gid: vec3<u32> ) {
 }
 `;
 
+const PACK_WG_SIZE = 8;
+const PACK_WGSL = /* wgsl */`
+@group(0) @binding(0) var src: texture_2d<f32>;
+@group(0) @binding(1) var<storage, read_write> dst: array<vec4<f32>>;
+@group(0) @binding(2) var<uniform> size: vec2<u32>;
+
+@compute @workgroup_size(${PACK_WG_SIZE}, ${PACK_WG_SIZE})
+fn main( @builtin(global_invocation_id) gid: vec3<u32> ) {
+
+	if ( gid.x >= size.x || gid.y >= size.y ) { return; }
+	dst[ gid.y * size.x + gid.x ] = textureLoad( src, gid.xy, 0 );
+}
+`;
+
 export class OIDNDenoiser extends EventDispatcher {
 
 	/**
@@ -210,11 +224,10 @@ export class OIDNDenoiser extends EventDispatcher {
 		// Cached GPU storage buffers for texture→buffer copies (reused across denoise calls)
 		this._gpuInputBuffers = { color: null, albedo: null, normal: null };
 		this._gpuInputBufferSize = { width: 0, height: 0 };
-		// Shared pad-strip buffer for non-256-aligned widths. Reused across
-		// color/albedo/normal copies within the same encoder (WebGPU command
-		// order guarantees the overwrites are serialized).
-		this._gpuInputPadBuffer = null;
-		this._gpuInputPaddedRowBytes = 0;
+		// Packs widths copyTextureToBuffer cannot take; see _beginPack.
+		this._packPipeline = null;
+		this._packLayout = null;
+		this._packParams = null;
 		// The autoexposure scale never leaves the GPU — _applyColorScale and the output pack
 		// both read _inputScaleBuffer directly.
 		this._lumReducePipeline = null;
@@ -671,42 +684,62 @@ export class OIDNDenoiser extends EventDispatcher {
 		// Ensure storage buffers are sized correctly (recreate on resolution change)
 		this._ensureGPUInputBuffers( width, height );
 
-		// Copy render target textures → tightly packed GPU storage buffers for oidn-web.
-		// copyTextureToBuffer requires bytesPerRow to be a multiple of 256. When the tight
-		// row size (width * 16) isn't aligned, copy via a shared pre-allocated padded buffer
-		// (see _ensureGPUInputBuffers) then strip padding row-by-row. The pad buffer is
-		// reused across color/albedo/normal — safe because WebGPU serializes commands
-		// within a single encoder.
+		this._copyInputs( device, textures, width, height );
+
+		// Autoexposure and the pre-multiply it drives, both on the GPU and both queued behind the
+		// copies above. Nothing is awaited here — an await would drain the queue before the UNet.
+		this._computeInputScale( device, width * height );
+		this._applyColorScale( device, width * height );
+
+		// A final denoise is shown tile by tile, so the tiles still to come must show this render
+		// rather than the blank or previous-view picture the output holds between runs.
+		if ( ! continuous && ! this._hasOutput ) {
+
+			this._unpackToTexture( this._gpuInputBuffers.color, width, { x: 0, y: 0, width, height }, false );
+
+		}
+
+		// Pass GPU storage buffers to oidn-web (GPUBuffer path, well-tested)
+		const config = {
+			color: { data: this._gpuInputBuffers.color, width, height },
+			albedo: { data: this._gpuInputBuffers.albedo, width, height },
+			normal: { data: this._gpuInputBuffers.normal, width, height }
+		};
+
+		return this._executeWithAbortGPU( config, continuous );
+
+	}
+
+	/** Copies the render's colour, albedo and normal into the tightly packed buffers oidn-web reads. @private */
+	_copyInputs( device, textures, width, height ) {
+
+		// copyTextureToBuffer takes only 256-byte-aligned rows; any other width packs on the GPU.
 		const encoder = device.createCommandEncoder( { label: 'oidn-tex-to-buf' } );
 		const tightRowBytes = width * 16; // rgba32float
-		const paddedRowBytes = this._gpuInputPaddedRowBytes;
-		const needsPadStrip = paddedRowBytes > tightRowBytes;
-		const padBuf = this._gpuInputPadBuffer;
+		const pass = tightRowBytes % 256 === 0 ? null : this._beginPack( device, encoder, width, height );
 
 		const copyTex = ( tex, tightBuf ) => {
 
-			if ( ! needsPadStrip ) {
+			if ( pass ) {
 
-				encoder.copyTextureToBuffer(
-					{ texture: tex, mipLevel: 0 },
-					{ buffer: tightBuf, offset: 0, bytesPerRow: tightRowBytes, rowsPerImage: height },
-					{ width, height, depthOrArrayLayers: 1 }
-				);
+				pass.setBindGroup( 0, device.createBindGroup( {
+					layout: this._packLayout,
+					entries: [
+						{ binding: 0, resource: tex.createView() },
+						{ binding: 1, resource: { buffer: tightBuf } },
+						{ binding: 2, resource: { buffer: this._packParams } },
+					],
+				} ) );
+				pass.dispatchWorkgroups( Math.ceil( width / PACK_WG_SIZE ), Math.ceil( height / PACK_WG_SIZE ) );
 
 			} else {
 
 				encoder.copyTextureToBuffer(
 					{ texture: tex, mipLevel: 0 },
-					{ buffer: padBuf, offset: 0, bytesPerRow: paddedRowBytes, rowsPerImage: height },
+					{ buffer: tightBuf, offset: 0, bytesPerRow: tightRowBytes, rowsPerImage: height },
 					{ width, height, depthOrArrayLayers: 1 }
 				);
 
-				for ( let row = 0; row < height; row ++ ) {
-
-					encoder.copyBufferToBuffer( padBuf, row * paddedRowBytes, tightBuf, row * tightRowBytes, tightRowBytes );
-
-				}
-
 			}
 
 		};
@@ -719,30 +752,9 @@ export class OIDNDenoiser extends EventDispatcher {
 		// measured 0.878 -> 2.439 denoise ratio at 64 spp. Do not "fix" it.
 		copyTex( textures.normal, this._gpuInputBuffers.normal );
 
+		pass?.end();
 		device.queue.submit( [ encoder.finish() ] );
 
-		// Autoexposure and the pre-multiply it drives, both on the GPU and both queued behind the
-		// copies above. Nothing is awaited here — an await would drain the queue before the UNet.
-		this._computeInputScale( device, width * height );
-		this._applyColorScale( device, width * height );
-
-		// A final denoise is shown tile by tile, so the tiles still to come must show this render
-		// rather than the blank or previous-view picture the output holds between runs.
-		if ( ! continuous && ! this._hasOutput ) {
-
-			this._unpackToTexture( this._gpuInputBuffers.color, width, { x: 0, y: 0, width, height }, false );
-
-		}
-
-		// Pass GPU storage buffers to oidn-web (GPUBuffer path, well-tested)
-		const config = {
-			color: { data: this._gpuInputBuffers.color, width, height },
-			albedo: { data: this._gpuInputBuffers.albedo, width, height },
-			normal: { data: this._gpuInputBuffers.normal, width, height }
-		};
-
-		return this._executeWithAbortGPU( config, continuous );
-
 	}
 
 	/**
@@ -767,25 +779,41 @@ export class OIDNDenoiser extends EventDispatcher {
 		this._gpuInputBuffers.normal = device.createBuffer( { label: 'oidn-in-normal', size: byteSize, usage } );
 		this._gpuInputBufferSize = { width, height };
 
-		// Pre-allocate the row-pad staging buffer when width * 16 isn't 256-aligned.
-		// Shared across the three texture copies; recreated only on resolution change.
-		const tightRowBytes = width * 16;
-		const paddedRowBytes = Math.ceil( tightRowBytes / 256 ) * 256;
-		if ( paddedRowBytes !== tightRowBytes ) {
+	}
+
+	/** Opens the compute pass that packs unaligned rows; one dispatch per texture follows. @private */
+	_beginPack( device, encoder, width, height ) {
+
+		if ( ! this._packPipeline ) {
 
-			this._gpuInputPadBuffer = device.createBuffer( {
-				label: 'oidn-in-pad',
-				size: paddedRowBytes * height,
-				usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC
+			// Explicit: rgba32float is unfilterable, which an auto layout would not declare.
+			this._packLayout = device.createBindGroupLayout( {
+				label: 'oidn-pack',
+				entries: [
+					{ binding: 0, visibility: GPUShaderStage.COMPUTE, texture: { sampleType: 'unfilterable-float' } },
+					{ binding: 1, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage' } },
+					{ binding: 2, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'uniform' } },
+				],
 			} );
-			this._gpuInputPaddedRowBytes = paddedRowBytes;
+			this._packPipeline = device.createComputePipeline( {
+				label: 'oidn-pack',
+				layout: device.createPipelineLayout( { bindGroupLayouts: [ this._packLayout ] } ),
+				compute: { module: device.createShaderModule( { label: 'oidn-pack', code: PACK_WGSL } ), entryPoint: 'main' },
+			} );
+
+		}
 
-		} else {
+		if ( ! this._packParams ) {
 
-			this._gpuInputPaddedRowBytes = tightRowBytes;
+			this._packParams = device.createBuffer( { label: 'oidn-pack-size', size: 8, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST } );
+			device.queue.writeBuffer( this._packParams, 0, new Uint32Array( [ width, height ] ) );
 
 		}
 
+		const pass = encoder.beginComputePass( { label: 'oidn-pack' } );
+		pass.setPipeline( this._packPipeline );
+		return pass;
+
 	}
 
 	_destroyGPUInputBuffers() {
@@ -793,7 +821,7 @@ export class OIDNDenoiser extends EventDispatcher {
 		this._gpuInputBuffers.color?.destroy();
 		this._gpuInputBuffers.albedo?.destroy();
 		this._gpuInputBuffers.normal?.destroy();
-		this._gpuInputPadBuffer?.destroy();
+		this._packParams?.destroy();
 
 		// Bind groups hold the destroyed buffers; pipelines are device-scoped and survive.
 		this._colorScaleBindGroup = null;
@@ -805,8 +833,7 @@ export class OIDNDenoiser extends EventDispatcher {
 		this._inputScaleBuffer?.destroy();
 		this._inputScaleBuffer = null;
 		this._gpuInputBuffers = { color: null, albedo: null, normal: null };
-		this._gpuInputPadBuffer = null;
-		this._gpuInputPaddedRowBytes = 0;
+		this._packParams = null;
 		this._gpuInputBufferSize = { width: 0, height: 0 };
 
 	}
@@ -994,7 +1021,7 @@ export class OIDNDenoiser extends EventDispatcher {
 
 		const { color, albedo, normal } = this._gpuInputBuffers;
 		const out = this._outGPUTexture ? this._outTexSize.width * this._outTexSize.height * 8 : 0; // rgba16float
-		return ( color?.size ?? 0 ) + ( albedo?.size ?? 0 ) + ( normal?.size ?? 0 ) + ( this._gpuInputPadBuffer?.size ?? 0 ) + out;
+		return ( color?.size ?? 0 ) + ( albedo?.size ?? 0 ) + ( normal?.size ?? 0 ) + out;
 
 	}
 

package/src/Passes/OIDNTemporalHistory.js

@@ -1,4 +1,4 @@
-import { GBUFFER_MISS_THRESHOLD } from '../EngineDefaults.js';
+import { GBUFFER_MISS_THRESHOLD } from '../Stages/DenoiserSettings.js';
 
 /**
  * History of the frames the path tracer restarted while the view moved, reprojected into the