rayzee 10.0.0 → 11.0.0

package/src/Processor/AtmosphereModel.js

@@ -311,8 +311,7 @@ function transmittanceSpectrum( coefficients, depth ) {
 
 }
 
-// Hestroffer & Magnan 1998: I(µ)/I(1) = µ^α, α = −0.023 + 0.292 / λ[µm], at each primary's centroid.
-export const LIMB_DARKENING_EXPONENT = [ 610, 550, 465 ].map( l => - 0.023 + 0.292 / ( l / 1000 ) );
+export { LIMB_DARKENING_EXPONENT } from './SolarLimb.js';
 
 /** Solid angle of a cone of the given half-angle, without the cancellation `2π(1 − cos)` suffers. */
 export function coneSolidAngle( halfAngle ) {

package/src/Processor/BVHBuilder.js

@@ -1,26 +1,14 @@
-import { TreeletOptimizer } from './TreeletOptimizer.js';
 import { ReinsertionOptimizer } from './ReinsertionOptimizer.js';
-// Logger is worker-safe (globalThis only, storage access guarded), unlike Constants.js below.
+// Logger is worker-safe (globalThis only, storage access guarded).
 import { createLogger, fmt } from '../utils/Logger.js';
 import { foldLeaves } from './BVHLeafFold.js';
 import { hasWorkers } from '../Platform.js';
+import { BVH_LEAF_MARKERS, bvhIndexView, assertBVHIndexFits, TRIANGLE_DATA_LAYOUT } from './BufferLayout.js';
 
 const log = createLogger( 'bvh' );
 
-// Inline copies of EngineDefaults.BVH_LEAF_MARKERS / bvhIndexView — this module also runs inside
-// a worker, where importing Constants is not safe. Keep in step with EngineDefaults.js.
-// Index fields are u32 BIT PATTERNS, never float values: as floats they round past 2^24.
-const TRIANGLE_LEAF = 0x40000000;
-const FRONTIER_LEAF = 0x40000002;
-const indexView = f32 => new Uint32Array( f32.buffer, f32.byteOffset, f32.length );
-const BVH_MAX_INDEX = 0x40000000;
-
-function assertFits( count, what ) {
-
-	if ( count >= BVH_MAX_INDEX ) throw new RangeError( `${what} is ${count}, at or past the BVH index limit of ${BVH_MAX_INDEX}` );
-	return count;
-
-}
+const TRIANGLE_LEAF = BVH_LEAF_MARKERS.TRIANGLE_LEAF;
+const FRONTIER_LEAF = BVH_LEAF_MARKERS.FRONTIER;
 
 // Injected, not imported: this module also runs inside the worker, and `?worker&inline`
 // would embed a second copy of BVHWorker's source there.
@@ -32,16 +20,6 @@ export function setBVHWorkerFactory( factory ) {
 
 }
 
-// Inline copy of TRIANGLE_DATA_LAYOUT (mirrors Constants.js).
-// Cannot import Constants.js because BVHBuilder runs inside BVHWorker
-// where `window` (used elsewhere in Constants.js) is not defined.
-const TRIANGLE_DATA_LAYOUT = {
-	FLOATS_PER_TRIANGLE: 20,
-	POSITION_A_OFFSET: 0,
-	POSITION_B_OFFSET: 4,
-	POSITION_C_OFFSET: 8
-};
-
 const FPT = TRIANGLE_DATA_LAYOUT.FLOATS_PER_TRIANGLE;
 
 // The record buffer is uint; positions are f32 in it. Views share the memory, no copy.
@@ -104,23 +82,11 @@ export class BVHBuilder {
 			totalSplitAttempts: 0,
 			mortonSortTime: 0,
 			totalBuildTime: 0,
-			treeletOptimizationTime: 0,
-			treeletsProcessed: 0,
-			treeletsImproved: 0,
-			averageSAHImprovement: 0,
 			reinsertionOptimizationTime: 0,
 			reinsertionsApplied: 0,
 			reinsertionIterations: 0
 		};
 
-		// Off: repairs LBVH trees, so on this binned-SAH build it buys 0.005% tree SAH for 72%
-		// of build time.
-		this.enableTreeletOptimization = false;
-		this.treeletSize = 5;
-		this.treeletOptimizationPasses = 1;
-		this.treeletMinImprovement = 0.02;
-		this.treeletComplexityThreshold = 50000;
-
 		// Reinsertion optimization configuration
 		this.enableReinsertionOptimization = true;
 		this.reinsertionBatchSizeRatio = 0.02;
@@ -201,22 +167,6 @@ export class BVHBuilder {
 
 	}
 
-	setTreeletConfig( config ) {
-
-		if ( config.enabled !== undefined ) this.enableTreeletOptimization = config.enabled;
-		if ( config.size !== undefined ) this.treeletSize = Math.max( 3, Math.min( 12, config.size ) );
-		if ( config.passes !== undefined ) this.treeletOptimizationPasses = Math.max( 1, Math.min( 3, config.passes ) );
-		if ( config.minImprovement !== undefined ) this.treeletMinImprovement = Math.max( 0.001, config.minImprovement );
-		if ( config.complexityThreshold !== undefined ) this.treeletComplexityThreshold = config.complexityThreshold;
-
-	}
-
-	disableTreeletOptimization() {
-
-		this.enableTreeletOptimization = false;
-
-	}
-
 	setReinsertionConfig( config ) {
 
 		if ( config.enabled !== undefined ) this.enableReinsertionOptimization = config.enabled;
@@ -442,7 +392,7 @@ export class BVHBuilder {
 
 					worker.onmessage = ( e ) => {
 
-						const { bvhData, triangles: transferredTriangles, originalToBvh, error, progress, treeletStats } = e.data;
+						const { bvhData, triangles: transferredTriangles, originalToBvh, error, progress, splitStats } = e.data;
 
 						if ( error ) {
 
@@ -459,9 +409,9 @@ export class BVHBuilder {
 
 						}
 
-						if ( treeletStats ) {
+						if ( splitStats ) {
 
-							this.splitStats = treeletStats;
+							this.splitStats = splitStats;
 
 						}
 
@@ -493,12 +443,6 @@ export class BVHBuilder {
 						depth,
 						reportProgress: !! progressCallback,
 						sharedReorderBuffer,
-						treeletOptimization: {
-							enabled: this.enableTreeletOptimization,
-							size: this.treeletSize,
-							passes: this.treeletOptimizationPasses,
-							minImprovement: this.treeletMinImprovement
-						},
 						reinsertionOptimization: {
 							enabled: this.enableReinsertionOptimization,
 							batchSizeRatio: this.reinsertionBatchSizeRatio,
@@ -571,10 +515,6 @@ export class BVHBuilder {
 			totalSplitAttempts: 0,
 			mortonSortTime: 0,
 			totalBuildTime: 0,
-			treeletOptimizationTime: 0,
-			treeletsProcessed: 0,
-			treeletsImproved: 0,
-			averageSAHImprovement: 0,
 			reinsertionOptimizationTime: 0,
 			reinsertionsApplied: 0,
 			reinsertionIterations: 0,
@@ -608,58 +548,7 @@ export class BVHBuilder {
 		const root = this.buildNodeRecursive( 0, n, depth, progressCallback );
 		this.splitStats.sahBuildTime = performance.now() - sahStart;
 
-		// Phase 4: Treelet optimization
-		if ( this.enableTreeletOptimization && this.totalTriangles > 1000 ) {
-
-			const isLargeScene = this.totalTriangles > this.treeletComplexityThreshold;
-			const adaptiveTreeletSize = isLargeScene ? 3 : this.treeletSize;
-
-			const optimizer = new TreeletOptimizer( this.traversalCost, this.intersectionCost );
-			optimizer.setTreeletSize( adaptiveTreeletSize );
-			optimizer.setMinImprovement( this.treeletMinImprovement );
-
-			const optimizationStartTime = performance.now();
-
-			for ( let pass = 0; pass < this.treeletOptimizationPasses; pass ++ ) {
-
-				const passCallback = progressCallback ? ( status ) => {
-
-					progressCallback( `Treelet optimization pass ${pass + 1}/${this.treeletOptimizationPasses}: ${status}` );
-
-				} : null;
-
-				try {
-
-					optimizer.optimizeBVH( root, passCallback );
-
-				} catch ( error ) {
-
-					log.error( `treelet optimizer failed in pass ${pass + 1}:`, error );
-					break;
-
-				}
-
-				// optimizeBVH resets stats internally, so afterStats reflects this pass only
-				const afterStats = optimizer.getStatistics();
-				const passTime = performance.now() - optimizationStartTime;
-				if ( ( afterStats.treeletsImproved === 0 && pass > 0 ) || passTime > 15000 ) {
-
-					break;
-
-				}
-
-			}
-
-			const treeletTime = performance.now() - optimizationStartTime;
-			this.splitStats.treeletOptimizationTime = treeletTime;
-			const treeletStats = optimizer.getStatistics();
-			this.splitStats.treeletsProcessed = treeletStats.treeletsProcessed;
-			this.splitStats.treeletsImproved = treeletStats.treeletsImproved;
-			this.splitStats.averageSAHImprovement = treeletStats.averageSAHImprovement;
-
-		}
-
-		// Phase 4b: Reinsertion optimization (Meister & Bittner)
+		// Phase 4: Reinsertion optimization (Meister & Bittner)
 		if ( this.enableReinsertionOptimization && this.totalTriangles > 1000 ) {
 
 			const reinsertionOptimizer = new ReinsertionOptimizer( this.traversalCost, this.intersectionCost );
@@ -728,7 +617,6 @@ export class BVHBuilder {
 		log.debug(
 			`${fmt.n( n )} tris → ${fmt.n( this.totalNodes )} nodes in ${fmt.ms( total )}` +
 			` | SAH ${s.sahSplits} objMed ${s.objectMedianSplits} spatMed ${s.spatialMedianSplits} failed ${s.failedSplits}` +
-			( s.treeletsProcessed ? ` | treelets ${s.treeletsImproved}/${s.treeletsProcessed} improved` : '' ) +
 			( s.reinsertionsApplied ? ` | reinsertions ${s.reinsertionsApplied}` : '' )
 		);
 
@@ -1598,9 +1486,9 @@ export class BVHBuilder {
 		// 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]
 		const FLOATS_PER_NODE = 16;
-		assertFits( nodes.length, 'BLAS node count' );
+		assertBVHIndexFits( nodes.length, 'BLAS node count' );
 		const data = new Float32Array( nodes.length * FLOATS_PER_NODE );
-		const idx = indexView( data );
+		const idx = bvhIndexView( data );
 
 		for ( let i = 0; i < nodes.length; i ++ ) {
 
@@ -1672,10 +1560,10 @@ export class BVHBuilder {
 		}
 
 		// Second pass: write flat data
-		assertFits( nodes.length, 'BLAS node count' );
+		assertBVHIndexFits( nodes.length, 'BLAS node count' );
 		const data = new Float32Array( nodes.length * FLOATS_PER_NODE );
 		const frontierMap = [];
-		const idx = indexView( data );
+		const idx = bvhIndexView( data );
 
 		for ( let i = 0; i < nodes.length; i ++ ) {
 
@@ -1754,9 +1642,9 @@ export class BVHBuilder {
 		}
 
 		// Allocate final array
-		assertFits( totalNodes, 'assembled BLAS node count' );
+		assertBVHIndexFits( totalNodes, 'assembled BLAS node count' );
 		const finalData = new Float32Array( totalNodes * FLOATS_PER_NODE );
-		const finalIdx = indexView( finalData );
+		const finalIdx = bvhIndexView( finalData );
 
 		// Copy top-level data
 		finalData.set( topFlatData );

package/src/Processor/BVHLeafFold.js

@@ -1,12 +1,10 @@
-// Inline copies of EngineDefaults' BVH_LEAF_MARKERS.TRIANGLE_LEAF, BVH_MAX_INDEX and
-// BVH_FOLDED_LEAF_MAX: this runs in the BVH workers, which cannot import it. Keep in step.
-const TRIANGLE_LEAF = 0x40000000;
-const BVH_MAX_INDEX = 0x40000000;
-const BVH_FOLDED_LEAF_MAX = 15;
+import { BVH_LEAF_MARKERS, BVH_MAX_INDEX, BVH_FOLDED_LEAF_MAX } from './BufferLayout.js';
+
+const TRIANGLE_LEAF = BVH_LEAF_MARKERS.TRIANGLE_LEAF;
 const FLOATS_PER_NODE = 16;
 const FOLDED = 0x80000000;
 
-/** A folded leaf as its parent stores it (EngineDefaults: BVH_FOLDED_LEAF_MAX). */
+/** A folded leaf as its parent stores it (see BVH_FOLDED_LEAF_MAX). */
 export const foldedRef = ( first, count ) => ( ~ ( ( first << 4 ) | count ) ) >>> 0;
 export const isFoldedRef = ref => ref >= FOLDED;
 export const foldedFirst = ref => ( ( ~ ref ) >>> 0 ) >>> 4;

package/src/Processor/BVHRefitter.js

@@ -10,18 +10,7 @@
  */
 
 import { isFoldedRef, foldedFirst, foldedCount } from './BVHLeafFold.js';
-
-// Inline copy of layout constants (source of truth: EngineDefaults.js).
-// Cannot import because this runs inside Web Workers where window is not defined.
-const TRIANGLE_DATA_LAYOUT = {
-	FLOATS_PER_TRIANGLE: 20,
-	POSITION_A_OFFSET: 0,
-	POSITION_B_OFFSET: 4,
-	POSITION_C_OFFSET: 8,
-	NORMAL_A_PACKED_OFFSET: 3,
-	NORMAL_B_PACKED_OFFSET: 7,
-	NORMAL_C_PACKED_OFFSET: 11,
-};
+import { TRIANGLE_DATA_LAYOUT, packNormalOct, BVH_LEAF_MARKERS } from './BufferLayout.js';
 
 const FPT = TRIANGLE_DATA_LAYOUT.FLOATS_PER_TRIANGLE;
 
@@ -62,41 +51,9 @@ const triAccess = ( triangleData ) => {
 
 };
 
-// Octahedral snorm16 pair, matching packNormalOct in EngineDefaults (not importable here).
-function packNormalOct( x, y, z ) {
-
-	const len = Math.sqrt( x * x + y * y + z * z );
-	if ( len > 0 ) {
-
-		x /= len; y /= len; z /= len;
-
-	} else {
-
-		x = 0; y = 0; z = 1;
-
-	}
-
-	const sum = Math.abs( x ) + Math.abs( y ) + Math.abs( z );
-	let u = x / sum, v = y / sum;
-	if ( z < 0 ) {
-
-		const au = u, av = v;
-		u = ( 1 - Math.abs( av ) ) * ( au >= 0 ? 1 : - 1 );
-		v = ( 1 - Math.abs( au ) ) * ( av >= 0 ? 1 : - 1 );
-
-	}
-
-	const qu = Math.round( Math.min( 1, Math.max( - 1, u ) ) * 32767 ) & 0xffff;
-	const qv = Math.round( Math.min( 1, Math.max( - 1, v ) ) * 32767 ) & 0xffff;
-	return ( ( qv << 16 ) | qu ) >>> 0;
-
-}
-
 const FLOATS_PER_NODE = 16; // 4 vec4s per BVH node
-// Inline copies of EngineDefaults.BVH_LEAF_MARKERS — this module also runs inside a worker.
-// Index fields are u32 BIT PATTERNS (exact past 2^24), read through `indexView`.
-const LEAF_MARKER = 0x40000000;
-const BLAS_POINTER_MARKER = 0x40000001;
+const LEAF_MARKER = BVH_LEAF_MARKERS.TRIANGLE_LEAF;
+const BLAS_POINTER_MARKER = BVH_LEAF_MARKERS.BLAS_POINTER_LEAF;
 
 // Relative to the matrix's own magnitude, never an absolute floor — see transformBoundsToWorld.
 const SINGULAR_REL_EPS = 1e-12;
@@ -194,6 +151,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 +244,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 +337,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