rayzee 11.2.1 → 11.4.0

package/src/Processor/TLASBuilder.js

@@ -94,9 +94,10 @@ export class TLASBuilder {
 	 */
 	build( table ) {
 
-		const aabbs = new Float64Array( table.count * 6 );
-		table.writeWorldAABBs( aabbs );
-		const built = this.buildStructure( aabbs, table.count );
+		const clustered = table.clusterCount > 0;
+		const aabbs = clustered ? table.clusterBounds : new Float64Array( table.entryCount * 6 );
+		if ( ! clustered ) table.writeEntryWorldAABBs( aabbs );
+		const built = this.buildStructure( aabbs, clustered ? table.clusterCount : table.entryCount );
 		TLASBuilder.fillLeaves( built.data, built.nodeCount, table );
 		return built;
 
@@ -235,22 +236,34 @@ export class TLASBuilder {
 	 */
 	static fillLeaves( data, nodeCount, table ) {
 
-		const world = table.world, src = table.sourceMesh;
-		const blasOffset = table.tplBlasOffset, visible = table.visible, leafOf = table.tlasLeafIndex;
 		const idx = bvhIndexView( data );
 
+		if ( table.clusterCount > 0 ) {
+
+			// Built over clusters: each leaf holds one, its copies' transforms in records (table.writeRecord).
+			for ( let node = 0; node < nodeCount; node ++ ) {
+
+				const o = node * FLOATS_PER_NODE;
+				if ( idx[ o + 3 ] === BVH_LEAF_MARKERS.BLAS_POINTER_LEAF ) table.writeClusterLeaf( data, idx, o, idx[ o + 1 ], table.clusterWorld, node );
+
+			}
+
+			return;
+
+		}
+
 		for ( let node = 0; node < nodeCount; node ++ ) {
 
 			const o = node * FLOATS_PER_NODE;
 			if ( idx[ o + 3 ] !== BVH_LEAF_MARKERS.BLAS_POINTER_LEAF ) continue;
 
-			const i = idx[ o + 1 ] & TLAS_PLACEMENT_MASK;
-			idx[ o ] = blasOffset[ src[ i ] ];
-			data[ o + 2 ] = visible[ i ] ? 1.0 : 0.0;
+			const e = idx[ o + 1 ] & TLAS_PLACEMENT_MASK;
+			idx[ o ] = table.entryRoot( e );
+			data[ o + 2 ] = table.entryVisible( e ) ? 1.0 : 0.0;
 
-			TLASBuilder.writeLeafMatrix( data, idx, o, world, i );
+			TLASBuilder.writeLeafMatrix( data, idx, o, table, table.repOf( e ), e );
 
-			leafOf[ i ] = node;
+			table.setLeafOf( e, node );
 
 		}
 
@@ -261,25 +274,27 @@ export class TLASBuilder {
 	 * its own whenever a placement moves, so a rigid transform costs a matrix rather than a
 	 * rewrite of the geometry the placement may be sharing.
 	 *
-	 * Slot [1] is rewritten too: the placement index, with {@link TLAS_LEAF_IDENTITY} set when
-	 * the matrix is identity so traversal can skip the ray transform for that leaf.
+	 * Slot [1] is rewritten too: the TLAS entry (the placement, unless placements are grouped), with
+	 * {@link TLAS_LEAF_IDENTITY} set when the matrix is identity so traversal can skip the ray transform for that leaf.
 	 *
 	 * @param {Float32Array} data - the node buffer, or one chunk of it
 	 * @param {Uint32Array} idx - u32 view over the same memory as `data`
 	 * @param {number} off - float offset of the leaf within `data`
-	 * @param {Float32Array} world - the instance table's object-to-world column
-	 * @param {number} placement
+	 * @param {import('./InstanceTable.js').InstanceTable} table
+	 * @param {number} placement - whose transform the leaf carries
+	 * @param {number} [entry] - the TLAS entry it stands for
 	 */
-	static writeLeafMatrix( data, idx, off, world, placement ) {
+	static writeLeafMatrix( data, idx, off, table, placement, entry = placement ) {
 
 		const inv = _inverseScratch;
-		invertAffineInto( world, placement * 16, inv );
+		const row = table.matrixRow( placement ), world = table.rowArray;
+		invertAffineInto( world, row, inv );
 
 		data[ off + 4 ] = inv[ 0 ]; data[ off + 5 ] = inv[ 4 ]; data[ off + 6 ] = inv[ 8 ]; data[ off + 7 ] = inv[ 12 ];
 		data[ off + 8 ] = inv[ 1 ]; data[ off + 9 ] = inv[ 5 ]; data[ off + 10 ] = inv[ 9 ]; data[ off + 11 ] = inv[ 13 ];
 		data[ off + 12 ] = inv[ 2 ]; data[ off + 13 ] = inv[ 6 ]; data[ off + 14 ] = inv[ 10 ]; data[ off + 15 ] = inv[ 14 ];
 
-		idx[ off + 1 ] = ( placement | ( isIdentityAt( world, placement * 16 ) ? TLAS_LEAF_IDENTITY : 0 ) ) >>> 0;
+		idx[ off + 1 ] = ( entry | ( isIdentityAt( world, row ) ? TLAS_LEAF_IDENTITY : 0 ) ) >>> 0;
 
 	}
 

package/src/Processor/ToneMapCPU.js

@@ -128,21 +128,33 @@ export function applySaturation( out, saturation ) {
  * @param {number} options.toneMapping - a registered view transform id
  * @param {number} [options.saturation=1]
  * @param {boolean} [options.preserveAlpha=false]
+ * @param {{fn: function(number, number, number, number): number, width: number, height: number}} [options.pixelGain] -
+ *   the twin of the GPU pass's `gain`: `fn( u, v, luminance, log2 exposure )` per pixel, before the curve
  * @returns {Uint8ClampedArray} RGBA bytes
  */
-export function toneMapToRGBA8( linear, { exposure, toneMapping, saturation = 1, preserveAlpha = false } ) {
+export function toneMapToRGBA8( linear, { exposure, toneMapping, saturation = 1, preserveAlpha = false, pixelGain = null } ) {
 
 	const curve = TONE_MAP_FNS.get( toneMapping ) ?? TONE_MAP_FNS.get( NoToneMapping );
 	const gain = effectiveExposure( exposure, toneMapping );
 	const encoded = isOutputEncoded( toneMapping );
 	const out = new Uint8ClampedArray( linear.length );
 	const scratch = [ 0, 0, 0 ];
+	const logExposure = Math.log2( exposure );
 
 	for ( let i = 0; i < linear.length; i += 4 ) {
 
-		scratch[ 0 ] = linear[ i ] * gain;
-		scratch[ 1 ] = linear[ i + 1 ] * gain;
-		scratch[ 2 ] = linear[ i + 2 ] * gain;
+		let g = gain;
+		if ( pixelGain ) {
+
+			const p = i >> 2, x = p % pixelGain.width, y = ( p - x ) / pixelGain.width;
+			const lum = linear[ i ] * 0.2126 + linear[ i + 1 ] * 0.7152 + linear[ i + 2 ] * 0.0722;
+			g *= pixelGain.fn( ( x + 0.5 ) / pixelGain.width, ( y + 0.5 ) / pixelGain.height, lum, logExposure );
+
+		}
+
+		scratch[ 0 ] = linear[ i ] * g;
+		scratch[ 1 ] = linear[ i + 1 ] * g;
+		scratch[ 2 ] = linear[ i + 2 ] * g;
 
 		applySaturation( scratch, saturation );
 		curve( scratch[ 0 ], scratch[ 1 ], scratch[ 2 ], 1.0, scratch );

package/src/Processor/ToneMapGPU.js

@@ -88,7 +88,7 @@ fn rayzee_store( i: u32, linear: vec4<f32>, mapped: vec3<f32> ) {
 
 const BYTES_PER_PIXEL = { rgba8: 4, planar: 16 };
 
-const toneMapPassWGSL = ( transformWGSL, input, output ) => /* wgsl */ `
+const toneMapPassWGSL = ( transformWGSL, input, output, gainWGSL ) => /* wgsl */ `
 struct Params {
 	width: u32,
 	height: u32,
@@ -104,6 +104,7 @@ ${SOURCES[ input ]}
 
 ${transformWGSL}
 ${OUTPUTS[ output ]}
+${gainWGSL ?? ''}
 
 @compute @workgroup_size(8, 8)
 fn main( @builtin(global_invocation_id) gid: vec3<u32> ) {
@@ -113,7 +114,9 @@ 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 );
-	rayzee_store( gid.y * params.width + gid.x, linear, rayzee_tone_map( linear.rgb, params.mode, params.exposure, params.saturation ) );
+	let uv = vec2<f32>( ( f32( gid.x ) + 0.5 ) / f32( params.width ), ( f32( gid.y ) + 0.5 ) / f32( params.height ) );
+	let rgb = linear.rgb${gainWGSL ? ' * rayzee_gain( uv, linear.rgb, params.exposure )' : ''};
+	rayzee_store( gid.y * params.width + gid.x, linear, rayzee_tone_map( rgb, params.mode, params.exposure, params.saturation ) );
 }
 `;
 
@@ -136,7 +139,7 @@ export class PackedToneMapper {
 		this.output = output;
 		this.width = 0;
 		this.height = 0;
-		this._pipeline = null;
+		this._pipelines = new Map();
 		this._storage = null;
 		this._map = null;
 		this._params = null;
@@ -157,21 +160,31 @@ export class PackedToneMapper {
 	 * heard of. Without this the readback silently falls through to the clamp and a saved image
 	 * comes back untone-mapped.
 	 */
-	_ensurePipeline() {
+	_ensurePipeline( gain = null ) {
 
 		const { wgsl, bindings, version } = currentShader();
-		if ( this._pipeline && this._shaderVersion === version ) return;
+		if ( this._shaderVersion !== version ) {
 
-		this._bindings = bindings;
-		this._shaderVersion = version;
-		this._pipeline = this.device.createComputePipeline( {
+			this._pipelines.clear();
+			this._bindings = bindings;
+			this._shaderVersion = version;
+
+		}
+
+		const key = gain?.key ?? '';
+		let pipeline = this._pipelines.get( key );
+		if ( pipeline ) return pipeline;
+
+		pipeline = this.device.createComputePipeline( {
 			label: this.label,
 			layout: 'auto',
 			compute: {
-				module: this.device.createShaderModule( { label: this.label, code: toneMapPassWGSL( wgsl, this.input, this.output ) } ),
+				module: this.device.createShaderModule( { label: this.label, code: toneMapPassWGSL( wgsl, this.input, this.output, gain?.wgsl ) } ),
 				entryPoint: 'main',
 			},
 		} );
+		this._pipelines.set( key, pipeline );
+		return pipeline;
 
 	}
 
@@ -262,6 +275,8 @@ export class PackedToneMapper {
 	 * @param {number} [tone.saturation=1]
 	 * @param {boolean} [tone.flipY=false]
 	 * @param {boolean} [tone.preserveAlpha=false] - the source's alpha, rounded as the CPU rounds it; else 255
+	 * @param {{key: string, wgsl: string, entries: GPUBindGroupEntry[]}} [tone.gain] - a per-pixel gain before the
+	 *   curve: WGSL defining `rayzee_gain( uv, linear, exposure ) -> f32` over bind group 1
 	 * @returns {Promise<Uint8ClampedArray>} RGBA bytes, `width * height * 4`
 	 */
 	async toRGBA8( src, tone ) {
@@ -283,14 +298,14 @@ export class PackedToneMapper {
 
 	}
 
-	async _run( src, { exposure = 1, toneMapping = 0, saturation = 1, flipY = false, preserveAlpha = false } = {} ) {
+	async _run( src, { exposure = 1, toneMapping = 0, saturation = 1, flipY = false, preserveAlpha = false, gain = null } = {} ) {
 
 		if ( this.disposed ) throw new Error( 'PackedToneMapper: disposed' );
 		if ( ! this._storage ) throw new Error( 'PackedToneMapper: call ensureSize() first' );
 
 		// A config can be loaded between two readbacks, so the registry is re-checked here rather
 		// than only on resize.
-		this._ensurePipeline();
+		const pipeline = this._ensurePipeline( gain );
 		this._ensureTables();
 
 		const { width, height } = this;
@@ -309,7 +324,7 @@ export class PackedToneMapper {
 			.map( ( [ binding, held ] ) => ( { binding, resource: held.view } ) );
 
 		const group = this.device.createBindGroup( {
-			layout: this._pipeline.getBindGroupLayout( 0 ),
+			layout: pipeline.getBindGroupLayout( 0 ),
 			entries: [
 				...tableEntries,
 				{ binding: 0, resource: this.input === 'texture' ? src.createView() : { buffer: src, size: width * height * 8 } },
@@ -320,8 +335,9 @@ export class PackedToneMapper {
 
 		const encoder = this.device.createCommandEncoder( { label: this.label } );
 		const pass = encoder.beginComputePass();
-		pass.setPipeline( this._pipeline );
+		pass.setPipeline( pipeline );
 		pass.setBindGroup( 0, group );
+		if ( gain ) pass.setBindGroup( 1, this.device.createBindGroup( { layout: pipeline.getBindGroupLayout( 1 ), entries: gain.entries } ) );
 		pass.dispatchWorkgroups( Math.ceil( width / 8 ), Math.ceil( height / 8 ) );
 		pass.end();
 		encoder.copyBufferToBuffer( this._storage, 0, this._map, 0, bytes );
@@ -360,7 +376,7 @@ export class PackedToneMapper {
 		this._releaseBuffers();
 		for ( const held of this._tables.values() ) held.texture.destroy();
 		this._tables.clear();
-		this._pipeline = null;
+		this._pipelines.clear();
 
 	}