rayzee 11.1.0 → 11.2.0

package/dist/{sceneCachePolicy-C67jbci-.js → sceneCachePolicy-DA7iGoL4.js}

@@ -124,7 +124,7 @@ function w(e, t, n) {
 	let r = n ? new e(new SharedArrayBuffer(t * e.BYTES_PER_ELEMENT)) : new e(t);
 	return S && r.byteLength > 0 && S(r.byteLength, n), r;
 }
-var T = class e {
+var ee = class e {
 	constructor(e, t, n, r = b, i = !1) {
 		let a = t * n.BYTES_PER_ELEMENT, o = Math.max(1, Math.floor(r / a));
 		this.recordCount = e, this.lanesPerRecord = t, this.LaneType = n, this.recordsPerChunk = e <= o ? Math.max(e, 1) : o, this.shared = i, this.chunks = [];
@@ -288,31 +288,73 @@ var T = class e {
 		let n = (e) => new t(e.buffer, e.byteOffset, e.byteLength / t.BYTES_PER_ELEMENT), r = e.adopt(this.chunks.map((e) => e ? n(e) : void 0), this.recordCount, this.lanesPerRecord, this.recordsPerChunk);
 		return r.LaneType = t, r._owner = this, this._views ? this._views.push(r) : (this._weakViews ??= []).push(new WeakRef(r)), r._spilled = this._spilled ??= /* @__PURE__ */ new Set(), r;
 	}
-}, E = 5;
-function D(e, t) {
+}, T = {
+	Worker: null,
+	decodeImage: null
+};
+function E(e) {
+	e && Object.assign(T, e);
+}
+function D() {
+	return T;
+}
+function O() {
+	return typeof navigator < "u" && navigator.hardwareConcurrency || 4;
+}
+function k() {
+	return !!T.decodeImage || typeof self < "u" && (typeof createImageBitmap < "u" || typeof document < "u");
+}
+function A() {
+	return !!T.Worker || typeof Worker < "u";
+}
+var j = 0;
+async function M(e) {
+	if (!T.Worker || j === 0 && globalThis.Worker !== void 0) return e();
+	j++ === 0 && (globalThis.Worker = T.Worker);
+	try {
+		return await e();
+	} finally {
+		--j === 0 && globalThis.Worker === T.Worker && delete globalThis.Worker;
+	}
+}
+function N(e, t) {
+	let n = T.Worker;
+	if (!n) return new e(t);
+	let r = Object.prototype.hasOwnProperty.call(globalThis, "Worker"), i = globalThis.Worker;
+	globalThis.Worker = n;
+	try {
+		return new e(t);
+	} finally {
+		r ? globalThis.Worker = i : delete globalThis.Worker;
+	}
+}
+//#endregion
+//#region src/Storage/CDFCache.js
+var P = 5;
+function F(e, t) {
 	e && t && (e.userData.__rayzeeSource = t);
 }
-function O(e) {
+function I(e) {
 	let t = e?.userData?.__rayzeeSource;
 	if (!t) return null;
 	let { width: n = 0, height: r = 0 } = e.image ?? {};
-	return `cdf:${E}:${t}|${n}x${r}|${e.userData.__rayzeeColorSpace ?? "native"}`;
+	return `cdf:${P}:${t}|${n}x${r}|${e.userData.__rayzeeColorSpace ?? "native"}`;
 }
-var k = () => n(i().cacheNamespace)?.area(r.CDF) ?? null, A = [
+var L = () => n(i().cacheNamespace)?.area(r.CDF) ?? null, R = [
 	"exactConditional",
 	"exactMarginal",
 	"exactRowGuide",
 	"exactMarginalGuide"
-], j = A.map((e) => `${e}.f32`);
-async function M(e) {
-	let t = O(e), n = t ? await k()?.open(t) : null;
+], z = R.map((e) => `${e}.f32`);
+async function B(e) {
+	let t = I(e), n = t ? await L()?.open(t) : null;
 	if (!n) return null;
 	try {
-		let e = await Promise.all(j.map((e) => n.file(e)));
+		let e = await Promise.all(z.map((e) => n.file(e)));
 		if (e.some((e) => !e)) return null;
 		let t = await Promise.all(e.map(async (e) => new Float32Array(await e.arrayBuffer()))), { totalSum: r, width: i, height: a, exactWidth: o, exactHeight: s, radianceIntegral: c } = n.extra;
 		return {
-			...Object.fromEntries(A.map((e, n) => [e, t[n]])),
+			...Object.fromEntries(R.map((e, n) => [e, t[n]])),
 			totalSum: r,
 			width: i,
 			height: a,
@@ -324,8 +366,8 @@ async function M(e) {
 		n.release();
 	}
 }
-async function N(e, t) {
-	let { totalSum: n, width: r, height: i, exactWidth: a, exactHeight: o, radianceIntegral: s } = t, c = A.map((e) => t[e]), l = O(e), u = l ? k() : null;
+async function te(e, t) {
+	let { totalSum: n, width: r, height: i, exactWidth: a, exactHeight: o, radianceIntegral: s } = t, c = R.map((e) => t[e]), l = I(e), u = l ? L() : null;
 	if (!u || c.some((e) => !e)) return !1;
 	let d = await u.create(l, {
 		label: e.name || "environment",
@@ -333,7 +375,7 @@ async function N(e, t) {
 	});
 	if (!d) return !1;
 	try {
-		for (let e = 0; e < j.length; e++) await d.write(j[e], c[e]);
+		for (let e = 0; e < z.length; e++) await d.write(z[e], c[e]);
 		return await d.commit({
 			totalSum: n,
 			width: r,
@@ -348,8 +390,8 @@ async function N(e, t) {
 }
 //#endregion
 //#region src/Processor/HostMemory.js
-var P = t.FLOATS_PER_TRIANGLE * 4, F = 64, I = .9, L = 64, R = 4, z = 1536 * 1024 * 1024, B = 7040 * 1024 * 1024, V = 9216 * 1024 * 1024, H = 6e7, U = 8e6;
-function W(e) {
+var V = t.FLOATS_PER_TRIANGLE * 4, H = 64, U = .9, W = 64, G = 4, K = 1536 * 1024 * 1024, q = 7040 * 1024 * 1024, J = 9216 * 1024 * 1024, Y = 6e7, X = 8e6;
+function Z(e) {
 	if (e > 0) return {
 		gb: e,
 		assumed: !1
@@ -363,19 +405,19 @@ function W(e) {
 		assumed: !0
 	};
 }
-var G = 1.15, K = 12 * 1024 * 1024 * 1024;
-function q({ triangles: e, placements: t, geometryBytes: n = 0 }) {
+var Q = 1.15, ne = 12 * 1024 * 1024 * 1024;
+function re({ triangles: e, placements: t, geometryBytes: n = 0 }) {
 	let r = {
-		triangles: e * P,
-		bvh: Math.ceil(e * I) * F,
+		triangles: e * V,
+		bvh: Math.ceil(e * U) * H,
 		geometry: n,
-		placements: t * L,
-		orderMaps: e * R
+		placements: t * W,
+		orderMaps: e * G
 	};
 	return r.total = r.triangles + r.bvh + r.geometry + r.placements + r.orderMaps, r;
 }
-function J(e, { chunkBytes: t = b, shared: n = !1, allocate: r = null } = {}) {
-	let i = Math.min(e, K), a = r ?? (n ? (e) => new SharedArrayBuffer(e) : (e) => new ArrayBuffer(e)), o = [], s = 0;
+function ie(e, { chunkBytes: t = b, shared: n = !1, allocate: r = null } = {}) {
+	let i = Math.min(e, ne), a = r ?? (n ? (e) => new SharedArrayBuffer(e) : (e) => new ArrayBuffer(e)), o = [], s = 0;
 	try {
 		for (; s < i;) {
 			let e = Math.min(t, i - s);
@@ -390,7 +432,7 @@ function J(e, { chunkBytes: t = b, shared: n = !1, allocate: r = null } = {}) {
 		capped: e > i
 	};
 }
-var Y = class {
+var ae = class {
 	constructor() {
 		this.reset();
 	}
@@ -435,9 +477,9 @@ var Y = class {
 			samples: this.samples.slice()
 		};
 	}
-}, X = "11.1.0", Z = 1e4, Q = 15e5;
-function $(e, t, n = Z) {
-	return e >= n && t / Q < e / 3;
+}, oe = "11.2.0", $ = 1e4, se = 15e5;
+function ce(e, t, n = $) {
+	return e >= n && t / se < e / 3;
 }
 //#endregion
-export { c as A, g as C, s as D, u as E, o as O, y as S, m as T, T as _, Y as a, C as b, B as c, W as d, q as f, D as g, N as h, V as i, l as j, _ as k, U as l, M as m, $ as n, z as o, J as p, X as r, G as s, Z as t, H as u, b as v, h as w, v as x, x as y };
+export { g as A, M as C, C as D, x as E, o as F, _ as I, c as L, m as M, u as N, v as O, s as P, l as R, A as S, b as T, E as _, ae as a, O as b, q as c, Z as d, re as f, F as g, te as h, J as i, h as j, y as k, X as l, B as m, ce as n, K as o, ie as p, oe as r, Q as s, $ as t, Y as u, N as v, ee as w, k as x, D as y };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rayzee",
-  "version": "11.1.0",
+  "version": "11.2.0",
   "type": "module",
   "description": "Real-time WebGPU path tracing engine built on Three.js",
   "main": "dist/rayzee.umd.js",

package/src/EngineDefaults.js

@@ -77,7 +77,7 @@ export const ENGINE_DEFAULTS = deepFreeze( {
 
 	// Read when a model loads
 	maxTextureSize: 4096, // longest edge of a material texture; clamped to the hardware ceiling
-	areaLightIntensityScale: 0.1, // power of a glTF model's placeholder area lights (RectAreaLight extras)
+	areaLightIntensityScale: 1, // power of a glTF model's placeholder area lights (RectAreaLight extras)
 
 	// Debug
 	visMode: 0, // a debug view (TSL/Debugger.js); 0 renders normally

package/src/PathTracerApp.js

@@ -461,6 +461,7 @@ export class PathTracerApp extends RayzeeRenderer {
 
 		this._syncControlsAfterLoad();
 		this.cameraManager.currentCameraIndex = 0;
+		if ( this.cameraManager.cameras.length > 1 ) this.cameraManager.switchCamera( 1 );
 
 	}
 

package/src/Processor/ArchiveImporter.js

@@ -12,11 +12,11 @@ import { HDRLoader } from 'three/addons/loaders/HDRLoader.js';
 import { EXRLoader } from 'three/addons/loaders/EXRLoader.js';
 import { zipSync, strFromU8 } from 'three/addons/libs/fflate.module.js';
 import {
-	detectArchiveKind, readTarGz, elementFilter, listArchiveElements, openTar, indexTarHeaders } from './ArchiveReader.js';
+	detectArchiveKind, readTarGz, elementFilter, listArchiveElements, openTar, indexTarHeaders, openFolder } from './ArchiveReader.js';
 import { openZip, readZipDirectory } from './ZipReader.js';
 import { unpackTarGz, loadTarIndex, saveTarIndex } from './ArchiveCache.js';
 import { setEnvironmentSource } from '../Storage/CDFCache.js';
-import { fileIdentity, identityKey, sampleHash } from '../Storage/identity.js';
+import { fileIdentity, folderIdentity, identityKey, sampleHash } from '../Storage/identity.js';
 import { ENGINE_AREAS } from '../Storage/areas.js';
 import { encodeSceneGraph, writeSceneGraph, decodeSceneGraph, SceneGraphUnsupported, SCENE_GRAPH_FORMAT, ARCHIVE_PATH, ARCHIVE_LOADER } from '../Storage/SceneGraphCodec.js';
 import { worthStoring } from '../Storage/sceneCachePolicy.js';
@@ -27,12 +27,40 @@ import { pfmTexture } from './PBRT/PFM.js';
 import { extractSceneMetadata } from './SceneMetadata.js';
 import { ISSUE_CODES, ISSUE_SEVERITY } from '../EngineIssues.js';
 import { ARCHIVE_FORMATS } from './archiveFormats.js';
+import { withHostWorker } from '../Platform.js';
 
 // Loose USD layers inside a ZIP compose into one scene; these pick out the
 // layers and the image assets they reference.
 const USD_LAYER_RE = /\.(usd|usda|usdc)$/i;
 const USD_IMAGE_RE = /\.(png|jpg|jpeg|avif)$/i;
 const MTL_TEXTURE_TIMEOUT_MS = 30000;
+const MAIN_MODEL_FILES = [ 'scene.gltf', 'scene.glb', 'model.gltf', 'model.glb', 'main.gltf', 'main.glb', 'asset.gltf', 'asset.glb' ];
+
+// An entry is bytes already read, or a Blob read only when a loader asks for it.
+const asBlob = entry => ( entry instanceof Blob ? entry : new Blob( [ entry ], { type: 'application/octet-stream' } ) );
+const bytesOf = async entry => ( entry instanceof Blob ? new Uint8Array( await entry.arrayBuffer() ) : entry );
+const textOf = async entry => ( entry instanceof Blob ? entry.text() : strFromU8( entry ) );
+const joinPath = ( dir, ref ) => {
+
+	const out = [];
+	for ( const part of `${dir}/${ref}`.split( '/' ) ) {
+
+		if ( part === '..' ) out.pop();
+		else if ( part && part !== '.' ) out.push( part );
+
+	}
+
+	return out.join( '/' );
+
+};
+
+const bufferOf = async entry => {
+
+	const bytes = await bytesOf( entry );
+	return bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength ? bytes.buffer : bytes.slice().buffer;
+
+};
+
 /**
  * Unpacked size past which a multi-part scene archive asks which parts to load rather than
  * taking all of them. Not a hard limit — picking every part is a valid answer.
@@ -227,6 +255,29 @@ export class ArchiveImporter {
 
 	}
 
+	/**
+	 * Loads a folder as it would the same folder zipped — a glTF with its .bin and textures, an OBJ with its
+	 * materials, a pbrt scene — reading each file only when the scene asks for it.
+	 * @param {{name: string, files: Array<{path: string, file: Blob}>}} folder - from `localFolder`
+	 * @param {object} [options] - `element`, `pbrtEntry`, `promptBytes` and the pbrt options, as loadArchiveFromFile
+	 */
+	async loadFolder( folder, { pbrtEntry = null, element = null, promptBytes, ...pbrt } = {} ) {
+
+		const chosen = ( Array.isArray( element ) ? element : [ element ] ).filter( Boolean );
+		const source = openFolder( folder, { filter: chosen.length ? elementFilter( chosen ) : null } );
+		const totalBytes = source.listing.reduce( ( n, e ) => n + e.size, 0 );
+		if ( chosen.length === 0 ) this._requireElementChoice( folder.name, source.listing, totalBytes, promptBytes );
+
+		console.info(
+			`Folder "${folder.name}": ${source.listing.length} files, ${( totalBytes / 1e9 ).toFixed( 1 )} GB` +
+			( chosen.length ? `, ${chosen.length} part${chosen.length > 1 ? 's' : ''} selected.` : '.' )
+		);
+
+		const archiveId = this.loader.storage ? identityKey( await folderIdentity( folder ) ) : null;
+		return await this._loadSource( source, folder.name, { element, pbrtEntry, pbrt, archiveId, kind: 'folder' } );
+
+	}
+
 	async _loadNonPBRTArchive( entries, filename ) {
 
 		const result = await this.processObjMtlPairsInZip( entries, filename );
@@ -243,6 +294,13 @@ export class ArchiveImporter {
 	async _loadSeekable( file, filename, { element, promptBytes, pbrtEntry, pbrt, index = null, zip = false, archiveId = null } ) {
 
 		const source = await this._openSeekableArchive( file, filename, element, promptBytes, { index, zip } );
+		return await this._loadSource( source, filename, { element, pbrtEntry, pbrt, archiveId } );
+
+	}
+
+	/** Loads what an opened archive or folder holds. @private */
+	async _loadSource( source, filename, { element, pbrtEntry, pbrt, archiveId, kind = 'archive' } ) {
+
 		source.archiveId = archiveId;
 		source.elements = ( Array.isArray( element ) ? element : [ element ] ).filter( Boolean );
 		if ( source.listing.some( e => e.path.toLowerCase().endsWith( '.pbrt' ) ) ) {
@@ -251,10 +309,10 @@ export class ArchiveImporter {
 
 		}
 
-		// Not a pbrt scene: fall back to materialising it, which those paths still expect.
-		for ( const e of source.listing ) if ( e.offset !== undefined ) source.entries[ e.path ] ??= await source.read( e.path );
-		const result = await this._loadNonPBRTArchive( source.entries, filename );
-		this.loader._sourceKey = this.loader._keyed( 'archive', archiveId );
+		const entries = Object.create( null );
+		for ( const e of source.listing ) if ( e.offset !== undefined ) entries[ e.path ] = source.entries[ e.path ] ?? await source.slice( e.path );
+		const result = await this._loadNonPBRTArchive( entries, filename );
+		this.loader._sourceKey = this.loader._keyed( kind, archiveId );
 		return result;
 
 	}
@@ -691,7 +749,7 @@ export class ArchiveImporter {
 		updateLoading( { isLoading: true, status: 'Processing PBRT geometry...', progress: 10 } );
 		await this.loader.onModelLoad( this.loader.targetModel );
 
-		this.loader.dispatchEvent( { type: 'load', model: group, filename: `${loadedEntry} (from ZIP)` } );
+		this.loader.dispatchEvent( { type: 'load', model: group, filename: `${loadedEntry} (from ${filename})` } );
 		return group;
 
 	}
@@ -833,42 +891,38 @@ export class ArchiveImporter {
 
 	}
 
-	async findAndLoadModelFromZip( zip ) {
+	async findAndLoadModelFromZip( zip, filename = 'the ZIP archive' ) {
 
-		const mainModelFiles = [
-			'scene.gltf', 'scene.glb', 'model.gltf', 'model.glb',
-			'main.gltf', 'main.glb', 'asset.gltf', 'asset.glb'
-		];
-
-		for ( const mainFile of mainModelFiles ) {
+		const paths = Object.keys( zip );
+		const top = paths[ 0 ]?.split( '/' )[ 0 ];
+		const root = top !== undefined && paths.every( p => p.startsWith( top + '/' ) ) ? top + '/' : '';
+		const models = paths.filter( p => p.split( '.' ).pop().toLowerCase() === 'obj' || this.loader.getFileFormat( p )?.type === 'model' );
+		if ( models.length === 0 ) throw new Error( `No supported model files found in ${filename}` );
 
-			if ( zip[ mainFile ] ) {
+		// Shallowest first, glTF before other formats at the same depth.
+		const rank = p => p.split( '/' ).length * 2 + ( /\.(gltf|glb)$/i.test( p ) ? 0 : 1 );
+		const main = MAIN_MODEL_FILES.map( name => root + name ).find( p => zip[ p ] );
+		const path = main ?? models.reduce( ( best, p ) => ( rank( p ) < rank( best ) ? p : best ) );
 
-				console.log( `Found main model file: ${mainFile}` );
-				const extension = mainFile.split( '.' ).pop().toLowerCase();
-				return await this.loadModelFromZipEntry( zip[ mainFile ], mainFile, extension, zip );
-
-			}
+		// A loose layer is only one slice of a USD scene — hand the whole
+		// archive over so its references and payloads can resolve.
+		if ( ! main && USD_LAYER_RE.test( path ) ) return await this.loadUSDHierarchyFromZip( zip );
 
-		}
-
-		for ( const path in zip ) {
-
-			const extension = path.split( '.' ).pop().toLowerCase();
-			if ( extension === 'obj' || this.loader.getFileFormat( path )?.type === 'model' ) {
-
-				// A loose layer is only one slice of a USD scene — hand the whole
-				// archive over so its references and payloads can resolve.
-				if ( USD_LAYER_RE.test( path ) ) return await this.loadUSDHierarchyFromZip( zip );
-
-				console.log( `Loading model file from ZIP: ${path}` );
-				return await this.loadModelFromZipEntry( zip[ path ], path, extension, zip );
+		const others = models.filter( p => p !== path && ! USD_LAYER_RE.test( p ) );
+		if ( others.length > 0 ) {
 
-			}
+			console.warn( `${filename} holds ${others.length + 1} models; loaded "${path}". Others: ${others.join( ', ' )}` );
+			this.loader._issues?.record(
+				ISSUE_CODES.ASSET_AMBIGUOUS_ENTRY,
+				`${filename} holds ${others.length + 1} models; loaded "${path}"`,
+				{ loaded: path, alternatives: others.slice( 0, 50 ) },
+				ISSUE_SEVERITY.WARNING
+			);
 
 		}
 
-		throw new Error( 'No supported model files found in the ZIP archive' );
+		console.log( `Loading model file from ${filename}: ${path}` );
+		return await this.loadModelFromZipEntry( zip[ path ], path, path.split( '.' ).pop().toLowerCase(), zip, filename );
 
 	}
 
@@ -883,11 +937,11 @@ export class ArchiveImporter {
 		const root = ArchiveImporter._pickUSDRootLayer( layers );
 		console.log( `Loading USD scene from ZIP: ${root} (${layers.length} layers)` );
 
-		const packed = { [ root ]: [ zip[ root ], { level: 0 } ] };
+		const packed = { [ root ]: [ await bytesOf( zip[ root ] ), { level: 0 } ] };
 		for ( const name of Object.keys( zip ) ) {
 
 			if ( name === root ) continue;
-			if ( USD_LAYER_RE.test( name ) || USD_IMAGE_RE.test( name ) ) packed[ name ] = [ zip[ name ], { level: 0 } ];
+			if ( USD_LAYER_RE.test( name ) || USD_IMAGE_RE.test( name ) ) packed[ name ] = [ await bytesOf( zip[ name ] ), { level: 0 } ];
 
 		}
 
@@ -914,13 +968,11 @@ export class ArchiveImporter {
 
 	}
 
-	async loadModelFromZipEntry( fileContent, filePath, extension, zipContents ) {
+	async loadModelFromZipEntry( fileContent, filePath, extension, zipContents, from = 'ZIP' ) {
 
 		try {
 
-			updateLoading( { isLoading: true, status: `Processing ${extension.toUpperCase()} from ZIP...`, progress: 5 } );
-			const blob = new Blob( [ fileContent.buffer ], { type: 'application/octet-stream' } );
-			const blobUrl = URL.createObjectURL( blob );
+			updateLoading( { isLoading: true, status: `Processing ${extension.toUpperCase()} from ${from}...`, progress: 5 } );
 			let result;
 
 			switch ( extension ) {
@@ -937,17 +989,16 @@ export class ArchiveImporter {
 
 			}
 
-			URL.revokeObjectURL( blobUrl );
 			this.loader.dispatchEvent( {
 				type: 'load',
 				model: this.loader.targetModel,
-				filename: `${filePath} (from ZIP)`
+				filename: `${filePath} (from ${from})`
 			} );
 			return result;
 
 		} catch ( error ) {
 
-			console.error( `Error loading ${extension} from ZIP:`, error );
+			console.error( `Error loading ${extension} from ${from}:`, error );
 			this.loader.dispatchEvent( { type: 'error', message: error.message, filename: filePath } );
 			throw error;
 
@@ -959,7 +1010,7 @@ export class ArchiveImporter {
 
 		if ( extension === 'gltf' ) {
 
-			const gltfContent = strFromU8( fileContent );
+			const gltfContent = await textOf( fileContent );
 			const manager = new LoadingManager();
 			const gltfDir = filePath.split( '/' ).slice( 0, - 1 ).join( '/' );
 
@@ -969,32 +1020,13 @@ export class ArchiveImporter {
 
 			try {
 
-				return await new Promise( ( resolve, reject ) => {
-
-					loader.parse( gltfContent, '',
-						gltf => {
-
-							try {
-
-								this.loader._throwDeferred();
-
-							} catch ( error ) {
-
-								reject( error );
-								return;
-
-							}
-
-							this.loader.releaseTargetModel();
-							this.loader.targetModel = gltf.scene;
-							this.loader.sceneMetadata = extractSceneMetadata( gltf );
-							this.loader.onModelLoad( this.loader.targetModel ).then( () => resolve( gltf ) );
-
-						},
-						error => reject( error )
-					);
-
-				} );
+				const gltf = await withHostWorker( () => new Promise( ( resolve, reject ) => loader.parse( gltfContent, '', resolve, reject ) ) );
+				this.loader._throwDeferred();
+				this.loader.releaseTargetModel();
+				this.loader.targetModel = gltf.scene;
+				this.loader.sceneMetadata = extractSceneMetadata( gltf );
+				await this.loader.onModelLoad( this.loader.targetModel );
+				return gltf;
 
 			} finally {
 
@@ -1004,7 +1036,7 @@ export class ArchiveImporter {
 
 		} else {
 
-			return await this.loader.loadGLBFromArrayBuffer( fileContent.buffer, filePath );
+			return await this.loader.loadGLBFromArrayBuffer( await bufferOf( fileContent ), filePath );
 
 		}
 
@@ -1012,7 +1044,7 @@ export class ArchiveImporter {
 
 	async handleObjFromZip( fileContent, filePath, zipContents ) {
 
-		const objContent = strFromU8( fileContent );
+		const objContent = await textOf( fileContent );
 		const mtlMatch = objContent.match( /mtllib\s+([^\s]+)/ );
 		let materials = null;
 
@@ -1100,7 +1132,7 @@ export class ArchiveImporter {
 			if ( zipContents[ path ] ) {
 
 				const { MTLLoader } = await import( 'three/examples/jsm/loaders/MTLLoader.js' );
-				const mtlContent = strFromU8( zipContents[ path ] );
+				const mtlContent = await textOf( zipContents[ path ] );
 				const manager = new LoadingManager();
 				manager.setURLModifier( url => this.resolveZipResource( url, objDir, zipContents ) );
 				const mtlLoader = new MTLLoader( manager );
@@ -1118,25 +1150,30 @@ export class ArchiveImporter {
 
 	resolveZipResource( url, baseDir, zipContents ) {
 
-		const normalizedUrl = url.replace( /^\.\/|^\//, '' );
-		const possiblePaths = [
-			normalizedUrl,
-			`${baseDir}/${normalizedUrl}`,
-			normalizedUrl.split( '/' ).pop()
-		];
+		if ( /^(data|blob|https?):/i.test( url ) ) return url;
 
-		for ( const path of possiblePaths ) {
+		const raw = url.replace( /^\.\/|^\//, '' );
+		let decoded = raw;
+		try {
 
-			if ( zipContents[ path ] ) {
+			decoded = decodeURIComponent( raw );
 
-				const fileBlob = new Blob( [ zipContents[ path ].buffer ], { type: 'application/octet-stream' } );
-				return URL.createObjectURL( fileBlob );
+		} catch {
 
-			}
+			// a literal '%'
+
+		}
+
+		for ( const ref of new Set( [ raw, decoded ] ) ) {
+
+			const name = ref.split( '/' ).pop();
+			const path = [ joinPath( baseDir, ref ), ref, name ].find( p => zipContents[ p ] )
+				?? ( name ? Object.keys( zipContents ).find( p => p.endsWith( `/${name}` ) ) : undefined );
+			if ( path ) return URL.createObjectURL( asBlob( zipContents[ path ] ) );
 
 		}
 
-		console.warn( `Resource not found in ZIP: ${url}` );
+		console.warn( `Resource not found in the archive: ${url}` );
 		return url;
 
 	}
@@ -1151,13 +1188,13 @@ export class ArchiveImporter {
 		const mtlDir = mtlFile.path.split( '/' ).slice( 0, - 1 ).join( '/' );
 
 		manager.setURLModifier( url => this.resolveTextureInZip( url, objDir, mtlDir, mtlFile, zip, createdUrls ) );
-		const mtlContent = this.prepareFixedMtlContent( mtlFile );
+		const mtlContent = await this.prepareFixedMtlContent( mtlFile );
 		const materials = new MTLLoader( manager ).parse( mtlContent, mtlDir );
 		await this.preloadMtlTextures( materials );
 
 		const objLoader = new OBJLoader( manager );
 		objLoader.setMaterials( materials );
-		const objContent = strFromU8( objFile.content );
+		const objContent = await textOf( objFile.content );
 		const object = objLoader.parse( objContent );
 
 		this.loader.releaseTargetModel();
@@ -1175,9 +1212,9 @@ export class ArchiveImporter {
 
 	}
 
-	prepareFixedMtlContent( mtlFile ) {
+	async prepareFixedMtlContent( mtlFile ) {
 
-		const mtlContent = strFromU8( mtlFile.content );
+		const mtlContent = await textOf( mtlFile.content );
 		return mtlContent
 			.replace( new RegExp( `${mtlFile.path.split( '/' ).pop()}\\s+`, 'g' ), ' ' )
 			.replace( /([a-zA-Z_]+)([\\/])/g, '$1 $2' );
@@ -1210,8 +1247,7 @@ export class ArchiveImporter {
 
 			if ( zip[ location ] ) {
 
-				const blob = new Blob( [ zip[ location ].buffer ], { type: 'application/octet-stream' } );
-				const blobUrl = URL.createObjectURL( blob );
+				const blobUrl = URL.createObjectURL( asBlob( zip[ location ] ) );
 				createdUrls.push( blobUrl );
 				return blobUrl;
 
@@ -1231,8 +1267,7 @@ export class ArchiveImporter {
 
 			if ( zipPath.endsWith( textureFilename ) ) {
 
-				const blob = new Blob( [ zip[ zipPath ].buffer ], { type: 'application/octet-stream' } );
-				const blobUrl = URL.createObjectURL( blob );
+				const blobUrl = URL.createObjectURL( asBlob( zip[ zipPath ] ) );
 				createdUrls.push( blobUrl );
 				return blobUrl;
 
@@ -1247,8 +1282,7 @@ export class ArchiveImporter {
 				const zipFilename = zipPath.split( '/' ).pop();
 				if ( zipFilename.includes( textureFilename ) || textureFilename.includes( zipFilename ) ) {
 
-					const blob = new Blob( [ zip[ zipPath ].buffer ], { type: 'application/octet-stream' } );
-					const blobUrl = URL.createObjectURL( blob );
+					const blobUrl = URL.createObjectURL( asBlob( zip[ zipPath ] ) );
 					createdUrls.push( blobUrl );
 					return blobUrl;