rayzee 6.5.0 → 7.1.0

package/src/Processor/QueueManager.js

@@ -0,0 +1,173 @@
+/**
+ * QueueManager.js — wavefront ray queues: active indices (ping-pong), sorted indices, atomic counters.
+ */
+
+import { storage } from 'three/tsl';
+import { StorageInstancedBufferAttribute } from 'three/webgpu';
+
+/** Counter indices — must match ResetCounters kernel */
+export const COUNTER = {
+	ACTIVE_RAY_COUNT: 0,
+	// rays entering current bounce; snapshotted before ACTIVE_RAY_COUNT reset so over-sized dispatch is safe.
+	ENTERING_COUNT: 1,
+	COUNT: 2,
+};
+
+/** Ray flag bits packed into rayBounceFlags (uint) */
+export const RAY_FLAG = {
+	BOUNCE_MASK: 0xFF, // bits 0-7: bounce count (0-255)
+	ACTIVE: 1 << 8, // bit 8: ray is alive
+	SPECULAR: 1 << 9, // bit 9: last bounce was specular
+	INSIDE_MEDIUM: 1 << 10, // bit 10: ray is inside a transmissive medium
+	// bits 11-15: ray type
+	RAY_TYPE_SHIFT: 11,
+	RAY_TYPE_MASK: 0x1F << 11,
+	// bits 16-31: spare per-ray state carried across bounces
+	HAS_HIT_OPAQUE: 1 << 16, // bit 16: ray chain has hit non-transmissive geometry (transparent-bg alpha; megakernel hasHitOpaqueSurface)
+	AUX_LOCKED: 1 << 17, // bit 17: OIDN aux (normal/albedo) locked onto first non-specular hit (megakernel auxLocked)
+};
+
+export class QueueManager {
+
+	/**
+	 * @param {number} maxRays - Maximum number of rays (typically width * height)
+	 */
+	constructor( maxRays = 0 ) {
+
+		this.capacity = 0;
+		this.counters = null;
+		// A/B alternate: one read by current bounce, other written by compaction
+		this.activeIndices = null;
+		this.activeIndicesRO = null;
+		this.pingPong = 0; // 0 = read A / write B, 1 = read B / write A
+
+		if ( maxRays > 0 ) {
+
+			this.allocate( maxRays );
+
+		}
+
+	}
+
+	// capacity must match RayBufferPool.allocatedCapacity
+	allocate( capacity ) {
+
+		this.dispose();
+		this.capacity = capacity;
+
+		// explicit attribute (not attributeArray) so it can be referenced for async readback
+		this._countersAttr = new StorageInstancedBufferAttribute( new Uint32Array( COUNTER.COUNT ), 1 );
+		this.counters = storage( this._countersAttr, 'uint' ).toAtomic();
+
+		// per-bounce ACTIVE_RAY_COUNT snapshots; read back async to size/skip late bounces next frame
+		this.MAX_BOUNCE_SNAPSHOTS = 32;
+		this._bounceCountsAttr = new StorageInstancedBufferAttribute(
+			new Uint32Array( this.MAX_BOUNCE_SNAPSHOTS ), 1,
+		);
+		this.bounceCounts = storage( this._bounceCountsAttr, 'uint' );
+
+		const attrA = new StorageInstancedBufferAttribute( new Uint32Array( capacity ), 1 );
+		const attrB = new StorageInstancedBufferAttribute( new Uint32Array( capacity ), 1 );
+		this._attrA = attrA;
+		this._attrB = attrB;
+
+		this.activeIndices = {
+			a: storage( attrA, 'uint' ),
+			b: storage( attrB, 'uint' ),
+		};
+
+		// RO reuses the same attribute so RW/RO share one GPU buffer
+		this.activeIndicesRO = {
+			a: storage( attrA, 'uint' ).toReadOnly(),
+			b: storage( attrB, 'uint' ).toReadOnly(),
+		};
+
+		this.pingPong = 0;
+
+		const totalBytes = (
+			COUNTER.COUNT * 4 +
+			capacity * 4 * 2
+		);
+
+		console.log(
+			`QueueManager: Allocated capacity=${capacity}, ` +
+			`total=${( totalBytes / ( 1024 * 1024 ) ).toFixed( 1 )} MB`
+		);
+
+	}
+
+	// returns true if reallocation occurred
+	resize( capacity ) {
+
+		if ( capacity <= this.capacity && this.capacity > 0 ) return false;
+		this.allocate( capacity );
+		return true;
+
+	}
+
+	getCounters() {
+
+		return this.counters;
+
+	}
+
+	getActiveReadRO() {
+
+		return this.pingPong === 0 ? this.activeIndicesRO.a : this.activeIndicesRO.b;
+
+	}
+
+	// RW version for compaction input
+	getActiveRead() {
+
+		return this.pingPong === 0 ? this.activeIndices.a : this.activeIndices.b;
+
+	}
+
+	getActiveWrite() {
+
+		return this.pingPong === 0 ? this.activeIndices.b : this.activeIndices.a;
+
+	}
+
+	// raw attribute for `renderer.getArrayBufferAsync(...)` readback
+	getCountersAttribute() {
+
+		return this._countersAttr;
+
+	}
+
+	getBounceCounts() {
+
+		return this.bounceCounts;
+
+	}
+
+	getBounceCountsAttribute() {
+
+		return this._bounceCountsAttr;
+
+	}
+
+	swap() {
+
+		this.pingPong = 1 - this.pingPong;
+
+	}
+
+	resetPingPong() {
+
+		this.pingPong = 0;
+
+	}
+
+	dispose() {
+
+		this.counters = null;
+		this.activeIndices = null;
+		this.activeIndicesRO = null;
+		this.capacity = 0;
+
+	}
+
+}

package/src/Processor/SceneProcessor.js

@@ -297,6 +297,7 @@ export class SceneProcessor {
 			// Store other extracted data
 			this.materials = extractedData.materials;
 			this.materialCount = this.materials.length; // Store material count for feature scanning
+			this.materialTriangleCounts = extractedData.materialTriangleCounts; // Per-material tri count for sort-bin remap
 			this.meshes = extractedData.meshes;
 			this.meshTriangleRanges = extractedData.meshTriangleRanges; // Per-mesh { start, count } for TLAS/BLAS
 			this.maps = extractedData.maps;

package/src/Processor/ShaderBuilder.js

@@ -1,110 +1,29 @@
 /**
- * ShaderBuilder.js
- * Owns TSL shader graph construction and compute node management
- * for the path tracing pipeline.
+ * ShaderBuilder.js — shared scene texture-node factory for the path tracer.
  *
- * "Copy approach": Single compute node writes to 3 write-only StorageTextures.
- * Previous-frame reads use texture() sampling from a MRT RenderTarget
- * (populated by copyTextureToTexture after each dispatch).
- *
- * Texture nodes are created once and updated in-place via .value mutation
- * to preserve compiled shader graph references.
+ * Creates the texture/storage nodes the wavefront kernels read (environment, material map
+ * arrays, previous-frame MRT, adaptive-sampling, gobo/IES) and configures the module-level
+ * shadow/alpha/gobo/IES shader state. Nodes are created once and updated in-place via
+ * .value mutation to preserve compiled shader-graph references.
  */
 
-import { Fn, texture, vec2, float, int, uniform, If,
-	localId, workgroupId } from 'three/tsl';
-import { TextureNode } from 'three/webgpu';
+import { texture } from 'three/tsl';
 import { LinearFilter, DataArrayTexture } from 'three';
-import { pathTracerMain } from '../TSL/PathTracer.js';
 import { setShadowAlbedoMaps, setAlphaShadowsUniform } from '../TSL/LightsDirect.js';
 import { setGoboMapsTexture, setIESProfilesTexture } from '../TSL/LightsCore.js';
-import { BuildTimer } from './BuildTimer.js';
-
-const WG_SIZE = 8;
 
 export class ShaderBuilder {
 
 	constructor() {
 
-		// Single compute node (no dual ping-pong — copy approach)
-		this.computeNode = null;
-
 		// Previous-frame texture nodes (sample from MRT RenderTarget)
 		this.prevColorTexNode = null;
 		this.prevNormalDepthTexNode = null;
 		this.prevAlbedoTexNode = null;
 
-		// Adaptive sampling texture (updated per-frame from context)
-		this.adaptiveSamplingTexNode = null;
-
-		// Tile offset uniforms — pixel origin of the active tile region
-		// Dispatch covers only tile-sized workgroups; offset maps them to image space
-		this.tileOffsetX = uniform( 0, 'int' );
-		this.tileOffsetY = uniform( 0, 'int' );
-
-		// Render dimensions for edge-workgroup bounds checking
-		this.renderWidth = uniform( 1920, 'int' );
-		this.renderHeight = uniform( 1080, 'int' );
-
-		// Dispatch dimensions
-		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;
-
-	}
-
-	/**
-	 * Creates the full compute shader graph from scratch.
-	 *
-	 * @param {Object} config
-	 * @param {Object} config.stage - PathTracer instance
-	 * @param {Object} config.storageTextures - StorageTexturePool
-	 */
-	setupCompute( config ) {
-
-		const { stage, storageTextures } = config;
-
-		const timer = new BuildTimer( 'setupCompute' );
-
-		timer.start( 'Create texture nodes' );
-		const textureNodes = this._createTextureNodes( stage, storageTextures );
-		timer.end( 'Create texture nodes' );
-
-		timer.start( 'Build compute node (TSL)' );
-
-		const width = storageTextures.renderWidth;
-		const height = storageTextures.renderHeight;
-		this._dispatchX = Math.ceil( width / WG_SIZE );
-		this._dispatchY = Math.ceil( height / WG_SIZE );
-
-		this.renderWidth.value = width;
-		this.renderHeight.value = height;
-
-		const writeTex = storageTextures.getWriteTextures();
-
-		this.computeNode = this._buildComputeNode(
-			stage, textureNodes,
-			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();
-
 	}
 
 	updateSceneTextures( stage ) {
@@ -165,98 +84,10 @@ export class ShaderBuilder {
 
 	}
 
-	setSize( width, height ) {
-
-		this._dispatchX = Math.ceil( width / WG_SIZE );
-		this._dispatchY = Math.ceil( height / WG_SIZE );
-
-		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;
-
-		// Reset tile offset (full-screen)
-		this.tileOffsetX.value = 0;
-		this.tileOffsetY.value = 0;
-
-	}
-
-	/**
-	 * Set dispatch to cover only the active tile region.
-	 * Adjusts dispatch count and tile offset so threads map directly to tile pixels.
-	 * @param {number} offsetX - Tile origin X in pixels
-	 * @param {number} offsetY - Tile origin Y in pixels
-	 * @param {number} tileWidth - Tile width in pixels
-	 * @param {number} tileHeight - Tile height in pixels
-	 */
-	setTileDispatch( offsetX, offsetY, tileWidth, tileHeight ) {
-
-		this.tileOffsetX.value = offsetX;
-		this.tileOffsetY.value = offsetY;
-
-		const dispatchX = Math.ceil( tileWidth / WG_SIZE );
-		const dispatchY = Math.ceil( tileHeight / WG_SIZE );
-
-		if ( this.computeNode ) {
-
-			this._dispatchSize[ 0 ] = dispatchX;
-			this._dispatchSize[ 1 ] = dispatchY;
-			this.computeNode.dispatchSize = this._dispatchSize;
-
-		}
-
-	}
-
-	/**
-	 * Reset dispatch to full-screen (no tiling).
-	 */
-	setFullScreenDispatch() {
-
-		this.tileOffsetX.value = 0;
-		this.tileOffsetY.value = 0;
-
-		if ( this.computeNode ) {
-
-			this._dispatchSize[ 0 ] = this._dispatchX;
-			this._dispatchSize[ 1 ] = this._dispatchY;
-			this.computeNode.dispatchSize = this._dispatchSize;
-
-		}
-
-	}
-
-	/**
-	 * 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 ) {
-
-		if ( this._compiled || ! this.computeNode || ! renderer ) return;
-
-		this._compiled = true;
-		renderer.compute( this.computeNode );
-
-	}
-
-	// ===== PRIVATE =====
-
-	_createTextureNodes( stage, storageTextures ) {
+	// Creates the shared scene texture nodes (env, material maps, prev-frame, adaptive, gobo, IES)
+	// + configures the module-level shadow/alpha/gobo/IES shader state read by the wavefront kernels.
+	// Call from setupMaterial before the kernels are built.
+	createSceneTextureNodes( stage, storageTextures ) {
 
 		const triStorage = stage.triangleStorageNode;
 		const bvhStorage = stage.bvhStorageNode;
@@ -270,14 +101,6 @@ export class ShaderBuilder {
 
 		const envTex = texture( stage.environment.environmentTexture );
 
-		// Adaptive sampling texture
-		const adaptiveSamplingTex = new TextureNode();
-		this.adaptiveSamplingTexNode = adaptiveSamplingTex;
-
-		// 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();
 		this.prevColorTexNode = texture( readTextures.color );
@@ -319,7 +142,7 @@ export class ShaderBuilder {
 
 		const result = {
 			triStorage, bvhStorage, matStorage, lightBufferStorage,
-			envTex, adaptiveSamplingTex, envCDFStorage,
+			envTex,
 			albedoMapsTex, normalMapsTex, bumpMapsTex,
 			metalnessMapsTex, roughnessMapsTex, emissiveMapsTex, displacementMapsTex,
 			goboMapsTex, iesProfilesTex,
@@ -330,141 +153,12 @@ export class ShaderBuilder {
 
 	}
 
-	/**
-	 * Build a single compute node.
-	 * Previous-frame reads use texture() nodes bound to MRT RenderTarget textures.
-	 */
-	_buildComputeNode( stage, textureNodes,
-		writeColorTex, writeNDTex, writeAlbedoTex ) {
-
-		const {
-			triStorage, bvhStorage, matStorage, lightBufferStorage,
-			envTex, adaptiveSamplingTex, envCDFStorage,
-			albedoMapsTex, normalMapsTex, bumpMapsTex,
-			metalnessMapsTex, roughnessMapsTex, emissiveMapsTex, displacementMapsTex,
-		} = textureNodes;
-
-		const tileOffsetX = this.tileOffsetX;
-		const tileOffsetY = this.tileOffsetY;
-		const renderWidth = this.renderWidth;
-		const renderHeight = this.renderHeight;
-
-		const prevColorTexNode = this.prevColorTexNode;
-		const prevNormalDepthTexNode = this.prevNormalDepthTexNode;
-		const prevAlbedoTexNode = this.prevAlbedoTexNode;
-
-		const computeFn = Fn( () => {
-
-			// Map thread to image-space pixel via tile offset
-			const gx = tileOffsetX.add( int( workgroupId.x ).mul( WG_SIZE ) ).add( int( localId.x ) );
-			const gy = tileOffsetY.add( int( workgroupId.y ).mul( WG_SIZE ) ).add( int( localId.y ) );
-
-			// Bounds check only needed for edge workgroups that overshoot render dimensions
-			If( gx.lessThan( renderWidth ).and( gy.lessThan( renderHeight ) ), () => {
-
-				const pixelCoord = vec2( float( gx ).add( 0.5 ), float( gy ).add( 0.5 ) );
-
-				pathTracerMain( {
-					pixelCoord,
-					writeColorTex, writeNDTex, writeAlbedoTex,
-					// Previous-frame textures from MRT RenderTarget (sampled via texture())
-					prevAccumTexture: prevColorTexNode,
-					prevNormalDepthTexture: prevNormalDepthTexNode,
-					prevAlbedoTexture: prevAlbedoTexNode,
-					resolution: stage.resolution,
-					frame: stage.frame,
-					samplesPerPixel: stage.samplesPerPixel,
-					visMode: stage.visMode,
-					cameraWorldMatrix: stage.cameraWorldMatrix,
-					cameraProjectionMatrixInverse: stage.cameraProjectionMatrixInverse,
-					cameraViewMatrix: stage.cameraViewMatrix,
-					cameraProjectionMatrix: stage.cameraProjectionMatrix,
-					bvhBuffer: bvhStorage,
-					triangleBuffer: triStorage,
-					materialBuffer: matStorage,
-					albedoMaps: albedoMapsTex,
-					normalMaps: normalMapsTex,
-					bumpMaps: bumpMapsTex,
-					metalnessMaps: metalnessMapsTex,
-					roughnessMaps: roughnessMapsTex,
-					emissiveMaps: emissiveMapsTex,
-					displacementMaps: displacementMapsTex,
-					directionalLightsBuffer: stage.directionalLightsBufferNode,
-					numDirectionalLights: stage.numDirectionalLights,
-					areaLightsBuffer: stage.areaLightsBufferNode,
-					numAreaLights: stage.numAreaLights,
-					pointLightsBuffer: stage.pointLightsBufferNode,
-					numPointLights: stage.numPointLights,
-					spotLightsBuffer: stage.spotLightsBufferNode,
-					numSpotLights: stage.numSpotLights,
-					envTexture: envTex,
-					environmentIntensity: stage.environmentIntensity,
-					envMatrix: stage.environmentMatrix,
-					envCDFBuffer: envCDFStorage,
-					envTotalSum: stage.envTotalSum,
-					envCompensationDelta: stage.envCompensationDelta,
-					envResolution: stage.envResolution,
-					enableEnvironmentLight: stage.enableEnvironment,
-					useEnvMapIS: stage.useEnvMapIS,
-					groundProjectionEnabled: stage.groundProjectionEnabled,
-					groundProjectionRadius: stage.groundProjectionRadius,
-					groundProjectionHeight: stage.groundProjectionHeight,
-					maxBounceCount: stage.maxBounces,
-					transmissiveBounces: stage.transmissiveBounces,
-					maxSubsurfaceSteps: stage.maxSubsurfaceSteps,
-					showBackground: stage.showBackground,
-					transparentBackground: stage.transparentBackground,
-					backgroundIntensity: stage.backgroundIntensity,
-					fireflyThreshold: stage.fireflyThreshold,
-					globalIlluminationIntensity: stage.globalIlluminationIntensity,
-					enableEmissiveTriangleSampling: stage.enableEmissiveTriangleSampling,
-					emissiveTriangleBuffer: lightBufferStorage,
-					emissiveTriangleCount: stage.emissiveTriangleCount,
-					emissiveTotalPower: stage.emissiveTotalPower,
-					emissiveBoost: stage.emissiveBoost,
-					emissiveVec4Offset: stage.emissiveVec4Offset,
-					lightBVHBuffer: lightBufferStorage,
-					lightBVHNodeCount: stage.lightBVHNodeCount,
-					debugVisScale: stage.debugVisScale,
-					enableAccumulation: stage.enableAccumulation,
-					hasPreviousAccumulated: stage.hasPreviousAccumulated,
-					accumulationAlpha: stage.accumulationAlpha,
-					cameraIsMoving: stage.cameraIsMoving,
-					useAdaptiveSampling: stage.useAdaptiveSampling,
-					adaptiveSamplingTexture: adaptiveSamplingTex,
-					adaptiveSamplingMin: stage.adaptiveSamplingMin,
-					adaptiveSamplingMax: stage.adaptiveSamplingMax,
-					enableDOF: stage.enableDOF,
-					focalLength: stage.focalLength,
-					aperture: stage.aperture,
-					focusDistance: stage.focusDistance,
-					sceneScale: stage.sceneScale,
-					apertureScale: stage.apertureScale,
-					anamorphicRatio: stage.anamorphicRatio,
-				} );
-
-			} );
-
-		} );
-
-		return computeFn().compute(
-			[ this._dispatchX, this._dispatchY, 1 ],
-			[ WG_SIZE, WG_SIZE, 1 ]
-		);
-
-	}
-
 	dispose() {
 
-		this.computeNode?.dispose();
-
-		this.computeNode = null;
 		this.prevColorTexNode = null;
 		this.prevNormalDepthTexNode = null;
 		this.prevAlbedoTexNode = null;
-		this.adaptiveSamplingTexNode = null;
 		this._sceneTextureNodes = null;
-		this._compiled = false;
 
 	}
 

package/src/Processor/StorageTexturePool.js

@@ -13,11 +13,12 @@
  */
 
 import { StorageTexture, RenderTarget } from 'three/webgpu';
-import { RGBAFormat, FloatType, LinearFilter, NearestFilter } from 'three';
+import { RGBAFormat, FloatType, LinearFilter, NearestFilter, Box2, Vector2 } from 'three';
+import { MAX_STORAGE_TEXTURE_SIZE } from '../EngineDefaults.js';
 
-function createWriteStorageTex( width, height ) {
+function createWriteStorageTex() {
 
-	const tex = new StorageTexture( width, height );
+	const tex = new StorageTexture( MAX_STORAGE_TEXTURE_SIZE, MAX_STORAGE_TEXTURE_SIZE );
 	tex.type = FloatType;
 	tex.format = RGBAFormat;
 	tex.minFilter = LinearFilter;
@@ -44,6 +45,9 @@ export class StorageTexturePool {
 		this.renderWidth = 0;
 		this.renderHeight = 0;
 
+		// Reused srcRegion for copies out of the over-allocated StorageTextures.
+		this._srcRegion = new Box2( new Vector2( 0, 0 ), new Vector2( 0, 0 ) );
+
 		if ( width > 0 && height > 0 ) {
 
 			this.create( width, height );
@@ -59,10 +63,10 @@ export class StorageTexturePool {
 		this.renderWidth = width;
 		this.renderHeight = height;
 
-		// Write-only StorageTextures
-		this.writeColor = createWriteStorageTex( width, height );
-		this.writeNormalDepth = createWriteStorageTex( width, height );
-		this.writeAlbedo = createWriteStorageTex( width, height );
+		// Write-only StorageTextures allocated at max — never resized (see resize crash fix).
+		this.writeColor = createWriteStorageTex();
+		this.writeNormalDepth = createWriteStorageTex();
+		this.writeAlbedo = createWriteStorageTex();
 
 		// Readable MRT RenderTarget (3 color attachments, no depth/stencil)
 		this.readTarget = new RenderTarget( width, height, {
@@ -85,13 +89,22 @@ export class StorageTexturePool {
 
 	ensureSize( width, height ) {
 
-		if ( this.renderWidth !== width || this.renderHeight !== height || ! this.writeColor ) {
+		if ( ! this.writeColor ) {
 
 			this.create( width, height );
 			return true;
 
 		}
 
+		if ( this.renderWidth !== width || this.renderHeight !== height ) {
+
+			// Resize only the readTarget — never dispose/recreate the write StorageTextures
+			// (that destroys the texture the compute bind group holds → submit crash).
+			this.setSize( width, height );
+			return true;
+
+		}
+
 		return false;
 
 	}
@@ -131,9 +144,13 @@ export class StorageTexturePool {
 	 */
 	copyToReadTargets( renderer ) {
 
-		renderer.copyTextureToTexture( this.writeColor, this.readTarget.textures[ 0 ] );
-		renderer.copyTextureToTexture( this.writeNormalDepth, this.readTarget.textures[ 1 ] );
-		renderer.copyTextureToTexture( this.writeAlbedo, this.readTarget.textures[ 2 ] );
+		// Source write StorageTextures are over-allocated at the max size; the Box2 region
+		// restricts the copy to the active render size so source and destination extents match.
+		this._srcRegion.max.set( this.renderWidth, this.renderHeight );
+
+		renderer.copyTextureToTexture( this.writeColor, this.readTarget.textures[ 0 ], this._srcRegion );
+		renderer.copyTextureToTexture( this.writeNormalDepth, this.readTarget.textures[ 1 ], this._srcRegion );
+		renderer.copyTextureToTexture( this.writeAlbedo, this.readTarget.textures[ 2 ], this._srcRegion );
 
 	}
 
@@ -163,10 +180,7 @@ export class StorageTexturePool {
 		this.renderWidth = width;
 		this.renderHeight = height;
 
-		this.writeColor?.setSize( width, height );
-		this.writeNormalDepth?.setSize( width, height );
-		this.writeAlbedo?.setSize( width, height );
-
+		// Write StorageTextures stay at max allocation — never resized (see resize crash fix).
 		if ( this.readTarget ) {
 
 			this.readTarget.setSize( width, height );