rayzee 7.31.0 → 8.0.0

package/src/Processor/PBRT/index.js

@@ -53,62 +53,279 @@ function joinPath( dir, rel ) {
  * Wraps the zip contents with tolerant, case-insensitive lookup that falls back
  * to a basename match — pbrt scenes are inconsistent about path roots.
  */
-class VirtualFS {
-
-	constructor( entries ) {
-
-		// entries: { path: Uint8Array }
-		this.byPath = new Map(); // normalized lowercase -> { norm, bytes }
-		this.byBase = new Map(); // basename lowercase -> [ { norm, bytes } ] (insertion order)
-		for ( const key in entries ) {
+export class VirtualFS {
+
+	/**
+	 * @param {Object<string,Uint8Array>} entries - materialised bytes, possibly empty
+	 * @param {object} [source] - seekable archive: `{ listing, read(path) }`. When present the
+	 *   records it lists are read on demand and never held, so a multi-gigabyte archive is
+	 *   indexed rather than resident.
+	 */
+	constructor( entries, source = null ) {
+
+		// entries: { path: Uint8Array }. Held so a release can drop the caller's reference
+		// too — nulling only our own copy frees nothing while the archive object is alive,
+		// and that object is every byte of a 30 GB scene.
+		this.entries = entries;
+		this.source = source;
+		this.records = [];
+		this.byPath = new Map(); // normalized lowercase -> { key, norm, bytes }
+		this.byBase = new Map(); // basename lowercase -> [ { key, norm, bytes } ] (insertion order)
+		const add = ( key, bytes, lazy ) => {
 
 			const norm = normalizePath( key ).toLowerCase();
-			const rec = { norm, bytes: entries[ key ] };
+			if ( this.byPath.has( norm ) ) return;
+			const rec = { key, norm, bytes, lazy };
+			this.records.push( rec );
 			this.byPath.set( norm, rec );
 			const base = norm.split( '/' ).pop();
 			const bucket = this.byBase.get( base );
 			if ( bucket ) bucket.push( rec );
 			else this.byBase.set( base, [ rec ] );
 
-		}
+		};
+
+		for ( const key in entries ) add( key, entries[ key ], false );
+		for ( const e of source?.listing ?? [] ) if ( e.offset !== undefined ) add( e.path, null, true );
 
 	}
 
-	find( path ) {
+	/** Bytes for a record: already held, or read from the source on demand. */
+	async read( rec ) {
 
-		const norm = normalizePath( path ).toLowerCase();
-		if ( this.byPath.has( norm ) ) return this.byPath.get( norm ).bytes;
+		if ( ! rec ) return null;
+		if ( rec.bytes ) return rec.bytes;
+		if ( ! rec.lazy || ! this.source ) return null;
+		return this.source.read( rec.key );
+
+	}
 
-		// Resolve by basename (O(1)); among collisions prefer a path-suffix match,
-		// else fall back to the first entry with that name. pbrt scenes are
-		// inconsistent about path roots, so this tolerates relative/absolute drift.
+	/** Resolve and read in one step; `dir` is joined first, as Include does. */
+	async readPath( path, dir = null ) {
+
+		const rec = ( dir !== null && this.findRecord( joinPath( dir, path ) ) ) || this.findRecord( path );
+		return this.read( rec );
+
+	}
+
+	release( rec ) {
+
+		rec.bytes = null;
+		delete this.entries[ rec.key ];
+
+	}
+
+	releasePath( path, dir = null ) {
+
+		const rec = ( dir !== null && this.findRecord( joinPath( dir, path ) ) ) || this.findRecord( path );
+		// Only a lazy record, which can be read again. Releasing a resident one would drop a
+		// fragment that a later Include still needs — isHibiscusYoung pulls one in six times.
+		if ( rec?.lazy ) this.release( rec );
+
+	}
+
+	/** Drop every .pbrt entry's bytes. Safe only once parsing is complete. */
+	releaseScenes() {
+
+		for ( const rec of this.records ) if ( rec.norm.endsWith( '.pbrt' ) ) this.release( rec );
+
+	}
+
+	findRecord( path ) {
+
+		const norm = normalizePath( path ).toLowerCase();
+		if ( this.byPath.has( norm ) ) return this.byPath.get( norm );
+
+		// Resolve by basename (O(1)); among collisions only a path-suffix match will do.
+		// The blind first-entry fallback is safe only when the name is unique: every Moana
+		// element ships its own `objects.pbrt`, and `Include "isPalmRig/objects.pbrt"` joined
+		// against isPalmRig/ makes a doubled path that matches no suffix — so loading several
+		// elements together silently handed each one the FIRST element's instance templates,
+		// and every placement that referenced a real template was then dropped.
 		const bucket = this.byBase.get( norm.split( '/' ).pop() );
 		if ( ! bucket ) return null;
 		const suffixHit = bucket.find( rec => rec.norm.endsWith( '/' + norm ) );
-		return ( suffixHit || bucket[ 0 ] ).bytes;
+		return suffixHit || ( bucket.length === 1 ? bucket[ 0 ] : null );
+
+	}
+
+	find( path ) {
+
+		return this.findRecord( path )?.bytes ?? null;
 
 	}
 
 }
 
-/** Pick the top-level .pbrt entry: shallowest path, preferring scene/main names. */
-export function pickEntryPath( entries ) {
+/** Byte offset of `needle` in `bytes` at or after `from`, or -1. */
+function findBytes( bytes, needle, from = 0 ) {
+
+	const first = needle[ 0 ];
+	const last = bytes.length - needle.length;
+	outer: for ( let i = from; i <= last; i ++ ) {
+
+		if ( bytes[ i ] !== first ) continue;
+		for ( let j = 1; j < needle.length; j ++ ) if ( bytes[ i + j ] !== needle[ j ] ) continue outer;
+		return i;
+
+	}
+
+	return - 1;
+
+}
+
+const ASCII = s => Uint8Array.from( s, c => c.charCodeAt( 0 ) );
+const WORLD_BEGIN = ASCII( 'WorldBegin' );
+const INCLUDE_WORDS = [ ASCII( 'Include' ), ASCII( 'Import' ) ];
+
+function startsLine( bytes, at ) {
+
+	for ( let i = at - 1; i >= 0; i -- ) {
+
+		const b = bytes[ i ];
+		if ( b === 10 ) return true;
+		if ( b !== 32 && b !== 9 ) return false;
+
+	}
+
+	return true;
+
+}
+
+/** True when the entry declares a world block, i.e. it is a scene and not a fragment. */
+function hasWorldBegin( bytes ) {
+
+	for ( let at = findBytes( bytes, WORLD_BEGIN ); at >= 0; at = findBytes( bytes, WORLD_BEGIN, at + 1 ) ) {
+
+		if ( startsLine( bytes, at ) ) return true;
+
+	}
+
+	return false;
+
+}
+
+/** Basenames this entry pulls in via Include/Import, lowercased. */
+function includedBasenames( bytes, out ) {
+
+	for ( const word of INCLUDE_WORDS ) {
+
+		for ( let at = findBytes( bytes, word ); at >= 0; at = findBytes( bytes, word, at + 1 ) ) {
+
+			if ( ! startsLine( bytes, at ) ) continue;
+			let i = at + word.length;
+			while ( i < bytes.length && ( bytes[ i ] === 32 || bytes[ i ] === 9 ) ) i ++;
+			if ( bytes[ i ] !== 34 ) continue;
+			const start = ++ i;
+			while ( i < bytes.length && bytes[ i ] !== 34 && bytes[ i ] !== 10 ) i ++;
+			if ( bytes[ i ] !== 34 ) continue;
+			const path = decoder.decode( bytes.subarray( start, i ) );
+			out.add( normalizePath( path ).toLowerCase().split( '/' ).pop() );
+
+		}
+
+	}
+
+}
+
+/**
+ * Rank every .pbrt in the archive that could be a top-level scene, best first.
+ *
+ * Name shape alone is not enough: a scene's `geometry.pbrt` fragment carries a shorter
+ * name than the real entry and would win on sort, loading every shape with an unresolved
+ * NamedMaterial and no camera or lights. Content decides first — a fragment has no
+ * `WorldBegin` and is named by someone else's Include — and the name only breaks ties.
+ *
+ * More than one survivor is a real archive shape, not an error: transparent-machines
+ * ships five independent frames side by side. Callers should say which one they took.
+ */
+export function listEntryPaths( entries ) {
 
 	const pbrts = Object.keys( entries ).filter( k => k.toLowerCase().endsWith( '.pbrt' ) );
-	if ( pbrts.length === 0 ) return null;
+	if ( pbrts.length <= 1 ) return pbrts;
+
+	// Scanned over bytes: a fragment can be gigabytes, past what a string would hold.
+	const included = new Set();
+	const worlds = new Map();
+	for ( const k of pbrts ) {
 
-	const preferred = pbrts.filter( k => /(^|\/)(scene|main)\.pbrt$/i.test( k ) );
-	const pool = preferred.length ? preferred : pbrts;
+		const bytes = entries[ k ];
+		worlds.set( k, hasWorldBegin( bytes ) );
+		includedBasenames( bytes, included );
 
-	// Shallowest (fewest path segments), then shortest name.
-	pool.sort( ( a, b ) => {
+	}
+
+	return rankEntryPaths( pbrts, worlds, included );
+
+}
+
+/** Shared ranking for the eager and lazy entry pickers. */
+function rankEntryPaths( pbrts, worlds, included ) {
+
+	const narrow = ( candidates, keep ) => {
+
+		const kept = candidates.filter( keep );
+		return kept.length ? kept : candidates;
+
+	};
+
+	let pool = narrow( pbrts, k => worlds.get( k ) );
+	pool = narrow( pool, k => ! included.has( k.toLowerCase().split( '/' ).pop() ) );
+	pool = narrow( pool, k => /(^|\/)(scene|main)\.pbrt$/i.test( k ) );
+
+	// Shallowest, then shortest name, then the path itself — the last key keeps the
+	// order independent of however the zip happened to enumerate its entries.
+	return pool.sort( ( a, b ) => {
 
 		const da = a.split( '/' ).length, db = b.split( '/' ).length;
-		return da !== db ? da - db : a.length - b.length;
+		if ( da !== db ) return da - db;
+		if ( a.length !== b.length ) return a.length - b.length;
+		return a < b ? - 1 : a > b ? 1 : 0;
 
 	} );
 
-	return pool[ 0 ];
+}
+
+/** Best top-level .pbrt entry, or null when the archive has none. */
+export function pickEntryPath( entries ) {
+
+	return listEntryPaths( entries )[ 0 ] || null;
+
+}
+
+/**
+ * Entry .pbrt for a VirtualFS, reading each candidate in turn and dropping it again so a
+ * lazily-indexed archive is never materialised just to pick a starting file.
+ */
+export async function pickEntryPathFrom( vfs ) {
+
+	return ( await listEntryPathsFrom( vfs ) )[ 0 ] || null;
+
+}
+
+/**
+ * Candidate scene files for a VirtualFS, best first. Each candidate is read to test it and
+ * dropped again, so a lazily-indexed archive is never materialised just to rank its entries.
+ */
+export async function listEntryPathsFrom( vfs ) {
+
+	const pbrts = vfs.records.filter( r => r.norm.endsWith( '.pbrt' ) );
+	if ( pbrts.length === 0 ) return [];
+	if ( pbrts.length === 1 ) return [ pbrts[ 0 ].key ];
+
+	const included = new Set();
+	const worlds = new Map();
+	for ( const rec of pbrts ) {
+
+		const bytes = await vfs.read( rec );
+		if ( ! bytes ) continue;
+		worlds.set( rec.key, hasWorldBegin( bytes ) );
+		includedBasenames( bytes, included );
+		if ( rec.lazy ) vfs.release( rec ); // read again later if it is actually used
+
+	}
+
+	return rankEntryPaths( pbrts.map( r => r.key ), worlds, included );
 
 }
 
@@ -124,56 +341,100 @@ export function pickEntryPath( entries ) {
  */
 export async function loadPBRTScene( args ) {
 
-	const { vfs: rawEntries, plyParser, imageFromBytes, envFromBytes, convertHandedness } = args;
-	const vfs = new VirtualFS( rawEntries );
+	const { vfs: rawEntries, source, plyParser, imageFromBytes, envFromBytes, convertHandedness } = args;
+	const vfs = new VirtualFS( rawEntries, source );
+	const warnings = [];
+
+	// Ranked once here so a caller does not have to read every .pbrt a second time to learn
+	// what else was in the archive.
+	const candidates = await listEntryPathsFrom( vfs );
+	if ( candidates.length === 0 ) throw new Error( 'PBRT loader: no .pbrt file found in archive' );
+
+	const requested = args.entryPath && candidates.includes( args.entryPath ) ? args.entryPath : null;
+	if ( args.entryPath && ! requested ) {
 
-	const entryPath = args.entryPath || pickEntryPath( rawEntries );
-	if ( ! entryPath ) throw new Error( 'PBRT loader: no .pbrt file found in archive' );
+		warnings.push( `PBRT entry "${args.entryPath}" is not a scene in this archive — auto-detecting instead` );
 
-	const entryBytes = vfs.find( entryPath );
+	}
+
+	const entryPath = requested || candidates[ 0 ];
+	const entryBytes = await vfs.readPath( entryPath );
 	if ( ! entryBytes ) throw new Error( `PBRT loader: entry "${entryPath}" not readable` );
 
 	const baseDir = entryPath.includes( '/' ) ? entryPath.slice( 0, entryPath.lastIndexOf( '/' ) ) : '';
 
-	// Parse (with Include resolution)
+	// Parse (with Include resolution). Bytes go straight to the lexer — a scene file can
+	// be larger than the longest string JavaScript will build.
 	const parser = new PBRTParser( {
-		resolveInclude: ( path, currentDir ) => {
+		resolveInclude: ( path, currentDir ) => vfs.readPath( path, currentDir ),
+		// Depth-first, so this keeps only the open include chain live rather than every
+		// scene file at once — the difference between 5.7 GB resident and a few MB.
+		releaseInclude: ( path, currentDir ) => vfs.releasePath( path, currentDir ),
+		maxPlacements: args.maxPlacements
+	} );
 
-			const bytes = vfs.find( joinPath( currentDir, path ) ) || vfs.find( path );
-			return bytes ? decoder.decode( bytes ) : null;
+	const parseStart = performance.now();
+	const ir = await parser.parse( entryBytes, baseDir );
+	const parseMs = performance.now() - parseStart;
 
-		}
-	} );
-	const ir = parser.parse( decoder.decode( entryBytes ), baseDir );
+	// Scene text is dead once parsed, and it is the bulk of a big element — isIronwoodA1 is
+	// 6.9 GB of it. Freeing before the builder runs halves peak while geometry is allocated.
+	// Only after the whole parse: a file can be Included more than once (isHibiscusYoung
+	// pulls its xgBonsai scatter in six times, once per placement of the plant).
+	vfs.releaseScenes();
 
 	// Build scene graph
-	const sliceBuf = ( bytes ) => bytes.buffer.slice( bytes.byteOffset, bytes.byteOffset + bytes.byteLength );
+	const sliceBuf = ( bytes ) => (
+		bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength
+			? bytes.buffer
+			: bytes.buffer.slice( bytes.byteOffset, bytes.byteOffset + bytes.byteLength )
+	);
+
+	// Cached against the RESOLVED entry, not the spelling used, so a file is decoded once and
+	// its source bytes can go — isCoral's 8,596 .ply files are 2.3 GB of the load.
+	const plyCache = new Map();
+	const decodePly = async ( rec ) => {
+
+		const bytes = await vfs.read( rec );
+		if ( ! bytes ) return null;
+		vfs.release( rec );
+		return plyParser( sliceBuf( bytes ) );
+
+	};
+
 	const builder = new PBRTSceneBuilder( {
 		convertHandedness,
+		maxTriangles: args.maxTriangles,
+		maxPlacements: args.maxPlacements,
+		mergeShapesAbove: args.mergeShapesAbove,
+		curveSteps: args.curveSteps,
+		curveSides: args.curveSides,
 		resolvePLY: async ( filename ) => {
 
-			const bytes = vfs.find( filename );
-			if ( ! bytes ) return null;
-			return plyParser( sliceBuf( bytes ) );
+			const rec = vfs.findRecord( filename );
+			if ( ! rec ) return null;
+			if ( ! plyCache.has( rec.norm ) ) plyCache.set( rec.norm, await decodePly( rec ) );
+			return plyCache.get( rec.norm );
 
 		},
 		resolveImage: async ( filename ) => {
 
-			const bytes = vfs.find( filename );
+			const bytes = await vfs.readPath( filename );
 			if ( ! bytes ) return null;
 			return imageFromBytes( bytes, filename );
 
 		},
 		resolveEnvironment: async ( filename ) => {
 
-			const bytes = vfs.find( filename );
+			const bytes = await vfs.readPath( filename );
 			if ( ! bytes ) return null;
 			return ( envFromBytes || imageFromBytes )( bytes, filename );
 
 		}
 	} );
 
+	const buildStart = performance.now();
 	const result = await builder.build( ir );
-	return { ...result, entryPath };
+	return { ...result, entryPath, candidates, warnings: [ ...warnings, ...( result.warnings ?? [] ) ], parseMs, buildMs: performance.now() - buildStart };
 
 }

package/src/Processor/PackedRayBuffer.js

@@ -1,13 +1,17 @@
 /**
  * Packed buffer manager for wavefront path tracing — one storage buffer per data category.
  * RAY/HIT are SoA-within-a-buffer (field `slot` of element `id` lives at `id + slot*_cap`).
+ *
+ * All three are GPU-only: every lane is written by a kernel before anything reads it and none
+ * is ever read back, so they carry no CPU array (see gpuOnlyStorageAttribute).
  */
 
 import {
 	storage, uintBitsToFloat, floatBitsToUint, vec2, vec3, vec4, uvec4, uint, int, float, clamp,
 	packSnorm2x16, packUnorm2x16, unpackSnorm2x16, unpackUnorm2x16, select, floor, log2, exp2, max,
 } from 'three/tsl';
-import { StorageInstancedBufferAttribute } from 'three/webgpu';
+import { gpuOnlyStorageAttribute } from '../TSL/patches.js';
+import { packNormalOct, unpackTriangleNormal } from '../TSL/Common.js';
 import { createLogger, fmt } from '../utils/Logger.js';
 
 const log = createLogger( 'gpu' );
@@ -32,9 +36,12 @@ export const RAY = {
 	SSS_SIGMA_S: 6, // vec4(sigmaS.xyz, g) — SSS scattering coeff + Henyey-Greenstein anisotropy (sigmaS==0 ⇒ glass)
 };
 
+// uvec4 so packed lanes keep their exact bits — an f32 lane may canonicalise a NaN pattern.
 export const HIT = {
-	DIST_TRI_BARY: 0, // vec4(distance, uintBitsToFloat(triIndex), bary.u, bary.v)
-	NORMAL_MAT: 1, // vec4(geoNormal.xyz, uintBitsToFloat(matIndex | meshIndex<<16))
+	DIST_TRI_BARY: 0, // uvec4(bits(distance), triIndex, bits(bary.u), bits(bary.v))
+	// The geometric normal rides as one oct16 word (it was interpolated from oct16 triangle
+	// normals to begin with), which leaves the instance leaf a full 32-bit lane of its own.
+	NORMAL_MAT: 1, // uvec4(octNormal, matIndex, instanceLeaf + 1, 0)
 };
 
 // SoA region stride, baked into the shader graph at build time; single instance, rebuilt on resize.
@@ -82,14 +89,14 @@ export class PackedRayBuffer {
 
 		// count=0 so StorageBufferNode.getHash() shares the buffer → RW and RO nodes bind the same GPU data.
 		const rayCount = capacity * RAY_STRIDE;
-		const rayAttr = new StorageInstancedBufferAttribute( new Float32Array( rayCount * 4 ), 4 );
+		const rayAttr = gpuOnlyStorageAttribute( rayCount, 4 );
 		this._attrs.ray = rayAttr;
 		this.rayBuffer = {
 			rw: storage( rayAttr, 'vec4' ),
 			ro: storage( rayAttr, 'vec4' ).toReadOnly(),
 		};
 
-		const rngAttr = new StorageInstancedBufferAttribute( new Uint32Array( capacity ), 1 );
+		const rngAttr = gpuOnlyStorageAttribute( capacity, 1, Uint32Array );
 		this._attrs.rng = rngAttr;
 		this.rngBuffer = {
 			rw: storage( rngAttr, 'uint' ),
@@ -97,11 +104,11 @@ export class PackedRayBuffer {
 		};
 
 		const hitCount = capacity * HIT_STRIDE;
-		const hitAttr = new StorageInstancedBufferAttribute( new Float32Array( hitCount * 4 ), 4 );
+		const hitAttr = gpuOnlyStorageAttribute( hitCount, 4, Uint32Array );
 		this._attrs.hit = hitAttr;
 		this.hitBuffer = {
-			rw: storage( hitAttr, 'vec4' ),
-			ro: storage( hitAttr, 'vec4' ).toReadOnly(),
+			rw: storage( hitAttr, 'uvec4' ),
+			ro: storage( hitAttr, 'uvec4' ).toReadOnly(),
 		};
 
 		// Kept for the [gpu] startup summary in PathTracer._buildWavefrontKernels.
@@ -253,29 +260,33 @@ export const writeRayRadiance = ( buf, id, radiance ) =>
 		.assign( radiance );
 
 export const readHitDistance = ( buf, id ) =>
-	buf.element( soa( id, HIT.DIST_TRI_BARY ) ).x;
+	uintBitsToFloat( buf.element( soa( id, HIT.DIST_TRI_BARY ) ).x );
 
 export const readHitTriangleIndex = ( buf, id ) =>
-	floatBitsToUint( buf.element( soa( id, HIT.DIST_TRI_BARY ) ).y );
+	buf.element( soa( id, HIT.DIST_TRI_BARY ) ).y;
 
 export const readHitBarycentrics = ( buf, id ) =>
-	buf.element( soa( id, HIT.DIST_TRI_BARY ) ).zw;
+	uintBitsToFloat( buf.element( soa( id, HIT.DIST_TRI_BARY ) ).zw );
 
 export const readHitNormal = ( buf, id ) =>
-	buf.element( soa( id, HIT.NORMAL_MAT ) ).xyz;
+	unpackTriangleNormal( buf.element( soa( id, HIT.NORMAL_MAT ) ).x );
 
 export const readHitMaterialIndex = ( buf, id ) =>
-	uint( floatBitsToUint( buf.element( soa( id, HIT.NORMAL_MAT ) ).w ).bitAnd( 0xFFFF ) );
+	uint( buf.element( soa( id, HIT.NORMAL_MAT ) ).y );
 
-export const readHitMeshIndex = ( buf, id ) =>
-	floatBitsToUint( buf.element( soa( id, HIT.NORMAL_MAT ) ).w ).shiftRight( 16 );
+/**
+ * TLAS leaf that owns the hit, biased by one so 0 reads as "no instance" — leaf 0 is a real
+ * node when the scene has a single mesh.
+ */
+export const readHitInstanceLeaf = ( buf, id ) =>
+	int( buf.element( soa( id, HIT.NORMAL_MAT ) ).z ).sub( int( 1 ) );
 
-export const writeHitPacked = ( buf, id, distance, triIndex, baryU, baryV, normal, matIndex, meshIndex ) => {
+export const writeHitPacked = ( buf, id, distance, triIndex, baryU, baryV, normal, matIndex, instanceLeaf ) => {
 
 	buf.element( soa( id, HIT.DIST_TRI_BARY ) )
-		.assign( vec4( distance, uintBitsToFloat( triIndex ), baryU, baryV ) );
+		.assign( uvec4( floatBitsToUint( distance ), triIndex, floatBitsToUint( baryU ), floatBitsToUint( baryV ) ) );
 	buf.element( soa( id, HIT.NORMAL_MAT ) )
-		.assign( vec4( normal, uintBitsToFloat( matIndex.bitOr( meshIndex.shiftLeft( 16 ) ) ) ) );
+		.assign( uvec4( packNormalOct( normal ), matIndex, instanceLeaf, uint( 0 ) ) );
 
 };
 

package/src/Processor/ParallelBVHBuilder.js

@@ -16,7 +16,7 @@ setBVHWorkerFactory( () => new BVHWorker() );
 
 const log = createLogger( 'bvh' );
 
-const FPT = 32; // FLOATS_PER_TRIANGLE
+const FPT = 20; // FLOATS_PER_TRIANGLE — the record is uint lanes, not floats
 const PARALLEL_THRESHOLD = 50000;
 const MAX_PARALLEL_WORKERS = 8;
 
@@ -27,11 +27,11 @@ const MAX_PARALLEL_WORKERS = 8;
  * Phase 2: Subtree workers build independent subtrees in parallel.
  * Phase 3: Coordinator assembles final BVH and reorders triangles.
  *
- * @param {Float32Array} triangles - Triangle data (32 floats per triangle)
+ * @param {Uint32Array} triangles - Triangle records (20 lanes each)
  * @param {number} depth - Maximum BVH depth
  * @param {Function|null} progressCallback - Optional progress callback (0-100)
  * @param {Object} config - Builder config (maxLeafSize, numBins, treelet settings, etc.)
- * @returns {Promise<{bvhData: Float32Array, bvhRoot: true, reorderedTriangles: Float32Array, splitStats: Object}>}
+ * @returns {Promise<{bvhData: Float32Array, bvhRoot: true, reorderedTriangles: Uint32Array, splitStats: Object}>}
  */
 export function buildBVHParallel( triangles, depth, progressCallback, config ) {
 
@@ -47,7 +47,8 @@ export function buildBVHParallel( triangles, depth, progressCallback, config ) {
 
 			// Allocate SharedArrayBuffers
 			const sharedTriangleData = new SharedArrayBuffer( triangles.byteLength );
-			new Float32Array( sharedTriangleData ).set( triangles );
+			new Uint32Array( sharedTriangleData ).set( triangles );
+			triangles = null; // shared copy is the only one needed; the fallback rebuilds from it
 
 			const sharedCentroids = new SharedArrayBuffer( triangleCount * 3 * 4 );
 			const sharedBMin = new SharedArrayBuffer( triangleCount * 3 * 4 );
@@ -97,8 +98,8 @@ export function buildBVHParallel( triangles, depth, progressCallback, config ) {
 				cleanup();
 				// Copy from SharedArrayBuffer to regular ArrayBuffer for transfer
 				const restoredBuffer = new ArrayBuffer( sharedTriangleData.byteLength );
-				new Float32Array( restoredBuffer ).set( new Float32Array( sharedTriangleData ) );
-				const restoredTriangles = new Float32Array( restoredBuffer );
+				new Uint32Array( restoredBuffer ).set( new Uint32Array( sharedTriangleData ) );
+				const restoredTriangles = new Uint32Array( restoredBuffer );
 				resolve( buildSingleWorker( restoredTriangles, depth, progressCallback, config ) );
 
 			};
@@ -149,7 +150,7 @@ export function buildBVHParallel( triangles, depth, progressCallback, config ) {
 
 					settled = true;
 					cleanup();
-					const reorderedTriangles = new Float32Array( sharedReorderBuffer );
+					const reorderedTriangles = new Uint32Array( sharedReorderBuffer );
 					resolve( { bvhData: msg.bvhData, bvhRoot: true, reorderedTriangles, originalToBvh: msg.originalToBvh || null, splitStats: phase1Stats || {} } );
 					return;
 
@@ -439,7 +440,7 @@ function buildSingleWorker( triangles, depth, progressCallback, config ) {
 
 				worker.terminate();
 				const reorderedTriangles = sharedReorderBuffer
-					? new Float32Array( sharedReorderBuffer )
+					? new Uint32Array( sharedReorderBuffer )
 					: transferredTriangles;
 
 				resolve( { bvhData, bvhRoot: true, reorderedTriangles, originalToBvh: originalToBvh || null, splitStats: treeletStats || {} } );

package/src/Processor/QueueManager.js

@@ -4,6 +4,7 @@
 
 import { storage } from 'three/tsl';
 import { StorageInstancedBufferAttribute } from 'three/webgpu';
+import { gpuOnlyStorageAttribute } from '../TSL/patches.js';
 import { freeStorageAttribute } from './PackedRayBuffer.js';
 import { createLogger, fmt } from '../utils/Logger.js';
 
@@ -94,8 +95,9 @@ export class QueueManager {
 		);
 		this.bounceCounts = storage( this._bounceCountsAttr, 'uint' );
 
-		const attrA = new StorageInstancedBufferAttribute( new Uint32Array( capacity ), 1 );
-		const attrB = new StorageInstancedBufferAttribute( new Uint32Array( capacity ), 1 );
+		// Index lists, not data: written wholesale by compaction before any read, never read back.
+		const attrA = gpuOnlyStorageAttribute( capacity, 1, Uint32Array );
+		const attrB = gpuOnlyStorageAttribute( capacity, 1, Uint32Array );
 		this._attrA = attrA;
 		this._attrB = attrB;
 
@@ -112,7 +114,7 @@ export class QueueManager {
 
 		// Material-sort output: a material-reordered permutation of the active index
 		// list, written by the global material sort and read by Shade in place of activeIndices.
-		const sortAttr = new StorageInstancedBufferAttribute( new Uint32Array( capacity ), 1 );
+		const sortAttr = gpuOnlyStorageAttribute( capacity, 1, Uint32Array );
 		this._sortAttr = sortAttr;
 		this.sortedIndices = storage( sortAttr, 'uint' );
 		this.sortedIndicesRO = storage( sortAttr, 'uint' ).toReadOnly();