rayzee 6.4.0 → 7.0.0

package/src/Processor/utils.js

@@ -27,21 +27,10 @@ export const updateStats = ( statsUpdate ) => {
 
 };
 
-/**
- * Convert raw frameCount to user-facing sample count.
- * In tiled mode, one "sample pass" spans all tiles.
- */
+// Raw frameCount is the user-facing sample count (one full-frame pass per frame).
 export function getDisplaySamples( pathTracerStage ) {
 
-	const frameCount = pathTracerStage.frameCount || 0;
-	if ( pathTracerStage.renderMode?.value === 1 && frameCount > 0 ) {
-
-		const totalTiles = pathTracerStage.tileManager?.totalTilesCache || 1;
-		return 1 + Math.floor( ( frameCount - 1 ) / totalTiles );
-
-	}
-
-	return frameCount;
+	return pathTracerStage.frameCount || 0;
 
 }
 
@@ -214,9 +203,9 @@ export function generateMaterialSpheres( rows = 5, columns = 5, spacing = 1.2 )
 
 // ── Path Tracer Utilities (formerly PathTracerUtils static class) ──
 
-export function updateCompletionThreshold( renderMode, maxFrames, totalTiles ) {
+export function updateCompletionThreshold( renderMode, maxFrames ) {
 
-	return renderMode === 1 ? totalTiles * maxFrames : maxFrames;
+	return maxFrames;
 
 }
 
@@ -335,33 +324,10 @@ export function areValuesEqual( a, b ) {
 
 }
 
-export function calculateAccumulationAlpha( frameValue, renderMode, totalTiles, isInteractionMode = false ) {
-
-	if ( isInteractionMode ) {
-
-		return 1.0;
-
-	}
-
-	if ( renderMode === 0 ) {
-
-		return 1.0 / ( frameValue + 1 );
-
-	} else {
-
-		if ( frameValue === 0 ) {
-
-			return 1.0;
-
-		} else {
-
-			const completedTileCycles = Math.floor( ( frameValue - 1 ) / totalTiles );
-			const totalSamples = 1 + completedTileCycles;
-			return 1.0 / ( totalSamples + 1 );
+export function calculateAccumulationAlpha( frameValue, isInteractionMode = false ) {
 
-		}
-
-	}
+	// Full-frame progressive accumulation: each frame is one complete pass.
+	return isInteractionMode ? 1.0 : 1.0 / ( frameValue + 1 );
 
 }
 
@@ -416,12 +382,6 @@ export function optimizeShaderDefines( defines, state ) {
 
 	const optimized = { ...defines };
 
-	if ( ! state.useAdaptiveSampling ) {
-
-		delete optimized.ENABLE_ADAPTIVE_SAMPLING;
-
-	}
-
 	if ( ! state.enableAccumulation ) {
 
 		delete optimized.ENABLE_ACCUMULATION;
@@ -438,49 +398,6 @@ export function optimizeShaderDefines( defines, state ) {
 
 }
 
-export function calculateSpiralOrder( tiles, center = null ) {
-
-	const totalTiles = tiles * tiles;
-	const centerPoint = center || new Vector2( ( tiles - 1 ) / 2, ( tiles - 1 ) / 2 );
-	const tilePositions = [];
-
-	for ( let i = 0; i < totalTiles; i ++ ) {
-
-		const x = i % tiles;
-		const y = Math.floor( i / tiles );
-		const distance = Math.sqrt(
-			Math.pow( x - centerPoint.x, 2 ) +
-			Math.pow( y - centerPoint.y, 2 )
-		);
-		const angle = Math.atan( y - centerPoint.y, x - centerPoint.x );
-
-		tilePositions.push( {
-			index: i,
-			x,
-			y,
-			distance,
-			angle
-		} );
-
-	}
-
-	tilePositions.sort( ( a, b ) => {
-
-		const distanceDiff = a.distance - b.distance;
-		if ( Math.abs( distanceDiff ) < 0.01 ) {
-
-			return a.angle - b.angle;
-
-		}
-
-		return distanceDiff;
-
-	} );
-
-	return tilePositions.map( pos => pos.index );
-
-}
-
 export function clamp( value, min, max ) {
 
 	return Math.min( Math.max( value, min ), max );
@@ -493,31 +410,15 @@ export function lerp( a, b, t ) {
 
 }
 
-export function isRenderComplete( frameValue, renderMode, maxFrames, totalTiles ) {
-
-	if ( renderMode === 0 ) {
-
-		return frameValue >= maxFrames;
-
-	} else {
-
-		return frameValue >= maxFrames * totalTiles;
+export function isRenderComplete( frameValue, renderMode, maxFrames ) {
 
-	}
+	return frameValue >= maxFrames;
 
 }
 
-export function getCurrentSampleCount( frameValue, renderMode, totalTiles ) {
-
-	if ( renderMode === 0 ) {
+export function getCurrentSampleCount( frameValue ) {
 
-		return frameValue;
-
-	} else {
-
-		return Math.floor( frameValue / totalTiles );
-
-	}
+	return frameValue;
 
 }
 

package/src/RenderSettings.js

@@ -18,6 +18,7 @@ const SETTING_ROUTES = {
 	maxBounces: { uniform: 'maxBounces', reset: true },
 	samplesPerPixel: { uniform: 'samplesPerPixel', reset: true },
 	transmissiveBounces: { uniform: 'transmissiveBounces', reset: true },
+	maxSubsurfaceSteps: { uniform: 'maxSubsurfaceSteps', reset: true },
 	environmentIntensity: { uniform: 'environmentIntensity', reset: true },
 	backgroundIntensity: { uniform: 'backgroundIntensity', reset: true },
 	showBackground: { uniform: 'showBackground', reset: true },
@@ -39,8 +40,6 @@ const SETTING_ROUTES = {
 	emissiveBoost: { uniform: 'emissiveBoost', reset: true },
 	visMode: { uniform: 'visMode', reset: true },
 	debugVisScale: { uniform: 'debugVisScale', reset: true },
-	useAdaptiveSampling: { uniform: 'useAdaptiveSampling', reset: true },
-	adaptiveSamplingMax: { uniform: 'adaptiveSamplingMax', reset: true },
 
 	// ── Multi-stage / special handling ────────────────────────────
 
@@ -62,7 +61,6 @@ const SETTING_ROUTES = {
  */
 const DEFAULTS_KEY_MAP = {
 	bounces: 'maxBounces',
-	adaptiveSampling: 'useAdaptiveSampling',
 	debugMode: 'visMode',
 };
 

package/src/Stages/ASVGF.js

@@ -2,10 +2,10 @@ import { Fn, vec3, vec4, float, int, uint, ivec2, uvec2, uniform,
 	If, dot, max, min, abs, mix, pow, exp,
 	textureLoad, textureStore, workgroupArray, workgroupBarrier, localId, workgroupId } from 'three/tsl';
 import { RenderTarget, TextureNode, StorageTexture } from 'three/webgpu';
-import { HalfFloatType, FloatType, RGBAFormat, NearestFilter, LinearFilter } from 'three';
+import { HalfFloatType, FloatType, RGBAFormat, NearestFilter, LinearFilter, Box2, Vector2 } from 'three';
 import { RenderStage, StageExecutionMode } from '../Pipeline/RenderStage.js';
 import { luminance } from '../TSL/Common.js';
-import { ALBEDO_EPS } from '../EngineDefaults.js';
+import { ALBEDO_EPS, MAX_STORAGE_TEXTURE_SIZE } from '../EngineDefaults.js';
 
 /**
  * ASVGF — SVGF temporal + spatial denoising with albedo demodulation.
@@ -57,30 +57,61 @@ export class ASVGF extends RenderStage {
 		// FloatType for ping-pong: demodulated lighting on dark materials
 		// (lighting ≈ color/0.01) exceeds HalfFloat's 65k cap on HDR.
 		// LinearFilter is required for textureLoad codegen on StorageTextures.
-		this._temporalTexA = new StorageTexture( w, h );
+		this._temporalTexA = new StorageTexture( MAX_STORAGE_TEXTURE_SIZE, MAX_STORAGE_TEXTURE_SIZE );
 		this._temporalTexA.type = FloatType;
 		this._temporalTexA.format = RGBAFormat;
 		this._temporalTexA.minFilter = LinearFilter;
 		this._temporalTexA.magFilter = LinearFilter;
 
-		this._temporalTexB = new StorageTexture( w, h );
+		this._temporalTexB = new StorageTexture( MAX_STORAGE_TEXTURE_SIZE, MAX_STORAGE_TEXTURE_SIZE );
 		this._temporalTexB.type = FloatType;
 		this._temporalTexB.format = RGBAFormat;
 		this._temporalTexB.minFilter = LinearFilter;
 		this._temporalTexB.magFilter = LinearFilter;
 
-		this._outputModulatedTex = new StorageTexture( w, h );
+		this._outputModulatedTex = new StorageTexture( MAX_STORAGE_TEXTURE_SIZE, MAX_STORAGE_TEXTURE_SIZE );
 		this._outputModulatedTex.type = FloatType;
 		this._outputModulatedTex.format = RGBAFormat;
 		this._outputModulatedTex.minFilter = LinearFilter;
 		this._outputModulatedTex.magFilter = LinearFilter;
 
-		this._gradientStorageTex = new StorageTexture( w, h );
+		this._gradientStorageTex = new StorageTexture( MAX_STORAGE_TEXTURE_SIZE, MAX_STORAGE_TEXTURE_SIZE );
 		this._gradientStorageTex.type = HalfFloatType;
 		this._gradientStorageTex.format = RGBAFormat;
 		this._gradientStorageTex.minFilter = LinearFilter;
 		this._gradientStorageTex.magFilter = LinearFilter;
 
+		// Over-allocated StorageTextures are sampled by UV downstream; copy the
+		// active region into right-sized RTs and publish those instead.
+		this._srcRegion = new Box2( new Vector2( 0, 0 ), new Vector2( 0, 0 ) );
+
+		this._demodulatedRT = new RenderTarget( w, h, {
+			type: FloatType,
+			format: RGBAFormat,
+			minFilter: LinearFilter,
+			magFilter: LinearFilter,
+			depthBuffer: false,
+			stencilBuffer: false
+		} );
+
+		this._outputRT = new RenderTarget( w, h, {
+			type: FloatType,
+			format: RGBAFormat,
+			minFilter: LinearFilter,
+			magFilter: LinearFilter,
+			depthBuffer: false,
+			stencilBuffer: false
+		} );
+
+		this._gradientRT = new RenderTarget( w, h, {
+			type: HalfFloatType,
+			format: RGBAFormat,
+			minFilter: LinearFilter,
+			magFilter: LinearFilter,
+			depthBuffer: false,
+			stencilBuffer: false
+		} );
+
 		// FloatType to match pathtracer:color (PT MRT). copyTextureToTexture
 		// requires identical formats.
 		this._prevColorRT = new RenderTarget( w, h, {
@@ -105,7 +136,7 @@ export class ASVGF extends RenderStage {
 		this.showHeatmap = false;
 		this.debugMode = uniform( 0, 'int' );
 
-		this._heatmapStorageTex = new StorageTexture( w, h );
+		this._heatmapStorageTex = new StorageTexture( MAX_STORAGE_TEXTURE_SIZE, MAX_STORAGE_TEXTURE_SIZE );
 		this._heatmapStorageTex.type = FloatType;
 		this._heatmapStorageTex.format = RGBAFormat;
 		this._heatmapStorageTex.minFilter = NearestFilter;
@@ -581,8 +612,9 @@ export class ASVGF extends RenderStage {
 		const img = colorTex.image;
 		if ( img && img.width > 0 && img.height > 0 ) {
 
-			if ( img.width !== this._temporalTexA.image.width ||
-				img.height !== this._temporalTexA.image.height ) {
+			// Compare against an active-size RT, not the fixed-2048 StorageTexture.
+			if ( img.width !== this._outputRT.width ||
+				img.height !== this._outputRT.height ) {
 
 				this.setSize( img.width, img.height );
 
@@ -647,9 +679,21 @@ export class ASVGF extends RenderStage {
 
 		}
 
-		context.setTexture( 'asvgf:demodulated', writeTemporal );
-		context.setTexture( 'asvgf:output', this._outputModulatedTex );
-		context.setTexture( 'asvgf:gradient', this._gradientStorageTex );
+		// Copy active region out of the over-allocated StorageTextures into
+		// right-sized RTs; downstream stages UV-sample these.
+		this._srcRegion.max.set( this.resW.value, this.resH.value );
+
+		this.renderer.copyTextureToTexture( writeTemporal, this._demodulatedRT.texture, this._srcRegion );
+		this.renderer.copyTextureToTexture( this._outputModulatedTex, this._outputRT.texture, this._srcRegion );
+		if ( needsGradient ) {
+
+			this.renderer.copyTextureToTexture( this._gradientStorageTex, this._gradientRT.texture, this._srcRegion );
+
+		}
+
+		context.setTexture( 'asvgf:demodulated', this._demodulatedRT.texture );
+		context.setTexture( 'asvgf:output', this._outputRT.texture );
+		context.setTexture( 'asvgf:gradient', this._gradientRT.texture );
 
 		this.currentMoments = 1 - this.currentMoments;
 
@@ -665,7 +709,8 @@ export class ASVGF extends RenderStage {
 			this._heatmapGradientTexNode.value = this._gradientStorageTex;
 
 			this.renderer.compute( this._heatmapComputeNode );
-			this.renderer.copyTextureToTexture( this._heatmapStorageTex, this.heatmapTarget.texture );
+			this._srcRegion.max.set( this.heatmapTarget.width, this.heatmapTarget.height );
+			this.renderer.copyTextureToTexture( this._heatmapStorageTex, this.heatmapTarget.texture, this._srcRegion );
 
 		}
 
@@ -704,13 +749,17 @@ export class ASVGF extends RenderStage {
 
 	setSize( width, height ) {
 
-		this._temporalTexA.setSize( width, height );
-		this._temporalTexB.setSize( width, height );
-		this._outputModulatedTex.setSize( width, height );
-		this._gradientStorageTex.setSize( width, height );
+		// StorageTextures stay at max alloc — see resize crash fix (three.js #33061).
+		this._demodulatedRT.setSize( width, height );
+		this._demodulatedRT.texture.needsUpdate = true;
+		this._outputRT.setSize( width, height );
+		this._outputRT.texture.needsUpdate = true;
+		this._gradientRT.setSize( width, height );
+		this._gradientRT.texture.needsUpdate = true;
 		this._prevColorRT.setSize( width, height );
-		this._heatmapStorageTex.setSize( width, height );
+		this._prevColorRT.texture.needsUpdate = true;
 		this.heatmapTarget.setSize( width, height );
+		this.heatmapTarget.texture.needsUpdate = true;
 		this.resW.value = width;
 		this.resH.value = height;
 
@@ -721,8 +770,12 @@ export class ASVGF extends RenderStage {
 		this._temporalNodeB.dispatchSize = [ this._dispatchX, this._dispatchY, 1 ];
 		this._heatmapComputeNode.dispatchSize = [ this._dispatchX, this._dispatchY, 1 ];
 
-		// Buffers reallocated → re-run first-frame compile and re-seed cache.
-		this._compiled = false;
+		// StorageTextures are over-allocated (never reallocated on resize), so the
+		// compute kernels stay valid — do NOT reset _compiled. Re-running the warmup
+		// would dispatch both temporal ping-pong nodes while _readTemporalTexNode still
+		// aliases one node's write target, producing a "write-only storage +
+		// TextureBinding in same synchronization scope" validation error.
+		// Only the size-dependent prev-color cache needs re-seeding.
 		this._prevColorReady = false;
 
 	}
@@ -743,6 +796,9 @@ export class ASVGF extends RenderStage {
 		this._temporalTexB?.dispose();
 		this._outputModulatedTex?.dispose();
 		this._gradientStorageTex?.dispose();
+		this._demodulatedRT?.dispose();
+		this._outputRT?.dispose();
+		this._gradientRT?.dispose();
 		this._prevColorRT?.dispose();
 		this._heatmapComputeNode?.dispose();
 		this._heatmapStorageTex?.dispose();

package/src/Stages/BilateralFilter.js

@@ -1,10 +1,10 @@
 import { Fn, wgslFn, vec3, vec4, float, int, uint, ivec2, uvec2, uniform, If, max, sqrt,
 	textureLoad, textureStore, localId, workgroupId } from 'three/tsl';
-import { TextureNode, StorageTexture } from 'three/webgpu';
-import { HalfFloatType, RGBAFormat, LinearFilter } from 'three';
+import { RenderTarget, TextureNode, StorageTexture } from 'three/webgpu';
+import { HalfFloatType, RGBAFormat, LinearFilter, Box2, Vector2 } from 'three';
 import { RenderStage, StageExecutionMode } from '../Pipeline/RenderStage.js';
 import { luminance } from '../TSL/Common.js';
-import { ALBEDO_EPS } from '../EngineDefaults.js';
+import { ALBEDO_EPS, MAX_STORAGE_TEXTURE_SIZE } from '../EngineDefaults.js';
 
 // SVGF bilateral edge-stopping weight. All three φ params are relative
 // tolerances (unitless fractions) so the filter is scale-invariant across
@@ -83,19 +83,35 @@ export class BilateralFilter extends RenderStage {
 		const w = options.width || 1;
 		const h = options.height || 1;
 
+		// Pre-allocate StorageTextures at max — defensive against three.js #33061
+		// (TSL compute pipeline keeps a stale GPUTextureView after setSize()).
+
 		// LinearFilter required for textureLoad codegen on StorageTextures.
-		this._storageTexA = new StorageTexture( w, h );
+		this._storageTexA = new StorageTexture( MAX_STORAGE_TEXTURE_SIZE, MAX_STORAGE_TEXTURE_SIZE );
 		this._storageTexA.type = HalfFloatType;
 		this._storageTexA.format = RGBAFormat;
 		this._storageTexA.minFilter = LinearFilter;
 		this._storageTexA.magFilter = LinearFilter;
 
-		this._storageTexB = new StorageTexture( w, h );
+		this._storageTexB = new StorageTexture( MAX_STORAGE_TEXTURE_SIZE, MAX_STORAGE_TEXTURE_SIZE );
 		this._storageTexB.type = HalfFloatType;
 		this._storageTexB.format = RGBAFormat;
 		this._storageTexB.minFilter = LinearFilter;
 		this._storageTexB.magFilter = LinearFilter;
 
+		this._srcRegion = new Box2( new Vector2( 0, 0 ), new Vector2( 0, 0 ) );
+
+		// Active-size RT published downstream; over-allocated storage tex sampled
+		// by UV would read the wrong region.
+		this._outputTarget = new RenderTarget( w, h, {
+			type: HalfFloatType,
+			format: RGBAFormat,
+			minFilter: LinearFilter,
+			magFilter: LinearFilter,
+			depthBuffer: false,
+			stencilBuffer: false
+		} );
+
 		this._compiled = false;
 
 		this._dispatchX = Math.ceil( w / 8 );
@@ -245,8 +261,9 @@ export class BilateralFilter extends RenderStage {
 		const img = inputTex.image;
 		if ( img && img.width > 0 && img.height > 0 ) {
 
-			if ( img.width !== this._storageTexA.image.width ||
-				img.height !== this._storageTexA.image.height ) {
+			// Compare against an active-size RT, not the fixed-2048 StorageTexture.
+			if ( img.width !== this._outputTarget.width ||
+				img.height !== this._outputTarget.height ) {
 
 				this.setSize( img.width, img.height );
 
@@ -295,7 +312,12 @@ export class BilateralFilter extends RenderStage {
 
 		}
 
-		context.setTexture( 'bilateralFiltering:output', readTex );
+		// Copy the final result out of the over-allocated StorageTexture into
+		// the active-size RenderTarget; downstream stages UV-sample the latter.
+		this._srcRegion.max.set( this._outputTarget.width, this._outputTarget.height );
+		this.renderer.copyTextureToTexture( readTex, this._outputTarget.texture, this._srcRegion );
+
+		context.setTexture( 'bilateralFiltering:output', this._outputTarget.texture );
 
 	}
 
@@ -313,8 +335,9 @@ export class BilateralFilter extends RenderStage {
 
 	setSize( width, height ) {
 
-		this._storageTexA.setSize( width, height );
-		this._storageTexB.setSize( width, height );
+		// StorageTextures stay at their max allocation (see constructor).
+		this._outputTarget.setSize( width, height );
+		this._outputTarget.texture.needsUpdate = true;
 		this.resW.value = width;
 		this.resH.value = height;
 
@@ -338,6 +361,7 @@ export class BilateralFilter extends RenderStage {
 		this._computeNodeB?.dispose();
 		this._storageTexA?.dispose();
 		this._storageTexB?.dispose();
+		this._outputTarget?.dispose();
 		this._readTexNode?.dispose();
 		this._normalDepthTexNode?.dispose();
 		this._albedoTexNode?.dispose();

package/src/Stages/EdgeFilter.js

@@ -5,6 +5,7 @@ import { RenderTarget, TextureNode, StorageTexture } from 'three/webgpu';
 import { HalfFloatType, RGBAFormat, NearestFilter, Box2, Vector2 } from 'three';
 import { RenderStage, StageExecutionMode } from '../Pipeline/RenderStage.js';
 import { REC709_LUMINANCE_COEFFICIENTS } from '../TSL/Common.js';
+import { MAX_STORAGE_TEXTURE_SIZE } from '../EngineDefaults.js';
 
 /**
  * WebGPU Edge-Aware Filtering Stage (Compute Shader).
@@ -50,11 +51,10 @@ export class EdgeFilter extends RenderStage {
 
 		// Pre-allocate StorageTexture at max — defensive against three.js #33061
 		// (TSL compute pipeline re-compile returns zeros after resize).
-		const MAX_STORAGE_SIZE = 2048;
 		const w = options.width || 1;
 		const h = options.height || 1;
 
-		this._outputStorageTex = new StorageTexture( MAX_STORAGE_SIZE, MAX_STORAGE_SIZE );
+		this._outputStorageTex = new StorageTexture( MAX_STORAGE_TEXTURE_SIZE, MAX_STORAGE_TEXTURE_SIZE );
 		this._outputStorageTex.type = HalfFloatType;
 		this._outputStorageTex.format = RGBAFormat;
 		this._outputStorageTex.minFilter = NearestFilter;
@@ -243,7 +243,6 @@ export class EdgeFilter extends RenderStage {
 
 		// Copy out of the over-allocated StorageTexture into the right-sized
 		// RenderTarget; downstream stages can sample the latter.
-		this._srcRegion.min.set( 0, 0 );
 		this._srcRegion.max.set( this.outputTarget.width, this.outputTarget.height );
 		this.renderer.copyTextureToTexture( this._outputStorageTex, this.outputTarget.texture, this._srcRegion );
 

package/src/Stages/MotionVector.js

@@ -1,8 +1,9 @@
 import { Fn, vec2, vec3, vec4, float, int, uint, ivec2, uvec2, uniform, If, normalize, mat3,
 	textureLoad, textureStore, workgroupId, localId } from 'three/tsl';
 import { RenderTarget, TextureNode, StorageTexture } from 'three/webgpu';
-import { HalfFloatType, RGBAFormat, NearestFilter, Matrix4 } from 'three';
+import { HalfFloatType, RGBAFormat, NearestFilter, Matrix4, Box2, Vector2 } from 'three';
 import { RenderStage, StageExecutionMode } from '../Pipeline/RenderStage.js';
+import { MAX_STORAGE_TEXTURE_SIZE } from '../EngineDefaults.js';
 
 /**
  * WebGPU Motion Vector Stage (Compute Shader)
@@ -89,19 +90,24 @@ export class MotionVector extends RenderStage {
 		// Input texture node (swappable — no shader recompile)
 		this._normalDepthTexNode = new TextureNode();
 
-		// Write-only StorageTextures (compute output)
-		this._screenSpaceStorageTex = new StorageTexture( width, height );
+		// Write-only StorageTextures (compute output).
+		// Pre-allocate at max — StorageTexture.setSize() destroys the GPU texture
+		// while the compute bind group keeps the stale view (three.js #33061).
+		this._screenSpaceStorageTex = new StorageTexture( MAX_STORAGE_TEXTURE_SIZE, MAX_STORAGE_TEXTURE_SIZE );
 		this._screenSpaceStorageTex.type = HalfFloatType;
 		this._screenSpaceStorageTex.format = RGBAFormat;
 		this._screenSpaceStorageTex.minFilter = NearestFilter;
 		this._screenSpaceStorageTex.magFilter = NearestFilter;
 
-		this._worldSpaceStorageTex = new StorageTexture( width, height );
+		this._worldSpaceStorageTex = new StorageTexture( MAX_STORAGE_TEXTURE_SIZE, MAX_STORAGE_TEXTURE_SIZE );
 		this._worldSpaceStorageTex.type = HalfFloatType;
 		this._worldSpaceStorageTex.format = RGBAFormat;
 		this._worldSpaceStorageTex.minFilter = NearestFilter;
 		this._worldSpaceStorageTex.magFilter = NearestFilter;
 
+		// Reused per-copy: copy only the active region out of the over-alloc texs.
+		this._srcRegion = new Box2( new Vector2( 0, 0 ), new Vector2( 0, 0 ) );
+
 		// Readable RenderTargets (copy destinations — published to context)
 		const rtOpts = {
 			type: HalfFloatType,
@@ -464,9 +470,11 @@ export class MotionVector extends RenderStage {
 		this.renderer.compute( this._worldSpaceComputeNode );
 
 		// Copy StorageTextures → RenderTargets (cross-dispatch reads from
-		// StorageTexture return zeros — must use RenderTarget for downstream stages)
-		this.renderer.copyTextureToTexture( this._screenSpaceStorageTex, this.screenSpaceTarget.texture );
-		this.renderer.copyTextureToTexture( this._worldSpaceStorageTex, this.worldSpaceTarget.texture );
+		// StorageTexture return zeros — must use RenderTarget for downstream stages).
+		// srcRegion = active size; StorageTextures are over-allocated at 2048.
+		this._srcRegion.max.set( this.screenSpaceTarget.width, this.screenSpaceTarget.height );
+		this.renderer.copyTextureToTexture( this._screenSpaceStorageTex, this.screenSpaceTarget.texture, this._srcRegion );
+		this.renderer.copyTextureToTexture( this._worldSpaceStorageTex, this.worldSpaceTarget.texture, this._srcRegion );
 
 		// Publish RenderTarget textures to context
 		context.setTexture( 'motionVector:screenSpace', this.screenSpaceTarget.texture );
@@ -501,8 +509,7 @@ export class MotionVector extends RenderStage {
 
 	setSize( width, height ) {
 
-		this._screenSpaceStorageTex.setSize( width, height );
-		this._worldSpaceStorageTex.setSize( width, height );
+		// StorageTextures stay at their max allocation (see constructor).
 		this.screenSpaceTarget.setSize( width, height );
 		this.screenSpaceTarget.texture.needsUpdate = true;
 		this.worldSpaceTarget.setSize( width, height );

package/src/Stages/NormalDepth.js

@@ -1,8 +1,9 @@
 import { Fn, vec3, vec4, float, int, uint, uvec2, uniform, normalize, mat3, storage, If,
 	textureStore, workgroupId, localId } from 'three/tsl';
 import { RenderTarget, StorageTexture } from 'three/webgpu';
-import { HalfFloatType, RGBAFormat, NearestFilter, Matrix4 } from 'three';
+import { HalfFloatType, RGBAFormat, NearestFilter, Matrix4, Box2, Vector2 } from 'three';
 import { RenderStage, StageExecutionMode } from '../Pipeline/RenderStage.js';
+import { MAX_STORAGE_TEXTURE_SIZE } from '../EngineDefaults.js';
 import { Ray, HitInfo } from '../TSL/Struct.js';
 import { traverseBVH } from '../TSL/BVHTraversal.js';
 
@@ -44,12 +45,15 @@ export class NormalDepth extends RenderStage {
 		const w = options.width || 1;
 		const h = options.height || 1;
 
-		this._outputStorageTex = new StorageTexture( w, h );
+		// StorageTexture stays at max alloc — see resize crash fix (three.js #33061).
+		this._outputStorageTex = new StorageTexture( MAX_STORAGE_TEXTURE_SIZE, MAX_STORAGE_TEXTURE_SIZE );
 		this._outputStorageTex.type = HalfFloatType;
 		this._outputStorageTex.format = RGBAFormat;
 		this._outputStorageTex.minFilter = NearestFilter;
 		this._outputStorageTex.magFilter = NearestFilter;
 
+		this._srcRegion = new Box2( new Vector2( 0, 0 ), new Vector2( 0, 0 ) );
+
 		// Ping-pong RTs share format with the StorageTexture so copyTextureToTexture works.
 		const rtOpts = {
 			type: HalfFloatType,
@@ -252,13 +256,16 @@ export class NormalDepth extends RenderStage {
 		const prevRT = this._currentIdx === 0 ? this._rtB : this._rtA;
 
 		this.renderer.compute( this._computeNode );
-		this.renderer.copyTextureToTexture( this._outputStorageTex, writeRT.texture );
+
+		// Copy only the active region out of the over-allocated StorageTexture.
+		this._srcRegion.max.set( writeRT.width, writeRT.height );
+		this.renderer.copyTextureToTexture( this._outputStorageTex, writeRT.texture, this._srcRegion );
 
 		// First dispatch: seed prev from current so ASVGF doesn't see false
 		// disocclusion on frame 1.
 		if ( ! this._hasHistory ) {
 
-			this.renderer.copyTextureToTexture( this._outputStorageTex, prevRT.texture );
+			this.renderer.copyTextureToTexture( this._outputStorageTex, prevRT.texture, this._srcRegion );
 			this._hasHistory = true;
 
 		}
@@ -279,9 +286,14 @@ export class NormalDepth extends RenderStage {
 
 	setSize( width, height ) {
 
-		this._outputStorageTex.setSize( width, height );
+		// StorageTexture stays at its max allocation (see constructor).
+		// RenderTarget.setSize() updates width/height but does NOT bump
+		// texture.version, so copyTextureToTexture's GPU texture would stay at
+		// the old size — needsUpdate forces the resize to take effect.
 		this._rtA.setSize( width, height );
+		this._rtA.texture.needsUpdate = true;
 		this._rtB.setSize( width, height );
+		this._rtB.texture.needsUpdate = true;
 		this._hasHistory = false;
 		this.resolutionWidth.value = width;
 		this.resolutionHeight.value = height;