rayzee 5.3.8 → 5.4.1

package/src/Processor/EquirectHDRInfo.js

@@ -220,53 +220,62 @@ export class EquirectHDRInfo {
 
 		const { floatData, width, height } = extractFloatData( hdr );
 
-		// Reuse worker across calls; create on first use
-		if ( ! this._worker ) {
+		// Fresh worker per call — terminated in finally to avoid ~30 MB residency.
+		try {
 
-			try {
+			this._worker = new Worker( CDF_WORKER_URL, { type: 'module' } );
 
-				this._worker = new Worker( CDF_WORKER_URL, { type: 'module' } );
+		} catch ( e ) {
 
-			} catch ( e ) {
+			if ( e.name !== 'SecurityError' ) throw e;
+			this._worker = await fetchAsWorker( CDF_WORKER_URL );
 
-				if ( e.name !== 'SecurityError' ) throw e;
-				this._worker = await fetchAsWorker( CDF_WORKER_URL );
+		}
 
-			}
+		try {
 
-		}
+			const result = await new Promise( ( resolve, reject ) => {
 
-		const result = await new Promise( ( resolve, reject ) => {
+				this._worker.onmessage = ( e ) => {
 
-			this._worker.onmessage = ( e ) => {
+					if ( e.data.error ) {
 
-				if ( e.data.error ) {
+						reject( new Error( e.data.error ) );
 
-					reject( new Error( e.data.error ) );
+					} else {
 
-				} else {
+						resolve( e.data );
 
-					resolve( e.data );
+					}
 
-				}
+				};
 
-			};
+				this._worker.onerror = reject;
 
-			this._worker.onerror = reject;
+				// Transfer floatData to worker (zero-copy)
+				this._worker.postMessage(
+					{ floatData, width, height },
+					[ floatData.buffer ]
+				);
 
-			// Transfer floatData to worker (zero-copy)
-			this._worker.postMessage(
-				{ floatData, width, height },
-				[ floatData.buffer ]
-			);
+			} );
 
-		} );
+			this.marginalData = result.marginalData;
+			this.conditionalData = result.conditionalData;
+			this.totalSum = result.totalSum;
+			this.width = result.width;
+			this.height = result.height;
 
-		this.marginalData = result.marginalData;
-		this.conditionalData = result.conditionalData;
-		this.totalSum = result.totalSum;
-		this.width = result.width;
-		this.height = result.height;
+		} finally {
+
+			if ( this._worker ) {
+
+				this._worker.terminate();
+				this._worker = null;
+
+			}
+
+		}
 
 	}
 

package/src/Processor/InstanceTable.js

@@ -57,10 +57,26 @@ export class InstanceTable {
 			worldAABB: null, // Computed from triangle data
 			originalToBvhMap,
 			bvhData,
+			visible: true, // Per-mesh visibility (baked into TLAS leaf slot [2])
+			tlasLeafIndex: - 1, // Set by TLASBuilder.flatten() — enables in-place visibility patching
 		};
 
 	}
 
+	/**
+	 * Set per-mesh visibility flag. Does NOT update the GPU buffer —
+	 * caller must patch combinedBvhData[tlasLeafIndex*16 + 2] and mark bvh attr dirty.
+	 *
+	 * @param {number} meshIndex
+	 * @param {boolean} visible
+	 */
+	setVisibility( meshIndex, visible ) {
+
+		const entry = this.entries[ meshIndex ];
+		if ( entry ) entry.visible = visible;
+
+	}
+
 	/**
 	 * Compute world-space AABBs for all entries from their BLAS root node data.
 	 * O(1) per mesh for inner roots; falls back to triangle scan for leaf roots (rare).

package/src/Processor/SceneProcessor.js

@@ -476,48 +476,36 @@ export class SceneProcessor {
 
 			const validEntries = this.instanceTable.entries.filter( e => e !== null );
 
-			if ( validEntries.length === 1 ) {
-
-				// Single mesh — use BLAS directly as flat BVH (no TLAS wrapper).
-				// Avoids per-ray TLAS overhead and the extra branch in traversal.
-				const entry = validEntries[ 0 ];
-				this.bvhData = entry.bvhData;
-				this.instanceTable.assignOffsets( 0 ); // BLAS at offset 0
-				this._buildGlobalOriginalToBvhMap();
-				entry.originalToBvhMap = null;
-				entry.bvhData = null;
-
-			} else {
-
-				// Multi-mesh — build TLAS over mesh AABBs
-				this.instanceTable.computeAABBs( this.triangleData );
-				const { root: tlasRoot, nodeCount: tlasNodeCount } = this.tlasBuilder.build( validEntries );
+			// Always build a TLAS — even for a single mesh — so the BLAS-pointer leaf
+			// carries packed per-mesh visibility in its slot [2]. The 1-node TLAS
+			// overhead (one extra leaf fetch per ray) is negligible and eliminates
+			// a dedicated visibility storage buffer binding.
+			this.instanceTable.computeAABBs( this.triangleData );
+			const { root: tlasRoot, nodeCount: tlasNodeCount } = this.tlasBuilder.build( validEntries );
 
-				this.instanceTable.assignOffsets( tlasNodeCount );
-				const totalNodes = this.instanceTable.totalNodeCount;
+			this.instanceTable.assignOffsets( tlasNodeCount );
+			const totalNodes = this.instanceTable.totalNodeCount;
 
-				const tlasData = this.tlasBuilder.flatten( tlasRoot, validEntries );
+			const tlasData = this.tlasBuilder.flatten( tlasRoot, validEntries );
 
-				// Assemble combined buffer: [TLAS][BLAS_0][BLAS_1]...[BLAS_M]
-				this.bvhData = new Float32Array( totalNodes * 16 );
-				this.bvhData.set( tlasData );
+			// Assemble combined buffer: [TLAS][BLAS_0][BLAS_1]...[BLAS_M]
+			this.bvhData = new Float32Array( totalNodes * 16 );
+			this.bvhData.set( tlasData );
 
-				for ( const entry of validEntries ) {
+			for ( const entry of validEntries ) {
 
-					const destOffset = entry.blasOffset * 16;
-					this.bvhData.set( entry.bvhData, destOffset );
-					this._offsetBLASInPlace( destOffset, entry.bvhData.length / 16, entry.blasOffset, entry.triOffset );
+				const destOffset = entry.blasOffset * 16;
+				this.bvhData.set( entry.bvhData, destOffset );
+				this._offsetBLASInPlace( destOffset, entry.bvhData.length / 16, entry.blasOffset, entry.triOffset );
 
-				}
-
-				this._buildGlobalOriginalToBvhMap();
+			}
 
-				for ( const entry of validEntries ) {
+			this._buildGlobalOriginalToBvhMap();
 
-					entry.originalToBvhMap = null;
-					entry.bvhData = null;
+			for ( const entry of validEntries ) {
 
-				}
+				entry.originalToBvhMap = null;
+				entry.bvhData = null;
 
 			}
 
@@ -1384,6 +1372,7 @@ export class SceneProcessor {
 		}
 
 		pathTracer.setBVHData( this.bvhData );
+		pathTracer.setInstanceTable( this.instanceTable );
 
 		if ( this.materialData ) {
 

package/src/Processor/ShaderBuilder.js

@@ -16,7 +16,6 @@ import { Fn, texture, vec2, float, int, uniform, If,
 import { TextureNode } from 'three/webgpu';
 import { LinearFilter, DataArrayTexture } from 'three';
 import { pathTracerMain } from '../TSL/PathTracer.js';
-import { setMeshVisibilityBuffer } from '../TSL/BVHTraversal.js';
 import { setShadowAlbedoMaps, setAlphaShadowsUniform } from '../TSL/LightsDirect.js';
 import { BuildTimer } from './BuildTimer.js';
 
@@ -50,9 +49,18 @@ export class ShaderBuilder {
 		this._dispatchX = 0;
 		this._dispatchY = 0;
 
+		// Reused per-frame dispatchSize array — avoids GC pressure from
+		// allocating [x,y,z] on every setFullScreenDispatch/setTileDispatch call.
+		// WebGPUBackend only reads indices 0..2 of this array during compute dispatch.
+		this._dispatchSize = [ 0, 0, 1 ];
+
 		// Scene texture nodes cache (for in-place updates on model change)
 		this._sceneTextureNodes = null;
 
+		// Whether the GPU compute pipeline has been compiled (via a real dispatch).
+		// Reset on setupCompute() rebuilds and on dispose().
+		this._compiled = false;
+
 	}
 
 	/**
@@ -89,6 +97,9 @@ export class ShaderBuilder {
 			writeTex.color, writeTex.normalDepth, writeTex.albedo
 		);
 
+		// New compute node → needs a fresh GPU pipeline compile
+		this._compiled = false;
+
 		timer.end( 'Build compute node (TSL)' );
 
 		timer.print();
@@ -131,7 +142,13 @@ export class ShaderBuilder {
 		this._dispatchX = Math.ceil( width / WG_SIZE );
 		this._dispatchY = Math.ceil( height / WG_SIZE );
 
-		if ( this.computeNode ) this.computeNode.setCount( [ this._dispatchX, this._dispatchY, 1 ] );
+		if ( this.computeNode ) {
+
+			this._dispatchSize[ 0 ] = this._dispatchX;
+			this._dispatchSize[ 1 ] = this._dispatchY;
+			this.computeNode.dispatchSize = this._dispatchSize;
+
+		}
 
 		this.renderWidth.value = width;
 		this.renderHeight.value = height;
@@ -158,7 +175,13 @@ export class ShaderBuilder {
 		const dispatchX = Math.ceil( tileWidth / WG_SIZE );
 		const dispatchY = Math.ceil( tileHeight / WG_SIZE );
 
-		if ( this.computeNode ) this.computeNode.setCount( [ dispatchX, dispatchY, 1 ] );
+		if ( this.computeNode ) {
+
+			this._dispatchSize[ 0 ] = dispatchX;
+			this._dispatchSize[ 1 ] = dispatchY;
+			this.computeNode.dispatchSize = this._dispatchSize;
+
+		}
 
 	}
 
@@ -170,13 +193,36 @@ export class ShaderBuilder {
 		this.tileOffsetX.value = 0;
 		this.tileOffsetY.value = 0;
 
-		if ( this.computeNode ) this.computeNode.setCount( [ this._dispatchX, this._dispatchY, 1 ] );
+		if ( this.computeNode ) {
+
+			this._dispatchSize[ 0 ] = this._dispatchX;
+			this._dispatchSize[ 1 ] = this._dispatchY;
+			this.computeNode.dispatchSize = this._dispatchSize;
+
+		}
 
 	}
 
-	forceCompile() {
+	/**
+	 * Front-load GPU compute pipeline creation via a single dispatch.
+	 *
+	 * Three.js WebGPU has no `createComputePipelineAsync` path — compute
+	 * pipelines always compile synchronously on first `renderer.compute(node)`.
+	 * Calling this at build time (while a "Compiling shaders…" status is
+	 * already visible) moves the stall off the first animate frame.
+	 *
+	 * The dispatch writes to ping-pong storage textures whose contents are
+	 * discarded by the subsequent `reset()` (frame counter back to 0 →
+	 * `hasPreviousAccumulated = 0` → prev textures are not read).
+	 *
+	 * @param {object} renderer - WebGPURenderer
+	 */
+	forceCompile( renderer ) {
 
-		// No-op — compilation happens on first renderer.compute() call.
+		if ( this._compiled || ! this.computeNode || ! renderer ) return;
+
+		this._compiled = true;
+		renderer.compute( this.computeNode );
 
 	}
 
@@ -187,11 +233,9 @@ export class ShaderBuilder {
 		const triStorage = stage.triangleStorageNode;
 		const bvhStorage = stage.bvhStorageNode;
 		const matStorage = stage.materialData.materialStorageNode;
-		const emissiveTriStorage = stage.emissiveTriangleStorageNode;
-		const lightBVHStorage = stage.lightBVHStorageNode;
-
-		// Set per-mesh visibility buffer (module-level in BVHTraversal.js, read during graph construction)
-		setMeshVisibilityBuffer( stage.meshVisibilityStorageNode );
+		// Packed light buffer — [lightBVH | emissive triangles]. One node fed to both
+		// TSL params; emissive reads offset by stage.emissiveVec4Offset.
+		const lightBufferStorage = stage.lightStorageNode;
 
 		// Set alpha-shadow uniform (module-level in LightsDirect.js, read at runtime)
 		setAlphaShadowsUniform( stage.uniforms.get( 'enableAlphaShadows' ) );
@@ -202,9 +246,9 @@ export class ShaderBuilder {
 		const adaptiveSamplingTex = new TextureNode();
 		this.adaptiveSamplingTexNode = adaptiveSamplingTex;
 
-		// Environment importance sampling CDF (storage buffers)
-		const marginalCDFStorage = stage.environment.envMarginalStorageNode;
-		const conditionalCDFStorage = stage.environment.envConditionalStorageNode;
+		// Environment importance sampling CDF — packed storage buffer
+		// Layout: [marginal (envResolution.y floats) | conditional (envResolution.x * envResolution.y floats)]
+		const envCDFStorage = stage.environment.envCDFStorageNode;
 
 		// Previous-frame texture nodes — initialized from readTarget textures
 		const readTextures = storageTextures.getReadTextures();
@@ -238,8 +282,8 @@ export class ShaderBuilder {
 		setShadowAlbedoMaps( albedoMapsTex );
 
 		const result = {
-			triStorage, bvhStorage, matStorage, emissiveTriStorage, lightBVHStorage,
-			envTex, adaptiveSamplingTex, marginalCDFStorage, conditionalCDFStorage,
+			triStorage, bvhStorage, matStorage, lightBufferStorage,
+			envTex, adaptiveSamplingTex, envCDFStorage,
 			albedoMapsTex, normalMapsTex, bumpMapsTex,
 			metalnessMapsTex, roughnessMapsTex, emissiveMapsTex, displacementMapsTex,
 		};
@@ -257,8 +301,8 @@ export class ShaderBuilder {
 		writeColorTex, writeNDTex, writeAlbedoTex ) {
 
 		const {
-			triStorage, bvhStorage, matStorage, emissiveTriStorage, lightBVHStorage,
-			envTex, adaptiveSamplingTex, marginalCDFStorage, conditionalCDFStorage,
+			triStorage, bvhStorage, matStorage, lightBufferStorage,
+			envTex, adaptiveSamplingTex, envCDFStorage,
 			albedoMapsTex, normalMapsTex, bumpMapsTex,
 			metalnessMapsTex, roughnessMapsTex, emissiveMapsTex, displacementMapsTex,
 		} = textureNodes;
@@ -319,8 +363,7 @@ export class ShaderBuilder {
 					envTexture: envTex,
 					environmentIntensity: stage.environmentIntensity,
 					envMatrix: stage.environmentMatrix,
-					envMarginalWeights: marginalCDFStorage,
-					envConditionalWeights: conditionalCDFStorage,
+					envCDFBuffer: envCDFStorage,
 					envTotalSum: stage.envTotalSum,
 					envResolution: stage.envResolution,
 					enableEnvironmentLight: stage.enableEnvironment,
@@ -334,11 +377,12 @@ export class ShaderBuilder {
 					globalIlluminationIntensity: stage.globalIlluminationIntensity,
 					totalTriangleCount: stage.totalTriangleCount,
 					enableEmissiveTriangleSampling: stage.enableEmissiveTriangleSampling,
-					emissiveTriangleBuffer: emissiveTriStorage,
+					emissiveTriangleBuffer: lightBufferStorage,
 					emissiveTriangleCount: stage.emissiveTriangleCount,
 					emissiveTotalPower: stage.emissiveTotalPower,
 					emissiveBoost: stage.emissiveBoost,
-					lightBVHBuffer: lightBVHStorage,
+					emissiveVec4Offset: stage.emissiveVec4Offset,
+					lightBVHBuffer: lightBufferStorage,
 					lightBVHNodeCount: stage.lightBVHNodeCount,
 					debugVisScale: stage.debugVisScale,
 					enableAccumulation: stage.enableAccumulation,
@@ -379,6 +423,7 @@ export class ShaderBuilder {
 		this.prevAlbedoTexNode = null;
 		this.adaptiveSamplingTexNode = null;
 		this._sceneTextureNodes = null;
+		this._compiled = false;
 
 	}
 

package/src/Processor/TLASBuilder.js

@@ -199,10 +199,13 @@ export class TLASBuilder {
 	/**
 	 * Flatten TLAS tree into Float32Array.
 	 * Inner nodes: same format as BVH.
-	 * Leaf nodes: [blasRootNodeIndex, 0, 0, -2] (BLAS-pointer marker).
+	 * Leaf nodes: [blasRootNodeIndex, meshIndex, visibility, -2] (BLAS-pointer marker).
+	 *
+	 * Side effect: records each entry's flat leaf index on `entry.tlasLeafIndex` so that
+	 * visibility can later be patched in place (combinedBvhData[tlasLeafIndex*16 + 2]).
 	 *
 	 * @param {TLASNode} root
-	 * @param {Array<{blasOffset: number}>} entries - Instance table entries with assigned blasOffsets
+	 * @param {Array<{blasOffset: number, visible: boolean, tlasLeafIndex: number}>} entries
 	 * @returns {Float32Array}
 	 */
 	flatten( root, entries ) {
@@ -268,10 +271,12 @@ export class TLASBuilder {
 				// Leaf node — BLAS pointer
 				const entry = entries[ n.entryIndex ];
 				data[ o ] = entry.blasOffset; // Absolute node index of BLAS root in combined buffer
-				data[ o + 1 ] = n.entryIndex; // meshIndex for per-mesh visibility check
-				// data[o+2] = 0
+				data[ o + 1 ] = n.entryIndex; // meshIndex (kept for debug/ID — traversal uses slot [2])
+				data[ o + 2 ] = entry.visible === false ? 0.0 : 1.0; // Per-mesh visibility (packed — frees a binding)
 				data[ o + 3 ] = BVH_LEAF_MARKERS.BLAS_POINTER_LEAF; // -2 marker
 
+				entry.tlasLeafIndex = i;
+
 			}
 
 		}

package/src/Stages/ASVGF.js

@@ -803,10 +803,10 @@ export class ASVGF extends RenderStage {
 		// Update dispatch dimensions
 		this._dispatchX = Math.ceil( width / 8 );
 		this._dispatchY = Math.ceil( height / 8 );
-		this._gradientNode.setCount( [ this._dispatchX, this._dispatchY, 1 ] );
-		this._temporalNodeA.setCount( [ this._dispatchX, this._dispatchY, 1 ] );
-		this._temporalNodeB.setCount( [ this._dispatchX, this._dispatchY, 1 ] );
-		this._heatmapComputeNode.setCount( [ this._dispatchX, this._dispatchY, 1 ] );
+		this._gradientNode.dispatchSize = [ this._dispatchX, this._dispatchY, 1 ];
+		this._temporalNodeA.dispatchSize = [ this._dispatchX, this._dispatchY, 1 ];
+		this._temporalNodeB.dispatchSize = [ this._dispatchX, this._dispatchY, 1 ];
+		this._heatmapComputeNode.dispatchSize = [ this._dispatchX, this._dispatchY, 1 ];
 
 	}
 

package/src/Stages/AdaptiveSampling.js

@@ -422,8 +422,8 @@ export class AdaptiveSampling extends RenderStage {
 		// Update dispatch dimensions
 		this._dispatchX = Math.ceil( width / 16 );
 		this._dispatchY = Math.ceil( height / 16 );
-		this._computeNode.setCount( [ this._dispatchX, this._dispatchY, 1 ] );
-		this._heatmapComputeNode.setCount( [ this._dispatchX, this._dispatchY, 1 ] );
+		this._computeNode.dispatchSize = [ this._dispatchX, this._dispatchY, 1 ];
+		this._heatmapComputeNode.dispatchSize = [ this._dispatchX, this._dispatchY, 1 ];
 
 	}
 

package/src/Stages/AutoExposure.js

@@ -1,6 +1,7 @@
 import { Fn, wgslFn, vec4, float, int, uint, ivec2, uvec2, uniform, If, max,
-	textureLoad, textureStore, workgroupArray, workgroupBarrier, localId, workgroupId } from 'three/tsl';
-import { RenderTarget, TextureNode, StorageTexture } from 'three/webgpu';
+	textureLoad, textureStore, workgroupArray, workgroupBarrier, localId, workgroupId,
+	attributeArray } from 'three/tsl';
+import { RenderTarget, TextureNode, StorageTexture, ReadbackBuffer } from 'three/webgpu';
 import { FloatType, RGBAFormat, NearestFilter } from 'three';
 import { RenderStage, StageExecutionMode } from '../Pipeline/RenderStage.js';
 import { luminance } from '../TSL/Common.js';
@@ -54,8 +55,11 @@ const adaptExposure = /*@__PURE__*/ wgslFn( `
  *   2. Reduction (compute): parallel reduction 64×64 → 1×1 via shared memory
  *      Single workgroup of 256 threads, each loads 16 texels.
  *      Computes geometric mean: exp(Σlog(L) / N)
- *   3. Adaptation (compute): temporal smoothing with prev exposure
- *   4. Async readback (1×1): apply to renderer.toneMappingExposure
+ *   3. Adaptation (compute): temporal smoothing with prev exposure; writes
+ *      vec4(exposure, luminance, targetExposure, 1) into a 1-element storage buffer.
+ *   4. Async readback via `renderer.getArrayBufferAsync(attr, ReadbackBuffer)`:
+ *      the ReadbackBuffer pools its staging GPUBuffer across frames, avoiding
+ *      per-frame allocation churn. Apply to renderer.toneMappingExposure.
  *
  * WebGPU advantage: async readback (no GPU pipeline stall).
  * 1-frame delay is imperceptible for slowly-changing exposure.
@@ -156,15 +160,12 @@ export class AutoExposure extends RenderStage {
 		// from StorageTexture return zeros — must copy to RenderTarget first)
 		this._reductionReadTarget = new RenderTarget( 1, 1, rtOpts );
 
-		// Adaptation StorageTexture (1×1) — compute writes here
-		this._adaptationStorageTex = new StorageTexture( 1, 1 );
-		this._adaptationStorageTex.type = FloatType;
-		this._adaptationStorageTex.format = RGBAFormat;
-		this._adaptationStorageTex.minFilter = NearestFilter;
-		this._adaptationStorageTex.magFilter = NearestFilter;
-
-		// Adaptation target (1×1) — readable copy for async readback
-		this._adaptationTarget = new RenderTarget( 1, 1, rtOpts );
+		// Adaptation result — 1×vec4 storage buffer attribute. Compute writes
+		// vec4(exposure, luminance, targetExposure, 1) here; CPU reads via
+		// getArrayBufferAsync + a pooled ReadbackBuffer (16 bytes).
+		this._adaptationResult = attributeArray( 1, 'vec4' );
+		this._readbackBuffer = new ReadbackBuffer( 16 );
+		this._readbackBuffer.name = 'AutoExposureAdaptation';
 
 	}
 
@@ -351,16 +352,15 @@ export class AutoExposure extends RenderStage {
 	 * Adaptation (compute): temporal smoothing
 	 *
 	 * Single-thread compute dispatch [1, 1, 1], workgroup [1, 1, 1].
-	 * Reads geometric mean from reduction RenderTarget (copied from StorageTexture),
-	 * reads previous adaptation from adaptation RenderTarget,
-	 * applies asymmetric temporal smoothing, writes to adaptation StorageTexture.
-	 *
-	 * Output: R = exposure, G = luminance, B = targetExposure, A = 1
+	 * Reads geometric mean from reduction RenderTarget, applies asymmetric
+	 * temporal smoothing using the previous-exposure uniform, and writes
+	 * vec4(exposure, luminance, targetExposure, 1) into a 1-element storage
+	 * buffer which the CPU reads via getArrayBufferAsync + ReadbackBuffer.
 	 */
 	_buildAdaptationCompute() {
 
 		const reductionTex = this._reductionReadTexNode;
-		const outputTex = this._adaptationStorageTex;
+		const resultBuf = this._adaptationResult;
 		const keyValue = this.keyValueU;
 		const minExp = this.minExposureU;
 		const maxExp = this.maxExposureU;
@@ -381,11 +381,7 @@ export class AutoExposure extends RenderStage {
 				dt, isFirst
 			);
 
-			textureStore(
-				outputTex,
-				uvec2( uint( 0 ), uint( 0 ) ),
-				result
-			).toWriteOnly();
+			resultBuf.element( uint( 0 ) ).assign( result );
 
 		} );
 
@@ -463,22 +459,31 @@ export class AutoExposure extends RenderStage {
 
 		this._reductionReadTexNode.value = this._reductionReadTarget.texture;
 		this.renderer.compute( this._adaptationComputeNode );
-		this.renderer.copyTextureToTexture( this._adaptationStorageTex, this._adaptationTarget.texture );
 
-		// ── Async readback (WebGPU advantage) ────────────
+		// ── Async readback via pooled ReadbackBuffer ─────
+		// getArrayBufferAsync reuses the ReadbackBuffer's internal staging
+		// GPUBuffer across frames. ReadbackBuffer.release() must be called
+		// before it can be reused — the _pendingReadback flag gates reentry.
 
 		if ( ! this._pendingReadback ) {
 
 			this._pendingReadback = true;
 			const generation = this._readbackGeneration;
 
-			this.renderer.readRenderTargetPixelsAsync(
-				this._adaptationTarget, 0, 0, 1, 1
-			).then( ( data ) => {
+			this.renderer.getArrayBufferAsync(
+				this._adaptationResult.value, this._readbackBuffer
+			).then( ( readback ) => {
 
+				// Copy the 4 floats out of the mapped buffer before release(),
+				// because release() nulls readback.buffer and unmaps the GPU buffer.
+				const data = readback && readback.buffer
+					? new Float32Array( readback.buffer.slice( 0 ) )
+					: null;
+				this._readbackBuffer.release();
 				this._pendingReadback = false;
+
 				// Discard stale readback from before a reset
-				if ( generation === this._readbackGeneration ) {
+				if ( data && generation === this._readbackGeneration ) {
 
 					this._applyReadback( data );
 
@@ -486,6 +491,12 @@ export class AutoExposure extends RenderStage {
 
 			} ).catch( () => {
 
+				try {
+
+					this._readbackBuffer.release();
+
+				} catch { /* buffer may not be mapped on error */ }
+
 				this._pendingReadback = false;
 
 			} );
@@ -612,8 +623,7 @@ export class AutoExposure extends RenderStage {
 		this._downsampleStorageTex?.dispose();
 		this._reductionStorageTex?.dispose();
 		this._reductionReadTarget?.dispose();
-		this._adaptationStorageTex?.dispose();
-		this._adaptationTarget?.dispose();
+		this._readbackBuffer?.dispose();
 
 	}
 

package/src/Stages/BilateralFilter.js

@@ -304,8 +304,8 @@ export class BilateralFilter extends RenderStage {
 		// Update dispatch dimensions
 		this._dispatchX = Math.ceil( width / 8 );
 		this._dispatchY = Math.ceil( height / 8 );
-		this._computeNodeA.setCount( [ this._dispatchX, this._dispatchY, 1 ] );
-		this._computeNodeB.setCount( [ this._dispatchX, this._dispatchY, 1 ] );
+		this._computeNodeA.dispatchSize = [ this._dispatchX, this._dispatchY, 1 ];
+		this._computeNodeB.dispatchSize = [ this._dispatchX, this._dispatchY, 1 ];
 
 	}
 

package/src/Stages/Display.js

@@ -111,7 +111,8 @@ export class Display extends RenderStage {
 	dispose() {
 
 		this.displayMaterial?.dispose();
-		this.displayQuad?.dispose();
+		// QuadMesh extends Mesh — no dispose method; material already disposed.
+		this.displayQuad = null;
 
 	}
 

package/src/Stages/EdgeFilter.js

@@ -50,7 +50,9 @@ export class EdgeFilter extends RenderStage {
 
 		// Output StorageTexture (compute writes here)
 		// Pre-allocated at max size — NEVER resize/dispose after this.
-		// StorageTexture.setSize() breaks textureStore bind groups (Three.js bug #32969).
+		// Kept as a defensive pattern: bug #32969 (setSize bind-group staleness)
+		// was fixed in r184 (PR #33028), but #33061 (TSL compute pipeline
+		// re-compile returns zeros) is still open.
 		const MAX_STORAGE_SIZE = 2048;
 		const w = options.width || 1;
 		const h = options.height || 1;
@@ -254,7 +256,8 @@ export class EdgeFilter extends RenderStage {
 	setSize( width, height ) {
 
 		// Only resize the RenderTarget — StorageTexture stays at max allocation
-		// (StorageTexture.setSize() breaks textureStore bind groups, Three.js bug #32969)
+		// (see constructor note: pre-allocation is a defensive pattern, retained
+		// after r184 fixed #32969, because #33061 is still open.)
 		this.outputTarget.setSize( width, height );
 		this.outputTarget.texture.needsUpdate = true;
 		this.resW.value = width;
@@ -263,7 +266,7 @@ export class EdgeFilter extends RenderStage {
 		// Update dispatch dimensions
 		this._dispatchX = Math.ceil( width / 16 );
 		this._dispatchY = Math.ceil( height / 16 );
-		this._computeNode.setCount( [ this._dispatchX, this._dispatchY, 1 ] );
+		this._computeNode.dispatchSize = [ this._dispatchX, this._dispatchY, 1 ];
 
 	}
 

package/src/Stages/MotionVector.js

@@ -515,13 +515,13 @@ export class MotionVector extends RenderStage {
 		this._dispatchY = Math.ceil( height / 16 );
 		if ( this._screenSpaceComputeNode ) {
 
-			this._screenSpaceComputeNode.setCount( [ this._dispatchX, this._dispatchY, 1 ] );
+			this._screenSpaceComputeNode.dispatchSize = [ this._dispatchX, this._dispatchY, 1 ];
 
 		}
 
 		if ( this._worldSpaceComputeNode ) {
 
-			this._worldSpaceComputeNode.setCount( [ this._dispatchX, this._dispatchY, 1 ] );
+			this._worldSpaceComputeNode.dispatchSize = [ this._dispatchX, this._dispatchY, 1 ];
 
 		}