rayzee 10.0.0 → 11.1.0

package/src/Pipeline/PipelineContext.js

@@ -62,10 +62,6 @@ export class PipelineContext {
 			// Time
 			time: 0,
 			deltaTime: 0,
-
-			// Feature flags
-			enableASVGF: false,
-			enableEdgeFiltering: false,
 			// Can be extended by stages as needed
 		};
 

package/src/Platform.js

@@ -41,6 +41,14 @@ export function hardwareThreads() {
 
 }
 
+/** Whether images can be decoded: by the host's `decodeImage`, or the browser's own (a canvas or `createImageBitmap`). */
+export function hasImageDecoder() {
+
+	return !! platform.decodeImage
+		|| ( typeof self !== 'undefined' && ( typeof createImageBitmap !== 'undefined' || typeof document !== 'undefined' ) );
+
+}
+
 /** Whether a worker can be started at all: the browser's or the host's. */
 export function hasWorkers() {
 
@@ -53,6 +61,34 @@ export function hasWorkers() {
  * themselves, so the host's class stands in for it while one is constructed.
  * @param {new ( options?: Object ) => Worker} WorkerClass
  */
+let lent = 0;
+
+/**
+ * Runs `task` with the host's Worker as the global `Worker`, for code outside the engine that starts its
+ * own after awaiting — three's DRACOLoader and KTX2Loader, during a glTF parse. Lent only where there is
+ * no global one (a browser keeps its own); overlapping tasks share one loan.
+ * @template T
+ * @param {() => Promise<T>} task
+ * @returns {Promise<T>}
+ */
+export async function withHostWorker( task ) {
+
+	if ( ! platform.Worker || ( lent === 0 && typeof globalThis.Worker !== 'undefined' ) ) return task();
+
+	if ( lent ++ === 0 ) globalThis.Worker = platform.Worker;
+
+	try {
+
+		return await task();
+
+	} finally {
+
+		if ( -- lent === 0 && globalThis.Worker === platform.Worker ) delete globalThis.Worker;
+
+	}
+
+}
+
 export function createWorker( WorkerClass, options ) {
 
 	const Host = platform.Worker;

package/src/Processor/ArchiveCache.js

@@ -1,5 +1,5 @@
 import { createTarIndexer } from './ArchiveReader.js';
-import { ENGINE_AREAS } from '../Storage/StorageManager.js';
+import { ENGINE_AREAS } from '../Storage/areas.js';
 import { fileIdentity, identityKey } from '../Storage/identity.js';
 import { ISSUE_CODES } from '../EngineIssues.js';
 
@@ -16,30 +16,43 @@ export async function archiveKey( kind, file ) {
 /**
  * Decompresses a .tar.gz into storage once, indexing it on the way, and hands back the unpacked
  * .tar as a seekable File. A second call for the same file skips the work.
+ *
+ * With `filter` (and `part`, naming what it keeps) only the entries it keeps are written, end to end, and only they
+ * get offsets in the listing: a 31 GB scene archive need not fit to load the part of it chosen. An unpack of the whole
+ * archive serves any part.
  * @returns {Promise<?{file: File, index: {v:number, listing:Array}, release: function(): void, cached: boolean}>}
  *   null when storage cannot take it — the caller reads the archive the old way.
  */
-export async function unpackTarGz( file, { storage, label = file.name, onProgress = null } ) {
+export async function unpackTarGz( file, { storage, label = file.name, onProgress = null, filter = null, part = null } ) {
 
 	if ( ! storage || typeof DecompressionStream === 'undefined' ) return null;
 
 	const area = storage.area( ENGINE_AREAS.ARCHIVES );
-	const key = await archiveKey( 'gunzip', file );
+	const whole = await archiveKey( 'gunzip', file );
+	let key = whole;
 
-	let entry = await area.open( key );
+	let entry = await area.open( whole );
+	if ( ! entry && filter ) entry = await area.open( key = `${whole}|${part}` );
 	const cached = !! entry;
 
 	if ( ! entry ) {
 
-		const writer = await area.create( key, { label, expectedBytes: file.size * GUESSED_EXPANSION } );
+		// A part's size is known only once its headers are read: a write past the quota falls back below.
+		const writer = await area.create( key, filter ? { label: `${label} (${part})` } : { label, expectedBytes: file.size * GUESSED_EXPANSION } );
 		if ( ! writer ) return null;
 
-		const indexer = createTarIndexer();
+		let out = null;
+		const indexer = createTarIndexer( filter ? { filter, sink: ( bytes ) => out.enqueue( bytes ) } : {} );
 		const tap = new TransformStream( {
+			start( controller ) {
+
+				out = controller;
+
+			},
 			transform( chunk, controller ) {
 
 				indexer.push( chunk );
-				controller.enqueue( chunk );
+				if ( ! filter ) controller.enqueue( chunk );
 
 			},
 		} );