@unikia/upe-renderer 0.186.110 → 0.187.11

package/examples/jsm/loaders/IESLoader.js

@@ -5,6 +5,7 @@ import {
 	RedFormat,
 	MathUtils,
 	Loader,
+	RepeatWrapping,
 	UnsignedByteType,
 	LinearFilter,
 	HalfFloatType,
@@ -50,7 +51,7 @@ class IESLoader extends Loader {
 
 	_getIESValues( iesLamp, type ) {
 
-		const width = 360;
+		const width = iesLamp.numHorAngles === 1 ? 1 : 360;
 		const height = 180;
 		const size = width * height;
 
@@ -61,7 +62,7 @@ class IESLoader extends Loader {
 			let phiIndex = 0, thetaIndex = 0;
 			let startTheta = 0, endTheta = 0, startPhi = 0, endPhi = 0;
 
-			for ( let i = 0; i < iesLamp.numHorAngles - 1; ++ i ) { // numHorAngles = horAngles.length-1 because of extra padding, so this wont cause an out of bounds error
+			for ( let i = 0; i < iesLamp.numHorAngles - 1; ++ i ) {
 
 				if ( theta < iesLamp.horAngles[ i + 1 ] || i == iesLamp.numHorAngles - 2 ) {
 
@@ -108,23 +109,32 @@ class IESLoader extends Loader {
 
 		}
 
-		const startTheta = iesLamp.horAngles[ 0 ], endTheta = iesLamp.horAngles[ iesLamp.numHorAngles - 1 ];
+		const endTheta = iesLamp.horAngles[ iesLamp.numHorAngles - 1 ];
 
 		for ( let i = 0; i < size; ++ i ) {
 
-			let theta = i % width;
+			// the horizontal angles cover 0 to 359 degrees
+			const theta = i % width;
 			const phi = Math.floor( i / width );
 
-			if ( endTheta - startTheta !== 0 && ( theta < startTheta || theta >= endTheta ) ) { // Handle symmetry for hor angles
+			let sampleTheta = theta;
 
-				theta %= endTheta * 2;
+ 			// mirror the measured range around the cycle
+ 			if ( endTheta !== 0 && sampleTheta > endTheta ) {
 
-				if ( theta > endTheta )
-					theta = endTheta * 2 - theta;
+				sampleTheta %= endTheta * 2;
+
+				if ( sampleTheta > endTheta ) {
+
+					sampleTheta = endTheta * 2 - sampleTheta;
+
+				}
 
 			}
 
-			data[ phi + theta * height ] = interpolateCandelaValues( phi, theta );
+			// the vertical angles span [0, 180]
+			const samplePhi = phi * 180 / ( height - 1 );
+			data[ phi + theta * height ] = interpolateCandelaValues( samplePhi, sampleTheta );
 
 		}
 
@@ -151,6 +161,8 @@ class IESLoader extends Loader {
 	load( url, onLoad, onProgress, onError ) {
 
 		const loader = new FileLoader( this.manager );
+		loader.setPriority( this.priority );
+		loader.setCache( this.cache );
 		loader.setResponseType( 'text' );
 		loader.setCrossOrigin( this.crossOrigin );
 		loader.setWithCredentials( this.withCredentials );
@@ -178,9 +190,12 @@ class IESLoader extends Loader {
 		const iesLamp = new IESLamp( text );
 		const data = this._getIESValues( iesLamp, type );
 
-		const texture = new DataTexture( data, 180, 1, RedFormat, type );
+		// X holds the vertical angle from 0 to 180 degrees inclusively, Y holds the horizontal
+		// angle from 0 to 359 degrees and wraps around, or a single row for symmetric profiles
+		const texture = new DataTexture( data, 180, data.length / 180, RedFormat, type );
 		texture.minFilter = LinearFilter;
 		texture.magFilter = LinearFilter;
+		texture.wrapT = RepeatWrapping;
 		texture.needsUpdate = true;
 
 		return texture;
@@ -339,16 +354,21 @@ function IESLamp( text ) {
 
 		for ( let j = 0; j < _self.numVerAngles; ++ j ) {
 
-			_self.candelaValues[ i ][ j ] *= _self.candelaValues[ i ][ j ] * _self.multiplier
-				* _self.ballFactor * _self.blpFactor;
+			_self.candelaValues[ i ][ j ] *= _self.multiplier * _self.ballFactor * _self.blpFactor;
 
 		}
 
 	}
 
+	const baseAngle = _self.horAngles[ 0 ];
+
 	let maxVal = - 1;
 	for ( let i = 0; i < _self.numHorAngles; ++ i ) {
 
+		// Shift the measured range to start at 0 so it can be mirrored across the full
+		// cycle when sampling.
+		_self.horAngles[ i ] -= baseAngle;
+
 		for ( let j = 0; j < _self.numVerAngles; ++ j ) {
 
 			const value = _self.candelaValues[ i ][ j ];
@@ -358,6 +378,20 @@ function IESLamp( text ) {
 
 	}
 
+	// A range wider than a half cycle is asymmetric, so it wraps back around to the
+	// first angle. Contrary to the standard some files skip that final 360 entry
+	// because it repeats the first one, which Blender's Cycles works around the same way
+	// https://github.com/blender/blender/blob/main/intern/cycles/util/ies.cpp
+	const endAngle = _self.horAngles[ _self.numHorAngles - 1 ];
+	if ( endAngle > 180 && endAngle < 360 ) {
+
+		_self.horAngles.push( 360 );
+		_self.candelaValues.push( _self.candelaValues[ 0 ].slice() );
+
+		_self.numHorAngles = _self.horAngles.length;
+
+	}
+
 	const bNormalize = true;
 	if ( bNormalize && maxVal > 0 ) {
 

package/examples/jsm/loaders/JXLLoader.js

@@ -0,0 +1,159 @@
+import {
+	DataTexture,
+	FileLoader,
+	HalfFloatType,
+	LinearFilter,
+	LinearSRGBColorSpace,
+	Loader,
+	RGBAFormat
+} from 'three';
+
+/**
+ * Loads HDR JPEG XL images using the browser's native decoder.
+ * Produces half-float textures in linear sRGB. Requires float16 Canvas2D,
+ * the srgb-linear canvas color space and globalHDRHeadroom.
+ *
+ * ```js
+ * const texture = await new JXLLoader().loadAsync( 'image.jxl' );
+ * const material = new THREE.MeshStandardMaterial( { emissive: 0xffffff, emissiveMap: texture } );
+ * ```
+ *
+ * @augments Loader
+ * @three_import import { JXLLoader } from 'three/addons/loaders/JXLLoader.js';
+ */
+class JXLLoader extends Loader {
+
+	/**
+	 * Loads a native HDR image into a half-float data texture.
+	 * @param {string} url - Image URL.
+	 * @param {function(DataTexture)} onLoad - Completion callback.
+	 * @param {Function} onProgress - Download progress callback.
+	 * @param {Function} onError - Error callback.
+	 * @return {DataTexture} Placeholder texture, populated after decoding.
+	 */
+	load( url, onLoad, onProgress, onError ) {
+
+		const texture = new DataTexture( null, 0, 0, RGBAFormat, HalfFloatType );
+		const loader = new FileLoader( this.manager );
+		loader.setPath( this.path );
+		loader.setRequestHeader( this.requestHeader );
+		loader.setWithCredentials( this.withCredentials );
+		loader.setResponseType( 'arraybuffer' );
+
+		// Track decoding so the manager does not finish after the download.
+		this.manager.itemStart( url );
+
+		const onFailure = error => {
+
+			if ( onError ) onError( error );
+			else console.error( error );
+
+			this.manager.itemError( url );
+			this.manager.itemEnd( url );
+
+		};
+
+		loader.load( url, buffer => {
+
+			this._decode( buffer ).then( data => {
+
+				this._applyData( texture, data );
+				if ( onLoad ) onLoad( texture );
+				this.manager.itemEnd( url );
+
+			}, onFailure );
+
+		}, onProgress, onFailure );
+
+		return texture;
+
+	}
+
+	/**
+	 * Decodes image bytes using the browser, preserving maximum HDR headroom.
+	 * @param {ArrayBuffer} buffer - JPEG XL bytes.
+	 * @param {function(DataTexture)} onLoad - Completion callback.
+	 * @param {Function} onError - Error callback.
+	 */
+	parse( buffer, onLoad, onError ) {
+
+		this.parseAsync( buffer ).then( onLoad, onError );
+
+	}
+
+	/**
+	 * Async version of {@link JXLLoader#parse}.
+	 * @param {ArrayBuffer} buffer - JPEG XL bytes.
+	 * @return {Promise<DataTexture>} Half-float texture in linear sRGB.
+	 */
+	async parseAsync( buffer ) {
+
+		const data = await this._decode( buffer );
+		const texture = new DataTexture();
+		this._applyData( texture, data );
+		return texture;
+
+	}
+
+	_applyData( texture, { data, width, height } ) {
+
+		texture.image = { data, width, height };
+		texture.format = RGBAFormat;
+		texture.type = HalfFloatType;
+		texture.colorSpace = LinearSRGBColorSpace;
+		texture.minFilter = LinearFilter;
+		texture.magFilter = LinearFilter;
+		texture.flipY = true;
+		texture.needsUpdate = true;
+
+	}
+
+	async _decode( buffer ) {
+
+		const canvas = document.createElement( 'canvas' );
+		const context = canvas.getContext( '2d', { colorSpace: 'srgb-linear', colorType: 'float16' } );
+
+		if ( context.getContextAttributes().colorType !== 'float16' || ! ( 'globalHDRHeadroom' in context ) ) {
+
+			throw new Error( 'JXLLoader: Canvas2D float16 storage and globalHDRHeadroom are required.' );
+
+		}
+
+		const url = URL.createObjectURL( new Blob( [ buffer ] ) );
+		const image = new Image();
+
+		try {
+
+			image.src = url;
+			await image.decode();
+
+			canvas.width = image.naturalWidth;
+			canvas.height = image.naturalHeight;
+			context.globalHDRHeadroom = Infinity;
+			context.drawImage( image, 0, 0 );
+
+			const pixels = context.getImageData( 0, 0, canvas.width, canvas.height, { colorSpace: 'srgb-linear', pixelFormat: 'rgba-float16' } );
+
+			if ( pixels.pixelFormat !== 'rgba-float16' ) {
+
+				throw new Error( 'JXLLoader: Canvas2D rgba-float16 readback is required.' );
+
+			}
+
+			// reinterpret the Float16Array readback as half-float bits
+			const data = new Uint16Array( pixels.data.buffer, pixels.data.byteOffset, pixels.data.length );
+
+			return { data, width: canvas.width, height: canvas.height };
+
+		} finally {
+
+			URL.revokeObjectURL( url );
+			canvas.width = canvas.height = 0;
+
+		}
+
+	}
+
+}
+
+export { JXLLoader };

package/examples/jsm/loaders/KMZLoader.js

@@ -47,6 +47,8 @@ class KMZLoader extends Loader {
 		const scope = this;
 
 		const loader = new FileLoader( scope.manager );
+		loader.setPriority( scope.priority );
+		loader.setCache( scope.cache );
 		loader.setPath( scope.path );
 		loader.setResponseType( 'arraybuffer' );
 		loader.setRequestHeader( scope.requestHeader );
@@ -130,6 +132,8 @@ class KMZLoader extends Loader {
 			if ( model ) {
 
 				const loader = new ColladaLoader( manager );
+				loader.setPriority( this.priority );
+				loader.setCache( this.cache );
 				return loader.parse( new TextDecoder().decode( zip[ model.textContent ] ) );
 
 			}
@@ -145,6 +149,8 @@ class KMZLoader extends Loader {
 				if ( extension === 'dae' ) {
 
 					const loader = new ColladaLoader( manager );
+					loader.setPriority( this.priority );
+					loader.setCache( this.cache );
 					return loader.parse( new TextDecoder().decode( zip[ path ] ) );
 
 				}

package/examples/jsm/loaders/KSPLATLoader.js

@@ -99,6 +99,8 @@ class KSPLATLoader extends Loader {
 		const scope = this;
 
 		const loader = new FileLoader( this.manager );
+		loader.setPriority( this.priority );
+		loader.setCache( this.cache );
 		loader.setPath( this.path );
 		loader.setResponseType( 'arraybuffer' );
 		loader.setRequestHeader( this.requestHeader );

package/examples/jsm/loaders/KTX2Loader.js

@@ -150,6 +150,15 @@ class KTX2Loader extends Loader {
 
 		super( manager );
 
+		/**
+		 * This flag can be used for type testing.
+		 *
+		 * @type {boolean}
+		 * @readonly
+		 * @default true
+		 */
+		this.isKTX2Loader = true;
+
 		this.transcoderPath = '';
 		this.transcoderBinary = null;
 		this.transcoderPending = null;
@@ -285,9 +294,13 @@ class KTX2Loader extends Loader {
 		if ( ! this.transcoderPending ) {
 
 			const jsLoader = new FileLoader( this.manager );
+			jsLoader.setPriority( this.priority );
+			jsLoader.setCache( this.cache );
 			jsLoader.setWithCredentials( this.withCredentials );
 
 			const binaryLoader = new FileLoader( this.manager );
+			binaryLoader.setPriority( this.priority );
+			binaryLoader.setCache( this.cache );
 			binaryLoader.setWithCredentials( this.withCredentials );
 			binaryLoader.setResponseType( 'arraybuffer' );
 
@@ -381,6 +394,8 @@ class KTX2Loader extends Loader {
 		}
 
 		const loader = new FileLoader( this.manager );
+		loader.setPriority( this.priority );
+		loader.setCache( this.cache );
 
 		loader.setPath( this.path );
 		loader.setCrossOrigin( this.crossOrigin );
@@ -1220,6 +1235,7 @@ async function createRawTexture( container ) {
 		texture = container.pixelDepth === 0
 			? new DataTexture( mipmaps[ 0 ].data, container.pixelWidth, container.pixelHeight )
 			: new Data3DTexture( mipmaps[ 0 ].data, container.pixelWidth, container.pixelHeight, container.pixelDepth );
+		texture.mipmaps = mipmaps;
 		texture.minFilter = useMipmaps ? NearestMipmapNearestFilter : NearestFilter;
 		texture.magFilter = NearestFilter;
 		texture.generateMipmaps = container.levelCount === 0;
@@ -1229,14 +1245,43 @@ async function createRawTexture( container ) {
 
 		if ( container.pixelDepth > 0 ) throw new Error( 'THREE.KTX2Loader: Unsupported pixelDepth.' );
 
-		texture = new CompressedTexture( mipmaps, container.pixelWidth, container.pixelHeight );
+		if ( container.faceCount === 6 ) {
+
+			const faces = [];
+
+			for ( let face = 0; face < 6; face ++ ) {
+
+				const faceMipmaps = [];
+
+				for ( const mipmap of mipmaps ) {
+
+					const faceLength = mipmap.data.length / 6;
+
+					faceMipmaps.push( {
+						data: mipmap.data.subarray( face * faceLength, ( face + 1 ) * faceLength ),
+						width: mipmap.width,
+						height: mipmap.height
+					} );
+
+				}
+
+				faces.push( { mipmaps: faceMipmaps, width: container.pixelWidth, height: container.pixelHeight } );
+
+			}
+
+			texture = new CompressedCubeTexture( faces );
+
+		} else {
+
+			texture = new CompressedTexture( mipmaps, container.pixelWidth, container.pixelHeight );
+
+		}
+
 		texture.minFilter = useMipmaps ? LinearMipmapLinearFilter : LinearFilter;
 		texture.magFilter = LinearFilter;
 
 	}
 
-	texture.mipmaps = mipmaps;
-
 	texture.type = TYPE_MAP[ vkFormat ];
 	texture.format = FORMAT_MAP[ vkFormat ];
 	texture.colorSpace = parseColorSpace( container );
@@ -1244,7 +1289,7 @@ async function createRawTexture( container ) {
 
 	//
 
-	return Promise.resolve( texture );
+	return texture;
 
 }
 

package/examples/jsm/loaders/KTXLoader.js

@@ -104,6 +104,7 @@ class KhronosTextureContainer {
 		const endianness = headerDataView.getUint32( 0, true );
 		const littleEndian = endianness === 0x04030201;
 
+		this.littleEndian = littleEndian;
 		this.glType = headerDataView.getUint32( 1 * dataSize, littleEndian ); // must be 0 for compressed textures
 		this.glTypeSize = headerDataView.getUint32( 2 * dataSize, littleEndian ); // must be 1 for compressed textures
 		this.glFormat = headerDataView.getUint32( 3 * dataSize, littleEndian ); // must be 0 for compressed textures
@@ -160,6 +161,7 @@ class KhronosTextureContainer {
 	mipmaps( loadMipmaps ) {
 
 		const mipmaps = [];
+		const dataView = new DataView( this.arrayBuffer );
 
 		// initialize width & height for level 1
 		let dataOffset = HEADER_LEN + this.bytesOfKeyValueData;
@@ -169,7 +171,7 @@ class KhronosTextureContainer {
 
 		for ( let level = 0; level < mipmapCount; level ++ ) {
 
-			const imageSize = new Int32Array( this.arrayBuffer, dataOffset, 1 )[ 0 ]; // size per face, since not supporting array cubemaps
+			const imageSize = dataView.getUint32( dataOffset, this.littleEndian ); // size per face, since not supporting array cubemaps
 			dataOffset += 4; // size of the image + 4 for the imageSize field
 
 			for ( let face = 0; face < this.numberOfFaces; face ++ ) {
@@ -183,8 +185,8 @@ class KhronosTextureContainer {
 
 			}
 
-			width = Math.max( 1.0, width * 0.5 );
-			height = Math.max( 1.0, height * 0.5 );
+			width = Math.max( width >> 1, 1 );
+			height = Math.max( height >> 1, 1 );
 
 		}
 

package/examples/jsm/loaders/LDrawLoader.js

@@ -124,7 +124,7 @@ function smoothNormals( faces, lineSegments, checkSubSegments = false ) {
 
 	const hardEdges = new Set();
 	const hardEdgeRays = new Map();
-	const halfEdgeList = {};
+	const halfEdgeList = new Map();
 	const normals = [];
 
 	// Save the list of hard edges by hash
@@ -243,29 +243,15 @@ function smoothNormals( faces, lineSegments, checkSubSegments = false ) {
 				index: index,
 				tri: tri
 			};
-			halfEdgeList[ hash ] = info;
+			halfEdgeList.set( hash, info );
 
 		}
 
 	}
 
 	// Iterate until we've tried to connect all faces to share normals
-	while ( true ) {
-
-		// Stop if there are no more faces left
-		let halfEdge = null;
-		for ( const key in halfEdgeList ) {
-
-			halfEdge = halfEdgeList[ key ];
-			break;
-
-		}
-
-		if ( halfEdge === null ) {
-
-			break;
-
-		}
+	// Map iterators skip entries deleted during iteration, so each face is visited once
+	for ( const halfEdge of halfEdgeList.values() ) {
 
 		// Exhaustively find all connected faces
 		const queue = [ halfEdge ];
@@ -288,10 +274,10 @@ function smoothNormals( faces, lineSegments, checkSubSegments = false ) {
 
 				// delete this triangle from the list so it won't be found again
 				const hash = hashEdge( v0, v1 );
-				delete halfEdgeList[ hash ];
+				halfEdgeList.delete( hash );
 
 				const reverseHash = hashEdge( v1, v0 );
-				const otherInfo = halfEdgeList[ reverseHash ];
+				const otherInfo = halfEdgeList.get( reverseHash );
 				if ( otherInfo ) {
 
 					const otherTri = otherInfo.tri;
@@ -312,10 +298,10 @@ function smoothNormals( faces, lineSegments, checkSubSegments = false ) {
 					// if this triangle has already been traversed then it won't be in
 					// the halfEdgeList. If it has not then add it to the queue and delete
 					// it so it won't be found again.
-					if ( reverseHash in halfEdgeList ) {
+					if ( halfEdgeList.has( reverseHash ) ) {
 
 						queue.push( otherInfo );
-						delete halfEdgeList[ reverseHash ];
+						halfEdgeList.delete( reverseHash );
 
 					}
 
@@ -627,6 +613,8 @@ class LDrawParsedCache {
 
 			const loader = this.loader;
 			const fileLoader = new FileLoader( loader.manager );
+			fileLoader.setPriority( loader.priority );
+			fileLoader.setCache( loader.cache );
 			fileLoader.setPath( loader.partsLibraryPath );
 			fileLoader.setRequestHeader( loader.requestHeader );
 			fileLoader.setWithCredentials( loader.withCredentials );
@@ -1838,6 +1826,7 @@ class LDrawLoader extends Loader {
 
 		this.ConditionalLineMaterial = type;
 		this.missingConditionalEdgeColorMaterial = new this.ConditionalLineMaterial( { name: Loader.DEFAULT_MATERIAL_NAME, fog: true, color: 0xFF00FF } );
+		this.conditionalEdgeMaterialCache.set( this.missingEdgeColorMaterial, this.missingConditionalEdgeColorMaterial );
 		return this;
 
 	}
@@ -1856,6 +1845,8 @@ class LDrawLoader extends Loader {
 	async preloadMaterials( url ) {
 
 		const fileLoader = new FileLoader( this.manager );
+		fileLoader.setPriority( this.priority );
+		fileLoader.setCache( this.cache );
 		fileLoader.setPath( this.path );
 		fileLoader.setRequestHeader( this.requestHeader );
 		fileLoader.setWithCredentials( this.withCredentials );
@@ -1893,6 +1884,8 @@ class LDrawLoader extends Loader {
 	load( url, onLoad, onProgress, onError ) {
 
 		const fileLoader = new FileLoader( this.manager );
+		fileLoader.setPriority( this.priority );
+		fileLoader.setCache( this.cache );
 		fileLoader.setPath( this.path );
 		fileLoader.setRequestHeader( this.requestHeader );
 		fileLoader.setWithCredentials( this.withCredentials );

package/examples/jsm/loaders/LUT3dlLoader.js

@@ -70,6 +70,10 @@ export class LUT3dlLoader extends Loader {
 	load( url, onLoad, onProgress, onError ) {
 
 		const loader = new FileLoader( this.manager );
+		loader.setPriority( this.priority );
+		loader.setCache( this.cache );
+		loader.setRequestHeader( this.requestHeader );
+		loader.setWithCredentials( this.withCredentials );
 		loader.setPath( this.path );
 		loader.setResponseType( 'text' );
 		loader.load( url, text => {
@@ -160,7 +164,7 @@ export class LUT3dlLoader extends Loader {
 		}
 
 		// Determine the bit depth to scale the values to [0.0, 1.0].
-		const bits = Math.ceil( Math.log2( maxValue ) );
+		const bits = Math.max( 0, Math.ceil( Math.log2( maxValue ) ) );
 		const maxBitValue = Math.pow( 2, bits );
 
 		const data = this.type === UnsignedByteType ? new Uint8Array( dataFloat.length ) : dataFloat;

package/examples/jsm/loaders/LUTCubeLoader.js

@@ -69,6 +69,10 @@ export class LUTCubeLoader extends Loader {
 	load( url, onLoad, onProgress, onError ) {
 
 		const loader = new FileLoader( this.manager );
+		loader.setPriority( this.priority );
+		loader.setCache( this.cache );
+		loader.setRequestHeader( this.requestHeader );
+		loader.setWithCredentials( this.withCredentials );
 		loader.setPath( this.path );
 		loader.setResponseType( 'text' );
 		loader.load( url, text => {
@@ -107,8 +111,8 @@ export class LUTCubeLoader extends Loader {
 
 		const regExpTitle = /TITLE +"([^"]*)"/;
 		const regExpSize = /LUT_3D_SIZE +(\d+)/;
-		const regExpDomainMin = /DOMAIN_MIN +([\d.]+) +([\d.]+) +([\d.]+)/;
-		const regExpDomainMax = /DOMAIN_MAX +([\d.]+) +([\d.]+) +([\d.]+)/;
+		const regExpDomainMin = /DOMAIN_MIN +([\d.e+-]+) +([\d.e+-]+) +([\d.e+-]+)/;
+		const regExpDomainMax = /DOMAIN_MAX +([\d.e+-]+) +([\d.e+-]+) +([\d.e+-]+)/;
 		const regExpDataPoints = /^([\d.e+-]+) +([\d.e+-]+) +([\d.e+-]+) *$/gm;
 
 		let result = regExpTitle.exec( input );

package/examples/jsm/loaders/LUTImageLoader.js

@@ -56,6 +56,8 @@ export class LUTImageLoader extends Loader {
 	load( url, onLoad, onProgress, onError ) {
 
 		const loader = new TextureLoader( this.manager );
+		loader.setPriority( this.priority );
+		loader.setCache( this.cache );
 
 		loader.setCrossOrigin( this.crossOrigin );
 

package/examples/jsm/loaders/LWOLoader.js

@@ -87,6 +87,10 @@ class LWOLoader extends Loader {
 		const modelName = url.split( path ).pop().split( '.' )[ 0 ];
 
 		const loader = new FileLoader( this.manager );
+		loader.setPriority( this.priority );
+		loader.setCache( this.cache );
+		loader.setRequestHeader( this.requestHeader );
+		loader.setWithCredentials( this.withCredentials );
 		loader.setPath( scope.path );
 		loader.setResponseType( 'arraybuffer' );
 
@@ -135,6 +139,8 @@ class LWOLoader extends Loader {
 		// console.log( 'lwoTree', lwoTree );
 
 		const textureLoader = new TextureLoader( this.manager ).setPath( this.resourcePath || path ).setCrossOrigin( this.crossOrigin );
+		textureLoader.setPriority( this.priority );
+		textureLoader.setCache( this.cache );
 
 		return new LWOTreeParser( textureLoader ).parse( modelName );
 

package/examples/jsm/loaders/MD2Loader.js

@@ -134,6 +134,8 @@ class MD2Loader extends Loader {
 		const scope = this;
 
 		const loader = new FileLoader( scope.manager );
+		loader.setPriority( scope.priority );
+		loader.setCache( scope.cache );
 		loader.setPath( scope.path );
 		loader.setResponseType( 'arraybuffer' );
 		loader.setRequestHeader( scope.requestHeader );

package/examples/jsm/loaders/MDDLoader.js

@@ -69,6 +69,10 @@ class MDDLoader extends Loader {
 		const scope = this;
 
 		const loader = new FileLoader( this.manager );
+		loader.setPriority( this.priority );
+		loader.setCache( this.cache );
+		loader.setRequestHeader( this.requestHeader );
+		loader.setWithCredentials( this.withCredentials );
 		loader.setPath( this.path );
 		loader.setResponseType( 'arraybuffer' );
 		loader.load( url, function ( data ) {