rayzee 11.2.0 → 11.3.0

package/src/Processor/BVHRefitter.js

@@ -10,7 +10,10 @@
  */
 
 import { isFoldedRef, foldedFirst, foldedCount } from './BVHLeafFold.js';
-import { TRIANGLE_DATA_LAYOUT, packNormalOct, BVH_LEAF_MARKERS } from './BufferLayout.js';
+import {
+	TRIANGLE_DATA_LAYOUT, packNormalOct, BVH_LEAF_MARKERS, BVH_EMPTY_BOX,
+	CLUSTER_FIRST_MASK, CLUSTER_COUNT_SHIFT, CLUSTER_ROOT_MASK, CLUSTER_SIZE, RECORD_VEC4, TLAS_LEAF_IDENTITY, encodeClusterBoxes,
+} from './BufferLayout.js';
 
 const FPT = TRIANGLE_DATA_LAYOUT.FLOATS_PER_TRIANGLE;
 
@@ -54,6 +57,7 @@ const triAccess = ( triangleData ) => {
 const FLOATS_PER_NODE = 16; // 4 vec4s per BVH node
 const LEAF_MARKER = BVH_LEAF_MARKERS.TRIANGLE_LEAF;
 const BLAS_POINTER_MARKER = BVH_LEAF_MARKERS.BLAS_POINTER_LEAF;
+const CLUSTER_MARKER = BVH_LEAF_MARKERS.CLUSTER_LEAF;
 
 // Relative to the matrix's own magnitude, never an absolute floor — see transformBoundsToWorld.
 const SINGULAR_REL_EPS = 1e-12;
@@ -64,6 +68,13 @@ const SINGULAR_REL_EPS = 1e-12;
  */
 function transformBoundsToWorld( bvhData, nodeOff, src, srcOff, dst, dstOff ) {
 
+	if ( src[ srcOff ] > src[ srcOff + 3 ] ) {
+
+		for ( let i = 0; i < 6; i ++ ) dst[ dstOff + i ] = src[ srcOff + i ];
+		return;
+
+	}
+
 	const a0 = bvhData[ nodeOff + 4 ], a1 = bvhData[ nodeOff + 5 ], a2 = bvhData[ nodeOff + 6 ], tx = bvhData[ nodeOff + 7 ];
 	const a3 = bvhData[ nodeOff + 8 ], a4 = bvhData[ nodeOff + 9 ], a5 = bvhData[ nodeOff + 10 ], ty = bvhData[ nodeOff + 11 ];
 	const a6 = bvhData[ nodeOff + 12 ], a7 = bvhData[ nodeOff + 13 ], a8 = bvhData[ nodeOff + 14 ], tz = bvhData[ nodeOff + 15 ];
@@ -151,6 +162,19 @@ function triangleBounds( acc, first, count, out, off ) {
 
 const folded = new Float32Array( 12 );
 
+// Empty bounds (a hidden group member, an empty leaf) are min > max while computed — neutral in a union — and stored
+// as the far point box no ray enters, read back as empty.
+const isEmptyStored = ( f, o ) => f[ o ] >= BVH_EMPTY_BOX * 0.5;
+
+/** A child's computed box into its slot at `o`: as it is, or the far point box when empty. */
+function writeChildSlot( f, o, src, s ) {
+
+	const empty = src[ s ] > src[ s + 3 ];
+	f[ o ] = empty ? BVH_EMPTY_BOX : src[ s ]; f[ o + 1 ] = empty ? BVH_EMPTY_BOX : src[ s + 1 ]; f[ o + 2 ] = empty ? BVH_EMPTY_BOX : src[ s + 2 ];
+	f[ o + 4 ] = empty ? BVH_EMPTY_BOX : src[ s + 3 ]; f[ o + 5 ] = empty ? BVH_EMPTY_BOX : src[ s + 4 ]; f[ o + 6 ] = empty ? BVH_EMPTY_BOX : src[ s + 5 ];
+
+}
+
 /** A node's own box from what it stores — its two child boxes, or a leaf's triangles — into out[ 0 .. 6 ). */
 function storedBounds( nodes, n, acc, out ) {
 
@@ -165,13 +189,56 @@ function storedBounds( nodes, n, acc, out ) {
 
 	}
 
+	const left = ! isEmptyStored( f, o ), right = ! isEmptyStored( f, o + 8 );
 	for ( let a = 0; a < 3; a ++ ) {
 
-		out[ a ] = Math.min( f[ o + a ], f[ o + 8 + a ] );
-		out[ 3 + a ] = Math.max( f[ o + 4 + a ], f[ o + 12 + a ] );
+		out[ a ] = Math.min( left ? f[ o + a ] : Infinity, right ? f[ o + 8 + a ] : Infinity );
+		out[ 3 + a ] = Math.max( left ? f[ o + 4 + a ] : - Infinity, right ? f[ o + 12 + a ] : - Infinity );
+
+	}
+
+}
+
+const recordRows = new Float32Array( 16 );
+const rootBox = new Float32Array( 6 );
+const copyBoxes = new Float32Array( CLUSTER_SIZE * 6 );
+
+/**
+ * A cluster leaf's boxes from its copies now: each copy's root's stored box carried to world through its record
+ * (behind the BLASes from node `recordNodeStart`), encoded into the leaf; the union into `out` at `outOff`.
+ */
+function refitClusterLeaf( nodes, i, acc, recordNodeStart, out, outOff ) {
+
+	const f = nodeF( nodes, i ), idx = nodeIdx( nodes, i ), o = nodeBase( nodes, i );
+	const first = idx[ o ] & CLUSTER_FIRST_MASK;
+	const count = ( ( idx[ o ] >>> CLUSTER_COUNT_SHIFT ) & 3 ) + 1;
+
+	for ( let k = 0; k < count; k ++ ) {
+
+		const word = idx[ o + 12 + k ];
+		storedBounds( nodes, word & CLUSTER_ROOT_MASK, acc, rootBox );
+		if ( word & TLAS_LEAF_IDENTITY ) {
+
+			for ( let a = 0; a < 6; a ++ ) copyBoxes[ k * 6 + a ] = rootBox[ a ];
+			continue;
+
+		}
+
+		// A record's 12 floats may straddle a node, and so a chunk.
+		const lane = recordNodeStart * 16 + ( first + k ) * RECORD_VEC4 * 4;
+		for ( let l = 0; l < 12; l ++ ) {
+
+			const n = ( lane + l ) >> 4;
+			recordRows[ 4 + l ] = nodeF( nodes, n )[ nodeBase( nodes, n ) + ( ( lane + l ) & 15 ) ];
+
+		}
+
+		transformBoundsToWorld( recordRows, 0, rootBox, 0, copyBoxes, k * 6 );
 
 	}
 
+	encodeClusterBoxes( f, idx, o, copyBoxes, count, out, outOff );
+
 }
 
 /**
@@ -179,7 +246,7 @@ function storedBounds( nodes, n, acc, out ) {
  * node's two child boxes rewritten from theirs. A leaf folded into its parent takes its box from
  * its triangles.
  */
-function refitNode( nodes, i, acc, bounds, base ) {
+function refitNode( nodes, i, acc, bounds, base, recordNodeStart = - 1 ) {
 
 	const bvhF = nodeF( nodes, i );
 	const idx = nodeIdx( nodes, i );
@@ -194,6 +261,13 @@ function refitNode( nodes, i, acc, bounds, base ) {
 
 	}
 
+	if ( marker === CLUSTER_MARKER ) {
+
+		refitClusterLeaf( nodes, i, acc, recordNodeStart, bounds, b );
+		return;
+
+	}
+
 	if ( marker === BLAS_POINTER_MARKER ) {
 
 		// BLAS-pointer leaf (TLAS): the BLAS root's bounds are in the instance's own
@@ -222,10 +296,8 @@ function refitNode( nodes, i, acc, bounds, base ) {
 
 	}
 
-	bvhF[ o ] = ls[ lb ]; bvhF[ o + 1 ] = ls[ lb + 1 ]; bvhF[ o + 2 ] = ls[ lb + 2 ];
-	bvhF[ o + 4 ] = ls[ lb + 3 ]; bvhF[ o + 5 ] = ls[ lb + 4 ]; bvhF[ o + 6 ] = ls[ lb + 5 ];
-	bvhF[ o + 8 ] = rs[ rb ]; bvhF[ o + 9 ] = rs[ rb + 1 ]; bvhF[ o + 10 ] = rs[ rb + 2 ];
-	bvhF[ o + 12 ] = rs[ rb + 3 ]; bvhF[ o + 13 ] = rs[ rb + 4 ]; bvhF[ o + 14 ] = rs[ rb + 5 ];
+	writeChildSlot( bvhF, o, ls, lb );
+	writeChildSlot( bvhF, o + 8, rs, rb );
 
 	for ( let a = 0; a < 3; a ++ ) {
 
@@ -346,15 +418,15 @@ export class BVHRefitter {
 	 * @param {ArrayLike<number>} blasRanges - flat [ startNode, nodeCount, ... ]
 	 * @param {number} tlasNodeCount - the TLAS occupies nodes [0, tlasNodeCount)
 	 */
-	refitPartial( bvhData, triangleData, blasRanges, tlasNodeCount ) {
+	refitPartial( bvhData, triangleData, blasRanges, tlasNodeCount, groupRange = null, recordNodeStart = - 1 ) {
 
 		for ( let r = 0; r < blasRanges.length; r += 2 ) this.refitRange( bvhData, triangleData, blasRanges[ r ], blasRanges[ r + 1 ] );
 
 		const acc = triAccess( triangleData );
 		const nodes = nodeAccess( bvhData );
+		if ( groupRange ) this.refitGroups( nodes, acc, groupRange[ 0 ], groupRange[ 1 ] );
 		if ( ! this._tlasBounds || this._tlasBounds.length < tlasNodeCount * 6 ) this._tlasBounds = new Float32Array( tlasNodeCount * 6 );
 		const bounds = this._tlasBounds;
-		const rootBox = this._rootBox ||= new Float32Array( 6 );
 
 		for ( let i = tlasNodeCount - 1; i >= 0; i -- ) {
 
@@ -368,7 +440,7 @@ export class BVHRefitter {
 
 			} else {
 
-				refitNode( nodes, i, acc, bounds, 0 );
+				refitNode( nodes, i, acc, bounds, 0, recordNodeStart );
 
 			}
 
@@ -376,6 +448,30 @@ export class BVHRefitter {
 
 	}
 
+	/**
+	 * Group trees between the TLAS and the BLASes: each inner node's child boxes from what its children store, last
+	 * node first, so a child group node is current before its parent reads it. The empty leaf is left alone.
+	 * @private
+	 */
+	refitGroups( nodes, acc, start, count ) {
+
+		const box = this._groupBox ||= new Float32Array( 6 );
+		for ( let i = start + count - 1; i >= start; i -- ) {
+
+			const f = nodeF( nodes, i );
+			const idx = nodeIdx( nodes, i );
+			const o = nodeBase( nodes, i );
+			if ( idx[ o + 3 ] === LEAF_MARKER ) continue;
+
+			storedBounds( nodes, idx[ o + 3 ], acc, box );
+			writeChildSlot( f, o, box, 0 );
+			storedBounds( nodes, idx[ o + 7 ], acc, box );
+			writeChildSlot( f, o + 8, box, 0 );
+
+		}
+
+	}
+
 	/**
 	 * Bottom-up refit of all BVH node AABBs.
 	 * Reverse pre-order iteration gives valid bottom-up order (children have higher
@@ -385,7 +481,7 @@ export class BVHRefitter {
 	 * @param {Uint32Array} triangleData - Updated triangle records
 	 * @param {number} nodeCount - Total number of BVH nodes
 	 */
-	refit( bvhData, triangleData, nodeCount ) {
+	refit( bvhData, triangleData, nodeCount, recordNodeStart = - 1 ) {
 
 		const acc = triAccess( triangleData );
 
@@ -398,7 +494,7 @@ export class BVHRefitter {
 		}
 
 		const nodes = nodeAccess( bvhData );
-		for ( let i = nodeCount - 1; i >= 0; i -- ) refitNode( nodes, i, acc, this._bounds, 0 );
+		for ( let i = nodeCount - 1; i >= 0; i -- ) refitNode( nodes, i, acc, this._bounds, 0, recordNodeStart );
 
 	}
 

package/src/Processor/BufferLayout.js

@@ -244,8 +244,116 @@ export const BVH_LEAF_MARKERS = {
 	TRIANGLE_LEAF: 0x40000000, // leaf containing triangle references
 	BLAS_POINTER_LEAF: 0x40000001, // TLAS leaf pointing to a BLAS root node
 	FRONTIER: 0x40000002, // parallel-build placeholder, overwritten during assembly
+	CLUSTER_LEAF: 0x40000003, // TLAS leaf over up to CLUSTER_SIZE copies of one object (copy clusters)
 };
 
+/**
+ * Copy clusters, for a TLAS over millions of copies: a leaf holds up to CLUSTER_SIZE neighbouring copies, and each
+ * copy's world-to-object rows are a record of RECORD_VEC4 vec4s behind the BLASes (48 B, against 64 B of leaf node and
+ * 64 B of inner node a copy without them). Leaf slots:
+ *   0       first record | ( count − 1 ) << CLUSTER_COUNT_SHIFT; copy k's record is first + k
+ *   1       byte a: the f32 exponent field of axis a's step, a power of two
+ *   2, 4, 5 the union box's min (x, y, z)
+ *   3       CLUSTER_LEAF
+ *   6–8     copy k's box min on axis 0–2, in steps from the union's min, byte k
+ *   9–11    the same for its max
+ *   12 + k  copy k's object root | TLAS_LEAF_IDENTITY (its record is identity) | CLUSTER_COPY_HIDDEN
+ * A traversal stack entry `COPY_ENTRY | leaf << 2 | k` enters copy k: node indices stay below it, folded leaves start at
+ * 2^31, so a leaf index and a record index must each stay below 2^28.
+ */
+export const CLUSTER_SIZE = 4;
+export const CLUSTER_FIRST_MASK = 0x0fffffff;
+export const CLUSTER_COUNT_SHIFT = 28;
+export const CLUSTER_ROOT_MASK = 0x3fffffff;
+export const CLUSTER_COPY_HIDDEN = 0x80000000;
+export const COPY_ENTRY = 0x40000000;
+export const RECORD_VEC4 = 3;
+
+const _f32 = new Float32Array( 1 );
+const _u32 = new Uint32Array( _f32.buffer );
+
+/** The f32 nearest `x` that is not above it. */
+function f32Down( x ) {
+
+	const f = Math.fround( x );
+	if ( f <= x ) return f;
+	_f32[ 0 ] = f;
+	_u32[ 0 ] += f > 0 ? - 1 : 1;
+	return _f32[ 0 ];
+
+}
+
+/** Four f32 steps at the larger magnitude of `a` and `b`: what an f32 sum near them can be off by, with room. */
+function f32Pad( a, b ) {
+
+	return Math.max( Math.abs( a ), Math.abs( b ), 1e-30 ) * 2 ** - 21;
+
+}
+
+const BASE_SLOT = [ 2, 4, 5 ];
+
+/**
+ * A cluster leaf's boxes (slots 1, 2 and 4–11 at float offset `o`): the union of `count` copies' world boxes (`boxes`,
+ * 6 a copy), then each as bytes of it. Everything is rounded outward by a few f32 steps of its own size, so the GPU's
+ * f32 decode never culls a copy from a ray that reaches it — far from the origin a byte step can be finer than one f32
+ * step. The exact union goes to `out` at `outOff`.
+ */
+export function encodeClusterBoxes( data, idx, o, boxes, count, out, outOff ) {
+
+	let exponents = 0;
+	for ( let a = 0; a < 3; a ++ ) {
+
+		let lo = Infinity, hi = - Infinity;
+		for ( let k = 0; k < count; k ++ ) {
+
+			lo = Math.min( lo, boxes[ k * 6 + a ] );
+			hi = Math.max( hi, boxes[ k * 6 + 3 + a ] );
+
+		}
+
+		if ( out ) {
+
+			out[ outOff + a ] = lo;
+			out[ outOff + 3 + a ] = hi;
+
+		}
+
+		// Every copy hidden (a group's members all are): the far point box no ray enters.
+		if ( ! ( lo <= hi ) ) {
+
+			data[ o + BASE_SLOT[ a ] ] = BVH_EMPTY_BOX;
+			idx[ o + 6 + a ] = 0;
+			idx[ o + 9 + a ] = 0;
+			continue;
+
+		}
+
+		const pad = f32Pad( lo, hi );
+		const base = f32Down( lo - pad );
+		let e = Math.max( - 126, Math.ceil( Math.log2( ( hi + pad - base ) / 255 ) ) );
+		while ( Math.fround( base + 255 * 2 ** e ) < hi + pad ) e ++;
+		const step = 2 ** e;
+		data[ o + BASE_SLOT[ a ] ] = base;
+		exponents |= ( e + 127 ) << ( a * 8 );
+		let qLo = 0, qHi = 0;
+		for ( let k = 0; k < count; k ++ ) {
+
+			const kLo = boxes[ k * 6 + a ], kHi = boxes[ k * 6 + 3 + a ];
+			const kPad = f32Pad( kLo, kHi );
+			qLo |= Math.max( 0, Math.min( 255, Math.floor( ( kLo - kPad - base ) / step ) ) ) << ( k * 8 );
+			qHi |= Math.max( 0, Math.min( 255, Math.ceil( ( kHi + kPad - base ) / step ) ) ) << ( k * 8 );
+
+		}
+
+		idx[ o + 6 + a ] = qLo >>> 0;
+		idx[ o + 9 + a ] = qHi >>> 0;
+
+	}
+
+	idx[ o + 1 ] = exponents >>> 0;
+
+}
+
 /**
  * A triangle leaf of at most this many triangles is folded into its parent: the child's slot ([3]
  * or [7]) holds `~( first << 4 | count )`, the very value traversal pushes, so an inner node is
@@ -256,6 +364,13 @@ export const BVH_LEAF_MARKERS = {
 export const BVH_FOLDED_LEAF_MAX = 15;
 export const BVH_FOLDED_FIRST_LIMIT = 1 << 27;
 
+/**
+ * A child no ray may enter — a hidden part of a grouped object — is stored as a point box this far out: its distance
+ * along any ray exceeds every hit, so it is never pushed. Refits read it back as empty. An inverted box (min > max)
+ * will not do: the slab test swaps the planes and the ray enters it everywhere.
+ */
+export const BVH_EMPTY_BOX = 1e30;
+
 /** A u32 view over a float buffer, for writing index fields as exact bit patterns. */
 export function bvhIndexView( f32 ) {
 

package/src/Processor/ChunkedRecords.js

@@ -241,9 +241,10 @@ export class ChunkedRecords {
 
 			if ( ! this._spilled.has( k ) ) continue;
 			const lanes = Math.min( this.recordsPerChunk, this.recordCount - k * this.recordsPerChunk ) * this.lanesPerRecord;
-			const bytes = await this._store.read( k, lanes * this.LaneType.BYTES_PER_ELEMENT );
 			const chunk = allocChunk( this.LaneType, lanes, this.shared );
-			new Uint8Array( chunk.buffer, chunk.byteOffset, chunk.byteLength ).set( new Uint8Array( bytes ) );
+			const target = new Uint8Array( chunk.buffer, chunk.byteOffset, chunk.byteLength );
+			if ( this._store.readInto ) await this._store.readInto( k, target );
+			else target.set( new Uint8Array( await this._store.read( k, target.byteLength ) ) );
 			this.chunks[ k ] = chunk;
 			for ( const v of this._liveViews() ) v.chunks[ k ] = new v.LaneType( chunk.buffer, chunk.byteOffset, chunk.byteLength / v.LaneType.BYTES_PER_ELEMENT );
 			this._spilled.delete( k );

package/src/Processor/EmissiveTriangleBuilder.js

@@ -132,8 +132,8 @@ export class EmissiveTriangleBuilder {
 				// another object's light as soon as any instanced mesh came earlier.
 				const placement = table?.placementRunOf?.( meshIndex )?.start ?? - 1;
 				const hasInstance = placement >= 0 && table.isSet[ placement ];
-				const m = hasInstance ? table.world : null;
-				const mo = hasInstance ? placement * 16 : 0;
+				const mo = hasInstance ? table.matrixRow( placement ) : 0;
+				const m = hasInstance ? table.rowArray : null;
 				const px = ( x, y, z ) => ( m ? m[ mo ] * x + m[ mo + 4 ] * y + m[ mo + 8 ] * z + m[ mo + 12 ] : x );
 				const py = ( x, y, z ) => ( m ? m[ mo + 1 ] * x + m[ mo + 5 ] * y + m[ mo + 9 ] * z + m[ mo + 13 ] : y );
 				const pz = ( x, y, z ) => ( m ? m[ mo + 2 ] * x + m[ mo + 6 ] * y + m[ mo + 10 ] * z + m[ mo + 14 ] : z );
@@ -231,8 +231,6 @@ export class EmissiveTriangleBuilder {
 		const chunkedF = chunked ? chunked.viewAs( Float32Array ) : null;
 		const flatF = chunked ? null : new Float32Array( triangleData.buffer, triangleData.byteOffset, triangleData.length );
 		const FLOATS_PER_TRIANGLE = TRIANGLE_DATA_LAYOUT.FLOATS_PER_TRIANGLE;
-		const m = table.world;
-
 		this.totalEmissivePower = 0;
 
 		for ( const tri of this.emissiveTriangles ) {
@@ -245,7 +243,7 @@ export class EmissiveTriangleBuilder {
 			const placement = table.placementRunOf?.( tri.meshIndex )?.start ?? - 1;
 			if ( placement >= 0 && table.isSet[ placement ] ) {
 
-				const o = placement * 16;
+				const o = table.matrixRow( placement ), m = table.rowArray;
 				for ( let k = 0; k < 9; k += 3 ) {
 
 					const x = v[ k ], y = v[ k + 1 ], z = v[ k + 2 ];
@@ -671,7 +669,9 @@ export class EmissiveTriangleBuilder {
 			this.lightBVHNodeData[ 14 ] = 1.0; // cone axis z
 			this.lightBVHNodeData[ 15 ] = - 1.0; // cosThetaO = whole sphere
 			this.lightBVHNodeCount = 1;
-			this.emissiveBitTrailMap = new Float32Array( Math.max( this._totalTriangleCount, 1 ) ).fill( - 1 );
+			// Shade reads the map only while emissiveTriangleCount > 0: one over every triangle was 446 MB on the Moana
+			// island, in the tab, on the GPU and in Chrome's upload pool.
+			this.emissiveBitTrailMap = new Float32Array( 4 ).fill( - 1 );
 			this.emissiveIndicesArray = new Int32Array( 0 );
 			this.emissivePowerArray = new Float32Array( 0 );
 			this._buildCDF();