rayzee 9.3.3 → 9.4.0

package/src/Storage/StorageManager.js

@@ -17,6 +17,8 @@ const MAX_DEFAULT_BUDGET = 100 * 1024 ** 3;
 const FREE_MARGIN = 64 * 1024 ** 2;
 const STREAM_BATCH = 8 * 1024 ** 2;
 const STREAM_WINDOW = 4;
+// Other tabs write too, so the cache total kept in memory is listed again at most this often.
+const CACHE_TOTAL_TTL_MS = 30_000;
 
 const encoder = new TextEncoder();
 
@@ -152,6 +154,7 @@ export class EntryWriter {
 		this._sizes = { ...sizes };
 		this._append = append;
 		this._done = false;
+		this._committedBytes = append ? Object.values( sizes ).reduce( ( n, b ) => n + b, 0 ) : 0;
 
 	}
 
@@ -313,6 +316,7 @@ export class EntryWriter {
 
 			const { args, list } = transferable( JSON.stringify( meta ), { copy: false } );
 			await this._transport.call( 'writeFile', { path: this._path, name: META, ...args }, list );
+			if ( this.area.kind === STORAGE_KIND.CACHE ) this.area.manager._countCacheBytes( meta.bytes - this._committedBytes );
 			this.area.manager._changed( this.area.name );
 			return meta;
 
@@ -700,6 +704,7 @@ export class StorageManager extends Emitter {
 		this._transport = transport;
 		this._areas = new Map();
 		this._budget = null;
+		this._cacheTotal = null;
 
 		for ( const name of Object.values( ENGINE_AREAS ) ) this.defineArea( name, { kind: name === ENGINE_AREAS.SPILL ? STORAGE_KIND.SCRATCH : STORAGE_KIND.CACHE } );
 
@@ -775,6 +780,40 @@ export class StorageManager extends Emitter {
 
 	}
 
+	/**
+	 * What cache areas hold together. Every new download asks, and a listing reads every entry's
+	 * metadata, so it is listed once and kept current by this manager's own commits.
+	 */
+	async _cacheBytes() {
+
+		let total = this._cacheTotal;
+		if ( ! total || Date.now() - total.at > CACHE_TOTAL_TTL_MS ) {
+
+			total = this._cacheTotal = { at: Date.now(), bytes: 0, ready: null };
+			total.ready = this._cacheEntries().then( ( entries ) => {
+
+				total.bytes += entries.reduce( ( n, e ) => n + ( e.meta.bytes ?? 0 ), 0 );
+
+			} );
+			total.ready.catch( () => {
+
+				if ( this._cacheTotal === total ) this._cacheTotal = null;
+
+			} );
+
+		}
+
+		await total.ready;
+		return total.bytes;
+
+	}
+
+	_countCacheBytes( bytes ) {
+
+		if ( this._cacheTotal ) this._cacheTotal.bytes += bytes;
+
+	}
+
 	async _cacheEntries() {
 
 		const out = [];
@@ -816,8 +855,8 @@ export class StorageManager extends Emitter {
 
 		const entries = await this._cacheEntries();
 		const budget = await this.budget();
-		let cacheBytes = entries.reduce( ( n, e ) => n + ( e.meta.bytes ?? 0 ), 0 );
-		const target = freeBytes ?? Math.max( 0, cacheBytes - budget );
+		const total = this._cacheTotal = { at: Date.now(), bytes: entries.reduce( ( n, e ) => n + ( e.meta.bytes ?? 0 ), 0 ), ready: null };
+		const target = freeBytes ?? Math.max( 0, total.bytes - budget );
 		if ( target <= 0 ) return 0;
 
 		const held = await heldLockNames();
@@ -832,7 +871,7 @@ export class StorageManager extends Emitter {
 			if ( await area.removeById( meta.id ) ) {
 
 				freed += meta.bytes ?? 0;
-				cacheBytes -= meta.bytes ?? 0;
+				total.bytes -= meta.bytes ?? 0;
 
 			}
 
@@ -855,8 +894,7 @@ export class StorageManager extends Emitter {
 			const free = bytes + FREE_MARGIN - ( quota - usage );
 			if ( kind !== STORAGE_KIND.CACHE ) return { free, budget: 0 };
 
-			const cacheBytes = ( await this._cacheEntries() ).reduce( ( n, e ) => n + ( e.meta.bytes ?? 0 ), 0 );
-			return { free, budget: cacheBytes + bytes - await this.budget() };
+			return { free, budget: await this._cacheBytes() + bytes - await this.budget() };
 
 		};
 

package/src/managers/GoboManager.js

@@ -71,6 +71,7 @@ export class GoboManager {
 		cnv.width = width;
 		cnv.height = height;
 		const ctx = cnv.getContext( '2d', { willReadFrequently: true } );
+		let lastYield = performance.now();
 
 		for ( let i = 0; i < depth; i ++ ) {
 
@@ -79,6 +80,14 @@ export class GoboManager {
 			const img = ctx.getImageData( 0, 0, width, height );
 			data.set( img.data, i * width * height * 4 );
 
+			// Each first draw decodes its image, so the library packs in short tasks.
+			if ( performance.now() - lastYield > 16 ) {
+
+				await new Promise( resolve => setTimeout( resolve, 0 ) );
+				lastYield = performance.now();
+
+			}
+
 		}
 
 		const tex = new DataArrayTexture( data, width, height, depth );

package/src/managers/UniformManager.js

@@ -19,6 +19,31 @@ const SHADER_NAMES = {
 	cameraProjectionMatrix: 'ptCameraProjectionMatrix',
 };
 
+/** Floats per light in each type's list (see LightSerializer). */
+export const LIGHT_FLOATS = Object.freeze( {
+	directional: 12, // 8 light fields + gobo { index, signed intensity, scale, pad }
+	area: 16, // 13 base + normalize, spread, shape
+	point: 9,
+	spot: 20, // 14 light fields + gobo { index, signed intensity } + IES { index, intensity } + 2 reserved
+} );
+
+/** Lights a list holds before it has to grow. */
+export const LIGHT_LIST_STEP = 16;
+
+// A uniform array gives each float its own vec4; WebGPU guarantees 64 KiB a binding.
+const MAX_UNIFORM_ELEMENTS = 65536 / 16;
+
+/**
+ * Lights a list of this type must hold for `lights`: a whole number of steps, but never past what
+ * fits a binding unless `lights` alone already does — a count that did not fit never did.
+ */
+export function lightListCapacity( type, lights ) {
+
+	const stepped = Math.ceil( lights / LIGHT_LIST_STEP ) * LIGHT_LIST_STEP;
+	return Math.max( lights, Math.min( stepped, Math.floor( MAX_UNIFORM_ELEMENTS / LIGHT_FLOATS[ type ] ) ) );
+
+}
+
 export class UniformManager {
 
 	constructor( width = 1920, height = 1080 ) {
@@ -266,13 +291,11 @@ export class UniformManager {
 		u( 'numPointLights', 0, 'int' );
 		u( 'numSpotLights', 0, 'int' );
 
-		// Light buffer nodes - pre-allocate for up to 16 lights per type (shader hard cap)
-		this._lightBuffers = {
-			directional: uniformArray( new Float32Array( 12 * 16 ), 'float' ),
-			area: uniformArray( new Float32Array( 16 * 16 ), 'float' ),
-			point: uniformArray( new Float32Array( 9 * 16 ), 'float' ),
-			spot: uniformArray( new Float32Array( 20 * 16 ), 'float' ),
-		};
+		// The shader bakes each list's length, so lights are written into these in place and a list is
+		// only replaced when a scene has more lights than it holds (PathTracerStage._writeLightList).
+		this._lightBuffers = Object.fromEntries( Object.entries( LIGHT_FLOATS ).map(
+			( [ type, floats ] ) => [ type, uniformArray( new Float32Array( floats * LIGHT_LIST_STEP ), 'float' ) ]
+		) );
 
 		// Camera matrices
 		u( 'cameraWorldMatrix', new Matrix4(), 'mat4' );