rayzee 11.2.0 → 11.3.0

package/src/TSL/patches.js

@@ -147,6 +147,90 @@ export function uploadStorageChunks( renderer, attr, chunks ) {
 
 }
 
+/**
+ * GPU-only storage attributes standing for one array too large for a single binding: lane l lives in part
+ * ⌊l / lanesPerPart⌋, and a part holds whole records, so no record straddles two. Read through `splitStorage`
+ * (TSL/Common.js).
+ */
+export class StorageParts {
+
+	/**
+	 * @param {number} totalLanes
+	 * @param {number} lanesPerRecord
+	 * @param {number} maxPartBytes - at most maxStorageBufferBindingSize
+	 * @param {Function} [LaneType]
+	 * @param {number} [itemSize] - lanes an element: 4 for vec4 storage, 2 for vec2
+	 */
+	constructor( totalLanes, lanesPerRecord, maxPartBytes, LaneType = Float32Array, itemSize = 4 ) {
+
+		this.LaneType = LaneType;
+		this.itemSize = itemSize;
+		this.lanesPerPart = Math.max( 1, Math.floor( maxPartBytes / ( lanesPerRecord * LaneType.BYTES_PER_ELEMENT ) ) ) * lanesPerRecord;
+		this.totalLanes = totalLanes;
+		this.attrs = [];
+		for ( let at = 0; at < totalLanes || this.attrs.length === 0; at += this.lanesPerPart ) {
+
+			const lanes = Math.max( lanesPerRecord, Math.min( this.lanesPerPart, totalLanes - at ) );
+			this.attrs.push( gpuOnlyStorageAttribute( lanes / itemSize, itemSize, LaneType ) );
+
+		}
+
+	}
+
+	/** Elements a full part holds. */
+	get elementsPerPart() {
+
+		return this.lanesPerPart / this.itemSize;
+
+	}
+
+	/** Creates every part's GPU buffer now. */
+	create( backend ) {
+
+		for ( const attr of this.attrs ) backend.createStorageAttribute( attr );
+
+	}
+
+	/** Writes `count` lanes of `src` from `srcOffset` to lane `lane`, across a part boundary if need be. */
+	write( backend, lane, src, srcOffset, count ) {
+
+		const bytes = this.LaneType.BYTES_PER_ELEMENT;
+		while ( count > 0 ) {
+
+			const p = Math.floor( lane / this.lanesPerPart );
+			const local = lane - p * this.lanesPerPart;
+			const n = Math.min( count, this.lanesPerPart - local );
+			const attr = this.attrs[ p ];
+			backend.createStorageAttribute( attr );
+			backend.device.queue.writeBuffer( backend.get( attr ).buffer, local * bytes, src, srcOffset, n );
+			lane += n;
+			srcOffset += n;
+			count -= n;
+
+		}
+
+	}
+
+	/** Writes lanes [startLane, startLane + laneCount) of chunked `records`. */
+	writeRecords( backend, records, startLane, laneCount ) {
+
+		const lanesPerChunk = records.recordsPerChunk * records.lanesPerRecord;
+		for ( let lane = startLane, end = startLane + laneCount; lane < end; ) {
+
+			const ci = Math.floor( lane / lanesPerChunk );
+			const chunk = records.chunks[ ci ];
+			if ( ! chunk ) throw new Error( `chunk ${ci} is on disk and was never uploaded` );
+			const local = lane - ci * lanesPerChunk;
+			const n = Math.min( chunk.length - local, end - lane );
+			this.write( backend, lane, chunk, local, n );
+			lane += n;
+
+		}
+
+	}
+
+}
+
 /**
  * Re-upload one lane range of a chunked storage attribute, spanning chunks as needed.
  *

package/src/integrators/BidirectionalIntegrator.js

@@ -13,7 +13,7 @@ import { LIGHT_FLOATS } from '../managers/UniformManager.js';
 import { HIT_STRIDE_BIDIRECTIONAL, LIGHT_VERTEX_STRIDE, freeStorageAttribute } from '../Processor/PackedRayBuffer.js';
 import { COUNTER, ENERGY_SCALE } from '../Processor/QueueManager.js';
 import { CAMERA_PROJECTION_IDS } from '../EngineDefaults.js';
-import { BVH_MAX_INDEX } from '../Processor/BufferLayout.js';
+import { BVH_MAX_INDEX, BVH_LEAF_MARKERS, CLUSTER_COUNT_SHIFT, CLUSTER_COPY_HIDDEN } from '../Processor/BufferLayout.js';
 import { BOUNCE_KERNELS, LIST_WG_SIZE } from '../Stages/PathTracer.js';
 import { buildLightGenerateKernel, LIGHT_GENERATE_WG_SIZE } from '../TSL/LightGenerateKernel.js';
 import { buildGuideKernel, buildGuideClearKernel, guidedDiscPdf, recordEscape, GUIDE_BINS, GUIDE_ROW_STRIDE, GUIDE_TEXTURE_WIDTH } from '../TSL/LightGuide.js';
@@ -652,6 +652,14 @@ export class BidirectionalIntegrator {
 		const records = this.pt._bvhRecords;
 		const flat = records ? null : this.pt.bvhStorageAttr?.array;
 		if ( ! records && ! ( flat?.length >= 16 ) ) return null;
+		// A spilled TLAS comes back for the next frame's disc.
+		const blasBase = this.pt._instanceTable?.blasBase ?? 1;
+		if ( records && ! records.isResident( 0, blasBase ) ) {
+
+			this.pt._whenTLASResident( () => {} );
+			return null;
+
+		}
 
 		const view = ( f ) => {
 
@@ -668,6 +676,16 @@ export class BidirectionalIntegrator {
 
 		};
 
+		// A copy cluster is visible while any of its copies is (BufferLayout CLUSTER_LEAF).
+		const leafVisible = ( n ) => {
+
+			if ( n.u[ n.o + 3 ] !== BVH_LEAF_MARKERS.CLUSTER_LEAF ) return n.f[ n.o + 2 ] !== 0;
+			const count = ( ( n.u[ n.o ] >>> CLUSTER_COUNT_SHIFT ) & 3 ) + 1;
+			for ( let k = 0; k < count; k ++ ) if ( ! ( n.u[ n.o + 12 + k ] & CLUSTER_COPY_HIDDEN ) ) return true;
+			return false;
+
+		};
+
 		const root = node( 0 );
 		if ( root.u[ root.o + 3 ] >= BVH_MAX_INDEX ) return null;
 		// A tree that reaches a node twice is malformed; no search visits more nodes than the tree holds.
@@ -699,7 +717,7 @@ export class BidirectionalIntegrator {
 				const n = node( index );
 				if ( n.u[ n.o + 3 ] >= BVH_MAX_INDEX ) {
 
-					if ( n.f[ n.o + 2 ] !== 0 ) best = s;
+					if ( leafVisible( n ) ) best = s;
 
 				} else push( n );
 

package/src/managers/DenoisingManager.js

@@ -988,10 +988,10 @@ export class DenoisingManager extends EventDispatcher {
 	 * @param {Float32Array} world - the placement matrix pool
 	 * @param {number} offset - where this placement's matrix starts in it
 	 */
-	notePlacementMoving( leaf, world, offset ) {
+	notePlacementMoving( leaf, matrixOf ) {
 
 		if ( leaf < 0 || ! this.historyActive || this._movedPlacements.has( leaf ) ) return;
-		this._movedPlacements.set( leaf, { world, offset, prev: world.slice( offset, offset + 16 ) } );
+		this._movedPlacements.set( leaf, { matrixOf, prev: matrixOf().slice() } );
 
 	}
 
@@ -1013,8 +1013,8 @@ export class DenoisingManager extends EventDispatcher {
 		const leaves = [ ...moved.keys() ].sort( ( a, b ) => a - b );
 		for ( let i = 0; i < leaves.length; i ++ ) {
 
-			const { world, offset, prev } = moved.get( leaves[ i ] );
-			this._matB.fromArray( world, offset ).invert();
+			const { matrixOf, prev } = moved.get( leaves[ i ] );
+			this._matB.fromArray( matrixOf() ).invert();
 			this._matA.fromArray( prev ).multiply( this._matB ).toArray( upload.toPrev, i * 16 );
 			upload.leaves[ i ] = leaves[ i ];
 

package/src/managers/InteractionManager.js

@@ -38,12 +38,13 @@ export function focusDistanceOfHit( hit, camera, panorama = false ) {
  */
 export class InteractionManager extends EventDispatcher {
 
-	constructor( { scene, camera, canvas, assetLoader, pathTracer, floorPlane } ) {
+	constructor( { scene, camera, canvas, assetLoader, pathTracer, floorPlane, isGeometryOnDisk = null } ) {
 
 		super();
 
 		// Core dependencies
 		this.scene = scene;
+		this.isGeometryOnDisk = isGeometryOnDisk;
 		this.camera = camera;
 		this.canvas = canvas;
 		this.assetLoader = assetLoader;
@@ -125,7 +126,8 @@ export class InteractionManager extends EventDispatcher {
 	select( object ) {
 
 		const outline = this._overlayManager?.getHelper( 'outline' );
-		if ( outline ) outline.setSelectedObjects( object ? [ object ] : [] );
+		// A spilled model's geometry is on disk: there is nothing to draw the outline from.
+		if ( outline ) outline.setSelectedObjects( object && ! this.isGeometryOnDisk?.() ? [ object ] : [] );
 
 		this.selectedObject = object || null;
 
@@ -221,7 +223,7 @@ export class InteractionManager extends EventDispatcher {
 		const mouseCoords = this.getMouseCoordinates( event );
 		this.raycaster.setFromCamera( mouseCoords, this.camera );
 
-		const intersects = this.raycaster.intersectObjects( this.scene.children, true );
+		const intersects = this._intersectScene();
 
 		if ( intersects.length > 0 ) {
 
@@ -490,7 +492,7 @@ export class InteractionManager extends EventDispatcher {
 			const mouseCoords = this.getMouseCoordinates( event );
 			this.raycaster.setFromCamera( mouseCoords, this.camera );
 
-			const intersects = this.raycaster.intersectObjects( this.scene.children, true );
+			const intersects = this._intersectScene();
 			const validIntersects = this.filterValidIntersects( intersects );
 			const lightHit = this._pickLightHelper();
 
@@ -576,7 +578,7 @@ export class InteractionManager extends EventDispatcher {
 		const mouseCoords = this.getMouseCoordinates( event );
 		this.raycaster.setFromCamera( mouseCoords, this.camera );
 
-		const intersects = this.raycaster.intersectObjects( this.scene.children, true );
+		const intersects = this._intersectScene();
 		const validIntersects = this.filterValidIntersects( intersects );
 
 		if ( validIntersects.length > 0 ) {
@@ -695,11 +697,22 @@ export class InteractionManager extends EventDispatcher {
 
 	}
 
+	/**
+	 * The scene under the raycaster. Nothing while a spilled model's geometry is on disk: its arrays are empty, and
+	 * testing tens of millions of empty copies held the page for seconds a pick.
+	 * @private
+	 */
+	_intersectScene() {
+
+		return this.isGeometryOnDisk?.() ? [] : this.raycaster.intersectObjects( this.scene.children, true );
+
+	}
+
 	/** The nearest scene surface under an NDC point, skipping the floor and helpers. */
 	pickSurface( ndcX, ndcY ) {
 
 		this.raycaster.setFromCamera( { x: ndcX, y: ndcY }, this.camera );
-		return this.filterValidIntersects( this.raycaster.intersectObjects( this.scene.children, true ) )[ 0 ] ?? null;
+		return this.filterValidIntersects( this._intersectScene() )[ 0 ] ?? null;
 
 	}
 

package/src/managers/MaterialDataManager.js

@@ -173,8 +173,17 @@ export class MaterialDataManager {
 		this._convertColorsToWorkingSpace( matImageData );
 
 		const vec4Count = matImageData.length / 4;
+		this.materialCount = Math.floor( vec4Count / PIXELS_PER_MATERIAL );
+
+		// The owning stage keeps materials at the front of its scene data buffer, the light data behind them: one
+		// binding for both, which the shading kernel's ten could not spare.
+		const shared = this.callbacks.adoptMaterials?.( matImageData );
+		if ( shared ) {
 
-		if ( this.materialStorageNode ) {
+			this.materialStorageAttr = shared.attr;
+			this.materialStorageNode = shared.node;
+
+		} else if ( this.materialStorageNode ) {
 
 			this.materialStorageAttr = new StorageInstancedBufferAttribute( matImageData, 4 );
 			this.materialStorageNode.value = this.materialStorageAttr;
@@ -187,7 +196,6 @@ export class MaterialDataManager {
 
 		}
 
-		this.materialCount = Math.floor( vec4Count / PIXELS_PER_MATERIAL );
 		this._sources = [ ...sources ];
 		this._hostSet = [];
 		this.callbacks.onMaterialFeaturesChanged?.();
@@ -195,6 +203,15 @@ export class MaterialDataManager {
 
 	}
 
+	/** Sends the materials to the GPU: only their region when the buffer carries the light data too. @private */
+	_uploadMaterials() {
+
+		const attr = this.materialStorageAttr;
+		if ( this.callbacks.adoptMaterials ) attr.addUpdateRange( 0, this.materialCount * PIXELS_PER_MATERIAL * 4 );
+		attr.needsUpdate = true;
+
+	}
+
 	/**
 	 * Get the material storage attribute (for dependent stages).
 	 * @returns {StorageInstancedBufferAttribute|null}
@@ -538,7 +555,7 @@ export class MaterialDataManager {
 
 		}
 
-		this.materialStorageAttr.needsUpdate = true;
+		this._uploadMaterials();
 		( this._hostSet[ materialIndex ] ??= new Map() ).set( property, toPortable( value ) );
 
 		// Recompute triangle-data opaque-blocker flag when any input to it changes.
@@ -588,7 +605,7 @@ export class MaterialDataManager {
 		this._recomputeOpaqueBlockerForMaterial( materialIndex );
 		this.callbacks.onMaterialFeaturesChanged?.();
 
-		this.materialStorageAttr.needsUpdate = true;
+		this._uploadMaterials();
 		this._notifyReset();
 
 	}
@@ -668,7 +685,7 @@ export class MaterialDataManager {
 
 		}
 
-		this.materialStorageAttr.needsUpdate = true;
+		this._uploadMaterials();
 		this._notifyReset();
 
 	}

package/src/managers/UniformManager.js

@@ -333,6 +333,9 @@ export class UniformManager {
 		u( 'emissiveTriangleCount', 0, 'int' );
 		u( 'emissiveTotalPower', 0.0, 'float' );
 		u( 'lightBVHNodeCount', 0, 'int' );
+		// Where the light data starts in the scene data buffer, after the materials (vec4 elements). Every light read
+		// adds it; the offsets below are within the light data.
+		u( 'lightVec4Offset', 0, 'int' );
 		// Offset (in vec4 elements) within the packed light buffer where emissive
 		// triangle data starts. Equals lightBVHNodeCount * LBVH_STRIDE; computed on upload.
 		u( 'emissiveVec4Offset', 0, 'int' );