rayzee 7.4.0 → 7.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rayzee",
-  "version": "7.4.0",
+  "version": "7.5.0",
   "type": "module",
   "description": "Real-time WebGPU path tracing engine built on Three.js",
   "main": "dist/rayzee.umd.js",

package/src/Passes/OIDNDenoiser.js

@@ -137,6 +137,8 @@ export class OIDNDenoiser extends EventDispatcher {
 
 		// Track in-flight tile staging buffers so they can be destroyed on abort
 		this._pendingStagingBuffers = new Set();
+		// Per-run tile-blit promises; done() awaits these so capture waits for every tile to paint.
+		this._pendingTileBlits = [];
 
 		this.currentTZAUrl = null;
 		this.unet = null;
@@ -629,6 +631,9 @@ export class OIDNDenoiser extends EventDispatcher {
 
 			let abortDenoise = null;
 
+			// Fresh per-run list of tile-blit promises (the progress callback appends to it).
+			this._pendingTileBlits = [];
+
 			const abortHandler = () => {
 
 				if ( abortDenoise ) {
@@ -653,7 +658,23 @@ export class OIDNDenoiser extends EventDispatcher {
 
 					try {
 
-						await this._displayGPUOutput( output );
+						if ( this._pendingTileBlits.length > 0 ) {
+
+							// Normal path: the progress callback already painted every tile progressively, with
+							// the same exposure/saturation/tonemap/sRGB math the full-frame readback uses (verified:
+							// tiles tile the image exactly, no overlap). Just wait for those blits — no redundant
+							// full-frame re-read + re-tonemap.
+							await Promise.allSettled( this._pendingTileBlits );
+
+						} else {
+
+							// Degenerate fallback (no per-tile progress was emitted): one authoritative full paint.
+							await this._displayGPUOutput( output );
+
+						}
+
+						// DENOISING_END (which gates screenshot/video capture) fires only after this resolves,
+						// so the captured canvas is always complete.
 						resolve();
 
 					} catch ( err ) {
@@ -703,8 +724,9 @@ export class OIDNDenoiser extends EventDispatcher {
 
 					device.queue.submit( [ enc.finish() ] );
 
-					// Map and blit asynchronously — GPU copy is already queued
-					staging.mapAsync( GPUMapMode.READ ).then( () => {
+					// Map and blit asynchronously — GPU copy is already queued. Track the whole chain so
+					// done() can await every tile paint before resolving (replaces the full-frame readback).
+					const tileBlit = staging.mapAsync( GPUMapMode.READ ).then( () => {
 
 						const f32 = new Float32Array( staging.getMappedRange() );
 						const tileImageData = new ImageData( clampedW, clampedH );
@@ -766,6 +788,8 @@ export class OIDNDenoiser extends EventDispatcher {
 
 					} );
 
+					this._pendingTileBlits.push( tileBlit );
+
 				}
 			} );
 

package/src/Processor/AssetLoader.js

@@ -1446,12 +1446,18 @@ export class AssetLoader extends EventDispatcher {
 
 				if ( userData.type === 'RectAreaLight' ) {
 
+					// Intensity is authored in Watts (Blender-style); emitted radiance
+					// is computed at render time as power/(π·area). Blender emission
+					// defaults: power-normalized, full Lambertian spread (π), rectangle.
 					const light = new RectAreaLight(
 						new Color( ...userData.color ),
-						userData.intensity * 0.1 / Math.PI, // Adjust intensity for better visual results
+						userData.intensity * 0.1,
 						userData.width,
 						userData.height
 					);
+					light.userData.normalize = userData.normalize ?? true;
+					light.userData.spread = Number.isFinite( userData.spread ) ? userData.spread : Math.PI;
+					light.userData.shape = userData.shape ?? 'rectangle';
 					light.position.z = - 2;
 					light.name = userData.name;
 					object.add( light );

package/src/Processor/LightSerializer.js

@@ -1,4 +1,31 @@
 import { Vector3, Quaternion } from 'three';
+import { blackbodyToLinearRGB } from './blackbody.js';
+
+// Point & spot lights specify Power in Watts; the shader uses radiant intensity
+// (W/sr) as `intensity / dist²`, so convert with I = P / 4π (isotropic emitter),
+// matching Blender. Area lights are already radiant power; the Sun is irradiance.
+const INV_4PI = 1 / ( 4 * Math.PI );
+
+// Effective emission colour + intensity after per-light Exposure (EV stops) and
+// optional blackbody Temperature tint (Blender-style). Both fold into the values
+// already sent to the GPU — no shader or struct change needed.
+function effectiveEmission( light ) {
+
+	const ud = light.userData || {};
+	const exposure = Number.isFinite( ud.exposure ) ? ud.exposure : 0;
+	const intensity = light.intensity * Math.pow( 2, exposure );
+
+	let r = light.color.r, g = light.color.g, b = light.color.b;
+	if ( ud.useTemperature ) {
+
+		const [ tr, tg, tb ] = blackbodyToLinearRGB( ud.temperature ?? 6500 );
+		r *= tr; g *= tg; b *= tb;
+
+	}
+
+	return { r, g, b, intensity };
+
+}
 
 export class LightSerializer {
 
@@ -90,6 +117,8 @@ export class LightSerializer {
 		// Get angle parameter from light (default to 0 for sharp shadows)
 		const angle = light.userData.angle || light.angle || 0.0; // In radians
 
+		const em = effectiveEmission( light );
+
 		// Optional projection mask. Sign of intensity carries the inverted flag.
 		const gobo = light.userData?.gobo;
 		const goboIndex = ( gobo && Number.isInteger( gobo.index ) ) ? gobo.index : - 1;
@@ -101,8 +130,8 @@ export class LightSerializer {
 		this.directionalLightCache.push( {
 			data: [
 				direction.x, direction.y, direction.z, // direction toward light (3)
-				light.color.r, light.color.g, light.color.b, // color (3)
-				light.intensity, // intensity (1)
+				em.r, em.g, em.b, // color (3) — incl. temperature tint
+				em.intensity, // intensity (1) — incl. exposure
 				angle, // angular diameter in radians (1)
 				goboIndex, // gobo layer index, -1 = none (1)
 				goboIntensity, // signed gobo strength (1)
@@ -133,14 +162,25 @@ export class LightSerializer {
 		// Calculate importance for sorting
 		const importance = this.calculateLightImportance( light, 'area' );
 
-		// Store in cache with importance
+		// Blender-style emission controls (stored on userData; sensible defaults).
+		// normalize ON → radiance ∝ 1/area (resizing keeps total power constant).
+		const normalize = ( light.userData?.normalize ?? true ) ? 1.0 : 0.0;
+		const spread = Number.isFinite( light.userData?.spread ) ? light.userData.spread : Math.PI;
+		const shape = ( light.userData?.shape === 'ellipse' || light.userData?.shape === 'disk' || light.userData?.shape === 1 ) ? 1.0 : 0.0;
+
+		const em = effectiveEmission( light );
+
+		// Store in cache with importance (16 floats, vec4-aligned)
 		this.areaLightCache.push( {
 			data: [
 				position.x, position.y, position.z, // position (3)
-				u.x, u.y, u.z, // u vector (3)
-				v.x, v.y, v.z, // v vector (3)
-				light.color.r, light.color.g, light.color.b, // color (3)
-				light.intensity // intensity (1)
+				u.x, u.y, u.z, // u half-vector (3)
+				v.x, v.y, v.z, // v half-vector (3)
+				em.r, em.g, em.b, // color (3) — incl. temperature tint
+				em.intensity, // radiant power in Watts (1) — incl. exposure
+				normalize, // power-normalize flag (1)
+				spread, // emission spread in radians (1)
+				shape, // 0 = rect, 1 = disk/ellipse (1)
 			],
 			importance: importance,
 			light: light
@@ -159,12 +199,14 @@ export class LightSerializer {
 		// Calculate importance for sorting
 		const importance = this.calculateLightImportance( light, 'point' );
 
+		const em = effectiveEmission( light );
+
 		// Store in cache with importance
 		this.pointLightCache.push( {
 			data: [
 				position.x, position.y, position.z, // position (3)
-				light.color.r, light.color.g, light.color.b, // color (3)
-				light.intensity, // intensity (1)
+				em.r, em.g, em.b, // color (3) — incl. temperature tint
+				em.intensity * INV_4PI, // radiant intensity W/sr = power(W)/4π, incl. exposure (1)
 				light.distance || 0.0, // cutoff distance (0 = infinite) (1)
 				light.decay !== undefined ? light.decay : 2.0 // decay exponent (1)
 			],
@@ -198,13 +240,15 @@ export class LightSerializer {
 		const iesIndex = ( ies && Number.isInteger( ies.index ) ) ? ies.index : - 1;
 		const iesIntensity = ( ies && typeof ies.intensity === 'number' ) ? ies.intensity : 1.0;
 
+		const em = effectiveEmission( light );
+
 		// Store in cache with importance
 		this.spotLightCache.push( {
 			data: [
 				position.x, position.y, position.z, // position (3)
 				direction.x, direction.y, direction.z, // direction (3)
-				light.color.r, light.color.g, light.color.b, // color (3)
-				light.intensity, // intensity (1)
+				em.r, em.g, em.b, // color (3) — incl. temperature tint
+				em.intensity * INV_4PI, // radiant intensity W/sr = power(W)/4π, incl. exposure (1)
 				light.angle || Math.PI / 4, // cone half-angle in radians (1)
 				light.penumbra || 0.0, // penumbra [0,1] (1)
 				light.distance || 0.0, // cutoff distance (0 = infinite) (1)
@@ -290,7 +334,7 @@ export class LightSerializer {
 
 		// Divide flat array lengths by per-light stride to get actual light counts
 		const directionalCount = Math.floor( this.lightData.directional.length / 12 );
-		const areaCount = Math.floor( this.lightData.rectArea.length / 13 );
+		const areaCount = Math.floor( this.lightData.rectArea.length / 16 );
 		const pointCount = Math.floor( this.lightData.point.length / 9 );
 		const spotCount = Math.floor( this.lightData.spot.length / 20 );
 

package/src/Processor/PackedRayBuffer.js

@@ -11,13 +11,12 @@ import { StorageInstancedBufferAttribute } from 'three/webgpu';
 
 export const RAY_STRIDE = 7;
 export const HIT_STRIDE = 2;
-// Per-pixel G-buffer (first-hit MRT staging): 2 uvec4/pixel (AoS, element p*GBUFFER_STRIDE + lane).
-//   lane 0 — half-packed normal/depth/albedo (pack2x16, no f32 bitcast); read by FinalWrite:
-//     .x=packSnorm2x16(normal.xy)  .y=packSnorm2x16(normal.z, depth)  .z=packUnorm2x16(albedo.rg)  .w=packUnorm2x16(albedo.b, 0)
-//   lane 1 — primary-hit surface ID for A-SVGF correlated-gradient re-projection (Tier 1); written at the
-//     bounce-0 hit, valid=0 on miss (Generate inits): .x=triIndex .y=meshIndex .z=packUnorm2x16(bary.u,bary.v) .w=valid
+// Per-pixel G-buffer (first-hit MRT staging): 1 uvec4/pixel — half-packed normal/depth/albedo
+// (pack2x16, no f32 bitcast); read by FinalWrite:
+//   .x=packSnorm2x16(normal.xy)  .y=packSnorm2x16(normal.z, depth)  .z=packUnorm2x16(albedo.rg)  .w=packUnorm2x16(albedo.b, 0)
 // Separate buffer from RAY (per-pixel, not per-ray×S) — written by Generate/Shade bounce-0.
-export const GBUFFER_STRIDE = 2;
+// (A second lane reserved for an A-SVGF Tier-1 surface ID was removed — write-only, never read.)
+export const GBUFFER_STRIDE = 1;
 
 export const RAY = {
 	ORIGIN_META: 0, // vec4(origin.xyz, uintBitsToFloat(perRayBounces | sssSteps<<8)); pixelIndex == rayID
@@ -152,36 +151,17 @@ export const readRayRadiance = ( buf, id ) =>
 // ── Per-pixel G-buffer (first-hit MRT). 2 uvec4/pixel (AoS), pack2x16 lanes. ──
 // normal: raw unit vec3; depth: linear [0,1]; albedo: vec3 [0,1]. Packed values live in u32 lanes
 // verbatim (no f32 bitcast) so NaN-range bit patterns (snorm ±1 → 0x7FFF) survive store/load intact.
-// gbLane resolves the AoS slot for a pixel (lane 0 = MRT, lane 1 = surface ID).
-const gbLane = ( pixelIndex, lane ) => {
-
-	const base = uint( pixelIndex ).mul( GBUFFER_STRIDE );
-	return lane === 0 ? base : base.add( lane );
-
-};
+// One uvec4 per pixel (stride 1); AoS base = pixelIndex * GBUFFER_STRIDE.
+const gbLane = ( pixelIndex ) => uint( pixelIndex ).mul( GBUFFER_STRIDE );
 
 export const writeGBuffer = ( buf, pixelIndex, normal, depth, albedo ) =>
-	buf.element( gbLane( pixelIndex, 0 ) ).assign( uvec4(
+	buf.element( gbLane( pixelIndex ) ).assign( uvec4(
 		packSnorm2x16( vec2( normal.x, normal.y ) ),
 		packSnorm2x16( vec2( normal.z, depth ) ),
 		packUnorm2x16( vec2( albedo.x, albedo.y ) ),
 		packUnorm2x16( vec2( albedo.z, 0.0 ) ),
 	) );
-export const readGBuffer = ( buf, pixelIndex ) => buf.element( gbLane( pixelIndex, 0 ) );
-
-// Lane 1 — primary-hit surface ID for A-SVGF correlated gradient re-projection (Tier 1).
-// valid=0 marks a miss (no primary surface); bary packed unorm (both in [0,1]).
-export const writeGBufferSurfaceID = ( buf, pixelIndex, triIndex, meshIndex, baryU, baryV, valid ) =>
-	buf.element( gbLane( pixelIndex, 1 ) ).assign( uvec4(
-		uint( triIndex ), uint( meshIndex ), packUnorm2x16( vec2( baryU, baryV ) ), uint( valid ),
-	) );
-export const readGBufferSurfaceID = ( buf, pixelIndex ) => {
-
-	const p = buf.element( gbLane( pixelIndex, 1 ) );
-	const bary = unpackUnorm2x16( p.z );
-	return { triIndex: p.x, meshIndex: p.y, baryU: bary.x, baryV: bary.y, valid: p.w };
-
-};
+export const readGBuffer = ( buf, pixelIndex ) => buf.element( gbLane( pixelIndex ) );
 
 // Decode for FinalWrite. normalDepth.xyz matches the prior path (normal*0.5+0.5), .w = raw depth.
 export const gbDecodeNormalDepth = ( packed ) => {

package/src/Processor/StorageTexturePool.js

@@ -141,16 +141,24 @@ export class StorageTexturePool {
 	 * Copy StorageTextures → RenderTarget textures via GPU copy.
 	 * Must be called after each compute dispatch.
 	 * @param {WebGPURenderer} renderer
+	 * @param {boolean} [includeAux=true] Copy the normalDepth + albedo attachments too. When no
+	 *   denoiser/OIDN consumes the aux MRT (default interactive), the wavefront doesn't write those
+	 *   StorageTextures, so skipping their copies saves two full-res GPU copies/frame. Color is always copied.
 	 */
-	copyToReadTargets( renderer ) {
+	copyToReadTargets( renderer, includeAux = true ) {
 
 		// 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 );
+
+		if ( includeAux ) {
+
+			renderer.copyTextureToTexture( this.writeNormalDepth, this.readTarget.textures[ 1 ], this._srcRegion );
+			renderer.copyTextureToTexture( this.writeAlbedo, this.readTarget.textures[ 2 ], this._srcRegion );
+
+		}
 
 	}
 

package/src/Processor/VRAMTracker.js

@@ -1,11 +1,15 @@
 /**
  * VRAMTracker.js — current/peak GPU memory accounting.
  *
- * Measures ACTUAL live bytes (attribute.array.byteLength, texture dims × format/type)
- * rather than re-deriving allocation formulas, so it never drifts when strides,
- * capacity rounding, or layouts change. Providers are thunks that read current state,
- * so they survive reallocation (resize, scene/material/env reload). A per-pass WeakSet
- * dedupes by resource identity, so overlapping registrations never double-count.
+ * Measures live GPU bytes: buffer attributes by backing-array byteLength, textures by
+ * dims × format/type — but ONLY when the backend actually holds a GPUTexture. three.js
+ * allocates a texture's GPUTexture lazily on first use, so a constructed-but-never-dispatched
+ * StorageTexture (e.g. a disabled stage's render targets) costs 0 here even though its JS
+ * `image` dimensions are set. Residency probing needs a renderer (constructor arg or
+ * setRenderer); without one it falls back to counting by dimensions (legacy behavior).
+ * Providers are thunks that read current state, so they survive reallocation (resize,
+ * scene/material/env reload). A per-pass WeakSet dedupes by resource identity, so
+ * overlapping registrations never double-count.
  */
 
 import {
@@ -60,15 +64,23 @@ export function textureBytes( tex ) {
 
 export class VRAMTracker {
 
-	constructor() {
+	constructor( renderer = null ) {
 
 		this._providers = [];
+		this._renderer = renderer;
 		this.current = 0;
 		this.peak = 0;
 		this.byCategory = {};
 
 	}
 
+	/** Late-bind the renderer so texture accounting can probe actual GPU residency. */
+	setRenderer( renderer ) {
+
+		this._renderer = renderer;
+
+	}
+
 	/**
 	 * @param {string} category - grouping label in the report
 	 * @param {Function} fn - returns a resource or array of resources: buffer
@@ -138,12 +150,12 @@ export class VRAMTracker {
 
 		}
 
-		// texture / render target — dedupe by object identity
+		// texture / render target — dedupe by object identity; count only GPU-resident bytes
 		if ( r.isRenderTarget || r.isTexture ) {
 
 			if ( seen.has( r ) ) return 0;
 			seen.add( r );
-			return textureBytes( r );
+			return this._residentTextureBytes( r );
 
 		}
 
@@ -151,6 +163,36 @@ export class VRAMTracker {
 
 	}
 
+	// three.js allocates a texture's GPUTexture lazily on first dispatch; a never-used StorageTexture
+	// (disabled stage) has none. Count only when the backend holds a real GPUTexture so the report is
+	// resident VRAM, not JS-declared dimensions. No renderer bound → assume resident (legacy behavior).
+	_isResident( tex ) {
+
+		const backend = this._renderer?.backend;
+		if ( ! backend || typeof backend.get !== 'function' ) return true;
+		if ( typeof backend.has === 'function' && ! backend.has( tex ) ) return false;
+		const data = backend.get( tex );
+		return !! ( data && ( data.texture || data.gpuTexture ) );
+
+	}
+
+	// RenderTarget bytes are attributed to its underlying texture(s); count each only if resident.
+	_residentTextureBytes( tex ) {
+
+		if ( tex.isRenderTarget ) {
+
+			const list = tex.textures?.length ? tex.textures : [ tex.texture ];
+			const w = tex.width || 0, h = tex.height || 0, d = tex.depth || 1;
+			let sum = 0;
+			for ( const t of list ) if ( t && this._isResident( t ) ) sum += w * h * d * texelBytes( t );
+			return sum;
+
+		}
+
+		return this._isResident( tex ) ? textureBytes( tex ) : 0;
+
+	}
+
 	/** Drop the high-water mark to the current value (call when a new render begins). */
 	resetPeak() {
 

package/src/Processor/blackbody.js

@@ -0,0 +1,74 @@
+// Blackbody temperature → linear Rec.709 (= linear sRGB) RGB.
+//
+// Ported verbatim from Blender/Cycles `svm_math_blackbody_color_rec709`
+// (Lukas Stockner's 7-segment rational/cubic fit; coefficients from
+// intern/cycles/kernel/tables.h). The fit is luminance-balanced — the Rec.709
+// luminance of the returned colour is ≈1.0 across the whole range — so it can be
+// multiplied straight into a light's colour without altering its power: the
+// temperature shifts hue only, brightness stays governed by intensity. This is
+// exactly how Cycles applies it (raw multiply into the light colour, no
+// renormalisation).
+
+const BB_R = [
+	[ 1.61919106e3, - 2.05010916e-3, 5.02995757e0 ],
+	[ 2.48845471e3, - 1.11330907e-3, 3.22621544e0 ],
+	[ 3.34143193e3, - 4.86551192e-4, 1.76486769e0 ],
+	[ 4.09461742e3, - 1.27446582e-4, 7.25731635e-1 ],
+	[ 4.67028036e3, 2.91258199e-5, 1.26703442e-1 ],
+	[ 4.59509185e3, 2.87495649e-5, 1.50345020e-1 ],
+	[ 3.78717450e3, 9.35907826e-6, 3.99075871e-1 ],
+];
+
+const BB_G = [
+	[ - 4.88999748e2, 6.04330754e-4, - 7.55807526e-2 ],
+	[ - 7.55994277e2, 3.16730098e-4, 4.78306139e-1 ],
+	[ - 1.02363977e3, 1.20223470e-4, 9.36662319e-1 ],
+	[ - 1.26571316e3, 4.87340896e-6, 1.27054498e0 ],
+	[ - 1.42529332e3, - 4.01150431e-5, 1.43972784e0 ],
+	[ - 1.17554822e3, - 2.16378048e-5, 1.30408023e0 ],
+	[ - 5.00799571e2, - 4.59832026e-6, 1.09098763e0 ],
+];
+
+const BB_B = [
+	[ 5.96945309e-11, - 4.85742887e-8, - 9.70622247e-5, - 4.07936148e-3 ],
+	[ 2.40430366e-11, 5.55021075e-8, - 1.98503712e-4, 2.89312858e-2 ],
+	[ - 1.40949732e-11, 1.89878968e-7, - 3.56632824e-4, 9.10767778e-2 ],
+	[ - 3.61460868e-11, 2.84822009e-7, - 4.93211319e-4, 1.56723440e-1 ],
+	[ - 1.97075738e-11, 1.75359352e-7, - 2.50542825e-4, - 2.22783266e-2 ],
+	[ - 1.61997957e-13, - 1.64216008e-8, 3.86216271e-4, - 7.38077418e-1 ],
+	[ 6.72650283e-13, - 2.73078809e-8, 4.24098264e-4, - 7.52335691e-1 ],
+];
+
+/**
+ * Convert a colour temperature in Kelvin to linear Rec.709 / linear-sRGB RGB.
+ * Negative out-of-gamut channels (very low temperatures) are clamped to 0.
+ * @param {number} kelvin
+ * @returns {[number, number, number]}
+ */
+export function blackbodyToLinearRGB( kelvin ) {
+
+	let r, g, b;
+
+	if ( kelvin >= 12000 ) {
+
+		r = 0.8262954810464208; g = 0.9945080501520986; b = 1.566307710274283;
+
+	} else if ( kelvin < 800 ) {
+
+		r = 5.413294490189271; g = - 0.20319390035873933; b = - 0.0822535242887164;
+
+	} else {
+
+		const i = kelvin >= 6365 ? 6 : kelvin >= 3315 ? 5 : kelvin >= 1902 ? 4
+			: kelvin >= 1449 ? 3 : kelvin >= 1167 ? 2 : kelvin >= 965 ? 1 : 0;
+		const cr = BB_R[ i ], cg = BB_G[ i ], cb = BB_B[ i ];
+		const tInv = 1 / kelvin;
+		r = cr[ 0 ] * tInv + cr[ 1 ] * kelvin + cr[ 2 ];
+		g = cg[ 0 ] * tInv + cg[ 1 ] * kelvin + cg[ 2 ];
+		b = ( ( cb[ 0 ] * kelvin + cb[ 1 ] ) * kelvin + cb[ 2 ] ) * kelvin + cb[ 3 ];
+
+	}
+
+	return [ Math.max( 0, r ), Math.max( 0, g ), Math.max( 0, b ) ];
+
+}

package/src/Stages/ASVGF.js

@@ -832,6 +832,33 @@ export class ASVGF extends RenderStage {
 
 	}
 
+	// Free the over-allocated 2048² StorageTextures' GPU memory when the stage is disabled, so toggling
+	// the denoiser off reclaims VRAM. The JS texture objects + compiled compute nodes are kept; three.js
+	// lazily re-creates each GPUTexture on the next dispatch after re-enable. History re-anchors via the
+	// warm reset (the RTs are render-res, not 2048² — left alone).
+	releaseGPUMemory() {
+
+		this._temporalTexA?.dispose();
+		this._temporalTexB?.dispose();
+		this._outputModulatedTex?.dispose();
+		this._gradientStorageTex?.dispose();
+		this._heatmapStorageTex?.dispose();
+		// Render-res RT textures (sized to render resolution → meaningful VRAM at high res). Dispose the
+		// .texture, not the RenderTarget (RT.dispose() doesn't free the backing GPUTexture here); these RTs
+		// are copyTextureToTexture targets, so three.js reallocates on the next dispatch after re-enable.
+		// Drop the published context outputs first so the Compositor fallback (reads asvgf:output) can't
+		// sample a freed texture; render() re-publishes on re-enable.
+		this.context?.removeTexture( 'asvgf:demodulated' );
+		this.context?.removeTexture( 'asvgf:output' );
+		this.context?.removeTexture( 'asvgf:gradient' );
+		this._demodulatedRT?.texture?.dispose();
+		this._outputRT?.texture?.dispose();
+		this._gradientRT?.texture?.dispose();
+		this.heatmapTarget?.texture?.dispose();
+		this.resetTemporalData();
+
+	}
+
 	dispose() {
 
 		this._gradientNode?.dispose();

package/src/Stages/BilateralFilter.js

@@ -367,6 +367,18 @@ export class BilateralFilter extends RenderStage {
 
 	}
 
+	// Free the 2048² StorageTextures when disabled; three.js re-creates them on the next dispatch
+	// after re-enable (no temporal state to re-anchor). See ASVGF.releaseGPUMemory.
+	releaseGPUMemory() {
+
+		this._storageTexA?.dispose();
+		this._storageTexB?.dispose();
+		// Render-res RT texture (dispose .texture, not the RT — RT.dispose() doesn't free it here).
+		this.context?.removeTexture( 'bilateralFiltering:output' );
+		this._outputTarget?.texture?.dispose();
+
+	}
+
 	reset() {
 
 		// No temporal state to reset

package/src/Stages/EdgeFilter.js

@@ -267,6 +267,18 @@ export class EdgeFilter extends RenderStage {
 
 	}
 
+	// Free the 2048² StorageTexture when disabled; three.js re-creates it on the next dispatch
+	// after re-enable, and reset() clears the iteration history. See ASVGF.releaseGPUMemory.
+	releaseGPUMemory() {
+
+		this._outputStorageTex?.dispose();
+		// Render-res RT texture (dispose .texture, not the RT — RT.dispose() doesn't free it here).
+		this.context?.removeTexture( 'edgeFiltering:output' );
+		this.outputTarget?.texture?.dispose();
+		this.reset();
+
+	}
+
 	reset() {
 
 		this._iterations = 0;

package/src/Stages/MotionVector.js

@@ -495,6 +495,16 @@ export class MotionVector extends RenderStage {
 	 * Reset — intentionally does NOT reset matricesInitialized.
 	 * Motion vectors must track camera motion across pipeline resets.
 	 */
+	// Free the 2048² StorageTextures when disabled (no consumer); three.js re-creates them on the next
+	// dispatch after re-enable. _syncGBufferStages additionally reseeds camera history on re-enable.
+	releaseGPUMemory() {
+
+		this._screenSpaceStorageTex?.dispose();
+		this._worldSpaceStorageTex?.dispose();
+		this.reset();
+
+	}
+
 	reset() {
 
 		if ( ! this.matricesInitialized ) {

package/src/Stages/NormalDepth.js

@@ -367,6 +367,16 @@ export class NormalDepth extends RenderStage {
 
 	}
 
+	// Free the 2048² StorageTextures when disabled (no consumer); three.js re-creates them on the next
+	// dispatch after re-enable, and reset() re-arms the dirty/history fast-path. See ASVGF.releaseGPUMemory.
+	releaseGPUMemory() {
+
+		this._outputStorageTex?.dispose();
+		this._shadingStorageTex?.dispose();
+		this.reset();
+
+	}
+
 	reset() {
 
 		this._dirty = true;

package/src/Stages/PathTracer.js

@@ -64,7 +64,7 @@ export class PathTracer extends PathTracerStage {
 
 		// VRAM accounting — providers are thunks reading CURRENT live resources,
 		// so they survive buffer/texture reallocation (resize, scene/material reload).
-		this.vramTracker = new VRAMTracker();
+		this.vramTracker = new VRAMTracker( this.renderer );
 		this._registerVRAMProviders();
 
 		console.log( 'PathTracer: initialized (wavefront)' );
@@ -322,7 +322,9 @@ export class PathTracer extends PathTracerStage {
 
 		this._maybeReadbackCounters();
 
-		this.storageTextures.copyToReadTargets( this.renderer );
+		// Skip the normalDepth/albedo copies when aux is off — the wavefront didn't write them and
+		// no stage reads them; saves two full-res GPU copies/frame in the default interactive path.
+		this.storageTextures.copyToReadTargets( this.renderer, this._auxGBufferEnabled );
 
 		const readTex = this.storageTextures.getReadTextures();
 		if ( context ) this._publishTexturesToContext( context, readTex );

package/src/Stages/PathTracerStage.js

@@ -571,11 +571,11 @@ export class PathTracerStage extends RenderStage {
 
 		}
 
-		// Area lights (13 floats per light)
+		// Area lights (16 floats per light — 13 base + normalize/spread/shape)
 		if ( this.areaLightsData && this.areaLightsData.length > 0 ) {
 
 			this.areaLightsBufferNode.array = Array.from( this.areaLightsData );
-			this.numAreaLights.value = Math.floor( this.areaLightsData.length / 13 );
+			this.numAreaLights.value = Math.floor( this.areaLightsData.length / 16 );
 
 		} else {
 

package/src/Stages/SSRC.js

@@ -171,6 +171,22 @@ export class SSRC extends RenderStage {
 
 	}
 
+	// Free the 2048² StorageTextures when disabled; three.js re-creates them on the next dispatch
+	// after re-enable, and reset() clears the temporal cache. See ASVGF.releaseGPUMemory.
+	releaseGPUMemory() {
+
+		this._cacheTexA?.dispose();
+		this._cacheTexB?.dispose();
+		this._prevNDTexA?.dispose();
+		this._prevNDTexB?.dispose();
+		this._outputTex?.dispose();
+		// Render-res RT texture (dispose .texture, not the RT — RT.dispose() doesn't free it here).
+		this.context?.removeTexture( 'ssrc:output' );
+		this.outputTarget?.texture?.dispose();
+		this.reset();
+
+	}
+
 	reset() {
 
 		this._resetCache();