rayzee 9.3.2 → 9.4.0

package/src/Processor/BVHRefitter.js

@@ -194,6 +194,29 @@ function triangleBounds( acc, first, count, out, off ) {
 
 const folded = new Float32Array( 12 );
 
+/** 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 ) {
+
+	const f = nodeF( nodes, n );
+	const idx = nodeIdx( nodes, n );
+	const o = nodeBase( nodes, n );
+
+	if ( idx[ o + 3 ] === LEAF_MARKER ) {
+
+		triangleBounds( acc, idx[ o ], idx[ o + 1 ], out, 0 );
+		return;
+
+	}
+
+	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 ] );
+
+	}
+
+}
+
 /**
  * One node of a bottom-up refit: its own bounds into `bounds[ ( i - base ) * 6 ]`, and an inner
  * node's two child boxes rewritten from theirs. A leaf folded into its parent takes its box from
@@ -264,6 +287,8 @@ export class BVHRefitter {
 		// Resized only when nodeCount changes (i.e., new scene loaded).
 		this._bounds = null;
 		this._boundsNodeCount = 0;
+		this._tlasBounds = null;
+		this._rootBox = null;
 
 	}
 
@@ -355,6 +380,45 @@ export class BVHRefitter {
 
 	}
 
+	/**
+	 * Refit the given BLAS node ranges, then the TLAS from every BLAS root's stored box. The same
+	 * nodes as refit() when every other BLAS is as the last refit left it.
+	 *
+	 * @param {Float32Array} bvhData - Combined BVH array (TLAS + all BLASes)
+	 * @param {Uint32Array} triangleData - Global triangle records
+	 * @param {ArrayLike<number>} blasRanges - flat [ startNode, nodeCount, ... ]
+	 * @param {number} tlasNodeCount - the TLAS occupies nodes [0, tlasNodeCount)
+	 */
+	refitPartial( bvhData, triangleData, blasRanges, tlasNodeCount ) {
+
+		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 ( ! 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 -- ) {
+
+			const idx = nodeIdx( nodes, i );
+			const o = nodeBase( nodes, i );
+
+			if ( idx[ o + 3 ] === BLAS_POINTER_MARKER ) {
+
+				storedBounds( nodes, idx[ o ], acc, rootBox );
+				transformBoundsToWorld( nodeF( nodes, i ), o, rootBox, 0, bounds, i * 6 );
+
+			} else {
+
+				refitNode( nodes, i, acc, bounds, 0 );
+
+			}
+
+		}
+
+	}
+
 	/**
 	 * Bottom-up refit of all BVH node AABBs.
 	 * Reverse pre-order iteration gives valid bottom-up order (children have higher

package/src/Processor/SceneProcessor.js

@@ -2597,6 +2597,7 @@ export class SceneProcessor {
 	async refitBVH( newPositions, newNormals ) {
 
 		this._geometryVersion = ( this._geometryVersion ?? 0 ) + 1;
+		this._tlasLeafBoxesOf = null;
 
 		if ( ! this.bvh || ! this.triangles || ! this.instanceTable ) {
 
@@ -2650,13 +2651,17 @@ export class SceneProcessor {
 		const table = this.instanceTable;
 		const FPT = TRIANGLE_DATA_LAYOUT.FLOATS_PER_TRIANGLE;
 		const triRanges = [];
+		const blasRanges = [];
+		let owners = 0;
 		for ( let i = 0; i < table.count; i ++ ) {
 
 			if ( ! table.isSet[ i ] || ! table.isOwner( i ) ) continue;
+			owners ++;
 
 			const p = positionsFor( i );
 			if ( ! p ) continue;
 			this._updateMeshTrianglePositions( i, p );
+			blasRanges.push( table.blasOffsetOf( i ), table.blasNodeCountOf( i ) );
 
 			// Smooth normals overwrite the face normals just computed, so they follow per mesh.
 			if ( normalsFor ) {
@@ -2673,6 +2678,11 @@ export class SceneProcessor {
 
 		}
 
+		const tlasNodeCount = table.tlasNodeCount;
+		const partial = tlasNodeCount > 0 && blasRanges.length / 2 < owners;
+		const bvhRanges = partial ? [ this.computeTLASDirtyRange() ] : null;
+		for ( let r = 0; partial && r < blasRanges.length; r += 2 ) bvhRanges.push( { offset: blasRanges[ r ] * 16, count: blasRanges[ r + 1 ] * 16 } );
+
 		return new Promise( ( resolve, reject ) => {
 
 			this._refitWorker.onmessage = ( e ) => {
@@ -2680,7 +2690,7 @@ export class SceneProcessor {
 				const msg = e.data;
 				if ( msg.type === 'refitComplete' ) {
 
-					resolve( { refitTimeMs: msg.refitTimeMs, triRanges } );
+					resolve( { refitTimeMs: msg.refitTimeMs, triRanges, bvhRanges } );
 
 				} else if ( msg.type === 'error' ) {
 
@@ -2691,7 +2701,7 @@ export class SceneProcessor {
 			};
 
 			// Signal worker — no data transfer needed, everything is in shared memory
-			this._refitWorker.postMessage( { type: 'refit' } );
+			this._refitWorker.postMessage( { type: 'refit', blasRanges: partial ? blasRanges : null, tlasNodeCount } );
 
 		} );
 
@@ -2841,6 +2851,8 @@ export class SceneProcessor {
 		const start = performance.now();
 		const table = this.instanceTable;
 		const composed = this._transformScratch ??= new Float32Array( 16 );
+		if ( this._movedPlacements?.length !== table.count ) this._movedPlacements = new Uint8Array( table.count );
+		const movedMask = this._movedPlacements;
 		let moved = 0;
 
 		for ( const meshIndex of meshIndices ) {
@@ -2877,13 +2889,15 @@ export class SceneProcessor {
 				}
 
 				this._writeLeafMatrix( p );
+				movedMask[ p ] = 1;
 				moved ++;
 
 			}
 
 		}
 
-		this._refitTLAS();
+		this._refitTLAS( movedMask );
+		movedMask.fill( 0 );
 
 		return { refitTimeMs: performance.now() - start, placements: moved };
 
@@ -3364,6 +3378,8 @@ export class SceneProcessor {
 	/** Keep the chunked BVH and its u32 index view in step. @private */
 	_setBVHData( data ) {
 
+		this._tlasLeafBoxesOf = null;
+
 		const records = ! data ? null
 			: ( data instanceof ChunkedRecords
 				? data
@@ -3545,9 +3561,11 @@ export class SceneProcessor {
 	/**
 	 * Refit TLAS AABBs in-place without rebuilding the tree structure.
 	 * O(tlasNodeCount) bottom-up pass — much faster than full SAH rebuild.
+	 * @param {Uint8Array} [moved] - by placement: only these leaves' world boxes are recomputed, the
+	 *   rest kept from the last pass. Every leaf when omitted, or when nothing valid was kept.
 	 * @private
 	 */
-	_refitTLAS() {
+	_refitTLAS( moved = null ) {
 
 		const tlasNodeCount = this.instanceTable.tlasNodeCount;
 
@@ -3555,10 +3573,12 @@ export class SceneProcessor {
 		if ( ! this._tlasBounds || this._tlasBounds.length < tlasNodeCount * 6 ) {
 
 			this._tlasBounds = new Float32Array( tlasNodeCount * 6 );
+			this._tlasLeafBoxesOf = null;
 
 		}
 
 		const table = this.instanceTable;
+		const keep = moved && this._tlasLeafBoxesOf === table;
 
 		// Bottom-up pass: reverse iteration over TLAS nodes
 		for ( let i = tlasNodeCount - 1; i >= 0; i -- ) {
@@ -3574,7 +3594,7 @@ export class SceneProcessor {
 				// every placement of a shared geometry onto one box, so all but one copy sat
 				// outside its own bounds and rays walked straight past it.
 				const entryIndex = idxChunk[ o + 1 ] & TLAS_PLACEMENT_MASK;
-				if ( entryIndex < table.count ) {
+				if ( entryIndex < table.count && ! ( keep && ! moved[ entryIndex ] ) ) {
 
 					table.writeWorldAABB( entryIndex, this._tlasBounds, i * 6 );
 
@@ -3615,6 +3635,8 @@ export class SceneProcessor {
 
 		}
 
+		this._tlasLeafBoxesOf = table;
+
 	}
 
 	/**

package/src/Processor/TextureCreator.js

@@ -15,6 +15,13 @@ const log = createLogger( 'textures' );
 // Below this a pack is cheaper than starting a worker for it.
 const WORKER_PACK_BYTES = 8 * 2 ** 20;
 
+// Main-thread work allowed between yields while streaming layers to a worker.
+const STREAM_YIELD_MS = 16;
+
+const SHARED_PACK_WORKERS = 4;
+// Below about one 8K source a bucket packs fast enough alone, and extra workers only compete with the BVH build.
+const SHARED_PACK_MIN_PIXELS = 8192 * 8192;
+
 // Buckets pack concurrently; this keeps their workers within the cores, beside the BVH pool's.
 const packSlots = { busy: 0, waiting: [] };
 
@@ -835,6 +842,9 @@ export class TextureCreator {
 				case 'worker-direct':
 					result = await this.processWithWorkerDirect( normalized );
 					break;
+				case 'worker-streaming':
+					result = await this.processInWorkerStreaming( normalized );
+					break;
 				case 'main-batch':
 					result = await this.processOnMainThreadBatch( normalized, strategy.batchSize );
 					break;
@@ -892,10 +902,7 @@ export class TextureCreator {
 
 		if ( this.capabilities.workers && estimatedMemory > MEMORY_CONSTANTS.MAX_TEXTURE_MEMORY ) {
 
-			// Very large texture set: stream on the main thread (GC-yielding, builds the
-			// full array correctly). The former 'worker-chunked' path combined its chunks
-			// by returning only the first, silently dropping the rest — removed.
-			return { method: 'main-streaming' };
+			return { method: 'worker-streaming' };
 
 		} else if ( this.capabilities.workers && totalPixels > 2097152 ) {
 
@@ -931,14 +938,24 @@ export class TextureCreator {
 		}
 
 		this.activeWorkers ++;
-
-		const worker = new TexturesWorker();
+		let slots = 1;
+		let worker = null;
 
 		try {
 
 			// Prepare textures for worker with direct transfer
 			const texturesData = await this.prepareTexturesForWorkerDirect( textures );
 
+			const extra = this._sharedPackSlots( texturesData );
+			if ( extra > 0 ) {
+
+				slots += extra;
+				this.activeWorkers += extra;
+				return this.createDataArrayTextureFromResult( await this._packAcrossWorkers( texturesData, slots ) );
+
+			}
+
+			worker = new TexturesWorker();
 			const result = await new Promise( ( resolve, reject ) => {
 
 				worker.onmessage = ( e ) => {
@@ -983,6 +1000,153 @@ export class TextureCreator {
 
 			return this.createDataArrayTextureFromResult( result );
 
+		} finally {
+
+			worker?.terminate();
+			this.activeWorkers -= slots;
+
+		}
+
+	}
+
+	/** Extra worker slots a bucket may take now, beyond its own. */
+	_sharedPackSlots( texturesData ) {
+
+		if ( typeof SharedArrayBuffer === 'undefined' || ! globalThis.crossOriginIsolated ) return 0;
+		if ( texturesData.reduce( ( sum, t ) => sum + t.width * t.height, 0 ) < SHARED_PACK_MIN_PIXELS ) return 0;
+		const free = this.maxConcurrentWorkers - this.activeWorkers;
+		return Math.max( 0, Math.min( texturesData.length, SHARED_PACK_WORKERS, free + 1 ) - 1 );
+
+	}
+
+	/**
+	 * The worker's direct path split across `count` workers, each drawing its layers straight into
+	 * one shared array. Large sources dominate (their downscale), so they are dealt out first.
+	 */
+	async _packAcrossWorkers( texturesData, count ) {
+
+		const { maxWidth: width, maxHeight: height } = this.calculateOptimalDimensions( texturesData.map( image => ( { image } ) ) );
+		const depth = texturesData.length;
+		const shared = new SharedArrayBuffer( width * height * depth * 4 );
+
+		const parts = Array.from( { length: count }, () => ( { cost: 0, layers: [], transfer: [] } ) );
+		const order = texturesData.map( ( _, index ) => index );
+		const cost = index => texturesData[ index ].width * texturesData[ index ].height;
+		order.sort( ( a, b ) => cost( b ) - cost( a ) );
+
+		for ( const index of order ) {
+
+			const part = parts.reduce( ( least, p ) => ( p.cost < least.cost ? p : least ) );
+			const texture = texturesData[ index ];
+			part.layers.push( { index, texture } );
+			part.cost += cost( index );
+			if ( texture.data instanceof ArrayBuffer ) part.transfer.push( texture.data );
+			else if ( texture.bitmap ) part.transfer.push( texture.bitmap );
+
+		}
+
+		const workers = [];
+
+		try {
+
+			await Promise.all( parts.filter( part => part.layers.length ).map( part => new Promise( ( resolve, reject ) => {
+
+				const worker = createWorker( TexturesWorker );
+				workers.push( worker );
+				worker.onmessage = ( { data } ) => ( data.error ? reject( new Error( data.error ) ) : resolve() );
+				worker.onerror = ( event ) => reject( new Error( event.message || 'texture worker failed' ) );
+				worker.postMessage( { shared, width, height, layers: part.layers, maxTextureSize: this.maxTextureSize }, part.transfer );
+
+			} ) ) );
+
+		} finally {
+
+			for ( const worker of workers ) worker.terminate();
+
+		}
+
+		return { data: shared, width, height, depth };
+
+	}
+
+	/**
+	 * `processOnMainThreadStreaming` with the draw and read moved to a worker: each layer is
+	 * resized here exactly as there, so the array is byte-for-byte the same.
+	 */
+	async processInWorkerStreaming( textures ) {
+
+		const validTextures = textures.filter( tex => tex?.image );
+		if ( validTextures.length === 0 ) return this.createFallbackTexture();
+
+		const { maxWidth, maxHeight } = this.calculateOptimalDimensions( validTextures );
+		const depth = validTextures.length;
+
+		while ( this.activeWorkers >= this.maxConcurrentWorkers ) {
+
+			await new Promise( resolve => setTimeout( resolve, 10 ) );
+
+		}
+
+		this.activeWorkers ++;
+		const worker = createWorker( TexturesWorker );
+
+		try {
+
+			let acked = 0;
+			let wake = null;
+			let settle;
+			const finished = new Promise( ( resolve, reject ) => settle = { resolve, reject } );
+			finished.catch( () => {} );
+
+			worker.onmessage = ( { data } ) => {
+
+				if ( data.error ) settle.reject( new Error( data.error ) );
+				else if ( data.stream === 'ack' ) acked ++;
+				else settle.resolve( data );
+				wake?.();
+
+			};
+
+			worker.onerror = ( event ) => {
+
+				settle.reject( new Error( event.message || 'texture worker failed' ) );
+				wake?.();
+
+			};
+
+			worker.postMessage( { stream: 'begin', width: maxWidth, height: maxHeight, depth } );
+			let lastYield = performance.now();
+
+			for ( let i = 0; i < depth; i ++ ) {
+
+				while ( i - acked >= MEMORY_CONSTANTS.STREAM_BATCH_SIZE ) {
+
+					await Promise.race( [ new Promise( resolve => wake = resolve ), finished ] );
+					lastYield = performance.now();
+
+				}
+
+				const texture = validTextures[ i ];
+				const bitmap = await createImageBitmap( texture.image, {
+					resizeWidth: maxWidth,
+					resizeHeight: maxHeight,
+					resizeQuality: 'high',
+					imageOrientation: texture.flipY !== false ? 'flipY' : 'none',
+				} );
+				worker.postMessage( { stream: 'layer', index: i, bitmap }, [ bitmap ] );
+
+				if ( performance.now() - lastYield > STREAM_YIELD_MS ) {
+
+					await new Promise( resolve => setTimeout( resolve, 0 ) );
+					lastYield = performance.now();
+
+				}
+
+			}
+
+			worker.postMessage( { stream: 'end' } );
+			return this.createDataArrayTextureFromResult( await finished );
+
 		} finally {
 
 			worker.terminate();

package/src/Processor/ToneMapGPU.js

@@ -56,7 +56,39 @@ fn rayzee_source( x: u32, y: u32 ) -> vec4<f32> {
 }`,
 };
 
-const toneMapPassWGSL = ( transformWGSL, input ) => /* wgsl */ `
+// RGBA bytes for a picture, or four float planes (r, g, b, a) for a network that wants the curve
+// unquantized. The planes take a 2.2 power, not the sRGB curve: what the AI upscaler has always fed
+// its network, so its output does not move.
+const OUTPUTS = {
+	rgba8: /* wgsl */ `
+@group(0) @binding(1) var<storage, read_write> dst: array<u32>;
+
+fn rayzee_store( i: u32, linear: vec4<f32>, mapped: vec3<f32> ) {
+	let b8 = rayzee_to_u8( rayzee_encode( mapped, params.mode ) );
+	var a8 = 255u;
+	if ( params.alpha == 1u ) { a8 = rayzee_to_u8( vec3<f32>( linear.a ) ).x; }
+	dst[ i ] = b8.x | ( b8.y << 8u ) | ( b8.z << 16u ) | ( a8 << 24u );
+}`,
+	planar: /* wgsl */ `
+@group(0) @binding(1) var<storage, read_write> dst: array<f32>;
+
+fn rayzee_store( i: u32, linear: vec4<f32>, mapped: vec3<f32> ) {
+	var c = clamp( mapped, vec3<f32>( 0.0 ), vec3<f32>( 1.0 ) );
+	if ( ! rayzee_output_encoded( params.mode ) ) {
+		let m = max( mapped, vec3<f32>( 0.0 ) );
+		c = select( pow( m, vec3<f32>( 1.0 / 2.2 ) ), vec3<f32>( 0.0 ), m <= vec3<f32>( 0.0 ) );
+	}
+	let n = params.width * params.height;
+	dst[ i ] = c.r;
+	dst[ n + i ] = c.g;
+	dst[ 2u * n + i ] = c.b;
+	dst[ 3u * n + i ] = linear.a;
+}`,
+};
+
+const BYTES_PER_PIXEL = { rgba8: 4, planar: 16 };
+
+const toneMapPassWGSL = ( transformWGSL, input, output ) => /* wgsl */ `
 struct Params {
 	width: u32,
 	height: u32,
@@ -67,11 +99,11 @@ struct Params {
 	alpha: u32,
 };
 
-@group(0) @binding(1) var<storage, read_write> dst: array<u32>;
 @group(0) @binding(2) var<uniform> params: Params;
 ${SOURCES[ input ]}
 
 ${transformWGSL}
+${OUTPUTS[ output ]}
 
 @compute @workgroup_size(8, 8)
 fn main( @builtin(global_invocation_id) gid: vec3<u32> ) {
@@ -81,11 +113,7 @@ fn main( @builtin(global_invocation_id) gid: vec3<u32> ) {
 	if ( params.flipY == 1u ) { srcY = params.height - 1u - gid.y; }
 
 	let linear = rayzee_source( gid.x, srcY );
-	let mapped = rayzee_tone_map( linear.rgb, params.mode, params.exposure, params.saturation );
-	let b8 = rayzee_to_u8( rayzee_encode( mapped, params.mode ) );
-	var a8 = 255u;
-	if ( params.alpha == 1u ) { a8 = rayzee_to_u8( vec3<f32>( linear.a ) ).x; }
-	dst[ gid.y * params.width + gid.x ] = b8.x | ( b8.y << 8u ) | ( b8.z << 16u ) | ( a8 << 24u );
+	rayzee_store( gid.y * params.width + gid.x, linear, rayzee_tone_map( linear.rgb, params.mode, params.exposure, params.saturation ) );
 }
 `;
 
@@ -94,17 +122,18 @@ const PARAMS_BYTES = 32;
 
 /**
  * Tone-maps a tightly packed rgba16float buffer (two `u32` per pixel), or with `input: 'texture'` a
- * float texture read by pixel, into RGBA bytes.
+ * float texture read by pixel, into RGBA bytes — or with `output: 'planar'` into float planes.
  *
  * Bound to one device and one image size; `ensureSize()` reallocates when the size changes.
  */
 export class PackedToneMapper {
 
-	constructor( device, label = 'rayzee:tonemap', { input = 'packed' } = {} ) {
+	constructor( device, label = 'rayzee:tonemap', { input = 'packed', output = 'rgba8' } = {} ) {
 
 		this.device = device;
 		this.label = label;
 		this.input = input;
+		this.output = output;
 		this.width = 0;
 		this.height = 0;
 		this._pipeline = null;
@@ -139,7 +168,7 @@ export class PackedToneMapper {
 			label: this.label,
 			layout: 'auto',
 			compute: {
-				module: this.device.createShaderModule( { label: this.label, code: toneMapPassWGSL( wgsl, this.input ) } ),
+				module: this.device.createShaderModule( { label: this.label, code: toneMapPassWGSL( wgsl, this.input, this.output ) } ),
 				entryPoint: 'main',
 			},
 		} );
@@ -202,7 +231,7 @@ export class PackedToneMapper {
 
 		this._releaseBuffers();
 
-		const bytes = width * height * 4;
+		const bytes = width * height * BYTES_PER_PIXEL[ this.output ];
 		this._storage = this.device.createBuffer( {
 			label: `${this.label}-out`,
 			size: bytes,
@@ -235,7 +264,26 @@ export class PackedToneMapper {
 	 * @param {boolean} [tone.preserveAlpha=false] - the source's alpha, rounded as the CPU rounds it; else 255
 	 * @returns {Promise<Uint8ClampedArray>} RGBA bytes, `width * height * 4`
 	 */
-	async toRGBA8( src, { exposure = 1, toneMapping = 0, saturation = 1, flipY = false, preserveAlpha = false } = {} ) {
+	async toRGBA8( src, tone ) {
+
+		return new Uint8ClampedArray( await this._run( src, tone ) );
+
+	}
+
+	/**
+	 * The same tone map into four float planes — r, g, b, then the source's alpha — each `width * height`.
+	 * Needs `output: 'planar'`.
+	 * @param {GPUBuffer|GPUTexture} src - as for toRGBA8
+	 * @param {object} tone - as for toRGBA8; `preserveAlpha` does not apply
+	 * @returns {Promise<Float32Array>}
+	 */
+	async toPlanar( src, tone ) {
+
+		return new Float32Array( await this._run( src, tone ) );
+
+	}
+
+	async _run( src, { exposure = 1, toneMapping = 0, saturation = 1, flipY = false, preserveAlpha = false } = {} ) {
 
 		if ( this.disposed ) throw new Error( 'PackedToneMapper: disposed' );
 		if ( ! this._storage ) throw new Error( 'PackedToneMapper: call ensureSize() first' );
@@ -246,6 +294,7 @@ export class PackedToneMapper {
 		this._ensureTables();
 
 		const { width, height } = this;
+		const bytes = width * height * BYTES_PER_PIXEL[ this.output ];
 
 		this._paramU32[ 0 ] = width;
 		this._paramU32[ 1 ] = height;
@@ -275,13 +324,13 @@ export class PackedToneMapper {
 		pass.setBindGroup( 0, group );
 		pass.dispatchWorkgroups( Math.ceil( width / 8 ), Math.ceil( height / 8 ) );
 		pass.end();
-		encoder.copyBufferToBuffer( this._storage, 0, this._map, 0, width * height * 4 );
+		encoder.copyBufferToBuffer( this._storage, 0, this._map, 0, bytes );
 		this.device.queue.submit( [ encoder.finish() ] );
 
 		await this._map.mapAsync( GPUMapMode.READ );
-		const bytes = new Uint8ClampedArray( this._map.getMappedRange().slice( 0 ) );
+		const out = this._map.getMappedRange().slice( 0 );
 		this._map.unmap();
-		return bytes;
+		return out;
 
 	}
 

package/src/Processor/Workers/BVHRefitWorker.js

@@ -3,7 +3,8 @@
  *
  * Protocol:
  *   'init'  → receives the shared triangle and node buffers (once per scene)
- *   'refit' → recomputes every node's AABB from the triangles already written there
+ *   'refit' → recomputes every node's AABB from the triangles already written there, or with
+ *             `blasRanges` only those BLASes and the TLAS
  *
  * 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.
@@ -45,7 +46,9 @@ self.onmessage = function ( e ) {
 
 			const startTime = performance.now();
 
-			refitter.refit( bvhData, triData, nodeCount );
+			const { blasRanges, tlasNodeCount } = e.data;
+			if ( blasRanges ) refitter.refitPartial( bvhData, triData, blasRanges, tlasNodeCount );
+			else refitter.refit( bvhData, triData, nodeCount );
 
 			self.postMessage( {
 				type: 'refitComplete',