rayzee 8.8.2 → 9.1.0

package/src/Processor/SplitBLAS.js

@@ -0,0 +1,249 @@
+import { TRIANGLE_DATA_LAYOUT } from '../EngineDefaults.js';
+import { rebaseNodes } from './BVHLeafFold.js';
+
+const FLOATS_PER_NODE = 16;
+const A = TRIANGLE_DATA_LAYOUT.POSITION_A_OFFSET;
+const B = TRIANGLE_DATA_LAYOUT.POSITION_B_OFFSET;
+const C = TRIANGLE_DATA_LAYOUT.POSITION_C_OFFSET;
+
+/**
+ * Sorts records [start, start + count) in place into spatial pieces of at most `pieceTriangles`,
+ * halving at the centroid median along the longest axis — so a mesh too large to build at once
+ * becomes pieces that build one per worker and join under a few nodes ({@link joinPieces}).
+ * @param {import('./ChunkedRecords.js').ChunkedRecords} records
+ * @param {{pause?: function(): Promise}} [options] - awaited every million records moved or so
+ * @returns {Promise<{order: Uint32Array, pieces: Array<{start: number, count: number}>, tree: Object}>}
+ *   `order[ j ]` is the index, within the range, that record j held before; piece starts are
+ *   relative to `start`, and `tree` is the halving as `{ left, right }` down to `{ piece }`.
+ */
+export async function partitionRange( records, start, count, pieceTriangles, { pause = null } = {} ) {
+
+	const lanes = records.lanesPerRecord;
+	// One array per axis, swapped in step with `order`, so every pass reads memory in sequence.
+	const axes = [ new Float32Array( count ), new Float32Array( count ), new Float32Array( count ) ];
+	const [ cx, cy, cz ] = axes;
+	for ( let j = 0; j < count; ) {
+
+		const chunk = records.chunkFor( start + j );
+		const f = new Float32Array( chunk.buffer, chunk.byteOffset, chunk.length );
+		const end = Math.min( count, ( ( ( ( start + j ) / records.recordsPerChunk ) | 0 ) + 1 ) * records.recordsPerChunk - start );
+		for ( let d = records.baseOf( start + j ); j < end; j ++, d += lanes ) {
+
+			cx[ j ] = f[ d + A ] + f[ d + B ] + f[ d + C ];
+			cy[ j ] = f[ d + A + 1 ] + f[ d + B + 1 ] + f[ d + C + 1 ];
+			cz[ j ] = f[ d + A + 2 ] + f[ d + B + 2 ] + f[ d + C + 2 ];
+
+		}
+
+	}
+
+	const order = new Uint32Array( count );
+	for ( let j = 0; j < count; j ++ ) order[ j ] = j;
+
+	const pieces = [];
+	const split = ( lo, hi ) => {
+
+		if ( hi - lo <= pieceTriangles ) {
+
+			pieces.push( { start: lo, count: hi - lo } );
+			return { piece: pieces.length - 1 };
+
+		}
+
+		const mid = lo + ( ( hi - lo ) >> 1 );
+		selectNth( order, axes, longestAxis( axes, lo, hi ), lo, hi, mid );
+		return { left: split( lo, mid ), right: split( mid, hi ) };
+
+	};
+
+	const tree = split( 0, count );
+	await pause?.();
+	await permuteInPlace( records, start, count, order, pause );
+	return { order, pieces, tree };
+
+}
+
+function longestAxis( axes, lo, hi ) {
+
+	let best = 0, widest = - 1;
+	for ( let a = 0; a < 3; a ++ ) {
+
+		const c = axes[ a ];
+		let min = Infinity, max = - Infinity;
+		for ( let i = lo; i < hi; i ++ ) {
+
+			const v = c[ i ];
+			if ( v < min ) min = v;
+			if ( v > max ) max = v;
+
+		}
+
+		if ( max - min > widest ) {
+
+			widest = max - min;
+			best = a;
+
+		}
+
+	}
+
+	return best;
+
+}
+
+// Quickselect with a three-way partition, so runs of equal keys cannot make it quadratic, and
+// pivots sampled with a fixed seed: the first, middle and last of a terrain grid's repeating rows
+// took a thousand passes. Fixed, so the same mesh always builds the same BVH.
+function selectNth( order, axes, axis, lo, hi, k ) {
+
+	const key = axes[ axis ];
+	const [ c0, c1, c2 ] = axes;
+	const swap = ( i, j ) => {
+
+		let t = order[ i ]; order[ i ] = order[ j ]; order[ j ] = t;
+		t = c0[ i ]; c0[ i ] = c0[ j ]; c0[ j ] = t;
+		t = c1[ i ]; c1[ i ] = c1[ j ]; c1[ j ] = t;
+		t = c2[ i ]; c2[ i ] = c2[ j ]; c2[ j ] = t;
+
+	};
+
+	let seed = 0x9e3779b9;
+	const sample = () => {
+
+		seed ^= seed << 13;
+		seed ^= seed >>> 17;
+		seed ^= seed << 5;
+		return key[ lo + ( seed >>> 0 ) % ( hi - lo ) ];
+
+	};
+
+	while ( hi - lo > 1 ) {
+
+		const a = sample(), b = sample(), c = sample();
+		const pivot = a < b ? ( b < c ? b : a < c ? c : a ) : ( a < c ? a : b < c ? c : b );
+
+		let lt = lo, i = lo, gt = hi;
+		while ( i < gt ) {
+
+			const v = key[ i ];
+			if ( v < pivot ) swap( lt ++, i ++ );
+			else if ( v > pivot ) swap( i, -- gt );
+			else i ++;
+
+		}
+
+		if ( k < lt ) hi = lt;
+		else if ( k >= gt ) lo = gt;
+		else return;
+
+	}
+
+}
+
+// Record j takes record order[ j ], following each cycle with one record held aside.
+async function permuteInPlace( records, start, count, order, pause ) {
+
+	const lanes = records.lanesPerRecord;
+	const held = new Uint32Array( lanes );
+	const done = new Uint8Array( count );
+	let moved = 0;
+
+	for ( let j = 0; j < count; j ++ ) {
+
+		if ( done[ j ] ) continue;
+		done[ j ] = 1;
+		if ( order[ j ] === j ) continue;
+
+		let chunk = records.chunkFor( start + j ), base = records.baseOf( start + j );
+		for ( let l = 0; l < lanes; l ++ ) held[ l ] = chunk[ base + l ];
+
+		for ( let k = j; ; ) {
+
+			const s = order[ k ];
+			const to = chunk, at = base;
+			if ( s === j ) {
+
+				for ( let l = 0; l < lanes; l ++ ) to[ at + l ] = held[ l ];
+				break;
+
+			}
+
+			chunk = records.chunkFor( start + s );
+			base = records.baseOf( start + s );
+			for ( let l = 0; l < lanes; l ++ ) to[ at + l ] = chunk[ base + l ];
+			done[ s ] = 1;
+			k = s;
+			if ( pause && ( ++ moved & 0xfffff ) === 0 ) await pause();
+
+		}
+
+	}
+
+}
+
+/**
+ * One BLAS from the pieces of {@link partitionRange}: the halving becomes inner nodes ahead of
+ * the pieces' own nodes, which are rebased in place to follow them, so children always sit after
+ * their parent as a refit requires. Handed back as parts, never one array the size of the mesh:
+ * a 600 MB request is what failed an 80M-triangle build with memory to spare.
+ * @param {Object} tree
+ * @param {Array<{start: number, count: number}>} pieces
+ * @param {Array<{bvhData: Float32Array, originalToBvh: ?Uint32Array, aabb: ArrayLike<number>}>} built - per piece
+ * @param {Uint32Array} order - from partitionRange
+ * @returns {{bvhData: Float32Array[], nodeCount: number, originalToBvh: Uint32Array}} the join's nodes
+ *   first, then each piece's; `originalToBvh` as one build of the whole range returns it
+ */
+export function joinPieces( tree, pieces, built, order ) {
+
+	const inner = pieces.length - 1;
+	const bases = [];
+	let total = inner;
+	for ( const { bvhData } of built ) {
+
+		bases.push( total );
+		total += bvhData.length / FLOATS_PER_NODE;
+
+	}
+
+	const data = new Float32Array( inner * FLOATS_PER_NODE );
+	const idx = new Uint32Array( data.buffer );
+	const parts = [ data ];
+	const originalToBvh = new Uint32Array( order.length );
+
+	for ( let k = 0; k < pieces.length; k ++ ) {
+
+		const { bvhData, originalToBvh: pieceOrder } = built[ k ];
+		built[ k ].bvhData = built[ k ].originalToBvh = null;
+		const base = bases[ k ];
+		const { start, count } = pieces[ k ];
+		rebaseNodes( new Uint32Array( bvhData.buffer, bvhData.byteOffset, bvhData.length ), base, start );
+
+		parts.push( bvhData );
+		for ( let i = 0; i < count; i ++ ) originalToBvh[ order[ start + i ] ] = start + ( pieceOrder ? pieceOrder[ i ] : i );
+
+	}
+
+	let next = 0;
+	const place = node => {
+
+		if ( node.piece !== undefined ) return { index: bases[ node.piece ], box: built[ node.piece ].aabb };
+
+		const index = next ++;
+		const l = place( node.left );
+		const r = place( node.right );
+		const o = index * FLOATS_PER_NODE;
+		data[ o ] = l.box[ 0 ]; data[ o + 1 ] = l.box[ 1 ]; data[ o + 2 ] = l.box[ 2 ]; idx[ o + 3 ] = l.index;
+		data[ o + 4 ] = l.box[ 3 ]; data[ o + 5 ] = l.box[ 4 ]; data[ o + 6 ] = l.box[ 5 ]; idx[ o + 7 ] = r.index;
+		data[ o + 8 ] = r.box[ 0 ]; data[ o + 9 ] = r.box[ 1 ]; data[ o + 10 ] = r.box[ 2 ];
+		data[ o + 12 ] = r.box[ 3 ]; data[ o + 13 ] = r.box[ 4 ]; data[ o + 14 ] = r.box[ 5 ];
+
+		const box = [ 0, 1, 2 ].map( a => Math.min( l.box[ a ], r.box[ a ] ) )
+			.concat( [ 3, 4, 5 ].map( a => Math.max( l.box[ a ], r.box[ a ] ) ) );
+		return { index, box };
+
+	};
+
+	place( tree );
+	return { bvhData: parts, nodeCount: total, originalToBvh };
+
+}

package/src/Processor/SunPosition.js

@@ -0,0 +1,41 @@
+/**
+ * Where the sun stands, from local solar time, day of the year and latitude. Declination is
+ * Spencer's (1971) series; azimuth is clockwise from north. Degrees in and out.
+ */
+
+const RAD = Math.PI / 180;
+
+function declination( dayOfYear ) {
+
+	const g = 2 * Math.PI * ( dayOfYear - 1 ) / 365;
+	return 0.006918 - 0.399912 * Math.cos( g ) + 0.070257 * Math.sin( g ) - 0.006758 * Math.cos( 2 * g )
+		+ 0.000907 * Math.sin( 2 * g ) - 0.002697 * Math.cos( 3 * g ) + 0.00148 * Math.sin( 3 * g );
+
+}
+
+/** @returns {{ azimuth: number, elevation: number }} */
+export function sunPosition( { hours, dayOfYear, latitude } ) {
+
+	const d = declination( dayOfYear );
+	const h = ( hours - 12 ) * 15 * RAD;
+	const lat = latitude * RAD;
+	const sinEl = Math.sin( lat ) * Math.sin( d ) + Math.cos( lat ) * Math.cos( d ) * Math.cos( h );
+	const elevation = Math.asin( Math.min( 1, Math.max( - 1, sinEl ) ) ) / RAD;
+	const azimuth = ( Math.atan2( Math.sin( h ), Math.cos( h ) * Math.sin( lat ) - Math.tan( d ) * Math.cos( lat ) ) / RAD + 540 ) % 360;
+	return { azimuth, elevation };
+
+}
+
+/** The solar time the sun reaches `elevation`, before or after noon; noon or midnight when it never does. */
+export function timeForSunElevation( { elevation, dayOfYear, latitude, afternoon = false } ) {
+
+	const d = declination( dayOfYear );
+	const lat = latitude * RAD;
+	const cosH = ( Math.sin( elevation * RAD ) - Math.sin( lat ) * Math.sin( d ) ) / ( Math.cos( lat ) * Math.cos( d ) );
+	const h = Math.acos( Math.min( 1, Math.max( - 1, cosH ) ) ) / RAD / 15;
+	return afternoon ? 12 + h : 12 - h;
+
+}
+
+/** Day of the year of the 21st of `month` (1–12), near each solstice and equinox. */
+export const dayOfYearForMonth = month => [ 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 ][ month - 1 ] + 21;

package/src/Processor/TextureCreator.js

@@ -251,6 +251,13 @@ class SmartBufferPool {
 
 	}
 
+	/** Stops counting a buffer that is being let go rather than returned. */
+	forget( buffer ) {
+
+		this.memoryUsage = Math.max( 0, this.memoryUsage - buffer.buffer.byteLength );
+
+	}
+
 	releaseBuffer( buffer, Type = Float32Array ) {
 
 		// Recover the full allocated size from the underlying ArrayBuffer
@@ -1407,6 +1414,20 @@ export class TextureCreator {
 
 		// Enhanced disposal
 		texture.userData = { buffer: data, bufferType: Uint8Array };
+
+		// Nothing reads these pixels once they are on the GPU — a rebuild packs new arrays from the
+		// three.js sources — so the CPU copy goes as soon as three.js has uploaded it. Not back to
+		// the pool, which would keep it alive; a cache lookup then sees `buffer: null` and rebuilds.
+		texture.onUpdate = () => {
+
+			const buffer = texture.userData.buffer;
+			if ( ! buffer ) return;
+			this.bufferPool.forget( buffer );
+			texture.userData.buffer = null;
+			texture.image.data = null;
+
+		};
+
 		const originalDispose = texture.dispose.bind( texture );
 		texture.dispose = () => {
 

package/src/Processor/Workers/AIUpscalerWorker.js

@@ -14,12 +14,16 @@
  *     { type: 'error', message, id? }
  */
 
+import { openInlineStorage } from '../../Storage/StorageManager.js';
+import { DownloadCache } from '../../Storage/DownloadCache.js';
+
 // Asset config supplied via 'load' message from the main thread.
 // Defaults match the upstream Rayzee deployment; override via configureAssets().
 let _assetConfig = {
 	ortRuntimeUrl: 'https://cdn.jsdelivr.net/npm/onnxruntime-web@1.24.3/dist/ort.webgpu.bundle.min.mjs',
 	ortWasmPaths: 'https://cdn.jsdelivr.net/npm/onnxruntime-web@1.24.3/dist/',
 	cacheNamespace: 'rayzee',
+	storage: 'auto',
 };
 
 let ort = null;
@@ -38,98 +42,120 @@ async function getOrt() {
 
 }
 
-// IndexedDB names are namespaced so multiple consumers on the same origin don't collide.
-function getIdbName() {
+let session = null;
+let currentModelUrl = null;
+let downloads = null;
 
-	return `${_assetConfig.cacheNamespace}:ai-upscaler-models`;
+// ─── Model cache (the engine's download storage, written from this worker) ─────
 
-}
+function getDownloads() {
 
-const IDB_STORE = 'models';
+	downloads ??= ( async () => {
 
-let session = null;
-let currentModelUrl = null;
+		if ( _assetConfig.storage === false || ! navigator.storage?.getDirectory ) return new DownloadCache( null );
 
-// ─── IndexedDB Model Cache ───────────────────────────────────────────────────
+		try {
 
-function openDB() {
+			const top = await navigator.storage.getDirectory();
+			const root = await top.getDirectoryHandle( _assetConfig.cacheNamespace, { create: true } );
+			const storage = openInlineStorage( { namespace: _assetConfig.cacheNamespace, root } );
+			await migrateIndexedDB( storage ).catch( () => {} );
+			return new DownloadCache( storage );
 
-	return new Promise( ( resolve, reject ) => {
+		} catch {
 
-		const req = indexedDB.open( getIdbName(), 1 );
-		req.onupgradeneeded = () => req.result.createObjectStore( IDB_STORE );
-		req.onsuccess = () => resolve( req.result );
-		req.onerror = () => reject( req.error );
+			return new DownloadCache( null );
 
-	} );
+		}
+
+	} )();
+
+	return downloads;
 
 }
 
-async function getCachedModel( url ) {
+// Earlier builds kept models in IndexedDB: move them across once, then drop the database.
+async function migrateIndexedDB( storage ) {
 
-	try {
+	const name = `${_assetConfig.cacheNamespace}:ai-upscaler-models`;
+	if ( typeof indexedDB === 'undefined' || ! indexedDB.databases ) return;
+	if ( ! ( await indexedDB.databases() ).some( ( d ) => d.name === name ) ) return;
 
-		const db = await openDB();
-		return await new Promise( ( resolve, reject ) => {
+	const entries = await new Promise( ( resolve, reject ) => {
 
-			const tx = db.transaction( IDB_STORE, 'readonly' );
-			const req = tx.objectStore( IDB_STORE ).get( url );
-			req.onsuccess = () => resolve( req.result || null );
-			req.onerror = () => reject( req.error );
+		const open = indexedDB.open( name );
+		open.onerror = () => reject( open.error );
+		open.onsuccess = () => {
 
-		} );
+			const db = open.result;
+			if ( ! db.objectStoreNames.contains( 'models' ) ) {
 
-	} catch {
+				db.close();
+				resolve( [] );
+				return;
 
-		return null;
+			}
 
-	}
+			const out = [];
+			const cursor = db.transaction( 'models', 'readonly' ).objectStore( 'models' ).openCursor();
+			cursor.onerror = () => reject( cursor.error );
+			cursor.onsuccess = () => {
 
-}
+				const c = cursor.result;
+				if ( ! c ) {
 
-async function cacheModel( url, buffer ) {
+					db.close();
+					resolve( out );
+					return;
 
-	try {
+				}
+
+				out.push( [ c.key, c.value ] );
+				c.continue();
 
-		const db = await openDB();
-		await new Promise( ( resolve, reject ) => {
+			};
 
-			const tx = db.transaction( IDB_STORE, 'readwrite' );
-			tx.objectStore( IDB_STORE ).put( buffer, url );
-			tx.oncomplete = () => resolve();
-			tx.onerror = () => reject( tx.error );
+		};
 
-		} );
+	} );
+
+	const area = storage.area( 'downloads' );
+	for ( const [ url, buffer ] of entries ) {
 
-	} catch {
+		if ( typeof url !== 'string' || ! ( buffer instanceof ArrayBuffer ) || await area.has( url ) ) continue;
+		const writer = await area.create( url, { label: url.split( '/' ).pop(), expectedBytes: buffer.byteLength } );
+		if ( ! writer ) continue;
+		await writer.write( 'data', buffer, { transfer: true } );
+		await writer.commit( { url, contentType: 'application/octet-stream', checkedAt: Date.now() } );
 
-		// Cache write failure is non-fatal
 	}
 
+	await new Promise( ( resolve ) => {
+
+		const request = indexedDB.deleteDatabase( name );
+		request.onsuccess = request.onerror = request.onblocked = () => resolve();
+
+	} );
+
 }
 
 // ─── Model Loading ───────────────────────────────────────────────────────────
 
 async function fetchModel( url ) {
 
-	// Try IndexedDB cache first
-	const cached = await getCachedModel( url );
-	if ( cached ) {
+	const { file, release, fromCache } = await ( await getDownloads() ).fetch( url );
 
-		console.log( `AI Upscaler Worker: model loaded from cache (${( cached.byteLength / 1024 / 1024 ).toFixed( 1 )}MB)` );
-		return cached;
+	try {
 
-	}
+		const buffer = await file.arrayBuffer();
+		if ( fromCache ) console.log( `AI Upscaler Worker: model loaded from cache (${( buffer.byteLength / 1024 / 1024 ).toFixed( 1 )}MB)` );
+		return buffer;
 
-	// Network fetch + cache
-	const response = await fetch( url );
-	if ( ! response.ok ) throw new Error( `Failed to fetch model: ${response.status}` );
-	const buffer = await response.arrayBuffer();
+	} finally {
 
-	// Cache in background (don't block session creation)
-	cacheModel( url, buffer.slice( 0 ) );
+		release();
 
-	return buffer;
+	}
 
 }
 
@@ -219,6 +245,7 @@ self.onmessage = async ( e ) => {
 			if ( e.data.ortRuntimeUrl ) _assetConfig.ortRuntimeUrl = e.data.ortRuntimeUrl;
 			if ( e.data.ortWasmPaths ) _assetConfig.ortWasmPaths = e.data.ortWasmPaths;
 			if ( e.data.cacheNamespace ) _assetConfig.cacheNamespace = e.data.cacheNamespace;
+			if ( e.data.storage !== undefined ) _assetConfig.storage = e.data.storage;
 			await loadModel( e.data.url, e.data.sessionOptions );
 
 		} else if ( type === 'infer' ) {

package/src/Processor/Workers/BVHWorker.js

@@ -1,4 +1,5 @@
 import { BVHBuilder } from '../BVHBuilder.js';
+import { foldLeaves } from '../BVHLeafFold.js';
 import { createLogger, fmt, applyWorkerLogLevel } from '../../utils/Logger.js';
 
 const log = createLogger( 'bvh' );
@@ -133,7 +134,7 @@ function handleAssemble( data ) {
 	const {
 		topFlatData, topNodeCount, frontierMap, subtreeResults,
 		sharedTriangleData, sharedIndices, sharedReorderBuffer,
-		triangleCount
+		triangleCount, foldLeaves: fold
 	} = data;
 
 	try {
@@ -142,20 +143,22 @@ function handleAssemble( data ) {
 		const builder = new BVHBuilder();
 
 		// Assemble the final BVH
-		const bvhData = builder.assembleParallelBVH(
-			topFlatData, topNodeCount, frontierMap, subtreeResults
-		);
+		const assembled = builder.assembleParallelBVH( topFlatData, topNodeCount, frontierMap, subtreeResults );
+		const bvhData = fold ? foldLeaves( assembled ) : assembled;
 
-		// Reorder triangles using final indices from SharedArrayBuffer
 		const indices = new Uint32Array( sharedIndices );
-		const src = new Uint32Array( sharedTriangleData );
-		const dst = new Uint32Array( sharedReorderBuffer );
+		if ( sharedReorderBuffer ) {
 
-		for ( let i = 0; i < triangleCount; i ++ ) {
+			const src = new Uint32Array( sharedTriangleData );
+			const dst = new Uint32Array( sharedReorderBuffer );
+
+			for ( let i = 0; i < triangleCount; i ++ ) {
+
+				const srcOff = indices[ i ] * FPT;
+				const dstOff = i * FPT;
+				dst.set( src.subarray( srcOff, srcOff + FPT ), dstOff );
 
-			const srcOff = indices[ i ] * FPT;
-			const dstOff = i * FPT;
-			dst.set( src.subarray( srcOff, srcOff + FPT ), dstOff );
+			}
 
 		}
 
@@ -190,7 +193,7 @@ function handleAssemble( data ) {
 
 function handleFullBuild( data ) {
 
-	const { triangleData, triangleByteOffset, triangleByteLength, depth, reportProgress, treeletOptimization, reinsertionOptimization, sharedReorderBuffer, maxLeafSize, numBins, maxBins, minBins } = data;
+	const { triangleData, triangleByteOffset, triangleByteLength, depth, reportProgress, treeletOptimization, reinsertionOptimization, sharedReorderBuffer, maxLeafSize, numBins, maxBins, minBins, foldLeaves: fold } = data;
 	const builder = new BVHBuilder();
 	// Honor the build params forwarded from SceneProcessor (previously ignored → default leaf 8).
 	if ( maxLeafSize !== undefined ) builder.maxLeafSize = maxLeafSize;
@@ -229,7 +232,8 @@ function handleFullBuild( data ) {
 		const bvhRoot = builder.buildSync( inputTriangles, depth, progressCallback, reorderTarget );
 
 		const flattenStart = performance.now();
-		const bvhData = builder.flattenBVH( bvhRoot );
+		const flat = builder.flattenBVH( bvhRoot );
+		const bvhData = fold ? foldLeaves( flat ) : flat;
 		const flattenTime = performance.now() - flattenStart;
 		log.debug( `flatten ${fmt.ms( flattenTime )} (${fmt.mb( bvhData.byteLength )})` );