rayzee 9.0.0 → 9.1.0

package/src/Processor/PBRT/PBRTSceneBuilder.js

@@ -14,6 +14,7 @@
  * needed. Enable only if a scene comes out z-mirrored against a known reference.
  */
 
+import { freeNow, resized } from './buffers.js';
 import {
 	Group, Mesh, InstancedMesh, PerspectiveCamera, OrthographicCamera, Matrix4, Vector3, Quaternion,
 	BufferGeometry, Float32BufferAttribute, Uint32BufferAttribute, SphereGeometry,
@@ -50,9 +51,7 @@ function grow( array, needed ) {
 	if ( needed <= array.length ) return array;
 	let length = array.length || 1;
 	while ( length < needed ) length *= 2;
-	const out = new array.constructor( length );
-	out.set( array );
-	return out;
+	return resized( array, length );
 
 }
 
@@ -76,6 +75,11 @@ const DEFAULT_TRIANGLE_BUDGET = 45_000_000;
 // Placements are their own budget: geometry is shared, but each costs a TLAS leaf and an
 // instance record. isCoastline's 5.09M loaded and rendered at 23 fps.
 const DEFAULT_PLACEMENT_BUDGET = 6_000_000;
+// With the memory spill the triangles and BVH leave the heap as the build goes, so the host
+// passes these instead. The whole 15-part Moana subset (55.7M / 7.0M) loads cold under them, at
+// an 8.1 GB preflight estimate; the preflight, not the budget, refuses anything larger.
+export const SPILL_TRIANGLE_BUDGET = 60_000_000;
+export const SPILL_PLACEMENT_BUDGET = 8_000_000;
 // Non-instanced shapes merge into a few large meshes: isPalmRig declares 173,338 of them,
 // and one BufferGeometry + Mesh each measured 3.3 GB — the loader OOM'd before tracing.
 const DEFAULT_MERGE_MIN_SHAPES = 256;
@@ -86,6 +90,20 @@ const MERGE_BATCH_TRIANGLES = 500_000;
 // a crossed pair of ribbons is 16 triangles a curve.
 const DEFAULT_CURVE_STEPS = 2;
 const DEFAULT_CURVE_SIDES = { flat: 1, ribbon: 1, cylinder: 2 };
+// A strip segment may stray 5 % of the half-width from the curve: 37 % of Moana's curve
+// triangles go, at 3 % frame time in a view full of them. 0.1 took 48 % for 6 %.
+const DEFAULT_CURVE_TOLERANCE = 0.05;
+
+/** Bumped whenever the same scene files build a different graph, so a stored graph is not reused. */
+export const PBRT_BUILD_REVISION = 4;
+
+function samePlacements( a, b ) {
+
+	if ( a.count !== b.count ) return false;
+	for ( let i = 0, n = a.count * 16; i < n; i ++ ) if ( a.matrices[ i ] !== b.matrices[ i ] ) return false;
+	return true;
+
+}
 
 /** Pixels out of an HTMLImageElement / ImageBitmap, which expose none of their own. */
 function pixelsFromDrawable( image, srgb ) {
@@ -160,6 +178,7 @@ export class PBRTSceneBuilder {
 		this.mergeShapesAbove = resolvers.mergeShapesAbove ?? DEFAULT_MERGE_MIN_SHAPES;
 		this.curveSteps = resolvers.curveSteps ?? DEFAULT_CURVE_STEPS;
 		this.curveSides = resolvers.curveSides ?? null;
+		this.curveTolerance = resolvers.curveTolerance ?? DEFAULT_CURVE_TOLERANCE;
 		this.resolvePLY = resolvers.resolvePLY || ( async () => null );
 		this.resolveImage = resolvers.resolveImage || ( async () => null );
 		this.resolveEnvironment = resolvers.resolveEnvironment || resolvers.resolveImage || ( async () => null );
@@ -189,6 +208,9 @@ export class PBRTSceneBuilder {
 	async build( ir ) {
 
 		this.ir = ir;
+		// Built again for their moving placements after the static ones, so never freed early.
+		this._keepShapes = new Set();
+		for ( const { name } of ir.animatedInstances ?? [] ) for ( const shape of ir.objects.get( name ) ?? [] ) this._keepShapes.add( shape );
 		this._recoveredColors = 0;
 		this.reportedMeshes = 0;
 		this.triangleCount = 0; // stored triangles — a shared geometry counts once
@@ -333,9 +355,53 @@ export class PBRTSceneBuilder {
 		const scratch = new Float64Array( 16 );
 		const matrix = new Matrix4();
 
-		for ( const [ name, list ] of ir.instances ) {
+		const place = ( list, geometry, material, rel, shapeType, materialType, tris ) => {
+
+			const affordable = Math.max( 0, this.maxPlacements - this.placementCount );
+			const count = Math.min( list.count, affordable );
+			if ( count < list.count ) this.skippedForBudget += list.count - count;
+			if ( count === 0 ) return;
+
+			const mesh = new InstancedMesh( geometry, material, count );
+			mesh.name = `instance_${n ++}`;
+			mesh.frustumCulled = false;
+
+			for ( let i = 0; i < count; i ++ ) {
+
+				if ( rel ) M.multiplyInto( scratch, list.matrices, i * 16, rel );
+				else for ( let e = 0; e < 16; e ++ ) scratch[ e ] = list.matrices[ i * 16 + e ];
+				mesh.setMatrixAt( i, matrix.fromArray( this.convertHandedness ? M.multiply( FLIP_Z, scratch ) : scratch ) );
+
+			}
+
+			mesh.instanceMatrix.needsUpdate = true;
+			group.add( mesh );
+
+			this.placementCount += count;
+			this.reportedMeshes += count;
+			if ( this.report.length < MAX_REPORT_ROWS ) this.report.push( {
+				mesh: `${mesh.name} ×${count}`,
+				shape: shapeType,
+				material: materialType,
+				color: '#' + material.color.getHexString(),
+				map: material.map ? 'yes' : '-',
+				uv: geometry.getAttribute( 'uv' ) ? 'yes' : 'NO',
+				normals: geometry.getAttribute( 'normal' ) ? 'yes' : 'NO',
+				emissive: material.emissiveIntensity > 0 ? `#${material.emissive.getHexString()}×${material.emissiveIntensity}` : '-',
+				size: `instanced`,
+				tris,
+			} );
+
+		};
+
+		const placeBatch = ( list, batch ) => {
+
+			if ( batch && batch.triangles > 0 ) place( list, this._batchGeometry( batch ), batch.material, null, 'merged', '-', batch.triangles );
+
+		};
+
+		for ( const { name, list, template } of this._samePlacementGroups( ir ) ) {
 
-			const template = ir.objects.get( name );
 			if ( ! template ) {
 
 				// Counted, not just warned: these are placements that silently leave the scene,
@@ -346,6 +412,13 @@ export class PBRTSceneBuilder {
 
 			}
 
+			// A template's own small shapes share its placements, so they merge in its space: the
+			// eight Pandanus trees in Moana hold 22,965 leaves each. A .ply may be shared with
+			// other templates and stays whole.
+			let inline = 0;
+			for ( const shape of template ) if ( shape.type !== 'plymesh' ) inline ++;
+			const batches = inline >= 2 ? new Map() : null;
+
 			for ( const shape of template ) {
 
 				if ( this._overBudget() ) {
@@ -361,47 +434,80 @@ export class PBRTSceneBuilder {
 				] );
 				if ( ! geometry ) continue;
 
-				const tris = this._accountGeometry( geometry );
-				const affordable = Math.max( 0, this.maxPlacements - this.placementCount );
-				const count = Math.min( list.count, affordable );
-				if ( count < list.count ) this.skippedForBudget += list.count - count;
-				if ( count === 0 ) continue;
+				if ( batches && shape.type !== 'plymesh' && geometry.getAttribute( 'position' ).count <= MERGE_VERTEX_LIMIT ) {
+
+					this._geometryCache.delete( shape );
+					const full = this._appendToBatch( batches, shape, geometry, sharedMaterial, shape.relativeCTM || shape.ctm );
+					this._releaseMerged( shape, geometry );
+					placeBatch( list, full );
+					continue;
 
+				}
+
+				const tris = this._accountGeometry( geometry );
 				const material = this._materialForGeometry( shape, geometry, sharedMaterial, `instances_${name}` );
-				const mesh = new InstancedMesh( geometry, material, count );
-				mesh.name = `instance_${n ++}`;
-				mesh.frustumCulled = false;
+				place( list, geometry, material, shape.relativeCTM || shape.ctm, shape.type, shape.material?.type || 'diffuse', tris );
 
-				const rel = shape.relativeCTM || shape.ctm;
-				for ( let i = 0; i < count; i ++ ) {
+			}
 
-					M.multiplyInto( scratch, list.matrices, i * 16, rel );
-					mesh.setMatrixAt( i, matrix.fromArray( this.convertHandedness ? M.multiply( FLIP_Z, scratch ) : scratch ) );
+			if ( batches ) for ( const slot of batches.values() ) {
 
-				}
+				placeBatch( list, slot[ 0 ] );
+				placeBatch( list, slot[ 1 ] );
+
+			}
+
+			// Copied into each InstancedMesh: 576 MB at 9M placements, held to the end otherwise.
+			freeNow( list.matrices );
+			freeNow( list.matricesEnd );
+
+		}
+
+	}
+
+	/**
+	 * Templates placed at exactly the same transforms, as one template. Each Pandanus tree
+	 * includes ten leaf files; kept apart they were ten overlapping instances a ray entered
+	 * one after another, and the tree rendered 60 % slower than with its leaves world-baked.
+	 * @private
+	 */
+	_samePlacementGroups( ir ) {
 
-				mesh.instanceMatrix.needsUpdate = true;
-				group.add( mesh );
-
-				this.placementCount += count;
-				this.reportedMeshes += count;
-				if ( this.report.length < MAX_REPORT_ROWS ) this.report.push( {
-					mesh: `${mesh.name} ×${count}`,
-					shape: shape.type,
-					material: shape.material?.type || 'diffuse',
-					color: '#' + material.color.getHexString(),
-					map: material.map ? 'yes' : '-',
-					uv: geometry.getAttribute( 'uv' ) ? 'yes' : 'NO',
-					normals: geometry.getAttribute( 'normal' ) ? 'yes' : 'NO',
-					emissive: material.emissiveIntensity > 0 ? `#${material.emissive.getHexString()}×${material.emissiveIntensity}` : '-',
-					size: `instanced`,
-					tris,
-				} );
+		const groups = [];
+		const buckets = new Map();
+
+		for ( const [ name, list ] of ir.instances ) {
+
+			const template = ir.objects.get( name );
+			if ( ! template || list.matricesEnd ) {
+
+				groups.push( { name, list, template } );
+				continue;
+
+			}
+
+			const key = `${list.count}:${Array.prototype.join.call( list.matrices.subarray( 0, 16 ), ',' )}`;
+			let bucket = buckets.get( key );
+			if ( ! bucket ) buckets.set( key, bucket = [] );
+
+			const same = bucket.find( g => samePlacements( g.list, list ) );
+			if ( same ) {
+
+				if ( same.template === ir.objects.get( same.name ) ) same.template = same.template.slice();
+				for ( const shape of template ) same.template.push( shape );
+				freeNow( list.matrices );
+				continue;
 
 			}
 
+			const group = { name, list, template };
+			bucket.push( group );
+			groups.push( group );
+
 		}
 
+		return groups;
+
 	}
 
 	/** Moving placements, one Group each: an InstancedMesh cannot move a single instance. */
@@ -637,6 +743,35 @@ export class PBRTSceneBuilder {
 	 */
 	_mergeShape( shape, geometry, sharedMaterial, group ) {
 
+		this.reportedMeshes ++;
+		const world = this.convertHandedness ? M.multiply( FLIP_Z, shape.ctm ) : shape.ctm;
+		const full = this._appendToBatch( this._batches, shape, geometry, sharedMaterial, world );
+		this._releaseMerged( shape, geometry );
+		if ( full ) this._flushBatch( full, group );
+
+	}
+
+	/**
+	 * A merged shape's arrays are in its batch now and nothing reads it again: freed at once, not at
+	 * a GC the build reaches with every one still held — isIronwoodA1's leaves were 3.9 GB twice over.
+	 * @private
+	 */
+	_releaseMerged( shape, geometry ) {
+
+		if ( this._keepShapes?.has( shape ) ) return;
+		for ( const name in geometry.attributes ) freeNow( geometry.attributes[ name ].array );
+		freeNow( geometry.index?.array );
+		for ( const name in shape.params ) if ( ArrayBuffer.isView( shape.params[ name ]?.value ) ) freeNow( shape.params[ name ].value );
+
+	}
+
+	/**
+	 * Copy one shape's triangles, moved by `transform`, into the batch for its material.
+	 * @returns {object|null} the batch, taken out of `batches`, once it is full
+	 * @private
+	 */
+	_appendToBatch( batches, shape, geometry, sharedMaterial, transform ) {
+
 		const material = this._materialForGeometry( shape, geometry, sharedMaterial, 'merged shape' );
 		const position = geometry.getAttribute( 'position' );
 		const normal = geometry.getAttribute( 'normal' );
@@ -646,11 +781,10 @@ export class PBRTSceneBuilder {
 
 		// Charged directly: a merged shape stores its own copy even when two share one .ply.
 		this.triangleCount += ( index ? index.count : vertices ) / 3;
-		this.reportedMeshes ++;
 		this.mergedShapes ++;
 
-		let slot = this._batches.get( material );
-		if ( ! slot ) this._batches.set( material, slot = [ null, null ] );
+		let slot = batches.get( material );
+		if ( ! slot ) batches.set( material, slot = [ null, null ] );
 		const k = uv ? 1 : 0;
 		let batch = slot[ k ];
 		if ( ! batch ) slot[ k ] = batch = {
@@ -662,7 +796,7 @@ export class PBRTSceneBuilder {
 			vertexCount: 0, indexCount: 0, triangles: 0
 		};
 
-		const world = this.convertHandedness ? M.multiply( FLIP_Z, shape.ctm ) : shape.ctm;
+		const world = transform;
 		const inv = M.invert( world );
 		const base = batch.vertexCount;
 
@@ -711,11 +845,26 @@ export class PBRTSceneBuilder {
 
 		if ( batch.triangles >= MERGE_BATCH_TRIANGLES ) {
 
-			this._flushBatch( batch, group );
 			slot[ k ] = null;
+			return batch;
 
 		}
 
+		return null;
+
+	}
+
+	/** A batch's triangles as one geometry; the batch's own arrays are released. @private */
+	_batchGeometry( batch ) {
+
+		const geometry = new BufferGeometry();
+		geometry.setAttribute( 'position', new Float32BufferAttribute( resized( batch.positions, batch.vertexCount * 3 ), 3 ) );
+		geometry.setAttribute( 'normal', new Float32BufferAttribute( resized( batch.normals, batch.vertexCount * 3 ), 3 ) );
+		if ( batch.uvs ) geometry.setAttribute( 'uv', new Float32BufferAttribute( resized( batch.uvs, batch.vertexCount * 2 ), 2 ) );
+		geometry.setIndex( new Uint32BufferAttribute( resized( batch.indices, batch.indexCount ), 1 ) );
+		batch.positions = batch.normals = batch.uvs = batch.indices = null;
+		return geometry;
+
 	}
 
 	/** Turn one accumulated batch into a single Mesh at the scene origin. @private */
@@ -723,12 +872,7 @@ export class PBRTSceneBuilder {
 
 		if ( ! batch || batch.triangles === 0 ) return;
 
-		const geometry = new BufferGeometry();
-		geometry.setAttribute( 'position', new Float32BufferAttribute( batch.positions.slice( 0, batch.vertexCount * 3 ), 3 ) );
-		geometry.setAttribute( 'normal', new Float32BufferAttribute( batch.normals.slice( 0, batch.vertexCount * 3 ), 3 ) );
-		if ( batch.uvs ) geometry.setAttribute( 'uv', new Float32BufferAttribute( batch.uvs.slice( 0, batch.vertexCount * 2 ), 2 ) );
-		geometry.setIndex( new Uint32BufferAttribute( batch.indices.slice( 0, batch.indexCount ), 1 ) );
-
+		const geometry = this._batchGeometry( batch );
 		const mesh = new Mesh( geometry, batch.material );
 		mesh.name = `merged_${this._mergedBatches ++}`;
 		mesh.frustumCulled = false;
@@ -748,8 +892,6 @@ export class PBRTSceneBuilder {
 			tris: batch.triangles
 		} );
 
-		batch.positions = batch.normals = batch.uvs = batch.indices = null;
-
 	}
 
 	_buildGeometry( shape ) {
@@ -833,7 +975,8 @@ export class PBRTSceneBuilder {
 			width1: pFloat( params, 'width1', width ),
 			N: params.N?.value || null,
 			steps: this.curveSteps,
-			sides: this.curveSides ?? DEFAULT_CURVE_SIDES[ type ] ?? 1
+			sides: this.curveSides ?? DEFAULT_CURVE_SIDES[ type ] ?? 1,
+			tolerance: this.curveTolerance
 		} );
 
 		if ( ! built ) {

package/src/Processor/PBRT/buffers.js

@@ -0,0 +1,27 @@
+/**
+ * A dropped ArrayBuffer is freed at the next major GC, which a parse allocating gigabytes of
+ * scene text and growing arrays reaches late: the 80M-triangle Moana parse held ~4 GB of such
+ * garbage. Transferring a buffer away frees it at once.
+ */
+
+const whole = view => view.byteOffset === 0 && view.byteLength === view.buffer.byteLength
+	&& typeof view.buffer.transfer === 'function'
+	&& ! ( typeof SharedArrayBuffer !== 'undefined' && view.buffer instanceof SharedArrayBuffer );
+
+/** Frees a view's memory now. Only for a view that alone holds its whole buffer. */
+export function freeNow( view ) {
+
+	if ( view && whole( view ) ) view.buffer.transfer( 0 );
+
+}
+
+/** `view` at `length` elements, the old memory let go at once; zero-filled when it grows. */
+export function resized( view, length ) {
+
+	const Type = view.constructor;
+	if ( whole( view ) ) return new Type( view.buffer.transfer( length * Type.BYTES_PER_ELEMENT ) );
+	const out = new Type( length );
+	out.set( length < view.length ? view.subarray( 0, length ) : view );
+	return out;
+
+}

package/src/Processor/PBRT/index.js

@@ -14,12 +14,13 @@
  *   await loadObject3D(group);
  */
 
+import { freeNow } from './buffers.js';
 import { PBRTParser } from './PBRTParser.js';
 import { PBRTSceneBuilder } from './PBRTSceneBuilder.js';
 import { findFrameSequence, FrameSequenceMerger, motionFromShutter, SEQUENCE_FPS } from './PBRTAnimation.js';
 
 export { PBRTParser } from './PBRTParser.js';
-export { PBRTSceneBuilder } from './PBRTSceneBuilder.js';
+export { PBRTSceneBuilder, PBRT_BUILD_REVISION, SPILL_TRIANGLE_BUDGET, SPILL_PLACEMENT_BUDGET } from './PBRTSceneBuilder.js';
 export { tokenize } from './PBRTTokenizer.js';
 export { findFrameSequence, SEQUENCE_FPS } from './PBRTAnimation.js';
 
@@ -105,6 +106,16 @@ export class VirtualFS {
 
 	}
 
+	/** The first `bytes` of a record, reading no more of a lazy one than that when the source can. */
+	async readHead( rec, bytes ) {
+
+		if ( ! rec ) return null;
+		if ( rec.bytes ) return rec.bytes.subarray( 0, bytes );
+		if ( ! rec.lazy || ! this.source ) return null;
+		return this.source.readHead ? this.source.readHead( rec.key, bytes ) : this.source.read( rec.key );
+
+	}
+
 	/** Resolve and read in one step; `dir` is joined first, as Include does. */
 	async readPath( path, dir = null ) {
 
@@ -120,12 +131,15 @@ export class VirtualFS {
 
 	}
 
-	releasePath( path, dir = null ) {
+	/** `bytes`, when given, are what a read of it returned, freed now rather than at the next GC. */
+	releasePath( path, dir = null, bytes = 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 );
+		if ( ! rec?.lazy ) return;
+		this.release( rec );
+		freeNow( bytes );
 
 	}
 
@@ -180,6 +194,7 @@ function findBytes( bytes, needle, from = 0 ) {
 }
 
 const ASCII = s => Uint8Array.from( s, c => c.charCodeAt( 0 ) );
+const ENTRY_HEAD_BYTES = 4 * 1024 * 1024;
 const WORLD_BEGIN = ASCII( 'WorldBegin' );
 const INCLUDE_WORDS = [ ASCII( 'Include' ), ASCII( 'Import' ) ];
 
@@ -311,6 +326,11 @@ export async function pickEntryPathFrom( vfs ) {
 /**
  * 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.
+ *
+ * WorldBegin may only follow the scene-wide options, so a scene declares it within its first
+ * megabytes: the heads decide, and when they name one scene no file is read whole — the full
+ * reads were 15 GB and 40 s for a 17-part Moana archive before its parse began. Heads that name
+ * none, or several, fall back to reading everything, as the ranking of several needs.
  */
 export async function listEntryPathsFrom( vfs ) {
 
@@ -318,18 +338,34 @@ export async function listEntryPathsFrom( vfs ) {
 	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 scan = async ( read ) => {
 
-		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
+		const included = new Set();
+		const worlds = new Map();
+		let cut = false;
+		for ( const rec of pbrts ) {
 
-	}
+			const bytes = await read( rec );
+			if ( ! bytes ) continue;
+			worlds.set( rec.key, hasWorldBegin( bytes ) );
+			includedBasenames( bytes, included );
+			if ( bytes.length >= ENTRY_HEAD_BYTES ) cut = true;
+			if ( rec.lazy ) {
+
+				vfs.release( rec ); // read again later if it is actually used
+				freeNow( bytes );
+
+			}
+
+		}
+
+		return { included, worlds, cut };
+
+	};
 
+	const heads = await scan( rec => vfs.readHead( rec, ENTRY_HEAD_BYTES ) );
+	const scenes = [ ...heads.worlds.values() ].filter( Boolean ).length;
+	const { included, worlds } = scenes === 1 || ! heads.cut ? heads : await scan( rec => vfs.read( rec ) );
 	return rankEntryPaths( pbrts.map( r => r.key ), worlds, included );
 
 }
@@ -377,11 +413,14 @@ export async function loadPBRTScene( args ) {
 			resolveInclude: ( include, currentDir ) => vfs.readPath( include, 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: ( include, currentDir ) => vfs.releasePath( include, currentDir ),
-			maxPlacements: args.maxPlacements
+			releaseInclude: ( include, currentDir, bytes ) => vfs.releasePath( include, currentDir, bytes ),
+			maxPlacements: args.maxPlacements,
+			instanceIncludes: args.instanceIncludes
 		} );
 
-		return parser.parse( bytes, path.includes( '/' ) ? path.slice( 0, path.lastIndexOf( '/' ) ) : '' );
+		const ir = await parser.parse( bytes, path.includes( '/' ) ? path.slice( 0, path.lastIndexOf( '/' ) ) : '' );
+		vfs.releasePath( path, null, bytes );
+		return ir;
 
 	};
 
@@ -450,6 +489,7 @@ export async function loadPBRTScene( args ) {
 		mergeShapesAbove: args.mergeShapesAbove,
 		curveSteps: args.curveSteps,
 		curveSides: args.curveSides,
+		curveTolerance: args.curveTolerance,
 		resolvePLY: async ( filename ) => {
 
 			const rec = vfs.findRecord( filename );

package/src/Processor/PackedRayBuffer.js

@@ -2,7 +2,7 @@
  * 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
+ * Both 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).
  */
 
@@ -17,7 +17,7 @@ import { createLogger, fmt } from '../utils/Logger.js';
 const log = createLogger( 'gpu' );
 
 export const RAY_STRIDE = 7;
-export const HIT_STRIDE = 2;
+export const HIT_STRIDE = 3;
 // Per-pixel G-buffer (first-hit MRT staging): 1 uvec4/pixel — half-packed normal/depth/albedo
 // (pack2x16, no f32 bitcast); read by FinalWrite:
 //   .x=packSnorm2x16(normal.xy)  .y=packSnorm2x16(normal.z, depth)  .z=packUnorm2x16(albedo.rg)
@@ -42,6 +42,9 @@ export const HIT = {
 	// 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)
+	// The path's RNG state, here rather than in a buffer of its own: Shade was at the device's
+	// 10 storage buffers, and the second triangle buffer needed the slot. Extend never writes it.
+	RNG: 2, // uvec4(rngState, 0, 0, 0)
 };
 
 // SoA region stride, baked into the shader graph at build time; single instance, rebuilt on resize.
@@ -73,7 +76,6 @@ export class PackedRayBuffer {
 
 		// Each: { rw: StorageBufferNode, ro: StorageBufferNode } over one shared GPU buffer.
 		this.rayBuffer = null;
-		this.rngBuffer = null;
 		this.hitBuffer = null;
 
 		if ( capacity > 0 ) this.allocate( capacity );
@@ -96,13 +98,6 @@ export class PackedRayBuffer {
 			ro: storage( rayAttr, 'vec4' ).toReadOnly(),
 		};
 
-		const rngAttr = gpuOnlyStorageAttribute( capacity, 1, Uint32Array );
-		this._attrs.rng = rngAttr;
-		this.rngBuffer = {
-			rw: storage( rngAttr, 'uint' ),
-			ro: storage( rngAttr, 'uint' ).toReadOnly(),
-		};
-
 		const hitCount = capacity * HIT_STRIDE;
 		const hitAttr = gpuOnlyStorageAttribute( hitCount, 4, Uint32Array );
 		this._attrs.hit = hitAttr;
@@ -112,7 +107,7 @@ export class PackedRayBuffer {
 		};
 
 		// Kept for the [gpu] startup summary in PathTracer._buildWavefrontKernels.
-		this.rayBytes = rayCount * 16 + capacity * 4;
+		this.rayBytes = rayCount * 16;
 		this.hitBytes = hitCount * 16;
 		this.totalBytes = this.rayBytes + this.hitBytes;
 
@@ -132,11 +127,9 @@ export class PackedRayBuffer {
 	dispose() {
 
 		freeStorageAttribute( this._renderer, this._attrs.ray );
-		freeStorageAttribute( this._renderer, this._attrs.rng );
 		freeStorageAttribute( this._renderer, this._attrs.hit );
 		this._attrs = {};
 		this.rayBuffer = null;
-		this.rngBuffer = null;
 		this.hitBuffer = null;
 		this.capacity = 0;
 
@@ -285,6 +278,10 @@ export const readHitInstanceLeaf = ( buf, id ) =>
 export const readHitFacet = ( buf, id ) =>
 	buf.element( soa( id, HIT.NORMAL_MAT ) ).w;
 
+export const readRngState = ( buf, id ) => buf.element( soa( id, HIT.RNG ) ).x;
+
+export const writeRngState = ( buf, id, state ) => buf.element( soa( id, HIT.RNG ) ).assign( uvec4( state, 0, 0, 0 ) );
+
 export const writeHitPacked = ( buf, id, distance, triIndex, baryU, baryV, normal, matIndex, instanceLeaf, facet = uint( 0 ) ) => {
 
 	buf.element( soa( id, HIT.DIST_TRI_BARY ) )