rayzee 7.4.0 → 7.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rayzee",
-  "version": "7.4.0",
+  "version": "7.4.1",
   "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/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/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/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();

package/src/Stages/Variance.js

@@ -363,6 +363,19 @@ export class Variance extends RenderStage {
 
 	}
 
+	// Free the 2048² StorageTextures when disabled; three.js re-creates them on the next dispatch
+	// after re-enable, and reset() re-anchors the EMA. 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( 'variance:output' );
+		this._outputTarget?.texture?.dispose();
+		this.reset();
+
+	}
+
 	reset() {
 
 		this.currentMoments = 0;

package/src/TSL/GenerateKernel.js

@@ -19,7 +19,7 @@ import { Ray } from './Struct.js';
 import { RAY_FLAG } from '../Processor/QueueManager.js';
 import {
 	writeRayOriginMeta, writeRayDirFlags, writeRayThroughputPdf,
-	writeRayRadiance, writeGBuffer, writeGBufferSurfaceID,
+	writeRayRadiance, writeGBuffer,
 	writeMediumStack,
 } from '../Processor/PackedRayBuffer.js';
 
@@ -86,8 +86,6 @@ export function buildGenerateKernel( params ) {
 
 				// default: normal +Z, depth 1 (far), black albedo (background/miss)
 				writeGBuffer( gBufferRW, uint( pixelIndex ), vec3( 0.0, 0.0, 1.0 ), float( 1.0 ), vec3( 0.0 ) );
-				// surface-ID lane defaults to invalid (valid=0); Shade overwrites it at the bounce-0 hit.
-				writeGBufferSurfaceID( gBufferRW, uint( pixelIndex ), uint( 0 ), uint( 0 ), float( 0.0 ), float( 0.0 ), uint( 0 ) );
 
 			} );
 

package/src/TSL/ShadeKernel.js

@@ -51,9 +51,9 @@ import {
 	readMediumStack, writeMediumStack, readMediumSigmaA, writeMediumSigmaA,
 	readPathBounces, readSssSteps, readSSSMedium, writeSSSMedium,
 	readHitDistance, readHitBarycentrics, readHitNormal,
-	readHitMaterialIndex, readHitTriangleIndex, readHitMeshIndex,
+	readHitMaterialIndex, readHitTriangleIndex,
 	writeRayOriginMeta, writeRayDirFlags, writeRayThroughputPdf, writeRayRadiance,
-	writeGBuffer, writeGBufferSurfaceID, readGBuffer, gbDecodeNormalDepth,
+	writeGBuffer, readGBuffer, gbDecodeNormalDepth,
 	readRayRadiance,
 } from '../Processor/PackedRayBuffer.js';
 
@@ -64,9 +64,6 @@ const MISS_DIST = 1e19;
 const CATCHER_T_MIN = 1e-4; // min ray-t for the analytic plane hit (skip behind/at the camera)
 const CATCHER_LUMA_FLOOR = 1e-4; // denominator floor for the shadow ratio
 const CATCHER_COVERAGE_MIN = 1e-3; // below this incident luma there is no shadow to catch
-// Reserved G-buffer surface ID for catcher pixels (no real triangle); stable across frames so the
-// denoiser treats the analytic plane as one coherent surface, not a background miss.
-const CATCHER_SURFACE_ID = 0xFFFFFFFE;
 
 export function buildShadeKernel( params ) {
 
@@ -297,7 +294,6 @@ export function buildShadeKernel( params ) {
 
 						const planeDepth = computeNDCDepth( { worldPos: planePoint, cameraProjectionMatrix, cameraViewMatrix } );
 						writeGBuffer( gBufferRW, pixelIndex, planeN, planeDepth, vec3( 1.0 ) );
-						writeGBufferSurfaceID( gBufferRW, pixelIndex, uint( CATCHER_SURFACE_ID ), uint( CATCHER_SURFACE_ID ), 0.5, 0.5, uint( 1 ) );
 
 					} );
 
@@ -587,9 +583,6 @@ export function buildShadeKernel( params ) {
 			// block before that capture, so a glass-then-escape pixel keeps this default aux — megakernel parity
 			// (objectNormal/objectColor stay at their init for transmissive-then-miss).
 			writeGBuffer( gBufferRW, pixelIndex, vec3( 0.0, 0.0, 1.0 ), linearDepth, vec3( 0.0 ) );
-			// Persist the primary-hit surface ID (Tier-1 A-SVGF correlated re-projection). Hit-only
-			// branch (misses Return above), so this marks the pixel valid; bary from the bounce-0 hit.
-			writeGBufferSurfaceID( gBufferRW, pixelIndex, hitTriIdx, readHitMeshIndex( hitBufferRO, rayID ), hitUV.x, hitUV.y, uint( 1 ) );
 
 		} );
 

package/src/managers/DenoisingManager.js

@@ -370,6 +370,16 @@ export class DenoisingManager extends EventDispatcher {
 		// MRT read-targets directly). When none are active the wavefront skips those writes entirely.
 		s.pathTracer?.setAuxGBufferEnabled?.( normalNeeded || !! this.denoiser?.enabled );
 
+		// Reclaim VRAM: free the big 2048² StorageTextures of any denoiser/G-buffer stage that ended up
+		// disabled (lazily re-created on the next dispatch after re-enable). Every strategy/denoiser
+		// toggle funnels through here after the enabled flags above are settled, so this is the one
+		// choke point. dispose() is idempotent, so re-running it for an already-released stage is a no-op.
+		for ( const stage of [ s.asvgf, s.variance, s.bilateralFilter, s.ssrc, s.edgeFilter, nd, mv ] ) {
+
+			if ( stage && ! stage.enabled ) stage.releaseGPUMemory?.();
+
+		}
+
 	}
 
 	// ── Render Completion Chain ───────────────────────────────────