rayzee 9.1.2 → 9.2.0

package/src/Processor/TextureCreator.js

@@ -2,13 +2,37 @@ import { DataArrayTexture, RGBAFormat, LinearFilter, UnsignedByteType, SRGBColor
 import { alignBucketWidth, TEXTURE_CONSTANTS, MEMORY_CONSTANTS, MATERIAL_DATA_LAYOUT, BVH_LEAF_MARKERS, assertBVHIndexFits, bvhIndexView } from '../EngineDefaults.js';
 import { packMaterial } from './MaterialPacking.js';
 import TexturesWorker from './Workers/TexturesWorker.js?worker&inline';
-import { ISSUE_CODES } from '../EngineIssues.js';
+import PackWorker from './Workers/PackWorker.js?worker&inline';
+import { resampleRGBA8 } from './ResampleRGBA8.js';
+import { ISSUE_CODES, EngineIssueError } from '../EngineIssues.js';
 import { linearToSRGB } from './ToneMapCPU.js';
 import { getActiveColorManagement } from '../Color/ColorManagement.js';
 import { createLogger } from '../utils/Logger.js';
+import { createWorker, hardwareThreads, hasWorkers } from '../Platform.js';
 
 const log = createLogger( 'textures' );
 
+// Below this a pack is cheaper than starting a worker for it.
+const WORKER_PACK_BYTES = 8 * 2 ** 20;
+
+// Buckets pack concurrently; this keeps their workers within the cores, beside the BVH pool's.
+const packSlots = { busy: 0, waiting: [] };
+
+async function acquirePackSlot() {
+
+	if ( packSlots.busy < Math.max( 1, hardwareThreads() - 1 ) ) packSlots.busy ++;
+	else await new Promise( ( resolve ) => packSlots.waiting.push( resolve ) );
+
+	return () => {
+
+		const next = packSlots.waiting.shift();
+		if ( next ) next();
+		else packSlots.busy --;
+
+	};
+
+}
+
 // A bucket array carries ONE colorSpace and the shader reads each slot from a fixed pool, so a
 // texture disagreeing with its pool cannot be re-routed — its pixels are re-encoded instead.
 const TRANSFER_LUT = { toSRGB: null, toLinear: null };
@@ -529,6 +553,7 @@ export class TextureCreator {
 	/** A failed map array leaves those surfaces untextured — complete-looking and wrong. @private */
 	_reportTextureFailure( map, error ) {
 
+		if ( error instanceof EngineIssueError ) throw error;
 		this._issues?.record(
 			ISSUE_CODES.TEXTURE_BUILD_FAILED,
 			`${map} texture array failed to build — those surfaces render untextured`,
@@ -537,6 +562,17 @@ export class TextureCreator {
 
 	}
 
+	// Layers are addressed by position, so a texture that cannot be read keeps its slot.
+	_reportTextureLayer( layer, cause ) {
+
+		this._issues?.record(
+			ISSUE_CODES.TEXTURE_BUILD_FAILED,
+			`texture ${layer} could not be read — its surfaces show a white placeholder`,
+			{ layer, cause: String( cause?.message ?? cause ) }
+		);
+
+	}
+
 	_clampTextureSize( size ) {
 
 		const n = Math.floor( Number( size ) || TEXTURE_CONSTANTS.DEFAULT_MAX_TEXTURE_SIZE );
@@ -562,7 +598,7 @@ export class TextureCreator {
 			offscreenCanvas: typeof OffscreenCanvas !== 'undefined',
 			imageBitmap: typeof createImageBitmap !== 'undefined',
 			workers: typeof Worker !== 'undefined',
-			hardwareConcurrency: navigator.hardwareConcurrency || 4
+			hardwareConcurrency: hardwareThreads()
 		};
 
 	}
@@ -775,6 +811,16 @@ export class TextureCreator {
 		const cached = this.textureCache.get( cacheKey );
 		if ( cached ) return cached;
 
+		if ( typeof createImageBitmap === 'undefined' ) {
+
+			const packed = await this.processOnCPU( textures );
+			const reencoded = this._harmonizeTransfer( packed, textures, srgbPool );
+			this._applyColorManagement( packed, textures, srgbPool, reencoded );
+			this.textureCache.set( cacheKey, packed );
+			return packed;
+
+		}
+
 		// Normalize non-drawable images (KTX2 CompressedTexture RGBA, DataTexture)
 		const { normalized, bitmapsToClose } = await this._normalizeTexturesForProcessing( textures );
 
@@ -813,6 +859,7 @@ export class TextureCreator {
 
 		} catch ( error ) {
 
+			if ( error instanceof EngineIssueError ) throw error;
 			this._issues?.warn(
 				ISSUE_CODES.TEXTURE_PROCESSING_FALLBACK,
 				'worker texture processing failed — retrying on the main thread',
@@ -885,9 +932,9 @@ export class TextureCreator {
 
 		this.activeWorkers ++;
 
-		try {
+		const worker = new TexturesWorker();
 
-			const worker = new TexturesWorker();
+		try {
 
 			// Prepare textures for worker with direct transfer
 			const texturesData = await this.prepareTexturesForWorkerDirect( textures );
@@ -934,11 +981,11 @@ export class TextureCreator {
 
 			} );
 
-			worker.terminate();
 			return this.createDataArrayTextureFromResult( result );
 
 		} finally {
 
+			worker.terminate();
 			this.activeWorkers --;
 
 		}
@@ -949,10 +996,18 @@ export class TextureCreator {
 	async prepareTexturesForWorkerDirect( textures ) {
 
 		const texturesData = [];
+		const placeholder = () => ( { data: new Uint8ClampedArray( [ 255, 255, 255, 255 ] ).buffer, width: 1, height: 1, isImageData: true } );
 
-		for ( const texture of textures ) {
+		for ( let layer = 0; layer < textures.length; layer ++ ) {
 
-			if ( ! texture?.image ) continue;
+			const texture = textures[ layer ];
+			if ( ! texture?.image ) {
+
+				this._reportTextureLayer( layer, 'no image' );
+				texturesData.push( placeholder() );
+				continue;
+
+			}
 
 			const flipY = texture.flipY !== false;
 
@@ -964,7 +1019,7 @@ export class TextureCreator {
 				// getImageData off the main thread (Option 2 blocks it per texture).
 				const img = texture.image;
 				const canDirect = typeof createImageBitmap !== 'undefined' && (
-					img instanceof HTMLImageElement
+					( typeof HTMLImageElement !== 'undefined' && img instanceof HTMLImageElement )
 					|| ( typeof ImageBitmap !== 'undefined' && img instanceof ImageBitmap )
 					|| ( typeof HTMLCanvasElement !== 'undefined' && img instanceof HTMLCanvasElement )
 					|| ( typeof OffscreenCanvas !== 'undefined' && img instanceof OffscreenCanvas )
@@ -1008,7 +1063,8 @@ export class TextureCreator {
 
 			} catch ( error ) {
 
-				console.warn( 'Failed to prepare texture for worker:', error );
+				this._reportTextureLayer( layer, error );
+				texturesData.push( placeholder() );
 
 			}
 
@@ -1018,6 +1074,93 @@ export class TextureCreator {
 
 	}
 
+	/**
+	 * Packing without a browser (no createImageBitmap, no 2D canvas): each layer must already be
+	 * pixels — a DataTexture, or an image the platform's decodeImage decoded. A layer that matches its
+	 * bucket is copied exactly; one that does not is resampled bilinearly, where a browser's canvas
+	 * would use its own filter, so those texels can differ slightly from a browser render. A large
+	 * bucket packs in a worker: on the main thread it starved the BVH workers of their next task.
+	 */
+	async processOnCPU( textures ) {
+
+		const layers = textures.map( ( texture, layer ) => {
+
+			const image = texture?.image;
+			const pixels = texture?.isCompressedTexture ? texture.mipmaps?.[ 0 ] : image;
+			const data = pixels?.data;
+			if ( data && pixels.width > 0 && pixels.height > 0 && data.byteLength >= pixels.width * pixels.height * 4 ) {
+
+				return { data: new Uint8Array( data.buffer, data.byteOffset, pixels.width * pixels.height * 4 ), width: pixels.width, height: pixels.height, flipY: texture.flipY !== false };
+
+			}
+
+			this._reportTextureLayer( layer, image ? 'not decoded to pixels, and there is no browser to decode it' : 'no image' );
+			return { data: new Uint8Array( [ 255, 255, 255, 255 ] ), width: 1, height: 1, flipY: false };
+
+		} );
+
+		const { maxWidth, maxHeight } = this.calculateOptimalDimensions( layers.map( ( image ) => ( { image } ) ) );
+		const layerBytes = maxWidth * maxHeight * 4;
+
+		const packed = hasWorkers() && layerBytes * layers.length >= WORKER_PACK_BYTES
+			? await this._packInWorker( layers, maxWidth, maxHeight )
+			: null;
+		if ( packed ) return this.createDataArrayTextureFromBuffer( packed, maxWidth, maxHeight, layers.length );
+
+		const data = this.bufferPool.getBuffer( layerBytes * layers.length, Uint8Array );
+		layers.forEach( ( layer, i ) => resampleRGBA8( layer, data, i * layerBytes, maxWidth, maxHeight ) );
+
+		return this.createDataArrayTextureFromBuffer( data, maxWidth, maxHeight, layers.length );
+
+	}
+
+	/** The packed pixels, or null to pack on the main thread instead. */
+	async _packInWorker( layers, width, height ) {
+
+		const release = await acquirePackSlot();
+		let worker = null;
+
+		try {
+
+			// A SharedArrayBuffer view crosses as itself; anything else as a copy of just its bytes,
+			// made only once this bucket has its slot so waiting buckets hold no copies.
+			const transfer = [];
+			const sent = layers.map( ( layer ) => {
+
+				if ( typeof SharedArrayBuffer !== 'undefined' && layer.data.buffer instanceof SharedArrayBuffer ) return layer;
+				const data = layer.data.slice();
+				transfer.push( data.buffer );
+				return { ...layer, data };
+
+			} );
+
+			worker = createWorker( PackWorker );
+			return await new Promise( ( resolve, reject ) => {
+
+				worker.onmessage = ( e ) => ( e.data.error ? reject( new Error( e.data.error ) ) : resolve( e.data.data ) );
+				worker.onerror = ( e ) => reject( e.error ?? new Error( e.message ?? 'texture pack worker failed' ) );
+				worker.postMessage( { layers: sent, width, height }, transfer );
+
+			} );
+
+		} catch ( error ) {
+
+			this._issues?.warn(
+				ISSUE_CODES.TEXTURE_PROCESSING_FALLBACK,
+				'worker texture packing failed — packing on the main thread',
+				{ cause: String( error?.message ?? error ) }
+			);
+			return null;
+
+		} finally {
+
+			worker?.terminate();
+			release();
+
+		}
+
+	}
+
 	async processOnMainThreadBatch( textures, batchSize ) {
 
 		const validTextures = textures.filter( tex => tex?.image );
@@ -1465,7 +1608,13 @@ export class TextureCreator {
 
 		for ( const tex of textures ) {
 
-			if ( ! tex?.image ) continue;
+			if ( ! tex?.image ) {
+
+				this._reportTextureLayer( normalized.length, 'no image' );
+				normalized.push( null );
+				continue;
+
+			}
 
 			// RGBA CompressedTexture (KTX2 Basis transcode wraps output as CompressedTexture)
 			if ( tex.isCompressedTexture && tex.format === RGBAFormat && tex.mipmaps?.[ 0 ]?.data ) {
@@ -1489,8 +1638,8 @@ export class TextureCreator {
 			}
 
 			// DataTexture with raw pixel array
-			if ( tex.image.data && ! ( tex.image instanceof HTMLImageElement ) &&
-				! ( tex.image instanceof HTMLCanvasElement ) &&
+			if ( tex.image.data && ! ( typeof HTMLImageElement !== 'undefined' && tex.image instanceof HTMLImageElement ) &&
+				! ( typeof HTMLCanvasElement !== 'undefined' && tex.image instanceof HTMLCanvasElement ) &&
 				! ( typeof ImageBitmap !== 'undefined' && tex.image instanceof ImageBitmap ) ) {
 
 				const idx = normalized.length;
@@ -1522,7 +1671,7 @@ export class TextureCreator {
 
 				} else {
 
-					console.warn( '[TextureCreator] Failed to create ImageBitmap:', result.reason );
+					this._reportTextureLayer( index, result.reason );
 
 				}
 

package/src/Processor/Workers/PackWorker.js

@@ -0,0 +1,28 @@
+/**
+ * Packs RGBA8 layers into one texture array off the main thread, for hosts without a browser, where
+ * TextureCreator.processOnCPU would otherwise hold up the BVH workers it feeds.
+ *
+ * Input:  { layers: [{ data: Uint8Array (SharedArrayBuffer-backed), width, height, flipY }], width, height }
+ * Output: { data: Uint8Array } — its buffer transferred
+ */
+
+import { resampleRGBA8 } from '../ResampleRGBA8.js';
+
+self.onmessage = function ( e ) {
+
+	const { layers, width, height } = e.data;
+
+	try {
+
+		const layerBytes = width * height * 4;
+		const data = new Uint8Array( layerBytes * layers.length );
+		layers.forEach( ( layer, i ) => resampleRGBA8( layer, data, i * layerBytes, width, height ) );
+		self.postMessage( { data }, [ data.buffer ] );
+
+	} catch ( error ) {
+
+		self.postMessage( { error: error.message } );
+
+	}
+
+};

package/src/Stages/Compositor.js

@@ -4,6 +4,16 @@ import { NoBlending, NoToneMapping } from 'three';
 import { RenderStage, StageExecutionMode } from '../Pipeline/RenderStage.js';
 import { REC709_LUMINANCE_COEFFICIENTS } from '../TSL/Common.js';
 
+// In priority order: the first one published wins.
+const LIGHT_SOURCES = [
+	'oidn:output',
+	'edgeFiltering:output',
+	'bilateralFiltering:output',
+	'asvgf:output',
+	'nrd:output',
+	'pathtracer:color',
+];
+
 /**
  * Compositor — Terminal pipeline stage.
  *
@@ -76,12 +86,21 @@ export class Compositor extends RenderStage {
 	 */
 	resolveLightTexture( context ) {
 
-		return context.getTexture( 'oidn:output' )
-			|| context.getTexture( 'edgeFiltering:output' )
-			|| context.getTexture( 'bilateralFiltering:output' )
-			|| context.getTexture( 'asvgf:output' )
-			|| context.getTexture( 'nrd:output' )
-			|| context.getTexture( 'pathtracer:color' );
+		return this.resolveLightSource( context )?.texture ?? null;
+
+	}
+
+	/** {@link resolveLightTexture} plus the context key it came from. */
+	resolveLightSource( context ) {
+
+		for ( const key of LIGHT_SOURCES ) {
+
+			const texture = context.getTexture( key );
+			if ( texture ) return { key, texture };
+
+		}
+
+		return null;
 
 	}
 

package/src/Stages/PathTracer.js

@@ -25,6 +25,7 @@ import {
 } from '../TSL/SortGlobalKernels.js';
 import { ENGINE_DEFAULTS, MAX_STORAGE_TEXTURE_SIZE } from '../EngineDefaults.js';
 import { createLogger, fmt } from '../utils/Logger.js';
+import { deviceMemoryGB } from '../Processor/HostMemory.js';
 import {
 	Fn, uint, int, atomicStore, atomicLoad, atomicAdd, instanceIndex, If, Return,
 } from 'three/tsl';
@@ -113,6 +114,11 @@ export class PathTracer extends PathTracerStage {
 		this._geometryPixelCount = 0;
 		this._convergedReadbackPending = false;
 
+		// Lockstep: readbacks issued on a fixed cadence and applied a fixed number of frames later,
+		// so when one lands cannot change the image. { due, read, apply } while one is in flight.
+		this._lockstep = false;
+		this._lockstepRead = null;
+
 		// Tier-2: last settled active-pixel count (maxRays − frozen), sizes next frame's bounce-0 grid.
 		// 0 until a settled readback lands (and on reset/camera-move/resize) → grid stays full-size until then.
 		this._lastActivePixelCount = 0;
@@ -131,6 +137,7 @@ export class PathTracer extends PathTracerStage {
 		this._wfIsFirstChunk = uniform( 1, 'uint' ); // 1 → zero frame-scoped counters (CONVERGED/FROZEN)
 		this._pathBudget = 0; // B, paths-in-flight; computed once from device limits in _buildWavefrontKernels
 		this._pathBudgetOverride = 0; // test hook: force B (0 = derive from device)
+		this.hostMemoryGB = options.hostMemoryGB;
 		this._chunkRows = 0; // rows per chunk = floor(B / renderWidth), clamped ≥1
 		this._numChunks = 1; // ceil(renderHeight / chunkRows)
 
@@ -244,6 +251,15 @@ export class PathTracer extends PathTracerStage {
 
 		}
 
+		const lockstepRead = this._lockstepRead;
+		if ( lockstepRead && this.frameCount >= lockstepRead.due ) {
+
+			if ( ! lockstepRead.apply ) return; // see readbackWait()
+			this._lockstepRead = null;
+			lockstepRead.apply();
+
+		}
+
 		if ( this.isComplete || this.frameCount >= this.completionThreshold || this._isConvergedComplete() ) {
 
 			// Denoiser switched on after the render finished — spend one more frame to fill the aux MRT.
@@ -657,6 +673,54 @@ export class PathTracer extends PathTracerStage {
 		this._auxSamples = 0;
 		this._auxSeedPending = false;
 
+		if ( this._lockstep ) {
+
+			// Nothing measured by the previous render may steer this one.
+			this._lockstepRead = null;
+			this._readbackGeneration ++;
+			this._lastBounceCounts = null;
+			this._lastBounceEnergy = null;
+			this._lastBounceCountsBudget = - 1;
+			this._lastBounceCountsLoopBound = - 1;
+			this._curveSizingValid = false;
+
+		}
+
+	}
+
+	/**
+	 * Lockstep readbacks: the survivor curve and the convergence counters are read every N frames
+	 * and applied exactly N frames later, waiting when they have not landed, and every reset starts
+	 * from nothing measured and from seed 0. The same input then renders the same image however fast
+	 * frames are submitted. Off by default: waiting costs a stall whenever the GPU falls N frames behind.
+	 * @param {boolean} enabled
+	 */
+	setLockstepReadbacks( enabled ) {
+
+		enabled = !! enabled;
+		if ( enabled === this._lockstep ) return;
+		this._lockstep = enabled;
+		this._lockstepRead = null;
+		this._readbackGeneration ++;
+
+	}
+
+	get lockstepReadbacks() {
+
+		return this._lockstep;
+
+	}
+
+	/**
+	 * While a lockstep readback is due and has not landed, render() traces nothing: await this
+	 * before the next frame. Null otherwise.
+	 * @returns {?Promise<void>}
+	 */
+	readbackWait() {
+
+		const pending = this._lockstepRead;
+		return pending && ! pending.apply && this.frameCount >= pending.due ? pending.read : null;
+
 	}
 
 	/**
@@ -805,6 +869,7 @@ export class PathTracer extends PathTracerStage {
 	_willReadCountersThisFrame() {
 
 		if ( this.cameraChanged || this.cameraOptimizer?.isInInteractionMode() ) return false;
+		if ( this._lockstep ) return ! this._lockstepRead && this.frameCount % this._readbackEveryNFrames === 0;
 		if ( this._readbackPending || this._convergedReadbackPending ) return false;
 		return this._readbackFrameCounter + 1 >= this._readbackEveryNFrames;
 
@@ -819,6 +884,13 @@ export class PathTracer extends PathTracerStage {
 	// Async readback of the per-bounce snapshot every N frames; never awaited, so the early-exit uses past-frame data.
 	_maybeReadbackCounters() {
 
+		if ( this._lockstep ) {
+
+			this._issueLockstepReadback();
+			return;
+
+		}
+
 		// Never sample the survivor curve mid-motion, nor while the CameraOptimizer is holding maxBounces
 		// down to its interaction value (1): mid-motion counts belong to a pose we're leaving, and a curve
 		// measured at the interaction budget stores _lastBounceCountsBudget=1 — when the real (high) budget
@@ -864,16 +936,7 @@ export class PathTracer extends PathTracerStage {
 			// Drop counts measured at a now-stale generation (a resize or camera move happened mid-flight).
 			// A surviving readback was initiated while settled (init is skipped mid-motion) and no motion
 			// happened before it resolved, so its counts match the current view — safe to size from.
-			if ( gen === this._readbackGeneration ) {
-
-				const all = new Uint32Array( buf.slice( 0 ) );
-				this._lastBounceCounts = all.subarray( 0, n );
-				this._lastBounceEnergy = all.subarray( n, 2 * n );
-				this._lastBounceCountsBudget = budget;
-				this._lastBounceCountsLoopBound = measuredLoopBound;
-				this._curveSizingValid = true;
-
-			}
+			if ( gen === this._readbackGeneration ) this._applyBounceCounts( buf, budget, measuredLoopBound, n );
 
 			this._readbackPending = false;
 
@@ -899,19 +962,7 @@ export class PathTracer extends PathTracerStage {
 				const total = this._wfRenderWidth.value * this._wfRenderHeight.value;
 				this.renderer.getArrayBufferAsync( cAttr ).then( ( buf ) => {
 
-					if ( cgen === this._readbackGeneration && total > 0 ) {
-
-						const c = new Uint32Array( buf );
-						this._convergedFraction = c[ COUNTER.CONVERGED_COUNT ] / total;
-						// No geometry at all (pure environment) leaves nothing to gate on — 1 lets the
-						// whole-frame fraction decide alone.
-						const geo = c[ COUNTER.GEOMETRY_COUNT ];
-						this._geometryPixelCount = geo;
-						this._convergedGeometryFraction = geo > 0 ? c[ COUNTER.CONVERGED_GEOMETRY_COUNT ] / geo : 1;
-						// Tier-2: bounce-0 active-pixel count measured this settled frame → sizes next frame's grid.
-						this._lastActivePixelCount = c[ COUNTER.ACTIVE_PIXEL_COUNT ];
-
-					}
+					if ( cgen === this._readbackGeneration && total > 0 ) this._applyCounters( buf, total );
 
 					this._convergedReadbackPending = false;
 
@@ -927,6 +978,72 @@ export class PathTracer extends PathTracerStage {
 
 	}
 
+	_issueLockstepReadback() {
+
+		// One in flight, and none mid-motion: frames there do not count, so frameCount stands still.
+		if ( this._lockstepRead || this.frameCount % this._readbackEveryNFrames !== 0 ) return;
+		if ( this.cameraChanged || this.cameraOptimizer?.isInInteractionMode() ) return;
+
+		const bounceAttr = this._queueManager?.getBounceCountsAttribute();
+		const counterAttr = this._queueManager?.getCountersAttribute();
+		if ( ! bounceAttr || ! counterAttr ) return;
+
+		const gen = this._readbackGeneration;
+		const budget = this.maxBounces.value;
+		const loopBound = this._bounceLoopBound();
+		const n = this._queueManager.MAX_BOUNCE_SNAPSHOTS;
+		const total = this._wfRenderWidth.value * this._wfRenderHeight.value;
+
+		const entry = { due: this.frameCount + this._readbackEveryNFrames, read: null, apply: null };
+		entry.read = Promise.all( [
+			this.renderer.getArrayBufferAsync( bounceAttr ),
+			this.renderer.getArrayBufferAsync( counterAttr ),
+		] ).then( ( [ bounceBuf, counterBuf ] ) => {
+
+			entry.apply = () => {
+
+				if ( gen !== this._readbackGeneration ) return;
+				this._applyBounceCounts( bounceBuf, budget, loopBound, n );
+				if ( total > 0 ) this._applyCounters( counterBuf, total );
+
+			};
+
+		}, ( e ) => {
+
+			log.warn( 'lockstep readback failed:', e );
+			entry.apply = () => {};
+
+		} );
+
+		this._lockstepRead = entry;
+
+	}
+
+	_applyBounceCounts( buf, budget, loopBound, n ) {
+
+		const all = new Uint32Array( buf.slice( 0 ) );
+		this._lastBounceCounts = all.subarray( 0, n );
+		this._lastBounceEnergy = all.subarray( n, 2 * n );
+		this._lastBounceCountsBudget = budget;
+		this._lastBounceCountsLoopBound = loopBound;
+		this._curveSizingValid = true;
+
+	}
+
+	_applyCounters( buf, total ) {
+
+		const c = new Uint32Array( buf );
+		this._convergedFraction = c[ COUNTER.CONVERGED_COUNT ] / total;
+		// No geometry at all (pure environment) leaves nothing to gate on — 1 lets the
+		// whole-frame fraction decide alone.
+		const geo = c[ COUNTER.GEOMETRY_COUNT ];
+		this._geometryPixelCount = geo;
+		this._convergedGeometryFraction = geo > 0 ? c[ COUNTER.CONVERGED_GEOMETRY_COUNT ] / geo : 1;
+		// Tier-2: bounce-0 active-pixel count measured this settled frame → sizes next frame's grid.
+		this._lastActivePixelCount = c[ COUNTER.ACTIVE_PIXEL_COUNT ];
+
+	}
+
 	// Sync wavefront's texture nodes with current env/material textures; only a changed ref triggers GPU rebind.
 	_refreshWfTextureNodes() {
 
@@ -1031,7 +1148,7 @@ export class PathTracer extends PathTracerStage {
 		const maxBuffer = limits?.maxBufferSize || maxBinding;
 
 		const bByBinding = Math.floor( ( maxBinding * 0.9 ) / RAY_BYTES );
-		const deviceMemBytes = ( ( typeof navigator !== 'undefined' && navigator.deviceMemory ) || 4 ) * 1024 * 1024 * 1024;
+		const deviceMemBytes = deviceMemoryGB( this.hostMemoryGB ).gb * 1024 * 1024 * 1024;
 		const poolVramBudget = Math.min( deviceMemBytes * 0.25, maxBuffer * 4 );
 		const bByVram = Math.floor( poolVramBudget / bytesPerPath );
 
@@ -1596,7 +1713,7 @@ export class PathTracer extends PathTracerStage {
 			cameraViewMatrix: this.cameraViewMatrix,
 			fireflyThreshold: this.fireflyThreshold,
 			shadowTerminatorOffset: this.shadowTerminatorOffset,
-			// RNG axis only (keys STBN via frame & 63).
+			// RNG axis only.
 			frame: this.seedFrame,
 			accumFrame: this.frame,
 			resolution: this.resolution,