rayzee 9.3.3 → 9.4.1

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/CameraManager.js

@@ -312,40 +312,7 @@ export class CameraManager extends EventDispatcher {
 
 		} else {
 
-			const sourceCamera = this.cameras[ index ];
-
-			this.camera.position.copy( sourceCamera.position );
-			this.camera.quaternion.copy( sourceCamera.quaternion );
-			// An imported camera can carry a mirror (a negative axis scale) that no
-			// quaternion can express — a pbrt scene's `Scale -1 1 1`, for one. Copying
-			// pose alone would silently un-mirror the view.
-			this.camera.scale.copy( sourceCamera.scale );
-			if ( sourceCamera.isPerspectiveCamera ) this.camera.fov = sourceCamera.fov;
-			this.camera.near = sourceCamera.near;
-			this.camera.far = sourceCamera.far;
-			this.camera.updateProjectionMatrix();
-			this.camera.updateMatrixWorld( true );
-
-			// Restore the saved orbit target for user cameras; otherwise place it
-			// along the forward direction at the focus distance.
-			if ( this.controls ) {
-
-				const savedTarget = sourceCamera.userData?.__rayzeeOrbitTarget;
-				if ( savedTarget ) {
-
-					this.controls.target.copy( savedTarget );
-
-				} else {
-
-					const forward = new Vector3( 0, 0, - 1 ).applyQuaternion( sourceCamera.quaternion );
-					const focusDist = focusDistance || 5.0;
-					this.controls.target.copy( this.camera.position ).addScaledVector( forward, focusDist );
-
-				}
-
-				this.controls.update();
-
-			}
+			this._placeAt( this.cameras[ index ], focusDistance );
 
 		}
 
@@ -370,6 +337,60 @@ export class CameraManager extends EventDispatcher {
 
 	}
 
+	/**
+	 * Puts the active camera back at the view it starts from: the default camera at the framing the
+	 * model loaded with, any other at its own pose and lens. Its effects and projection stay.
+	 */
+	resetView() {
+
+		const source = this.currentCameraIndex > 0 ? this.cameras[ this.currentCameraIndex ] : null;
+		if ( ! source ) {
+
+			this.controls.reset();
+			return;
+
+		}
+
+		this._placeAt( source, this._getSettings?.( 'focusDistance' ) );
+		const height = orthoHeightOf( source );
+		if ( this.camera.orthographic ) this._setView( true, height ? height / 2 : this.camera.orthoHalfHeight );
+		this._onReset?.();
+
+	}
+
+	// The view takes a camera's pose and lens, orbiting its saved target or a point ahead at the focus distance.
+	_placeAt( source, focusDistance ) {
+
+		this.camera.position.copy( source.position );
+		this.camera.quaternion.copy( source.quaternion );
+		// An imported camera can carry a mirror (a negative axis scale) that no
+		// quaternion can express — a pbrt scene's `Scale -1 1 1`, for one. Copying
+		// pose alone would silently un-mirror the view.
+		this.camera.scale.copy( source.scale );
+		if ( source.isPerspectiveCamera ) this.camera.fov = source.fov;
+		this.camera.near = source.near;
+		this.camera.far = source.far;
+		this.camera.updateProjectionMatrix();
+		this.camera.updateMatrixWorld( true );
+
+		if ( ! this.controls ) return;
+
+		const savedTarget = source.userData?.__rayzeeOrbitTarget;
+		if ( savedTarget ) {
+
+			this.controls.target.copy( savedTarget );
+
+		} else {
+
+			const forward = new Vector3( 0, 0, - 1 ).applyQuaternion( source.quaternion );
+			this.controls.target.copy( this.camera.position ).addScaledVector( forward, focusDistance || 5.0 );
+
+		}
+
+		this.controls.update();
+
+	}
+
 	/**
 	 * Makes the camera orthographic at `height`, or perspective for null, then hands the `cameraProjection`
 	 * setting the outcome — after, so its handler finds the camera already there. A 360° panorama stays on

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' );