<!-- SOLUV · part 237 -->
ials );
		loader.load( url, function ( buffer ) {

			let texData;

			try {

				texData = scope.parse( buffer );

			} catch ( e ) {

				if ( onError !== undefined ) {

					onError( e );

				} else {

					error( e );

				}

				return;

			}

			scope._applyTexData( texture, texData );

			if ( onLoad ) onLoad( texture, texData );

		}, onProgress, onError );


		return texture;

	}

	/**
	 * Parses the given buffer and returns a configured data texture. Use this method
	 * for parsing texture data that is already in memory (e.g. drag and drop or data
	 * loaded from a server) without going through {@link DataTextureLoader#load}.
	 *
	 * @param {ArrayBuffer} buffer - The raw texture data.
	 * @return {DataTexture} The data texture.
	 */
	createDataTexture( buffer ) {

		const texture = new DataTexture();

		this._applyTexData( texture, this.parse( buffer ) );

		return texture;

	}

	/**
	 * Applies the given parsed texture data to the given data texture.
	 *
	 * @private
	 * @param {DataTexture} texture - The data texture.
	 * @param {DataTextureLoader~TexData} texData - The parsed texture data.
	 */
	_applyTexData( texture, texData ) {

		if ( texData.image !== undefined ) {

			texture.image = texData.image;

		} else if ( texData.data !== undefined ) {

			texture.image.width = texData.width;
			texture.image.height = texData.height;
			texture.image.data = texData.data;

		}

		texture.wrapS = texData.wrapS !== undefined ? texData.wrapS : ClampToEdgeWrapping;
		texture.wrapT = texData.wrapT !== undefined ? texData.wrapT : ClampToEdgeWrapping;

		texture.magFilter = texData.magFilter !== undefined ? texData.magFilter : LinearFilter;
		texture.minFilter = texData.minFilter !== undefined ? texData.minFilter : LinearFilter;

		texture.anisotropy = texData.anisotropy !== undefined ? texData.anisotropy : 1;

		if ( texData.colorSpace !== undefined ) {

			texture.colorSpace = texData.colorSpace;

		}

		if ( texData.flipY !== undefined ) {

			texture.flipY = texData.flipY;

		}

		if ( texData.format !== undefined ) {

			texture.format = texData.format;

		}

		if ( texData.type !== undefined ) {

			texture.type = texData.type;

		}

		if ( texData.mipmaps !== undefined ) {

			texture.mipmaps = texData.mipmaps;
			texture.minFilter = LinearMipmapLinearFilter; // presumably...

		}

		if ( texData.mipmapCount === 1 ) {

			texture.minFilter = LinearFilter;

		}

		if ( texData.generateMipmaps !== undefined ) {

			texture.generateMipmaps = texData.generateMipmaps;

		}

		texture.needsUpdate = true;

	}

}

/**
 * Class for loading textures. Images are internally
 * loaded via {@link ImageLoader}.
 *
 * ```js
 * const loader = new THREE.TextureLoader();
 * const texture = await loader.loadAsync( 'textures/land_ocean_ice_cloud_2048.jpg' );
 *
 * const material = new THREE.MeshBasicMaterial( { map:texture } );
 * ```
 * Please note that `TextureLoader` has dropped support for progress
 * events in `r84`. For a `TextureLoader` that supports progress events, see
 * [this thread](https://github.com/mrdoob/three.js/issues/10439#issuecomment-293260145).
 *
 * @augments Loader
 */
class TextureLoader extends Loader {

	/**
	 * Constructs a new texture loader.
	 *
	 * @param {LoadingManager} [manager] - The loading manager.
	 */
	constructor( manager ) {

		super( manager );

	}

	/**
	 * Starts loading from the given URL and pass the fully loaded 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(Texture)} onLoad - Executed when the loading process has been finished.
	 * @param {onProgressCallback} onProgress - Unsupported in this loader.
	 * @param {onErrorCallback} onError - Executed when errors occur.
	 * @return {Texture} The texture.
	 */
	load( url, onLoad, onProgress, onError ) {

		const texture = new Texture();

		const loader = new ImageLoader( this.manager );
		loader.setCrossOrigin( this.crossOrigin );
		loader.setPath( this.path );

		loader.load( url, function ( image ) {

			texture.image = image;
			texture.needsUpdate = true;

			if ( onLoad !== undefined ) {

				onLoad( texture );

			}

		}, onProgress, onError );

		return texture;

	}

}

/**
 * Abstract base class for lights - all other light types inherit the
 * properties and methods described here.
 *
 * @abstract
 * @augments Object3D
 */
class Light extends Object3D {

	/**
	 * Constructs a new light.
	 *
	 * @param {(number|Color|string)} [color=0xffffff] - The light's color.
	 * @param {number} [intensity=1] - The light's strength/intensity.
	 */
	constructor( color, intensity = 1 ) {

		super();

		/**
		 * This flag can be used for type testing.
		 *
		 * @type {boolean}
		 * @readon