rayzee 7.31.1 → 8.0.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/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 );
 
 		}
 

package/src/Stages/PathTracerStage.js

@@ -1,4 +1,5 @@
 import { storage } from 'three/tsl';
+import { gpuOnlyStorageAttribute, uploadStorageChunkRange, uploadStorageChunks } from '../TSL/patches.js';
 import { StorageInstancedBufferAttribute } from 'three/webgpu';
 import {
 	NearestFilter, Vector2, Matrix4,
@@ -109,17 +110,21 @@ export class PathTracerStage extends RenderStage {
 		// Initialize material data manager
 		this.materialData = new MaterialDataManager( this.sdfs );
 		this.materialData.callbacks.onReset = () => this.reset();
-		// Triangle data carries the per-triangle `side` flag (NORMAL_C.w). The
-		// authoritative CPU array is triangleStorageAttr.array (not sdfs.triangleData,
-		// which isn't populated on the PathTracerApp build path). The patch mutates
-		// the array in place — only a dirty flag is needed for GPU re-upload.
+		// Triangle data carries the per-triangle `side` flag (NORMAL_C.w). The authoritative
+		// CPU copy is `_triangleRecords` when the scene is chunked and triangleStorageAttr.array
+		// otherwise (not sdfs.triangleData, which isn't populated on the PathTracerApp build
+		// path). The patch mutates it in place, then the GPU copy is refreshed.
 		this.materialData.callbacks.getTriangleData = () => ( {
 			array: this.triangleStorageAttr?.array,
+			records: this._triangleRecords,
 			count: this.triangleCount,
 		} );
 		this.materialData.callbacks.onTriangleDataChanged = () => {
 
-			if ( this.triangleStorageAttr ) this.triangleStorageAttr.needsUpdate = true;
+			if ( ! this.triangleStorageAttr ) return;
+			// A chunked attribute owns no CPU array for three.js to re-upload.
+			if ( this._triangleRecords ) uploadStorageChunks( this.renderer, this.triangleStorageAttr, this._triangleRecords.chunks );
+			else this.triangleStorageAttr.needsUpdate = true;
 
 		};
 
@@ -171,11 +176,13 @@ export class PathTracerStage extends RenderStage {
 
 		// Triangle data (storage buffer for WebGPU)
 		this.triangleStorageAttr = null;
+		this._triangleRecords = null;
 		this.triangleStorageNode = null;
 		this.triangleCount = 0;
 
 		// BVH data (storage buffer for WebGPU)
 		this.bvhStorageAttr = null;
+		this._bvhRecords = null;
 		this.bvhStorageNode = null;
 		this.bvhNodeCount = 0;
 
@@ -704,19 +711,28 @@ export class PathTracerStage extends RenderStage {
 	 * On first call, creates the storage buffer and node.
 	 * On subsequent calls, creates a new attribute with the correct size
 	 * and updates the storage node's value to preserve shader graph references.
-	 * @param {Float32Array} triangleData - Raw triangle data
+	 * @param {Uint32Array} triangleData - Packed triangle records (uvec4 lanes)
 	 * @param {number} triangleCount - Number of triangles
 	 */
 	setTriangleData( triangleData, triangleCount ) {
 
 		if ( ! triangleData ) return;
 
-		const vec4Count = triangleData.length / 4;
+		// Past the ~2 GB array cap the records arrive as several chunks; they still become one
+		// GPU buffer, written at their running byte offsets, so no binding or shader changes.
+		const chunked = triangleData.chunks && triangleData.chunks.length > 1 ? triangleData : null;
+		const flat = chunked ? null : ( triangleData.chunks ? triangleData.chunks[ 0 ] : triangleData );
+		const lanes = chunked ? chunked.recordCount * chunked.lanesPerRecord : flat.length;
+		const vec4Count = lanes / 4;
+
+		const makeAttr = () => chunked
+			? gpuOnlyStorageAttribute( vec4Count, 4, Uint32Array )
+			: new StorageInstancedBufferAttribute( flat, 4 );
 
 		if ( this.triangleStorageNode ) {
 
 			// Create new attribute with correct size (old one is GC'd, backend WeakMap cleans up GPU buffer)
-			this.triangleStorageAttr = new StorageInstancedBufferAttribute( triangleData, 4 );
+			this.triangleStorageAttr = makeAttr();
 
 			// Update storage node references (preserves compiled shader graph)
 			this.triangleStorageNode.value = this.triangleStorageAttr;
@@ -725,11 +741,14 @@ export class PathTracerStage extends RenderStage {
 		} else {
 
 			// First time: create storage buffer and node
-			this.triangleStorageAttr = new StorageInstancedBufferAttribute( triangleData, 4 );
-			this.triangleStorageNode = storage( this.triangleStorageAttr, 'vec4', vec4Count ).toReadOnly();
+			this.triangleStorageAttr = makeAttr();
+			this.triangleStorageNode = storage( this.triangleStorageAttr, 'uvec4', vec4Count ).toReadOnly();
 
 		}
 
+		this._triangleRecords = chunked;
+		if ( chunked ) uploadStorageChunks( this.renderer, this.triangleStorageAttr, chunked.chunks );
+
 		this.triangleCount = triangleCount;
 
 		log.debug( `${fmt.n( this.triangleCount )} triangles (storage buffer)` );
@@ -744,21 +763,33 @@ export class PathTracerStage extends RenderStage {
 
 		if ( ! bvhImageData ) return;
 
-		const vec4Count = bvhImageData.length / 4;
+		// Same story as the triangles: past the ~2 GB array cap the nodes arrive as several
+		// chunks and still become one GPU buffer.
+		const chunked = bvhImageData.chunks && bvhImageData.chunks.length > 1 ? bvhImageData : null;
+		const flat = chunked ? null : ( bvhImageData.chunks ? bvhImageData.chunks[ 0 ] : bvhImageData );
+		const lanes = chunked ? chunked.recordCount * chunked.lanesPerRecord : flat.length;
+		const vec4Count = lanes / 4;
+
+		const makeAttr = () => chunked
+			? gpuOnlyStorageAttribute( vec4Count, 4, Float32Array )
+			: new StorageInstancedBufferAttribute( flat, 4 );
 
 		if ( this.bvhStorageNode ) {
 
-			this.bvhStorageAttr = new StorageInstancedBufferAttribute( bvhImageData, 4 );
+			this.bvhStorageAttr = makeAttr();
 			this.bvhStorageNode.value = this.bvhStorageAttr;
 			this.bvhStorageNode.bufferCount = vec4Count;
 
 		} else {
 
-			this.bvhStorageAttr = new StorageInstancedBufferAttribute( bvhImageData, 4 );
+			this.bvhStorageAttr = makeAttr();
 			this.bvhStorageNode = storage( this.bvhStorageAttr, 'vec4', vec4Count ).toReadOnly();
 
 		}
 
+		this._bvhRecords = chunked;
+		if ( chunked ) uploadStorageChunks( this.renderer, this.bvhStorageAttr, chunked.chunks );
+
 		this.bvhNodeCount = Math.floor( vec4Count / BVH_VEC4_PER_NODE );
 		log.debug( `${fmt.n( this.bvhNodeCount )} BVH nodes (storage buffer)` );
 
@@ -784,13 +815,31 @@ export class PathTracerStage extends RenderStage {
 
 		if ( ! meshes || meshes.length === 0 || ! this._instanceTable ) return;
 
-		for ( let i = 0; i < meshes.length; i ++ ) {
+		this._patchVisibilityFromMeshes( meshes );
+		this._flushBVHEdits();
 
-			this._patchTLASLeafVisibility( i, this._isWorldVisible( meshes[ i ] ) );
+	}
 
-		}
+	/**
+	 * Resolve each placement's visibility from the object it came from. Entries are per
+	 * instance, so an InstancedMesh covers a whole run of them with one authored flag.
+	 * @private
+	 */
+	_patchVisibilityFromMeshes( meshes ) {
 
-		if ( this.bvhStorageAttr ) this.bvhStorageAttr.needsUpdate = true;
+		const table = this._instanceTable;
+		const cache = new Map();
+
+		for ( let i = 0; i < table.count; i ++ ) {
+
+			if ( ! table.isSet[ i ] ) continue;
+
+			const src = table.sourceMesh[ i ];
+			let visible = cache.get( src );
+			if ( visible === undefined ) cache.set( src, visible = this._isWorldVisible( meshes[ src ] ) );
+			this._patchTLASLeafVisibility( i, visible );
+
+		}
 
 	}
 
@@ -802,7 +851,7 @@ export class PathTracerStage extends RenderStage {
 	updateMeshVisibility( meshIndex, visible ) {
 
 		if ( ! this._patchTLASLeafVisibility( meshIndex, visible ) ) return;
-		if ( this.bvhStorageAttr ) this.bvhStorageAttr.needsUpdate = true;
+		this._flushBVHEdits();
 
 	}
 
@@ -814,13 +863,8 @@ export class PathTracerStage extends RenderStage {
 
 		if ( ! this._meshRefs || ! this._instanceTable ) return;
 
-		for ( let i = 0; i < this._meshRefs.length; i ++ ) {
-
-			this._patchTLASLeafVisibility( i, this._isWorldVisible( this._meshRefs[ i ] ) );
-
-		}
-
-		if ( this.bvhStorageAttr ) this.bvhStorageAttr.needsUpdate = true;
+		this._patchVisibilityFromMeshes( this._meshRefs );
+		this._flushBVHEdits();
 
 	}
 
@@ -831,15 +875,51 @@ export class PathTracerStage extends RenderStage {
 	 */
 	_patchTLASLeafVisibility( meshIndex, visible ) {
 
-		const entry = this._instanceTable?.entries?.[ meshIndex ];
-		if ( ! entry || entry.tlasLeafIndex < 0 || ! this.bvhStorageAttr ) return false;
+		const table = this._instanceTable;
+		if ( ! table || ! table.isSet?.[ meshIndex ] || ! this.bvhStorageAttr ) return false;
 
-		entry.visible = visible;
-		this.bvhStorageAttr.array[ entry.tlasLeafIndex * 16 + 2 ] = visible ? 1.0 : 0.0;
+		const leaf = table.tlasLeafIndex[ meshIndex ];
+		if ( leaf < 0 ) return false;
+
+		table.visible[ meshIndex ] = visible ? 1 : 0;
+
+		// A chunked attribute owns no CPU array; write into the chunk that holds this leaf.
+		if ( this._bvhRecords ) this._bvhRecords.chunkFor( leaf )[ this._bvhRecords.baseOf( leaf ) + 2 ] = visible ? 1.0 : 0.0;
+		else this.bvhStorageAttr.array[ leaf * 16 + 2 ] = visible ? 1.0 : 0.0;
+
+		this._dirtyBVHLeaves ??= new Set();
+		this._dirtyBVHLeaves.add( leaf );
 		return true;
 
 	}
 
+	/**
+	 * Push BVH edits to the GPU. A chunked attribute cannot go through three.js's dirty flag,
+	 * so the touched leaves are written straight into the buffer.
+	 * @private
+	 */
+	_flushBVHEdits() {
+
+		if ( ! this.bvhStorageAttr ) return;
+
+		if ( ! this._bvhRecords ) {
+
+			this.bvhStorageAttr.needsUpdate = true;
+			this._dirtyBVHLeaves?.clear();
+			return;
+
+		}
+
+		for ( const leaf of this._dirtyBVHLeaves ?? [] ) {
+
+			uploadStorageChunkRange( this.renderer, this.bvhStorageAttr, this._bvhRecords, leaf * 16, 16 );
+
+		}
+
+		this._dirtyBVHLeaves?.clear();
+
+	}
+
 	/**
 	 * Collect mesh references from scene, ordered by meshIndex (assigned during extraction).
 	 * @param {Object3D} scene
@@ -903,14 +983,28 @@ export class PathTracerStage extends RenderStage {
 	/** Update triangle positions in the existing GPU buffer (full). */
 	updateTriangleData( triangleData ) {
 
-		this._updateStorageBuffer( this.triangleStorageAttr, triangleData );
+		if ( this._triangleRecords ) {
+
+			uploadStorageChunks( this.renderer, this.triangleStorageAttr, this._triangleRecords.chunks );
+			return;
+
+		}
+
+		this._updateStorageBuffer( this.triangleStorageAttr, triangleData?.chunks ? triangleData.chunks[ 0 ] : triangleData );
 
 	}
 
 	/** Update BVH node data in the existing GPU buffer (full). */
 	updateBVHData( bvhData ) {
 
-		this._updateStorageBuffer( this.bvhStorageAttr, bvhData );
+		if ( this._bvhRecords ) {
+
+			uploadStorageChunks( this.renderer, this.bvhStorageAttr, this._bvhRecords.chunks );
+			return;
+
+		}
+
+		this._updateStorageBuffer( this.bvhStorageAttr, bvhData?.chunks ? bvhData.chunks[ 0 ] : bvhData );
 
 	}
 
@@ -925,29 +1019,55 @@ export class PathTracerStage extends RenderStage {
 
 		if ( this.triangleStorageAttr && triRanges.length > 0 ) {
 
-			this.triangleStorageAttr.clearUpdateRanges();
+			if ( this._triangleRecords ) {
 
-			for ( const r of triRanges ) {
+				// Chunked: three.js cannot re-upload an attribute with no CPU array, so write
+				// the dirty lanes straight into the GPU buffer.
+				for ( const r of triRanges ) {
 
-				this.triangleStorageAttr.addUpdateRange( r.offset, r.count );
+					uploadStorageChunkRange( this.renderer, this.triangleStorageAttr, this._triangleRecords, r.offset, r.count );
 
-			}
+				}
+
+			} else {
+
+				this.triangleStorageAttr.clearUpdateRanges();
 
-			this.triangleStorageAttr.version ++;
+				for ( const r of triRanges ) {
+
+					this.triangleStorageAttr.addUpdateRange( r.offset, r.count );
+
+				}
+
+				this.triangleStorageAttr.version ++;
+
+			}
 
 		}
 
 		if ( this.bvhStorageAttr && bvhRanges.length > 0 ) {
 
-			this.bvhStorageAttr.clearUpdateRanges();
+			if ( this._bvhRecords ) {
 
-			for ( const r of bvhRanges ) {
+				for ( const r of bvhRanges ) {
 
-				this.bvhStorageAttr.addUpdateRange( r.offset, r.count );
+					uploadStorageChunkRange( this.renderer, this.bvhStorageAttr, this._bvhRecords, r.offset, r.count );
 
-			}
+				}
 
-			this.bvhStorageAttr.version ++;
+			} else {
+
+				this.bvhStorageAttr.clearUpdateRanges();
+
+				for ( const r of bvhRanges ) {
+
+					this.bvhStorageAttr.addUpdateRange( r.offset, r.count );
+
+				}
+
+				this.bvhStorageAttr.version ++;
+
+			}
 
 		}
 
@@ -1449,8 +1569,10 @@ export class PathTracerStage extends RenderStage {
 
 		// Clear data references
 		this.triangleStorageAttr = null;
+		this._triangleRecords = null;
 		this.triangleStorageNode = null;
 		this.bvhStorageAttr = null;
+		this._bvhRecords = null;
 		this.bvhStorageNode = null;
 		this.placeholderTexture = null;