rayzee 7.31.1 → 8.1.0

package/src/Processor/TextureCreator.js

@@ -1,5 +1,5 @@
 import { DataArrayTexture, RGBAFormat, LinearFilter, UnsignedByteType, SRGBColorSpace, LinearSRGBColorSpace, RepeatWrapping } from "three";
-import { alignBucketWidth, TEXTURE_CONSTANTS, MEMORY_CONSTANTS, DEFAULT_TEXTURE_MATRIX, MATERIAL_DATA_LAYOUT, normalizeAttenuationDistance } from '../EngineDefaults.js';
+import { alignBucketWidth, TEXTURE_CONSTANTS, MEMORY_CONSTANTS, DEFAULT_TEXTURE_MATRIX, MATERIAL_DATA_LAYOUT, normalizeAttenuationDistance, BVH_LEAF_MARKERS, assertBVHIndexFits, bvhIndexView } from '../EngineDefaults.js';
 import TexturesWorker from './Workers/TexturesWorker.js?worker&inline';
 import { ISSUE_CODES } from '../EngineIssues.js';
 import { linearToSRGB } from './ToneMapCPU.js';
@@ -1148,12 +1148,15 @@ export class TextureCreator {
 
 		flattenBVH( bvhRoot );
 
-		// Layout: 4 vec4 per node (16 floats)
+		// Layout: 4 vec4 per node (16 floats). Bounds are floats; every index field is a u32
+		// bit pattern (see EngineDefaults.BVH_LEAF_MARKERS).
 		// Inner: [leftMin.xyz, leftChild] [leftMax.xyz, rightChild] [rightMin.xyz, 0] [rightMax.xyz, 0]
-		// Leaf:  [triOffset, triCount, 0, -1] [0,0,0,0] [0,0,0,0] [0,0,0,0]
+		// Leaf:  [triOffset, triCount, 0, TRIANGLE_LEAF] [0,0,0,0] [0,0,0,0] [0,0,0,0]
 		const floatsPerNode = TEXTURE_CONSTANTS.VEC4_PER_BVH_NODE * TEXTURE_CONSTANTS.FLOATS_PER_VEC4;
+		assertBVHIndexFits( nodes.length, 'BVH node count' );
 		const size = nodes.length * floatsPerNode;
 		const data = new Float32Array( size );
+		const idx = bvhIndexView( data ); // index fields are u32 bit patterns
 
 		for ( let i = 0; i < nodes.length; i ++ ) {
 
@@ -1171,12 +1174,12 @@ export class TextureCreator {
 				data[ stride ] = left.boundsMin.x;
 				data[ stride + 1 ] = left.boundsMin.y;
 				data[ stride + 2 ] = left.boundsMin.z;
-				data[ stride + 3 ] = leftIdx;
+				idx[ stride + 3 ] = leftIdx;
 
 				data[ stride + 4 ] = left.boundsMax.x;
 				data[ stride + 5 ] = left.boundsMax.y;
 				data[ stride + 6 ] = left.boundsMax.z;
-				data[ stride + 7 ] = rightIdx;
+				idx[ stride + 7 ] = rightIdx;
 
 				data[ stride + 8 ] = right.boundsMin.x;
 				data[ stride + 9 ] = right.boundsMin.y;
@@ -1188,10 +1191,9 @@ export class TextureCreator {
 
 			} else {
 
-				// Leaf node
-				data[ stride ] = node.triangleOffset;
-				data[ stride + 1 ] = node.triangleCount;
-				data[ stride + 3 ] = - 1; // Leaf marker
+				idx[ stride ] = node.triangleOffset;
+				idx[ stride + 1 ] = node.triangleCount;
+				idx[ stride + 3 ] = BVH_LEAF_MARKERS.TRIANGLE_LEAF;
 
 			}
 

package/src/Processor/VRAMTracker.js

@@ -32,10 +32,10 @@ function texelBytes( tex ) {
 
 }
 
-/** Exact byte size of a storage/buffer attribute's backing typed array. */
+/** Exact GPU byte size of a buffer attribute. GPU-only ones carry no backing array. */
 export function bufferBytes( attr ) {
 
-	return attr?.array?.byteLength || 0;
+	return attr?.gpuByteLength ?? attr?.array?.byteLength ?? 0;
 
 }
 
@@ -141,7 +141,16 @@ export class VRAMTracker {
 		// synthetic { bytes } (e.g. attributeArray-backed histograms)
 		if ( typeof r.bytes === 'number' && ! r.isTexture && ! r.isRenderTarget ) return r.bytes;
 
-		// buffer attribute — dedupe by backing array (rw/ro nodes share one buffer)
+		// buffer attribute — dedupe by backing array, or by the attribute itself when it is
+		// GPU-only and has none (rw/ro nodes share one buffer either way)
+		if ( r.gpuByteLength != null ) {
+
+			if ( seen.has( r ) ) return 0;
+			seen.add( r );
+			return r.gpuByteLength;
+
+		}
+
 		if ( r.array && r.array.byteLength != null ) {
 
 			if ( seen.has( r.array ) ) return 0;

package/src/Processor/Workers/BVHRefitWorker.js

@@ -2,20 +2,21 @@
  * BVHRefitWorker — Off-main-thread BVH refit using SharedArrayBuffer.
  *
  * Protocol:
- *   'init'  → receives SharedArrayBuffers + index map (once per scene)
- *   'refit' → reads shared positions, writes shared bvh/tri data (per frame)
+ *   'init'  → receives the shared triangle and node buffers (once per scene)
+ *   'refit' → recomputes every node's AABB from the triangles already written there
+ *
+ * Positions never reach here: the main thread scatters each mesh into the shared triangle
+ * records as it reads it, so no buffer the size of the scene exists on either side.
  */
 
 import { BVHRefitter } from '../BVHRefitter.js';
+import { ChunkedRecords } from '../ChunkedRecords.js';
 
-const FLOATS_PER_NODE = 16;
 const refitter = new BVHRefitter();
 
 // Cached shared memory views (set once on 'init', reused every frame)
 let bvhData = null;
 let triData = null;
-let posData = null;
-let bvhToOriginal = null;
 let nodeCount = 0;
 
 self.onmessage = function ( e ) {
@@ -24,11 +25,16 @@ self.onmessage = function ( e ) {
 
 	if ( type === 'init' ) {
 
-		bvhData = new Float32Array( e.data.sharedBvhBuf );
-		triData = new Float32Array( e.data.sharedTriBuf );
-		posData = new Float32Array( e.data.sharedPosBuf );
-		bvhToOriginal = e.data.bvhToOriginal; // transferred Uint32Array
-		nodeCount = bvhData.length / FLOATS_PER_NODE;
+		bvhData = ChunkedRecords.adopt(
+			e.data.sharedBvhBufs.map( buf => new Float32Array( buf ) ),
+			e.data.bvhRecordCount, 16, e.data.bvhRecordsPerChunk
+		);
+		// Triangles arrive as one shared buffer per chunk; a single-chunk scene is the usual case.
+		triData = ChunkedRecords.adopt(
+			e.data.sharedTriBufs.map( buf => new Uint32Array( buf ) ),
+			e.data.triRecordCount, e.data.triLanesPerRecord, e.data.triRecordsPerChunk
+		);
+		nodeCount = bvhData.recordCount;
 		return;
 
 	}
@@ -39,7 +45,6 @@ self.onmessage = function ( e ) {
 
 			const startTime = performance.now();
 
-			refitter.updateTrianglePositions( triData, posData, bvhToOriginal );
 			refitter.refit( bvhData, triData, nodeCount );
 
 			self.postMessage( {

package/src/Processor/Workers/BVHWorker.js

@@ -3,7 +3,7 @@ import { createLogger, fmt, applyWorkerLogLevel } from '../../utils/Logger.js';
 
 const log = createLogger( 'bvh' );
 
-const FPT = 32; // FLOATS_PER_TRIANGLE
+const FPT = 20; // FLOATS_PER_TRIANGLE — the record is uint lanes, not floats
 
 // --- Message dispatcher ---
 
@@ -60,7 +60,7 @@ function handlePhase1( data ) {
 		} : null;
 
 		// Attach shared buffer views
-		builder.triangles = new Float32Array( sharedTriangleData );
+		builder.triangles = new Uint32Array( sharedTriangleData );
 		builder.centroids = new Float32Array( sharedCentroids );
 		builder.bMin = new Float32Array( sharedBMin );
 		builder.bMax = new Float32Array( sharedBMax );
@@ -148,8 +148,8 @@ function handleAssemble( data ) {
 
 		// Reorder triangles using final indices from SharedArrayBuffer
 		const indices = new Uint32Array( sharedIndices );
-		const src = new Float32Array( sharedTriangleData );
-		const dst = new Float32Array( sharedReorderBuffer );
+		const src = new Uint32Array( sharedTriangleData );
+		const dst = new Uint32Array( sharedReorderBuffer );
 
 		for ( let i = 0; i < triangleCount; i ++ ) {
 
@@ -219,11 +219,11 @@ function handleFullBuild( data ) {
 		} : null;
 
 		const inputTriangles = triangleByteOffset !== undefined
-			? new Float32Array( triangleData, triangleByteOffset, triangleByteLength / 4 )
-			: new Float32Array( triangleData );
+			? new Uint32Array( triangleData, triangleByteOffset, triangleByteLength / 4 )
+			: new Uint32Array( triangleData );
 
 		const reorderTarget = sharedReorderBuffer
-			? new Float32Array( sharedReorderBuffer )
+			? new Uint32Array( sharedReorderBuffer )
 			: null;
 
 		const bvhRoot = builder.buildSync( inputTriangles, depth, progressCallback, reorderTarget );
@@ -243,21 +243,21 @@ function handleFullBuild( data ) {
 			self.postMessage( {
 				bvhData,
 				originalToBvh,
-				triangleCount: inputTriangles.length / 32,
+				triangleCount: inputTriangles.length / FPT,
 				treeletStats: builder.splitStats
 			}, transferables );
 
 		} else {
 
-			const reorderedFloat32Array = builder.reorderedTriangleData;
-			const triangleCount = reorderedFloat32Array.byteLength / ( 32 * 4 );
+			const reordered = builder.reorderedTriangleData;
+			const triangleCount = reordered.byteLength / ( FPT * 4 );
 
-			const transferables = [ bvhData.buffer, reorderedFloat32Array.buffer ];
+			const transferables = [ bvhData.buffer, reordered.buffer ];
 			if ( originalToBvh ) transferables.push( originalToBvh.buffer );
 
 			self.postMessage( {
 				bvhData,
-				triangles: reorderedFloat32Array,
+				triangles: reordered,
 				originalToBvh,
 				triangleCount,
 				treeletStats: builder.splitStats

package/src/Processor/Workers/TLASWorker.js

@@ -0,0 +1,37 @@
+/**
+ * Builds the TLAS off the main thread.
+ *
+ * Only the SAH tree runs here — it is the O(n log n) half, and at 6M placements it pinned the
+ * main thread for 25 s. The leaf payloads (BLAS pointer, visibility, world-to-object matrix)
+ * are filled in by the caller afterwards: that pass is O(n) and cheap, and keeping it out of
+ * the message avoids shipping a 16-float matrix per instance across the boundary.
+ */
+
+import { TLASBuilder } from '../TLASBuilder.js';
+import { createLogger, fmt, applyWorkerLogLevel } from '../../utils/Logger.js';
+
+const log = createLogger( 'bvh' );
+
+self.onmessage = function ( e ) {
+
+	const { aabbs, count, logLevel } = e.data;
+	applyWorkerLogLevel( logLevel );
+
+	try {
+
+		const start = performance.now();
+		// A fresh builder per message sizes its buffer exactly, so the result's ArrayBuffer can
+		// be transferred whole rather than copied out of a reused, oversized one.
+		const { data, nodeCount } = new TLASBuilder().buildStructure( new Float64Array( aabbs ), count );
+		log.debug( `TLAS ${fmt.n( nodeCount )} nodes in ${fmt.ms( performance.now() - start )}` );
+
+		self.postMessage( { tlasData: data, nodeCount }, [ data.buffer ] );
+
+	} catch ( error ) {
+
+		log.error( 'TLAS build failed:', error );
+		self.postMessage( { error: error.message } );
+
+	}
+
+};

package/src/Processor/utils.js

@@ -1,10 +1,6 @@
 import { SphereGeometry, Mesh, MeshPhysicalMaterial, Group, Object3D, Color, Vector3, ShaderMaterial, Vector2, Matrix4, GLSL3 } from 'three';
-import { QuadMesh } from 'three/webgpu';
 import { EngineEvents } from '../EngineEvents.js';
 
-/** Every QuadMesh in the realm shares this one geometry (module-level in three). */
-const _sharedQuadGeometry = /*@__PURE__*/ new QuadMesh( null ).geometry;
-
 let _statusCallback = null;
 
 /**
@@ -103,17 +99,18 @@ export function distroyBuffers( { material, geometry, children } ) {
 /**
  * Disposes a renderer without leaking it.
  *
- * Three.js 0.184–0.185: `Renderer.dispose()` does not remove the 'resize' listener
+ * Three.js 0.184–0.186: `Renderer.dispose()` does not remove the 'resize' listener
  * it installs on `_canvasTarget`. The bound handler closes over the renderer,
  * pinning the entire WebGPU graph (Backend, Nodes, Bindings, Pipelines, GPUDevice,
  * every TSL node) alive indefinitely — confirmed via heap-snapshot retainer
- * analysis. See three/src/renderers/common/Renderer.js:292 (attach) and :2503
- * (dispose — missing removal).
+ * analysis. See `Renderer.js` (attach in the constructor, still absent from
+ * `dispose()` in r186). Re-check on every upgrade; drop this when upstream fixes it.
  *
  * Renderers constructed with an external `device` do not destroy it here; three
  * only destroys a device it created itself.
  *
  * @param {import('three/webgpu').WebGPURenderer} renderer
+ * @returns {?Promise<void>} Settles once the backend is torn down.
  */
 export function disposeRenderer( renderer ) {
 
@@ -125,20 +122,11 @@ export function disposeRenderer( renderer ) {
 
 	}
 
-	renderer.dispose();
+	// r186+ `dispose()` is async and settles once the backend is torn down; anything that
+	// measures memory straight afterwards has to await the returned promise.
+	const disposed = renderer.dispose();
 	renderer._canvasTarget = null;
-
-	// Three.js 0.185: `RenderObjects.dispose()` drops its chain maps without disposing the
-	// render objects, so each one leaves behind the 'dispose' listener it registered on its
-	// geometry. Full-screen passes render a QuadMesh, and every QuadMesh in the realm shares
-	// one module-level geometry — so that listener list grows by one entry per renderer and
-	// keeps RenderObject → RenderObjects → Bindings → Backend → GPUDevice reachable for the
-	// page's lifetime. The chain maps are WeakMaps, so this list is the only handle on them.
-	//
-	// Clearing it also drops entries belonging to live renderers, which is safe: the
-	// singleton geometry is never disposed, so none of these listeners can ever fire.
-	const quadDisposeListeners = _sharedQuadGeometry._listeners?.dispose;
-	if ( quadDisposeListeners ) quadDisposeListeners.length = 0;
+	return disposed;
 
 }
 

package/src/Stages/NormalDepth.js

@@ -167,8 +167,9 @@ export class NormalDepth extends RenderStage {
 
 		if ( pt.triangleStorageAttr && ! this._triStorageNode ) {
 
+			// uvec4, matching PathTracerStage: packed lanes must keep their exact bit pattern.
 			this._triStorageNode = storage(
-				pt.triangleStorageAttr, 'vec4', pt.triangleStorageAttr.count
+				pt.triangleStorageAttr, 'uvec4', pt.triangleStorageAttr.count
 			).toReadOnly();
 
 		}
@@ -270,7 +271,10 @@ export class NormalDepth extends RenderStage {
 					const uvTangent = vec4( 0.0 ).toVar();
 					If( material.normalMapIndex.greaterThanEqual( int( 0 ) ), () => {
 
-						uvTangent.assign( triangleUVTangent( triStorage, hit.triangleIndex, hit.normal, material.normalTransform ) );
+						uvTangent.assign( triangleUVTangent(
+							triStorage, hit.triangleIndex, hit.normal, material.normalTransform,
+							bvhStorage, hit.instanceLeaf
+						) );
 
 					} );
 

package/src/Stages/PathTracer.js

@@ -5,7 +5,7 @@
  */
 
 import { uniform, texture, storage } from 'three/tsl';
-import { StorageInstancedBufferAttribute } from 'three/webgpu';
+import { gpuOnlyStorageAttribute } from '../TSL/patches.js';
 import { PathTracerStage } from './PathTracerStage.js';
 import { PackedRayBuffer, GBUFFER_STRIDE, RAY_STRIDE, HIT_STRIDE, freeStorageAttribute } from '../Processor/PackedRayBuffer.js';
 import { QueueManager, COUNTER, ENERGY_SCALE } from '../Processor/QueueManager.js';
@@ -993,7 +993,7 @@ export class PathTracer extends PathTracerStage {
 		// canonicalize; u32 stores the bits verbatim.
 		const gBufferVec4s = B * GBUFFER_STRIDE;
 		freeStorageAttribute( this.renderer, this._gBufferAttr );
-		this._gBufferAttr = new StorageInstancedBufferAttribute( new Uint32Array( gBufferVec4s * 4 ), 4 );
+		this._gBufferAttr = gpuOnlyStorageAttribute( gBufferVec4s, 4, Uint32Array );
 		const gBufferRW = storage( this._gBufferAttr, 'uvec4' );
 		const gBufferRO = storage( this._gBufferAttr, 'uvec4' ).toReadOnly();
 
@@ -1009,15 +1009,15 @@ export class PathTracer extends PathTracerStage {
 
 			// Tier-1 convergence: per-pixel running mean of luminance² (Welford second moment), read+written by FinalWrite.
 			freeStorageAttribute( this.renderer, this._m2Attr );
-			this._m2Attr = new StorageInstancedBufferAttribute( new Float32Array( maxPixels ), 1 );
+			this._m2Attr = gpuOnlyStorageAttribute( maxPixels, 1 );
 
 			// Tier-2: per-pixel freeze-candidate streak. FinalWrite writes (RW), buildActivePixels reads (RO).
 			freeStorageAttribute( this.renderer, this._streakAttr );
-			this._streakAttr = new StorageInstancedBufferAttribute( new Uint32Array( maxPixels ), 1 );
+			this._streakAttr = gpuOnlyStorageAttribute( maxPixels, 1, Uint32Array );
 
 			// Tier-2: dilated frozen mask (1 = skip). buildActivePixels writes; active-list + FinalWrite read → race-free.
 			freeStorageAttribute( this.renderer, this._frozenMaskAttr );
-			this._frozenMaskAttr = new StorageInstancedBufferAttribute( new Uint32Array( maxPixels ), 1 );
+			this._frozenMaskAttr = gpuOnlyStorageAttribute( maxPixels, 1, Uint32Array );
 
 		}