rayzee 11.12.0 → 11.13.0

package/package.json

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

package/src/Processor/ArchiveImporter.js

@@ -21,7 +21,7 @@ import { ENGINE_AREAS } from '../Storage/areas.js';
 import { encodeSceneGraph, writeSceneGraph, decodeSceneGraph, SceneGraphUnsupported, SCENE_GRAPH_FORMAT, ARCHIVE_PATH, ARCHIVE_LOADER } from '../Storage/SceneGraphCodec.js';
 import { worthStoring } from '../Storage/sceneCachePolicy.js';
 import { VERSION } from '../version.js';
-import { updateLoading } from './utils';
+import { timeSlicer, updateLoading } from './utils';
 import { loadPBRTScene, pickEntryPath, VirtualFS, PBRT_BUILD_REVISION } from './PBRT/index.js';
 import { loadUSDScene, listUSDRootLayers, listUSDParts, USDFiles, USDStage, USD_LAYER } from './USD/index.js';
 import { pfmTexture } from './PBRT/PFM.js';
@@ -687,7 +687,7 @@ export class ArchiveImporter {
 			: null;
 
 		const stored = graphKey ? await this._loadStoredGraph( graphKey, source, { imageFromBytes, envFromBytes } ) : null;
-		const built = stored ?? await loadPBRTScene( { vfs: zip, source, entryPath, plyParser, imageFromBytes, envFromBytes, ...shape } );
+		const built = stored ?? await loadPBRTScene( { vfs: zip, source, entryPath, plyParser, imageFromBytes, envFromBytes, ...shape, pause: this._buildPause( timeSlicer() ) } );
 		this.loader._throwDeferred();
 
 		const { group, environment, animations, report, warnings, meshCount, entryPath: loadedEntry, candidates,
@@ -819,7 +819,7 @@ export class ArchiveImporter {
 		const url = ext === 'pfm' ? null : URL.createObjectURL( blob );
 		try {
 
-			const texture = url ? await this.loader.loadEnvironmentByExtension( url, ext, { loader: ext === 'exr' ? this._exrLoader() : null } ) : pfmTexture( bytes );
+			const texture = url ? await this.loader.loadEnvironmentByExtension( url, ext, { loader: ext === 'exr' ? this._exrLoader() : null, quiet: true } ) : pfmTexture( bytes );
 			texture.mapping = EquirectangularReflectionMapping;
 			setEnvironmentSource( texture, `bytes:${await sampleHash( blob )}` );
 			texture.userData[ ARCHIVE_PATH ] = fname;
@@ -863,8 +863,17 @@ export class ArchiveImporter {
 		if ( chosen.length === 0 ) await this._requireUSDPartChoice( filename, files, entryPath, options.listing ?? paths.map( path => ( { path, size: entries[ path ]?.size ?? entries[ path ]?.byteLength ?? 0 } ) ), options.promptBytes );
 
 		const start = performance.now();
+		const slice = timeSlicer();
 		const built = await loadUSDScene( {
 			files, entryPath,
+			pauseRead: ( prims, counting ) => {
+
+				const turn = slice();
+				if ( turn ) updateLoading( { status: `${counting ? 'Counting' : 'Reading'} USD scene... ${prims.toLocaleString()} prims`, progress: counting ? 5 : 6 } );
+				return turn;
+
+			},
+			pauseBuild: this._buildPause( slice ),
 			resolveImage: async path => {
 
 				const bytes = await files.read( path );
@@ -918,6 +927,19 @@ export class ArchiveImporter {
 
 	}
 
+	/** The scene builder's pause: a turn for the page whenever `slice` gives one, with how far the build is. @private */
+	_buildPause( slice ) {
+
+		return ( done, total ) => {
+
+			const turn = slice();
+			if ( turn ) updateLoading( { status: `Building scene... ${done.toLocaleString()} of ${total.toLocaleString()} shapes`, progress: 8 } );
+			return turn;
+
+		};
+
+	}
+
 	/** Asks which parts of a large USD scene to load. @private */
 	async _requireUSDPartChoice( filename, files, entryPath, listing, promptBytes = USD_ELEMENT_PROMPT_BYTES ) {
 

package/src/Processor/AssetLoader.js

@@ -9,7 +9,7 @@ import { clone as cloneWithSkeletons } from 'three/addons/utils/SkeletonUtils.js
 import { DownloadCache, nameFromUrl, cachedObjectURL } from '../Storage/DownloadCache.js';
 import { setEnvironmentSource } from '../Storage/CDFCache.js';
 import { fileIdentity, identityKey } from '../Storage/identity.js';
-import { disposeEngineOwnedResources, disposeObjectFromMemory, updateLoading } from './utils';
+import { computeInstanceBoundingBoxes, disposeEngineOwnedResources, disposeObjectFromMemory, updateLoading } from './utils';
 import { BuildTimer } from './BuildTimer.js';
 import { getPlatform, hasImageDecoder, withHostWorker } from '../Platform.js';
 import { loadPlatformImage, platformImagesPlugin, missingImageDecoderPlugin } from './PlatformImageLoader.js';
@@ -723,7 +723,8 @@ export class AssetLoader extends EventDispatcher {
 	 * @param {string} extension
 	 * @param {{loader?: Object}} [options] - a three.js loader to read the file with, for a format nothing registered
 	 */
-	async loadEnvironmentByExtension( url, extension, { loader = null } = {} ) {
+	/** `quiet` leaves the loading bar to a larger load this environment is part of. */
+	async loadEnvironmentByExtension( url, extension, { loader = null, quiet = false } = {} ) {
 
 		const format = this._formats.get( extension );
 		if ( ! loader && format?.type === 'environment' ) loader = this.loaderCache[ extension ] ??= await format.createLoader( this._loadingManager );
@@ -733,7 +734,7 @@ export class AssetLoader extends EventDispatcher {
 		const cancelable = AssetLoader._isNetworkUrl( url );
 		const status = "Downloading Environment...";
 		const source = await this._viaCache( url, status, cancelable );
-		const onProgress = source.cached ? undefined : this._downloadProgress( status, cancelable );
+		const onProgress = source.cached || quiet ? undefined : this._downloadProgress( status, cancelable );
 
 		let texture;
 		try {
@@ -763,7 +764,7 @@ export class AssetLoader extends EventDispatcher {
 
 		}
 
-		this._downloadComplete( "Processing Environment...", 62 );
+		if ( ! quiet ) this._downloadComplete( "Processing Environment...", 62 );
 
 		if ( this.maxEnvironmentWidth ) limitEnvironmentWidth( texture, this.maxEnvironmentWidth );
 		texture.mapping = EquirectangularReflectionMapping;
@@ -1042,6 +1043,7 @@ export class AssetLoader extends EventDispatcher {
 
 		// Center model and adjust camera
 		buildTimer.start( 'Camera setup' );
+		computeInstanceBoundingBoxes( model );
 		const box = new Box3().setFromObject( model );
 		const center = box.getCenter( new Vector3() );
 		const size = box.getSize( new Vector3() );

package/src/Processor/InstanceTable.js

@@ -550,10 +550,20 @@ export class InstanceTable {
 	 */
 	formClusters( world ) {
 
+		const steps = this.clusterSteps( world );
+		let step;
+		do step = steps.next(); while ( ! step.done );
+		return step.value;
+
+	}
+
+	/** {@link formClusters} in steps: yields how many entries have their cluster, and returns what it returns. */
+	* clusterSteps( world ) {
+
 		const n = this.entryCount;
 		const sorted = new Int32Array( n );
 		for ( let e = 0; e < n; e ++ ) sorted[ e ] = e;
-		splitIntoRuns( sorted, 0, n, world );
+		yield * splitIntoRuns( sorted, 0, n, world );
 
 		const bounds = new Float64Array( this.clusterCount * 6 );
 		for ( let c = 0; c < this.clusterCount; c ++ ) {
@@ -936,31 +946,31 @@ export class InstanceTable {
 	}
 
 	/**
-	 * Every TLAS entry's world-space bounds, 6 floats each — what the TLAS sorts on.
+	 * Every TLAS entry's world-space bounds, 6 floats each — what the TLAS sorts on; entries `[from, to)` only, if given.
 	 * @param {Float64Array|Float32Array} out
 	 */
-	writeEntryWorldAABBs( out ) {
+	writeEntryWorldAABBs( out, from = 0, to = this.entryCount ) {
 
 		if ( ! this.entryRep ) {
 
-			this.writeWorldAABBs( out );
+			this.writeWorldAABBs( out, from, to );
 			return;
 
 		}
 
-		for ( let e = 0; e < this.entryCount; e ++ ) this.writeEntryWorldAABB( e, out, e * 6 );
+		for ( let e = from; e < to; e ++ ) this.writeEntryWorldAABB( e, out, e * 6 );
 
 	}
 
 	/**
-	 * Every placement's world-space bounds, 6 floats each.
+	 * Every placement's world-space bounds, 6 floats each; placements `[from, to)` only, if given.
 	 * @param {Float64Array|Float32Array} out
 	 */
-	writeWorldAABBs( out ) {
+	writeWorldAABBs( out, from = 0, to = this.count ) {
 
 		const aabb = this.tplObjectAABB, src = this.sourceMesh, set = this.isSet;
 
-		for ( let i = 0; i < this.count; i ++ ) {
+		for ( let i = from; i < to; i ++ ) {
 
 			const o = i * 6;
 
@@ -1204,15 +1214,30 @@ const _recordInverse = new Float64Array( 16 );
 
 /**
  * Orders `sorted[ lo, hi )` so each run of CLUSTER_SIZE holds neighbours: halved at the centre median of the widest
- * axis, the lower part a whole number of runs, which keeps the run count ⌈n / CLUSTER_SIZE⌉.
+ * axis, the lower part a whole number of runs, which keeps the run count ⌈n / CLUSTER_SIZE⌉. Yields how many entries
+ * are in their run, about every million entries of work.
  */
-function splitIntoRuns( sorted, lo, hi, world ) {
+function * splitIntoRuns( sorted, lo, hi, world ) {
 
 	const stack = [ lo, hi ];
+	let placed = 0, work = 0;
 	while ( stack.length ) {
 
 		const end = stack.pop(), start = stack.pop();
-		if ( end - start <= CLUSTER_SIZE ) continue;
+		if ( end - start <= CLUSTER_SIZE ) {
+
+			placed += end - start;
+			continue;
+
+		}
+
+		work += end - start;
+		if ( work >= 1 << 20 ) {
+
+			work = 0;
+			yield placed;
+
+		}
 
 		let axis = 0, widest = - 1;
 		for ( let a = 0; a < 3; a ++ ) {

package/src/Processor/PBRT/PBRTCurves.js

@@ -467,9 +467,9 @@ function withIndex( P, widths, index, basis ) {
 
 /**
  * A USD BasisCurves prim's curves (one point array, a count per curve) as one strip mesh. Modes and types are USD's;
- * the first normal of a curve orients its ribbon.
+ * the first normal of a curve orients its ribbon. `pause()` is awaited every 1024 curves, and again as they are joined.
  */
-export function tessellateCurves( spec ) {
+export async function tessellateCurves( spec, pause = null ) {
 
 	const { P, counts, widths = null, widthMode = 'constant', N = null, normalMode = 'vertex', type = 'cubic', basis = 'bspline', wrap = 'nonperiodic' } = spec;
 	const pieces = [];
@@ -523,6 +523,7 @@ export function tessellateCurves( spec ) {
 		}
 
 		start += n;
+		if ( pause && ( c & 1023 ) === 1023 ) await pause();
 
 	}
 
@@ -530,12 +531,14 @@ export function tessellateCurves( spec ) {
 	const positions = new Float32Array( vertices * 3 );
 	const indices = new Uint32Array( indexCount );
 	let v = 0, i = 0;
-	for ( const piece of pieces ) {
+	for ( let p = 0; p < pieces.length; p ++ ) {
 
+		const piece = pieces[ p ];
 		positions.set( piece.positions, v * 3 );
 		for ( let k = 0; k < piece.indices.length; k ++ ) indices[ i + k ] = piece.indices[ k ] + v;
 		v += piece.positions.length / 3;
 		i += piece.indices.length;
+		if ( pause && ( p & 1023 ) === 1023 ) await pause();
 
 	}
 

package/src/Processor/PBRT/PBRTSceneBuilder.js

@@ -31,6 +31,7 @@ import { octahedralToEquirect } from './EqualAreaOctahedral.js';
 import { tessellateCurve, tessellateCurves } from './PBRTCurves.js';
 import * as M from './PBRTMath.js';
 import { packUnitAttribute } from '../GeometryExtractor.js';
+import { computeInstanceBoundingBoxes } from '../utils.js';
 
 const LAMP_TYPES = new Set( [ 'distant', 'point', 'spot' ] );
 
@@ -590,6 +591,8 @@ export class PBRTSceneBuilder {
 	 * @param {(filename:string)=>Promise<import('three').Texture>} [resolvers.resolveImage]
 	 * @param {(filename:string)=>Promise<import('three').Texture>} [resolvers.resolveEnvironment]
 	 * @param {boolean} [resolvers.convertHandedness=false]
+	 * @param {(done:number, total:number)=>?Promise} [resolvers.pause] - called as shapes are built; a promise it
+	 *   returns is waited on, which lets the host redraw
 	 */
 	constructor( resolvers = {} ) {
 
@@ -604,6 +607,9 @@ export class PBRTSceneBuilder {
 		this.resolveEnvironment = resolvers.resolveEnvironment || resolvers.resolveImage || ( async () => null );
 		this.convertHandedness = resolvers.convertHandedness === true;
 		this._usage = resolvers.usage ?? null;
+		this.pause = resolvers.pause ?? null;
+		this._shapesDone = 0;
+		this._shapeTotal = 0;
 
 		this.warnings = [];
 		this.report = []; // per-mesh diagnostics for debugging imports
@@ -629,6 +635,13 @@ export class PBRTSceneBuilder {
 
 	}
 
+	/** @private */
+	_tick() {
+
+		return this.pause ? this.pause( this._shapesDone, this._shapeTotal ) : null;
+
+	}
+
 	/**
 	 * @param {object} ir - output of PBRTParser
 	 * @returns {Promise<{group:Group, camera:PerspectiveCamera|OrthographicCamera|null, environment:object|null, warnings:string[]}>}
@@ -671,6 +684,9 @@ export class PBRTSceneBuilder {
 		this.mergedShapes = 0;
 		this.droppedNoTemplate = 0;
 		this._animated = []; // { node, motion }
+		this._shapesDone = 0;
+		this._shapeTotal = ir.shapes.length;
+		for ( const name of ir.instances.keys() ) this._shapeTotal += ir.objects.get( name )?.length ?? 0;
 
 		// Shapes (direct + instanced)
 		for ( let i = 0; i < ir.shapes.length; i ++ ) {
@@ -682,6 +698,8 @@ export class PBRTSceneBuilder {
 
 			}
 
+			this._shapesDone ++;
+			await this._tick();
 			const shape = ir.shapes[ i ];
 			const [ geometry, surface ] = await Promise.all( [
 				this._batches && ! shape.shared ? this._createGeometry( shape ) : this._buildGeometry( shape ),
@@ -843,6 +861,9 @@ export class PBRTSceneBuilder {
 
 			}
 
+			// While the matrices are still in memory: the scene's framing reads every box.
+			computeInstanceBoundingBoxes( mesh );
+
 			group.add( mesh );
 
 			this.reportedMeshes += count;
@@ -888,6 +909,7 @@ export class PBRTSceneBuilder {
 
 			for ( const shape of template ) {
 
+				this._shapesDone ++;
 				if ( this._overBudget() ) {
 
 					this.skippedForBudget += list.count;
@@ -895,6 +917,7 @@ export class PBRTSceneBuilder {
 
 				}
 
+				await this._tick();
 				const [ built, sharedMaterial ] = await Promise.all( [
 					this._buildGeometry( shape ),
 					this._getMaterial( shape )
@@ -1576,9 +1599,9 @@ export class PBRTSceneBuilder {
 	}
 
 	/** Many curves on one point array, as USD writes them. */
-	_curves( params ) {
+	async _curves( params ) {
 
-		const built = tessellateCurves( {
+		const built = await tessellateCurves( {
 			P: param( params, 'P' ).value,
 			counts: param( params, 'counts' ).value,
 			widths: param( params, 'widths' )?.value ?? null,
@@ -1591,7 +1614,7 @@ export class PBRTSceneBuilder {
 			steps: this.curveSteps,
 			sides: this.curveSides ?? 1,
 			tolerance: this.curveTolerance,
-		} );
+		}, () => this._tick() );
 
 		if ( ! built ) {
 

package/src/Processor/PBRT/index.js

@@ -493,6 +493,7 @@ export async function loadPBRTScene( args ) {
 		curveSteps: args.curveSteps,
 		curveSides: args.curveSides,
 		curveTolerance: args.curveTolerance,
+		pause: args.pause,
 		usage,
 		resolvePLY: async ( filename ) => {
 

package/src/Processor/SceneProcessor.js

@@ -12,7 +12,7 @@ import {
 import { TextureCreator } from './TextureCreator.js';
 import { GeometryExtractor, geometryBytesOf, usesTextureCoordinates } from './GeometryExtractor.js';
 import { EmissiveTriangleBuilder } from './EmissiveTriangleBuilder.js';
-import { updateLoading } from '../Processor/utils.js';
+import { timeSlicer, updateLoading } from '../Processor/utils.js';
 import { BuildTimer } from './BuildTimer.js';
 import { createLogger, fmt, workerLogLevel } from '../utils/Logger.js';
 import { Box3, Matrix4, SRGBColorSpace, Sphere, Vector3 } from 'three';
@@ -38,6 +38,8 @@ import { createWorker, hardwareThreads } from '../Platform.js';
 
 // Under this the TLAS build is a few ms; the worker round trip would cost more than it saves.
 const TLAS_WORKER_MIN_ENTRIES = 50_000;
+// Per-copy passes run in slices this long, with a turn for the page between them when one is due.
+const SLICE_RECORDS = 1 << 16;
 
 // Meshes past this build across every core, one at a time.
 const LARGE_MESH_TRIANGLES = 200000;
@@ -934,9 +936,11 @@ export class SceneProcessor {
 	 */
 	async _buildBVH() {
 
+		// A streamed build has reported its BLASes up to 35 % already.
+		const startProgress = this._streamed ? 35 : 25;
 		updateLoading( {
 			status: "Building BVH...",
-			progress: 25
+			progress: startProgress
 		} );
 
 		if ( this.triangleCount === 0 ) {
@@ -948,6 +952,7 @@ export class SceneProcessor {
 		this._log( 'Building two-level BVH (TLAS/BLAS)' );
 		this.memory.mark( 'blas' );
 		const startTime = performance.now();
+		this._slice = timeSlicer();
 
 		try {
 
@@ -996,6 +1001,7 @@ export class SceneProcessor {
 
 			for ( let m = 0; m < meshCount; m ++ ) {
 
+				if ( ( m & 0xffff ) === 0xffff ) await this._turn( 'Matching copies to their shapes', m, meshCount, startProgress );
 				const range = ranges[ sourceOf( m ) ];
 				if ( ! range || range.count === 0 ) continue;
 
@@ -1115,6 +1121,7 @@ export class SceneProcessor {
 
 			for ( let m = 0; m < meshCount; m ++ ) {
 
+				if ( ( m & 0xffff ) === 0xffff ) await this._turn( 'Placing copies', m, meshCount, 70 );
 				const owner = aliasOf[ m ];
 				if ( owner < 0 ) continue;
 				this.instanceTable.setAlias(
@@ -1149,8 +1156,17 @@ export class SceneProcessor {
 
 				// Each entry's world box picks its cluster and sizes its byte box; dropped once the leaves are written.
 				table.clusterWorld = new Float32Array( table.entryCount * 6 );
-				table.writeEntryWorldAABBs( table.clusterWorld );
-				table.clusterBounds = table.formClusters( table.clusterWorld );
+				for ( let e = 0; e < table.entryCount; e += SLICE_RECORDS ) {
+
+					table.writeEntryWorldAABBs( table.clusterWorld, e, Math.min( table.entryCount, e + SLICE_RECORDS ) );
+					await this._turn( 'Measuring copies', e, table.entryCount, 72 );
+
+				}
+
+				const steps = table.clusterSteps( table.clusterWorld );
+				let step;
+				while ( ! ( step = steps.next() ).done ) await this._turn( 'Grouping copies', step.value, table.entryCount, 72 );
+				table.clusterBounds = step.value;
 
 			}
 
@@ -1218,6 +1234,7 @@ export class SceneProcessor {
 
 				for ( let t = 0; t < table.templateCount; t ++ ) {
 
+					await this._turn( 'Assembling the scene', t, table.templateCount, 74 );
 					// Only owning templates hold one; spilled, they are read back one at a time.
 					const blas = spill ? await this._readSpilledBLAS( spill, t ) : table.blasData.get( t );
 					if ( ! blas ) continue;
@@ -1283,10 +1300,23 @@ export class SceneProcessor {
 			} );
 			throw error;
 
+		} finally {
+
+			this._slice = null;
+
 		}
 
 	}
 
+	/** During a build, a turn for the page once a slice of it has passed, with how far `what` has got. @private */
+	_turn( what, done, total, progress ) {
+
+		const turn = this._slice?.();
+		if ( turn ) updateLoading( { status: `${what}: ${done.toLocaleString()} of ${total.toLocaleString()}`, progress } );
+		return turn;
+
+	}
+
 	/** Worker config shared by all BLAS builds. @private */
 	_blasWorkerOpts() {
 
@@ -3889,6 +3919,7 @@ export class SceneProcessor {
 			const used = Math.ceil( count * RECORD_VEC4 / 4 );
 			this.bvh.setRecords( at, used === nodes ? stage : stage.subarray( 0, used * 16 ) );
 			await flushBVH?.( at + used );
+			await this._turn( 'Writing copy records', r, n, 74 );
 
 		}
 
@@ -3907,8 +3938,15 @@ export class SceneProcessor {
 				// The worker needs a buffer it can own, and world bounds are derived anyway.
 				const aabbs = clustered ? table.clusterBounds : new Float64Array( n * 6 );
 				if ( ! clustered ) table.writeEntryWorldAABBs( aabbs );
+				updateLoading( { status: 'Building the scene tree...', progress: 73 } );
 				const { tlasData, nodeCount } = await this._runTLASWorker( aabbs, n );
-				TLASBuilder.fillLeaves( tlasData, nodeCount, table );
+				for ( let node = 0; node < nodeCount; node += SLICE_RECORDS ) {
+
+					TLASBuilder.fillLeaves( tlasData, nodeCount, table, node, Math.min( nodeCount, node + SLICE_RECORDS ) );
+					await this._turn( 'Writing the scene tree', node, nodeCount, 73 );
+
+				}
+
 				return tlasData;
 
 			} catch ( error ) {

package/src/Processor/TLASBuilder.js

@@ -227,21 +227,22 @@ export class TLASBuilder {
 
 	/**
 	 * Fill in each leaf's BLAS pointer, visibility and world-to-object matrix, and record where
-	 * the leaf landed. One O(n) pass, so it stays on the main thread while the SAH tree does not.
+	 * the leaf landed. One O(n) pass, so it stays on the main thread while the SAH tree does not;
+	 * nodes `[from, to)` only, if given.
 	 *
 	 * A node is 16 floats and the BLAS pointer needs 4, so the affine inverse fits in the
 	 * remaining 12: the ray moves into object space with no second binding, which matters
 	 * because Shade is already at the 10 storage buffers Metal allows. The inverse is derived
 	 * here rather than stored: a column of it costs 64 bytes a placement.
 	 */
-	static fillLeaves( data, nodeCount, table ) {
+	static fillLeaves( data, nodeCount, table, from = 0, to = nodeCount ) {
 
 		const idx = bvhIndexView( data );
 
 		if ( table.clusterCount > 0 ) {
 
 			// Built over clusters: each leaf holds one, its copies' transforms in records (table.writeRecord).
-			for ( let node = 0; node < nodeCount; node ++ ) {
+			for ( let node = from; node < to; node ++ ) {
 
 				const o = node * FLOATS_PER_NODE;
 				if ( idx[ o + 3 ] === BVH_LEAF_MARKERS.BLAS_POINTER_LEAF ) table.writeClusterLeaf( data, idx, o, idx[ o + 1 ], table.clusterWorld, node );
@@ -252,7 +253,7 @@ export class TLASBuilder {
 
 		}
 
-		for ( let node = 0; node < nodeCount; node ++ ) {
+		for ( let node = from; node < to; node ++ ) {
 
 			const o = node * FLOATS_PER_NODE;
 			if ( idx[ o + 3 ] !== BVH_LEAF_MARKERS.BLAS_POINTER_LEAF ) continue;

package/src/Processor/USD/USDScene.js

@@ -380,9 +380,12 @@ function thinCurves( curve, rate, salt ) {
 
 export class USDSceneReader {
 
-	constructor( stage, { maxTriangles = Infinity, maxPlacements = Infinity, curveSteps = 2, resolveImage = async () => null, warn = () => {} } = {} ) {
+	/** `pause( prims, counting )` is awaited every 256 prims, `counting` during the counting pass. */
+	constructor( stage, { maxTriangles = Infinity, maxPlacements = Infinity, curveSteps = 2, resolveImage = async () => null, warn = () => {}, pause = null } = {} ) {
 
 		this.stage = stage;
+		this.pause = pause;
+		this._visited = 0;
 		this.maxTriangles = maxTriangles;
 		this.maxPlacements = maxPlacements;
 		this.curveSteps = curveSteps;
@@ -430,6 +433,7 @@ export class USDSceneReader {
 
 	async walk() {
 
+		this._visited = 0;
 		const root = this.stage.pseudoRoot;
 		const top = this.stage.upAxis === 'Z' ? new Matrix4().makeRotationX( - Math.PI / 2 ) : new Matrix4();
 		for ( const name of root.childNames() ) {
@@ -527,6 +531,7 @@ export class USDSceneReader {
 
 	async visit( prim, parent, out, ctx ) {
 
+		if ( this.pause && ( ++ this._visited & 255 ) === 0 ) await this.pause( this._visited, this.dry );
 		if ( ! prim.isDefined || prim.meta( 'active' ) === false ) return;
 		if ( prim.value( 'visibility' ) === 'invisible' ) return;
 		const purpose = prim.value( 'purpose' );

package/src/Processor/USD/index.js

@@ -96,7 +96,7 @@ export async function loadUSDScene( args ) {
 	const warn = message => warnings.push( message );
 	const builder = new PBRTSceneBuilder( {
 		maxTriangles: args.maxTriangles, maxPlacements: args.maxPlacements, mergeShapesAbove: args.mergeShapesAbove,
-		curveSteps: args.curveSteps, curveSides: args.curveSides, curveTolerance: args.curveTolerance,
+		curveSteps: args.curveSteps, curveSides: args.curveSides, curveTolerance: args.curveTolerance, pause: args.pauseBuild,
 	} );
 
 	const parseStart = performance.now();
@@ -104,7 +104,7 @@ export async function loadUSDScene( args ) {
 	await stage.open( args.entryPath );
 	const reader = new USDSceneReader( stage, {
 		maxTriangles: builder.maxTriangles, maxPlacements: builder.maxPlacements, curveSteps: builder.curveSteps,
-		resolveImage: args.resolveImage, warn,
+		resolveImage: args.resolveImage, warn, pause: args.pauseRead,
 	} );
 	const read = await reader.read();
 	if ( stage.omittedArcs > 0 ) warn( `${stage.omittedArcs} reference(s) into the parts left out of this load skipped` );

package/src/Processor/utils.js

@@ -1,4 +1,4 @@
-import { SphereGeometry, Mesh, MeshPhysicalMaterial, Group, Object3D, ShaderMaterial, Vector2, Matrix4, GLSL3 } from 'three';
+import { SphereGeometry, Mesh, MeshPhysicalMaterial, Group, Object3D, ShaderMaterial, Vector2, Matrix4, GLSL3, Box3 } from 'three';
 import { EngineEvents } from '../EngineEvents.js';
 
 let _statusCallback = null;
@@ -27,6 +27,85 @@ export const updateStats = ( statsUpdate ) => {
 
 };
 
+// A message: unlike a timer it is not throttled in a background tab, and unlike scheduler.yield it queues behind the
+// page's own timers and posted renders instead of running ahead of them.
+function nextTask() {
+
+	if ( typeof MessageChannel === 'undefined' ) return new Promise( resolve => setTimeout( resolve, 0 ) );
+	return new Promise( resolve => {
+
+		const { port1, port2 } = new MessageChannel();
+		port1.onmessage = () => {
+
+			port1.close();
+			resolve();
+
+		};
+
+		port2.postMessage( null );
+
+	} );
+
+}
+
+/**
+ * For a long loop on the main thread: the returned function gives the page one task turn, to redraw, once `ms` have
+ * passed since the last, and returns null in between.
+ */
+export function timeSlicer( ms = 50 ) {
+
+	let since = performance.now();
+	const resume = () => {
+
+		since = performance.now();
+
+	};
+
+	return () => ( performance.now() - since < ms ? null : nextTask().then( resume ) );
+
+}
+
+/** InstancedMesh.computeBoundingBox, bit for bit, for each instanced mesh under `object` without a box yet. */
+export function computeInstanceBoundingBoxes( object ) {
+
+	object.traverse( mesh => {
+
+		if ( ! mesh.isInstancedMesh || mesh.boundingBox !== null ) return;
+		const geometry = mesh.geometry;
+		if ( geometry.boundingBox === null ) geometry.computeBoundingBox();
+		const box = mesh.boundingBox = new Box3();
+		const local = geometry.boundingBox;
+		if ( local.isEmpty() ) return;
+
+		const xs = [ local.min.x, local.max.x ], ys = [ local.min.y, local.max.y ], zs = [ local.min.z, local.max.z ];
+		const m = mesh.instanceMatrix.array;
+		let x0 = Infinity, y0 = Infinity, z0 = Infinity, x1 = - Infinity, y1 = - Infinity, z1 = - Infinity;
+		for ( let i = 0, o = 0; i < mesh.count; i ++, o += 16 ) {
+
+			const e0 = m[ o ], e1 = m[ o + 1 ], e2 = m[ o + 2 ], e3 = m[ o + 3 ], e4 = m[ o + 4 ], e5 = m[ o + 5 ], e6 = m[ o + 6 ], e7 = m[ o + 7 ];
+			const e8 = m[ o + 8 ], e9 = m[ o + 9 ], e10 = m[ o + 10 ], e11 = m[ o + 11 ], e12 = m[ o + 12 ], e13 = m[ o + 13 ], e14 = m[ o + 14 ], e15 = m[ o + 15 ];
+			for ( let c = 0; c < 8; c ++ ) {
+
+				const x = xs[ c >> 2 ], y = ys[ ( c >> 1 ) & 1 ], z = zs[ c & 1 ];
+				// Vector3.applyMatrix4's operations, in its order.
+				const w = 1 / ( e3 * x + e7 * y + e11 * z + e15 );
+				const px = ( e0 * x + e4 * y + e8 * z + e12 ) * w;
+				const py = ( e1 * x + e5 * y + e9 * z + e13 ) * w;
+				const pz = ( e2 * x + e6 * y + e10 * z + e14 ) * w;
+				x0 = Math.min( x0, px ); y0 = Math.min( y0, py ); z0 = Math.min( z0, pz );
+				x1 = Math.max( x1, px ); y1 = Math.max( y1, py ); z1 = Math.max( z1, pz );
+
+			}
+
+		}
+
+		box.min.set( x0, y0, z0 );
+		box.max.set( x1, y1, z1 );
+
+	} );
+
+}
+
 // Raw frameCount is the user-facing sample count (one full-frame pass per frame).
 export function getDisplaySamples( pathTracerStage ) {