rayzee 10.0.0 → 11.1.0

package/src/Processor/TextureBuckets.js

@@ -0,0 +1,237 @@
+// Texture processing constants
+export const TEXTURE_CONSTANTS = {
+	VEC4_PER_BVH_NODE: 4,
+	FLOATS_PER_VEC4: 4,
+	MIN_TEXTURE_WIDTH: 4,
+	MAX_CONCURRENT_WORKERS: Math.min( typeof navigator !== 'undefined' ? navigator.hardwareConcurrency || 4 : 4, 6 ),
+	BUFFER_POOL_SIZE: 20,
+	CANVAS_POOL_SIZE: 12,
+	CACHE_SIZE_LIMIT: 50,
+	// Hardware ceiling for a single texture-array dimension (WebGPU maxTextureDimension2D
+	// guaranteed minimum). The configurable maxTextureSize setting is clamped to this.
+	MAX_TEXTURE_SIZE: 8192,
+	// Default cap applied when no maxTextureSize is supplied (engine standalone use).
+	DEFAULT_MAX_TEXTURE_SIZE: 4096,
+	// Per-map-type ceiling before bucketing; the real cap is per (pool, bucket) in _bucketTextures.
+	MAX_TEXTURES_LIMIT: 4 * 256,
+	// Array shapes per colorSpace pool. Material maps are grouped into this many
+	// (width, height) classes so a small or oddly-shaped map no longer pays a large
+	// neighbour's footprint. 4 → ~8 bound material arrays (4 sRGB + 4 linear).
+	MATERIAL_BUCKET_COUNT: 4,
+	// Packing stride: a map's stored index encodes bucketId * BUCKET_LAYER_STRIDE + layer.
+	// Also the per-bucket layer cap. Kept at the WebGPU portable maxTextureArrayLayers floor (256)
+	// so a consolidated bucket (which merges several map types of one size) stays portable.
+	BUCKET_LAYER_STRIDE: 256,
+};
+
+// An RGBA8 row upload must be a multiple of 256 bytes, so bucket widths land on 64 texels.
+const BUCKET_WIDTH_ALIGN = 64;
+
+export function alignBucketWidth( width, maxTextureSize ) {
+
+	const aligned = Math.ceil( Math.max( 1, width ) / BUCKET_WIDTH_ALIGN ) * BUCKET_WIDTH_ALIGN;
+	return Math.min( maxTextureSize, Math.max( TEXTURE_CONSTANTS.MIN_TEXTURE_WIDTH, aligned ) );
+
+}
+
+function bucketOf( units ) {
+
+	let width = 0, height = 0, count = 0;
+	for ( const unit of units ) {
+
+		width = Math.max( width, unit.width );
+		height = Math.max( height, unit.height );
+		count += unit.count;
+
+	}
+
+	return { units, width, height, count };
+
+}
+
+// Footprint times layer count.
+function bucketCost( bucket, maxTextureSize ) {
+
+	return alignBucketWidth( bucket.width, maxTextureSize ) * bucket.height * bucket.count * 4;
+
+}
+
+function totalCost( buckets, maxTextureSize ) {
+
+	return buckets.reduce( ( sum, b ) => sum + bucketCost( b, maxTextureSize ), 0 );
+
+}
+
+// Repeatedly fuse the pair of buckets whose union wastes least, until `count` remain.
+function mergeDown( buckets, count, maxTextureSize ) {
+
+	let current = buckets.slice();
+
+	while ( current.length > count ) {
+
+		let best = null;
+
+		for ( let i = 0; i < current.length; i ++ ) {
+
+			for ( let j = i + 1; j < current.length; j ++ ) {
+
+				const fused = bucketOf( current[ i ].units.concat( current[ j ].units ) );
+				const delta = bucketCost( fused, maxTextureSize )
+					- bucketCost( current[ i ], maxTextureSize ) - bucketCost( current[ j ], maxTextureSize );
+				if ( ! best || delta < best.delta ) best = { i, j, delta, fused };
+
+			}
+
+		}
+
+		current = current.filter( ( _, k ) => k !== best.i && k !== best.j ).concat( [ best.fused ] );
+
+	}
+
+	return current;
+
+}
+
+// The pre-shape-aware layout, kept as a rival opening: square scenes still do well on it.
+function ladderBuckets( units, count, maxTextureSize ) {
+
+	const ladder = [];
+	for ( let i = count - 1; i >= 0; i -- ) {
+
+		ladder.push( Math.max( TEXTURE_CONSTANTS.MIN_TEXTURE_WIDTH, Math.round( maxTextureSize / Math.pow( 2, i ) ) ) );
+
+	}
+
+	const bins = ladder.map( () => [] );
+
+	for ( const unit of units ) {
+
+		const longest = Math.pow( 2, Math.ceil( Math.log2( Math.max( unit.width, unit.height ) ) ) );
+		let slot = ladder.findIndex( size => longest <= size );
+		if ( slot < 0 ) slot = ladder.length - 1;
+		bins[ slot ].push( unit );
+
+	}
+
+	return bins.filter( bin => bin.length ).map( bucketOf );
+
+}
+
+// Both openings above are greedy and stop short on mixed aspects; moving one shape at a time
+// to whichever bucket makes the pool cheapest recovers the difference.
+function refine( buckets, maxTextureSize ) {
+
+	let current = buckets;
+
+	for ( let pass = 0; pass < 8; pass ++ ) {
+
+		let improved = false;
+
+		for ( const unit of current.flatMap( b => b.units ) ) {
+
+			const from = current.findIndex( b => b.units.includes( unit ) );
+			if ( from < 0 ) continue;
+
+			for ( let to = 0; to < current.length; to ++ ) {
+
+				if ( to === from ) continue;
+
+				const moved = [];
+				for ( let i = 0; i < current.length; i ++ ) {
+
+					if ( i === from ) {
+
+						const rest = current[ i ].units.filter( u => u !== unit );
+						if ( rest.length ) moved.push( bucketOf( rest ) );
+
+					} else if ( i === to ) moved.push( bucketOf( current[ i ].units.concat( [ unit ] ) ) );
+					else moved.push( current[ i ] );
+
+				}
+
+				if ( totalCost( moved, maxTextureSize ) < totalCost( current, maxTextureSize ) ) {
+
+					current = moved;
+					improved = true;
+					break;
+
+				}
+
+			}
+
+		}
+
+		if ( ! improved ) break;
+
+	}
+
+	return current;
+
+}
+
+/**
+ * Choose up to `count` array shapes for one colorSpace pool. Grouping by longest edge alone
+ * forces a 2000x453 banner into a 2048x2048 array; grouping on both axes does not.
+ *
+ * @param {Array<{width: number, height: number}>} sizes - every texture in the pool
+ * @param {number} maxTextureSize
+ * @param {number} [count]
+ * @returns {Array<{width: number, height: number}>} ascending by footprint
+ */
+export function planTextureBuckets( sizes, maxTextureSize, count = TEXTURE_CONSTANTS.MATERIAL_BUCKET_COUNT ) {
+
+	const distinct = new Map();
+
+	for ( const { width, height } of sizes ) {
+
+		const w = Math.min( maxTextureSize, Math.max( 1, width || 1 ) );
+		const h = Math.min( maxTextureSize, Math.max( 1, height || 1 ) );
+		const key = `${w}x${h}`;
+		const seen = distinct.get( key );
+		if ( seen ) seen.count ++;
+		else distinct.set( key, { width: w, height: h, count: 1 } );
+
+	}
+
+	const units = [ ...distinct.values() ];
+	let buckets = units.map( unit => bucketOf( [ unit ] ) );
+
+	if ( buckets.length > count ) {
+
+		const ladder = ladderBuckets( units, count, maxTextureSize );
+		const merged = mergeDown( buckets, count, maxTextureSize );
+		buckets = totalCost( ladder, maxTextureSize ) < totalCost( merged, maxTextureSize ) ? ladder : merged;
+		buckets = refine( buckets, maxTextureSize );
+
+	}
+
+	return buckets
+		.map( b => ( { width: alignBucketWidth( b.width, maxTextureSize ), height: b.height } ) )
+		.sort( ( a, b ) => a.width * a.height - b.width * b.height );
+
+}
+
+/**
+ * Index of the cheapest planned bucket that can hold a texture at its native size.
+ * A texture larger than every bucket lands in the largest and is downscaled there.
+ *
+ * @param {number} width
+ * @param {number} height
+ * @param {Array<{width: number, height: number}>} shapes - from {@link planTextureBuckets}
+ * @returns {number}
+ */
+export function getTextureBucketId( width, height, shapes ) {
+
+	const w = Math.max( 1, width || 1 );
+	const h = Math.max( 1, height || 1 );
+	for ( let i = 0; i < shapes.length; i ++ ) if ( shapes[ i ].width >= w && shapes[ i ].height >= h ) return i;
+	return Math.max( 0, shapes.length - 1 );
+
+}
+
+// Pack (bucketId, layer) into the single int slot a material map index occupies.
+export function packTextureIndex( bucketId, layer ) {
+
+	return bucketId * TEXTURE_CONSTANTS.BUCKET_LAYER_STRIDE + layer;
+
+}

package/src/Processor/TextureCreator.js

@@ -1,20 +1,36 @@
 import { DataArrayTexture, RGBAFormat, LinearFilter, UnsignedByteType, SRGBColorSpace, LinearSRGBColorSpace, RepeatWrapping, FloatType, HalfFloatType } from "three";
-import { alignBucketWidth, TEXTURE_CONSTANTS, MEMORY_CONSTANTS, MATERIAL_DATA_LAYOUT, BVH_LEAF_MARKERS, assertBVHIndexFits, bvhIndexView } from '../EngineDefaults.js';
+import { MATERIAL_DATA_LAYOUT, BVH_LEAF_MARKERS, assertBVHIndexFits, bvhIndexView } from './BufferLayout.js';
+import { alignBucketWidth, TEXTURE_CONSTANTS } from './TextureBuckets.js';
 import { packMaterial } from './MaterialPacking.js';
 import TexturesWorker from './Workers/TexturesWorker.js?worker&inline';
 import PackWorker from './Workers/PackWorker.js?worker&inline';
 import { resampleRGBA8 } from './ResampleRGBA8.js';
 import { ISSUE_CODES, EngineIssueError } from '../EngineIssues.js';
 import { linearToSRGB } from './ToneMapCPU.js';
-import { getActiveColorManagement } from '../Color/ColorManagement.js';
+import { getActiveColorManagement } from '../Color/ActiveColor.js';
 import { createLogger } from '../utils/Logger.js';
 import { createWorker, hardwareThreads, hasWorkers } from '../Platform.js';
 
 const log = createLogger( 'textures' );
 
+// Memory management constants
+export const MEMORY_CONSTANTS = {
+	MAX_BUFFER_MEMORY: 1024 * 1024 * 1024,
+	MAX_TEXTURE_MEMORY: 2048 * 1024 * 1024,
+	CLEANUP_THRESHOLD: 0.8,
+	STREAM_BATCH_SIZE: 4
+};
+
 // 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 +851,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 +911,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 +947,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 +1009,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',