to cache only on HTTP success, so that we do not cache // error response bodies as proper responses to requests. Cache.add( `file:${url}`, data ); const callbacks = loading[ url ]; delete loading[ url ]; for ( let i = 0, il = callbacks.length; i < il; i ++ ) { const callback = callbacks[ i ]; if ( callback.onLoad ) callback.onLoad( data ); } } ) .catch( err => { // Abort errors and other errors are handled the same const callbacks = loading[ url ]; if ( callbacks === undefined ) { // When onLoad was called and url was deleted in `loading` this.manager.itemError( url ); throw err; } delete loading[ url ]; for ( let i = 0, il = callbacks.length; i < il; i ++ ) { const callback = callbacks[ i ]; if ( callback.onError ) callback.onError( err ); } this.manager.itemError( url ); } ) .finally( () => { this.manager.itemEnd( url ); } ); this.manager.itemStart( url ); } /** * Sets the expected response type. * * @param {('arraybuffer'|'blob'|'document'|'json'|'')} value - The response type. * @return {FileLoader} A reference to this file loader. */ setResponseType( value ) { this.responseType = value; return this; } /** * Sets the expected mime type of the loaded file. * * @param {string} value - The mime type. * @return {FileLoader} A reference to this file loader. */ setMimeType( value ) { this.mimeType = value; return this; } /** * Aborts ongoing fetch requests. * * @return {FileLoader} A reference to this instance. */ abort() { this._abortController.abort(); this._abortController = new AbortController(); return this; } } /** * Class for loading animation clips in the JSON format. The files are internally * loaded via {@link FileLoader}. * * ```js * const loader = new THREE.AnimationLoader(); * const animations = await loader.loadAsync( 'animations/animation.js' ); * ``` * * @augments Loader */ class AnimationLoader extends Loader { /** * Constructs a new animation loader. * * @param {LoadingManager} [manager] - The loading manager. */ constructor( manager ) { super( manager ); } /** * Starts loading from the given URL and pass the loaded animations as an array * holding instances of {@link AnimationClip} to the `onLoad()` callback. * * @param {string} url - The path/URL of the file to be loaded. This can also be a data URI. * @param {function(Array)} onLoad - Executed when the loading process has been finished. * @param {onProgressCallback} onProgress - Executed while the loading is in progress. * @param {onErrorCallback} onError - Executed when errors occur. */ load( url, onLoad, onProgress, onError ) { const scope = this; const loader = new FileLoader( this.manager ); loader.setPath( this.path ); loader.setRequestHeader( this.requestHeader ); loader.setWithCredentials( this.withCredentials ); loader.load( url, function ( text ) { try { onLoad( scope.parse( JSON.parse( text ) ) ); } catch ( e ) { if ( onError ) { onError( e ); } else { error( e ); } scope.manager.itemError( url ); } }, onProgress, onError ); } /** * Parses the given JSON object and returns an array of animation clips. * * @param {Object} json - The serialized animation clips. * @return {Array} The parsed animation clips. */ parse( json ) { const animations = []; for ( let i = 0; i < json.length; i ++ ) { const clip = AnimationClip.parse( json[ i ] ); animations.push( clip ); } return animations; } } /** * Abstract base class for loading compressed texture formats S3TC, ASTC or ETC. * Textures are internally loaded via {@link FileLoader}. * * Derived classes have to implement the `parse()` method which holds the parsing * for the respective format. * * @abstract * @augments Loader */ class CompressedTextureLoader extends Loader { /** * Constructs a new compressed texture loader. * * @param {LoadingManager} [manager] - The loading manager. */ constructor( manager ) { super( manager ); } /** * Starts loading from the given URL and passes the loaded compressed texture * to the `onLoad()` callback. The method also returns a new texture object which can * directly be used for material creation. If you do it this way, the texture * may pop up in your scene once the respective loading process is finished. * * @param {string} url - The path/URL of the file to be loaded. This can also be a data URI. * @param {function(CompressedTexture)} onLoad - Executed when the loading process has been finished. * @param {onProgressCallback} onProgress - Executed while the loading is in progress. * @param {onErrorCallback} onError - Executed when errors occur. * @return {CompressedTexture} The compressed texture. */ load( u