three-gpu-pathtracer 0.0.26 → 0.0.28

package/src/webgpu/compute/wavefront/ResetSlotsKernel.js

@@ -2,7 +2,7 @@ import { StorageBufferAttribute } from 'three/webgpu';
 import { uniform, storage, globalId } from 'three/tsl';
 import { ComputeKernel } from '../ComputeKernel.js';
 import { wgslTagFn } from 'three-mesh-bvh/webgpu';
-import { rayDataStruct, pixelQueueStruct } from './structs.js';
+import { rayDataStruct, PIXEL_QUEUE_ELEMENT_COUNT, PIXEL_QUEUE_HEADER } from './structs.js';
 
 // Moves pixels between a range of path slots and the queue when the pool is resized. Slots added
 // by a grow take a pixel from the queue tail and start idle, as MaterialKernel expects. Slots
@@ -14,7 +14,7 @@ export class ResetSlotsKernel extends ComputeKernel {
 
 		const params = {
 			rayDataStorage: storage( new StorageBufferAttribute( 1, 1 ), rayDataStruct ),
-			pixelQueue: storage( new StorageBufferAttribute( 1, 1 ), pixelQueueStruct ),
+			pixelQueue: storage( new StorageBufferAttribute( 1, 1 ), 'uint' ).toAtomic(),
 			start: uniform( 0, 'uint' ),
 			end: uniform( 0, 'uint' ),
 			addingSlots: uniform( 0, 'uint' ),
@@ -37,14 +37,14 @@ export class ResetSlotsKernel extends ComputeKernel {
 				if ( addingSlots == 0u ) {
 
 					// slots being removed hand their pixel back before the pool is discarded
-					let queueIndex = atomicAdd( &pixelQueue.elementCount, 1u );
-					atomicStore( &pixelQueue.elements[ queueIndex ], rayDataStorage[ index ].pixelIndex );
+					let queueIndex = atomicAdd( &pixelQueue[ ${ PIXEL_QUEUE_ELEMENT_COUNT }u ], 1u );
+					atomicStore( &pixelQueue[ ${ PIXEL_QUEUE_HEADER }u + queueIndex ], rayDataStorage[ index ].pixelIndex );
 
 				} else {
 
 					// the pool never exceeds the pixel count, so the queue holds enough for every new slot
-					let previousCount = atomicSub( &pixelQueue.elementCount, 1u );
-					rayDataStorage[ index ].pixelIndex = atomicLoad( &pixelQueue.elements[ previousCount - 1u ] );
+					let previousCount = atomicSub( &pixelQueue[ ${ PIXEL_QUEUE_ELEMENT_COUNT }u ], 1u );
+					rayDataStorage[ index ].pixelIndex = atomicLoad( &pixelQueue[ ${ PIXEL_QUEUE_HEADER }u + previousCount - 1u ] );
 					rayDataStorage[ index ].resultColor = vec4f( 0.0 );
 					rayDataStorage[ index ].throughputColor = vec3f( 0.0 );
 					rayDataStorage[ index ].objectIndex = - 1;

package/src/webgpu/compute/wavefront/TraceRayKernel.js

@@ -1,9 +1,9 @@
 import { StorageBufferAttribute } from 'three/webgpu';
 import { ComputeKernel } from '../ComputeKernel.js';
 import { storage, globalId } from 'three/tsl';
-import { proxy, wgslTagFn } from 'three-mesh-bvh/webgpu';
+import { contextProxy, wgslTagFn } from 'three-mesh-bvh/webgpu';
 import { rngInit } from '../../nodes/random.wgsl.js';
-import { rayQueueStruct, intersectionResultStruct } from './structs.js';
+import { traceQueuedRayStruct, intersectionResultStruct, RAY_QUEUE_LENGTH } from './structs.js';
 
 // Pure BVH traversal over the queued bounce rays: one thread per queued ray, writing a compact
 // intersection result at the ray's queue index for LogicKernel to consume next frame.
@@ -12,34 +12,36 @@ export class TraceRayKernel extends ComputeKernel {
 	constructor( ) {
 
 		const params = {
-			bvhData: { value: null },
 
-			rayQueue: storage( new StorageBufferAttribute( 1, 1 ), rayQueueStruct ),
+			rayQueue: storage( new StorageBufferAttribute( 1, 1 ), traceQueuedRayStruct ),
+			queueCounters: storage( new StorageBufferAttribute( 1, 1 ), 'uint' ),
 			rayIntersectionsStorage: storage( new StorageBufferAttribute( 1, 1 ), intersectionResultStruct ),
 
 			globalId: globalId,
 		};
 
-		const raycastOutput = proxy( 'bvhData.value.fns.raycastFirstHit.outputType', params );
-		const raycastFirstHitFn = proxy( 'bvhData.value.fns.raycastFirstHit', params );
+		const raycastOutput = contextProxy( 'bvhData.fns.raycastFirstHit.outputType' );
+		const raycastFirstHitFn = contextProxy( 'bvhData.fns.raycastFirstHit' );
 
 		const fn = wgslTagFn /* wgsl */`
 
 			fn compute( globalId: vec3u ) -> void {
 
 				let rayQueue = &${ params.rayQueue };
+				let queueCounters = &${ params.queueCounters };
 				let rayIntersectionsStorage = &${ params.rayIntersectionsStorage };
 
 				let index = globalId.x;
-				if ( index >= rayQueue.length ) {
+				if ( index >= queueCounters[ ${ RAY_QUEUE_LENGTH }u ] ) {
 
 					return;
 
 				}
 
-				let queuedRay = ( *rayQueue ).elements[ index ];
+				// whole structs are read from the buffer, not the pointer alias, which Safari fails to compile
+				let queuedRay = ${ params.rayQueue }[ index ];
 				let indexUV = vec2u( queuedRay.pixelIndex >> 16, queuedRay.pixelIndex & 0xFFFF );
-				${ rngInit }( indexUV, queuedRay.seed, queuedRay.currentBounce + queuedRay.alphaDepth );
+				${ rngInit }( indexUV, queuedRay.seed, queuedRay.rngIndex );
 
 				let ray = Ray( queuedRay.origin, queuedRay.direction, queuedRay.maxDist );
 				var hitResult: ${ raycastOutput };

package/src/webgpu/compute/wavefront/TraceShadowRayKernel.js

@@ -1,59 +1,54 @@
 import { StorageBufferAttribute } from 'three/webgpu';
 import { ComputeKernel } from '../ComputeKernel.js';
 import { storage, globalId } from 'three/tsl';
-import { proxy, wgslTagFn } from 'three-mesh-bvh/webgpu';
+import { contextProxy, wgslTagFn } from 'three-mesh-bvh/webgpu';
 import { rngInit } from '../../nodes/random.wgsl.js';
-import { rayQueueStruct, intersectionResultStruct } from './structs.js';
+import { traceQueuedRayStruct, shadowTraceResultStruct, SHADOW_RAY_QUEUE_LENGTH } from './structs.js';
 
-// Pure BVH traversal over the queued shadow rays. Uses the same first-hit traversal as the bounce
-// rays ( no dedicated any-hit traversal exists yet ); LogicKernel decides occlusion by comparing the
-// hit distance against the light distance.
+// Pure BVH traversal over the queued shadow rays. Uses an any-hit traversal without face culling that
+// passes partially transparent surfaces, accumulating the light they block.
 export class TraceShadowRayKernel extends ComputeKernel {
 
 	constructor( ) {
 
 		const params = {
-			bvhData: { value: null },
 
-			shadowRayQueue: storage( new StorageBufferAttribute( 1, 1 ), rayQueueStruct ),
-			shadowRayIntersectionsStorage: storage( new StorageBufferAttribute( 1, 1 ), intersectionResultStruct ),
+			shadowRayQueue: storage( new StorageBufferAttribute( 1, 1 ), traceQueuedRayStruct ),
+			queueCounters: storage( new StorageBufferAttribute( 1, 1 ), 'uint' ),
+			shadowRayIntersectionsStorage: storage( new StorageBufferAttribute( 1, 1 ), shadowTraceResultStruct ),
 
 			globalId: globalId,
 		};
 
-		const raycastOutput = proxy( 'bvhData.value.fns.raycastFirstHit.outputType', params );
-		const raycastFirstHitFn = proxy( 'bvhData.value.fns.raycastFirstHit', params );
+		const raycastOutput = contextProxy( 'bvhData.fns.raycastFirstHit.outputType' );
+		const raycastShadowFn = contextProxy( 'bvhData.fns.raycastShadow' );
 
 		const fn = wgslTagFn /* wgsl */`
 
 			fn compute( globalId: vec3u ) -> void {
 
 				let shadowRayQueue = &${ params.shadowRayQueue };
+				let queueCounters = &${ params.queueCounters };
 				let shadowRayIntersectionsStorage = &${ params.shadowRayIntersectionsStorage };
 
 				let index = globalId.x;
-				if ( index >= shadowRayQueue.length ) {
+				if ( index >= queueCounters[ ${ SHADOW_RAY_QUEUE_LENGTH }u ] ) {
 
 					return;
 
 				}
 
-				let queuedRay = ( *shadowRayQueue ).elements[ index ];
+				// whole structs are read from the buffer, not the pointer alias, which Safari fails to compile
+				let queuedRay = ${ params.shadowRayQueue }[ index ];
 				let indexUV = vec2u( queuedRay.pixelIndex >> 16, queuedRay.pixelIndex & 0xFFFF );
-				${ rngInit }( indexUV, queuedRay.seed, queuedRay.currentBounce + queuedRay.alphaDepth );
+				${ rngInit }( indexUV, queuedRay.seed, queuedRay.rngIndex );
 
 				let ray = Ray( queuedRay.origin, queuedRay.direction, queuedRay.maxDist );
 				var hitResult: ${ raycastOutput };
-				if ( ${ raycastFirstHitFn }( ray, &hitResult ) ) {
-
-					shadowRayIntersectionsStorage[ index ].objectIndex = i32( hitResult.objectIndex );
-					shadowRayIntersectionsStorage[ index ].dist = hitResult.dist;
-
-				} else {
-
-					shadowRayIntersectionsStorage[ index ].objectIndex = - 1;
-
-				}
+				let occluded = ${ raycastShadowFn }( ray, &hitResult );
+				shadowRayIntersectionsStorage[ index ].objectIndex = select( - 1, i32( hitResult.objectIndex ), occluded );
+				shadowRayIntersectionsStorage[ index ].skippedOcclusion = hitResult.skippedOcclusion;
+				shadowRayIntersectionsStorage[ index ].occlusion = hitResult.occlusion;
 
 			}
 		`;

package/src/webgpu/compute/wavefront/structs.js

@@ -1,4 +1,5 @@
 import { StructTypeNode } from 'three/webgpu';
+import { mediumStateStruct } from '../../nodes/medium.wgsl.js';
 
 // StructTypeNode that force-emits dependency structs. TSL can't discover a struct referenced only via
 // a type string, so we build each dependency first, which registers its definition ahead of this struct.
@@ -28,7 +29,7 @@ class DependentStructTypeNode extends StructTypeNode {
 
 // Persistent per-path-slot state. One slot per in-flight path, holding everything needed to resolve
 // the previous frame's trace results and stage the next bounce.
-export const rayDataStruct = new StructTypeNode( {
+const rayDataMembers = {
 
 	throughputColor: 'vec3f',
 	currentBounce: 'uint',
@@ -76,8 +77,10 @@ export const rayDataStruct = new StructTypeNode( {
 	// the traced segment length, for the transmission attenuation applied by MaterialKernel
 	dist: 'float',
 
-	// alpha test pass throughs, counted separately from the bounce count
+	// alpha test pass throughs, counted separately from the bounce count, and how far along the ray they
+	// moved the start of its traversal. The ray keeps the origin it scattered from
 	alphaDepth: 'uint',
+	rayStart: 'float',
 
 	// the camera segment's maximum trace distance, carried across alpha pass throughs
 	maxDist: 'float',
@@ -86,7 +89,30 @@ export const rayDataStruct = new StructTypeNode( {
 	// first dispersive interaction
 	dispersionWavelength: 'float',
 
-}, 'RayData' );
+	// the first scatter's albedo and normal, 8 bits per channel, for the denoiser's auxiliary buffers
+	auxAlbedo: 'uint',
+	auxNormal: 'uint',
+
+	// scatter events taken inside media, counted separately from the bounce count
+	subsurfaceBounces: 'uint',
+
+	// whether MediumKernel walks the path's next segment, cleared once the walk reaches a surface or ends
+	walkPending: 'uint',
+
+	// whether the staged segment starts at a medium scatter event, where no light is sampled
+	mediumScattered: 'uint',
+
+};
+
+// The path's medium, nested at the end to share the ray data buffer under the storage buffer limit. Sized
+// separately since nested structs aren't.
+export const rayDataStruct = new DependentStructTypeNode( {
+	...rayDataMembers,
+	medium: mediumStateStruct.name,
+}, 'RayData', [ mediumStateStruct ] );
+
+const rayDataLength = new StructTypeNode( rayDataMembers ).getLength();
+rayDataStruct.getLength = () => rayDataLength + mediumStateStruct.getLength();
 
 // A ray queued for BVH traversal by the trace kernels. A "maxDist" of zero traces unbounded.
 export const traceQueuedRayStruct = new StructTypeNode( {
@@ -95,12 +121,14 @@ export const traceQueuedRayStruct = new StructTypeNode( {
 	pixelIndex: 'uint',
 
 	direction: 'vec3f',
-	currentBounce: 'uint',
+
+	// the traversal's random sequence index: bounces, alpha pass throughs and subsurface bounces, as in the megakernel
+	rngIndex: 'uint',
 
 	seed: 'uint',
-	alphaDepth: 'uint',
 	maxDist: 'float',
 	_alignment0: 'uint',
+	_alignment1: 'uint',
 
 }, 'TraceQueuedRay' );
 
@@ -118,38 +146,38 @@ export const intersectionResultStruct = new StructTypeNode( {
 	side: 'float',
 
 	indices: 'vec3u',
-	_alignment0: 'uint',
 
 }, 'TraceResult' );
 
-// Queue wrappers that keep an append-only length counter in a header ahead of the elements. The
-// atomic variant is bound where rays are pushed with atomicAdd; the plain one where the length is
-// only read or reset. getLength returns just the header since the trailing array is runtime-sized.
-export const rayQueueStruct = new DependentStructTypeNode( {
-	length: 'uint',
-	elements: `array<${ traceQueuedRayStruct.name }>`,
-}, 'RayQueue', [ traceQueuedRayStruct ] );
-rayQueueStruct.getLength = () => 4;
-
-export const rayQueueAtomicStruct = new DependentStructTypeNode( {
-	length: { type: 'uint', atomic: true },
-	elements: `array<${ traceQueuedRayStruct.name }>`,
-}, 'RayQueue', [ traceQueuedRayStruct ] );
-rayQueueAtomicStruct.getLength = () => 4;
+// Shadow ray trace result, written by TraceShadowRayKernel at the ray's queue index and consumed by
+// LogicKernel the following frame. objectIndex >= 0 encodes an occluded light.
+export const shadowTraceResultStruct = new StructTypeNode( {
+
+	objectIndex: 'int',
+
+	// the share of bsdf rays the skipped faces would stop, whose light weight moves to the light sample
+	skippedOcclusion: 'float',
+
+	// the fraction of light blocked by the partially transparent surfaces passed
+	occlusion: 'float',
+
+}, 'ShadowTraceResult' );
+
+// The ray and shadow ray queues are plain arrays of queued rays, with their append-only lengths in a
+// separate counters buffer: storage buffers are always bound as arrays, which can't hold a struct
+// ending in a runtime-sized array.
+export const RAY_QUEUE_LENGTH = 0;
+export const SHADOW_RAY_QUEUE_LENGTH = 1;
+export const QUEUE_COUNTER_COUNT = 2;
+
+// The path slots walking through a medium this pass, for MediumKernel. Its length leads the same u32
+// array, ahead of the elements, as MediumKernel is at its storage buffer limit.
+export const MEDIUM_QUEUE_LENGTH = 0;
+export const MEDIUM_QUEUE_HEADER = 1;
 
 // Round-robin queue of pixel indices waiting for a free path slot when the output resolution exceeds
-// the ray data pool. Sized to the pixel count so retiring slots can always return their pixel. The
-// non-atomic variant is used for contention-free initialization.
-export const pixelQueueStruct = new DependentStructTypeNode( {
-	current: { type: 'uint', atomic: true },
-	elementCount: { type: 'uint', atomic: true },
-	elements: 'array<atomic<u32>>',
-}, 'PixelQueue' );
-pixelQueueStruct.getLength = () => 2;
-
-export const pixelQueueNonAtomicStruct = new DependentStructTypeNode( {
-	current: 'uint',
-	elementCount: 'uint',
-	elements: 'array<u32>',
-}, 'PixelQueue' );
-pixelQueueNonAtomicStruct.getLength = () => 2;
+// the ray data pool, sized to the pixel count so retiring slots can always return their pixel. Its
+// counters lead the same u32 array, ahead of the elements.
+export const PIXEL_QUEUE_CURRENT = 0;
+export const PIXEL_QUEUE_ELEMENT_COUNT = 1;
+export const PIXEL_QUEUE_HEADER = 2;

package/src/webgpu/constants.js

@@ -13,7 +13,7 @@ import * as bluedither from './nodes/rand/bluedither.wgsl.js';
 export const RANDOM_PCG = pcg;
 
 /**
- * Sobol low discrepancy samples, scrambled per pixel. Converges faster than `RANDOM_PCG`.
+ * Sobol low discrepancy samples, scrambled per pixel. Converges faster than `RANDOM_PCG`. The default.
  * @section Random Strategies
  * @type {Object}
  */
@@ -21,7 +21,7 @@ export const RANDOM_SOBOL = sobol;
 
 /**
  * The same Sobol sequence for every pixel, offset by a blue noise dither so early frames read as
- * smooth grain rather than clumped noise. The default.
+ * smooth grain rather than clumped noise.
  * @section Random Strategies
  * @type {Object}
  */

package/src/webgpu/denoise/OIDNDenoiser.js

@@ -1,8 +1,20 @@
-import { ExternalTexture, NearestFilter, NoToneMapping, RenderTarget, UnsignedByteType } from 'three/webgpu';
-import { diffuseColor, mrt, normalView, vec4 } from 'three/tsl';
+import { EventDispatcher, ExternalTexture } from 'three/webgpu';
+import { UnpackAuxKernel } from '../compute/UnpackAuxKernel.js';
+import { createAuxImageTarget } from '../compute/targets.js';
 
-/** @import { Camera, Scene, Texture, WebGPURenderer } from 'three/webgpu' */
-/** @import { DynamicTileSetting } from 'oidn-web' */
+/** @import { StorageArrayTexture, Texture, WebGPURenderer } from 'three/webgpu' */
+/** @import { DynamicTileSetting } from 'oidn-webgpu' */
+
+/**
+ * Fired when a pass started by `update` fails, such as the weights failing to download, with the
+ * failure as the event's `error`. No other pass starts until a reset.
+ * @event OIDNDenoiser#error
+ */
+
+/**
+ * Fired as each tile of a pass finishes, with the fraction of the pass done as `progress`.
+ * @event OIDNDenoiser#progress
+ */
 
 /**
  * Runs Open Image Denoise over a path traced image. Pass one to
@@ -12,14 +24,14 @@ import { diffuseColor, mrt, normalView, vec4 } from 'three/tsl';
  * nor the network files become a dependency.
  *
  * ```js
- * import { initUNetFromURL } from 'oidn-web';
+ * import { initUNetFromURL } from 'oidn-webgpu';
  * pathTracer.setDenoiser( new OIDNDenoiser( { initUNetFromURL, auxWeightsUrl } ) );
  * ```
  *
  * Weights come from the oidn-weights repository, where the "_small" and "_large" variants trade
  * quality against download size and per tile cost.
  */
-export class OIDNDenoiser {
+export class OIDNDenoiser extends EventDispatcher {
 
 	/**
 	 * The denoised result, or null until the first tile has been produced.
@@ -69,6 +81,8 @@ export class OIDNDenoiser {
 	 */
 	constructor( options = {} ) {
 
+		super();
+
 		const {
 			initUNetFromURL,
 			auxWeightsUrl,
@@ -80,7 +94,7 @@ export class OIDNDenoiser {
 
 		if ( ! initUNetFromURL ) {
 
-			throw new Error( 'OIDNDenoiser: "initUNetFromURL" from "oidn-web" must be provided.' );
+			throw new Error( 'OIDNDenoiser: "initUNetFromURL" from "oidn-webgpu" must be provided.' );
 
 		}
 
@@ -88,27 +102,32 @@ export class OIDNDenoiser {
 		this.auxWeightsUrl = auxWeightsUrl;
 		this.colorWeightsUrl = colorWeightsUrl;
 
-		// `false` falls back to the color only model, which is blurrier but skips a scene render
+		// `false` falls back to the color only model, which is blurrier but needs no auxiliary buffers
 		this.useAuxiliaryBuffers = useAuxiliaryBuffers;
 
-		// tiling, passed through to oidn-web. Null keeps its defaults
+		// tiling, passed through to oidn-webgpu. Null keeps its defaults
 		this.maxTileSize = maxTileSize;
 		this.dynamicTile = dynamicTile;
 
 		this.renderer = null;
-		this.scene = null;
-		this.camera = null;
 
 		this._texture = null;
 		this._running = false;
 		this._complete = false;
 		this._abort = null;
 		this._requestId = 0;
+
+		// set when a pass started by "update" fails, so the render loop doesn't start another until a reset
+		this._failed = false;
 		this._unets = { aux: null, color: null };
 
 		this._resultPipeline = null;
 		this._rawTexture = null;
-		this._auxTarget = null;
+
+		// the albedo and normal unpacked from the path tracer's auxiliary target for a pass
+		this._unpackAuxKernel = new UnpackAuxKernel().setWorkgroupSize( 8, 8, 1 );
+		this._albedoTarget = createAuxImageTarget( 'Denoiser Albedo' );
+		this._normalTarget = createAuxImageTarget( 'Denoiser Normal' );
 
 	}
 
@@ -122,41 +141,40 @@ export class OIDNDenoiser {
 	}
 
 	/**
-	 * @param {Scene} scene
-	 * @param {Camera} camera
-	 */
-	setScene( scene, camera ) {
-
-		this.scene = scene;
-		this.camera = camera;
-
-	}
-
-	/**
-	 * Renders the auxiliary buffers and starts a pass. Safe to call every frame.
+	 * Unpacks the auxiliary buffers the path tracer accumulated and starts a pass. Safe to call
+	 * every frame.
 	 *
 	 * @param {Texture} target - The path traced result, in linear HDR.
+	 * @param {StorageArrayTexture|null} aux - The packed auxiliary buffers, see "aux.wgsl.js".
 	 * @returns {Texture|null}
 	 */
-	update( target ) {
+	update( target, aux = null ) {
 
-		if ( this._complete || this._running ) {
+		if ( this._complete || this._running || this._failed ) {
 
 			return this._texture;
 
 		}
 
+		// TODO: denoise the alpha for transparent backgrounds. oidn-webgpu's "denoiseAlpha" runs as a
+		// second pass, but its "_updatePasses" doesn't rebuild its shaders when the option changes
 		let albedo = null;
 		let normal = null;
-		if ( this.useAuxiliaryBuffers ) {
+		if ( this.useAuxiliaryBuffers && aux ) {
 
-			const auxTarget = this._renderAuxiliaryBuffers( target.width, target.height );
-			albedo = auxTarget.textures[ 0 ];
-			normal = auxTarget.textures[ 1 ];
+			this._unpackAux( aux );
+			albedo = this._albedoTarget;
+			normal = this._normalTarget;
 
 		}
 
-		this.denoise( target, albedo, normal );
+		// a failure, such as the weights failing to download, is reported once rather than every frame
+		this.denoise( target, albedo, normal ).catch( error => {
+
+			this._failed = true;
+			this.dispatchEvent( { type: 'error', error } );
+
+		} );
 
 		return this._texture;
 
@@ -213,14 +231,22 @@ export class OIDNDenoiser {
 		const inputs = {
 			color: { data: backend.get( color ).texture, width, height },
 
+			// pace the tiles to display frames so the path tracer keeps rendering between them
+			scheduling: 'animation-frame',
+
 			// the output is seeded with the raw color, so copying per tile shows a progressive wipe
-			progress: output => this._copyOutputToTexture( output, width, height ),
-			done: output => {
+			progress: ( output, tileData, tile, tileIndex, tileCount ) => {
 
 				this._copyOutputToTexture( output, width, height );
+				this.dispatchEvent( { type: 'progress', progress: ( tileIndex + 1 ) / tileCount } );
+
+			},
+			done: output => {
+
 				this._running = false;
 				this._complete = true;
 				this._abort = null;
+				this._disposeAuxImages();
 
 			},
 		};
@@ -254,17 +280,18 @@ export class OIDNDenoiser {
 		this._rawTexture?.destroy();
 		this._rawTexture = null;
 
+		this._disposeAuxImages();
+
 		this._running = false;
 		this._complete = false;
+		this._failed = false;
 
 	}
 
 	dispose() {
 
 		this.reset();
-
-		this._auxTarget?.dispose();
-		this._auxTarget = null;
+		this._unpackAuxKernel.dispose();
 
 		// the networks hold the weights on the GPU, and a load may still be in flight
 		for ( const key in this._unets ) {
@@ -276,52 +303,28 @@ export class OIDNDenoiser {
 
 	}
 
-	// Rasterizes the albedo and normal buffers that guide the filter. oidn-web takes normals
-	// mapped into [0,1], with (0.5, 0.5, 1) as a flat normal.
-	_renderAuxiliaryBuffers( width, height ) {
+	// Unpacks the path tracer's auxiliary target into albedo and normal textures, since oidn-webgpu
+	// reads every input as the same kind as the color texture
+	_unpackAux( aux ) {
 
-		const { renderer, scene, camera } = this;
+		const { renderer, _unpackAuxKernel, _albedoTarget, _normalTarget } = this;
+		const { width, height } = aux.image;
 
-		if ( ! this._auxTarget ) {
+		_albedoTarget.setSize( width, height );
+		_normalTarget.setSize( width, height );
 
-			// Eight bits per channel since both buffers hold [0,1]. Multisampled so the rasterized
-			// silhouettes match the jittered path traced ones.
-			this._auxTarget = new RenderTarget( 1, 1, {
-				count: 2,
-				type: UnsignedByteType,
-				minFilter: NearestFilter,
-				magFilter: NearestFilter,
-				samples: 4,
-			} );
-
-			// the MRT keys are matched against these names
-			this._auxTarget.textures[ 0 ].name = 'output';
-			this._auxTarget.textures[ 1 ].name = 'normal';
-
-		}
+		_unpackAuxKernel.auxTarget = aux;
+		_unpackAuxKernel.albedoTarget = _albedoTarget;
+		_unpackAuxKernel.normalTarget = _normalTarget;
+		renderer.compute( _unpackAuxKernel.kernel, _unpackAuxKernel.getDispatchSize( width, height ) );
 
-		const auxTarget = this._auxTarget;
-		auxTarget.setSize( width, height );
-
-		const originalTarget = renderer.getRenderTarget();
-		const originalMRT = renderer.getMRT();
-		const originalToneMapping = renderer.toneMapping;
-
-		// the buffers are data rather than an image, so they must not be tone mapped
-		renderer.toneMapping = NoToneMapping;
-		renderer.setRenderTarget( auxTarget );
-		renderer.setMRT( mrt( {
-			output: diffuseColor,
-			normal: vec4( normalView.mul( 0.5 ).add( 0.5 ), 1.0 ),
-		} ) );
-
-		renderer.render( scene, camera );
+	}
 
-		renderer.setMRT( originalMRT );
-		renderer.setRenderTarget( originalTarget );
-		renderer.toneMapping = originalToneMapping;
+	// the unpacked images only live for a pass
+	_disposeAuxImages() {
 
-		return auxTarget;
+		this._albedoTarget.dispose();
+		this._normalTarget.dispose();
 
 	}
 
@@ -346,7 +349,7 @@ export class OIDNDenoiser {
 				if ( this.maxTileSize !== null ) options.maxTileSize = this.maxTileSize;
 				if ( this.dynamicTile !== null ) options.dynamicTile = this.dynamicTile;
 
-				return this.initUNetFromURL( url, { device, adapterInfo: device.adapterInfo }, options );
+				return this.initUNetFromURL( url, { device }, options );
 
 			} )();
 
@@ -358,7 +361,7 @@ export class OIDNDenoiser {
 
 	// Copies the denoiser's packed output buffer into a sampleable texture, using a compute pass
 	// since copyBufferToTexture requires 256 byte row alignment.
-	// TODO: remove the copy once oidn-web can write into a caller-provided storage texture.
+	// TODO: remove the copy once oidn-webgpu can write into a caller-provided storage texture.
 	_copyOutputToTexture( output, width, height ) {
 
 		const device = this.renderer.backend.device;