<!-- NEW5 — TEST 5 · THE BEND AT THE HEART · part 235 -->
e 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}
		 * @readonly
		 * @default true
		 */
		this.isLight = true;

		this.type = 'Light';

		/**
		 * The light's color.
		 *
		 * @type {Color}
		 */
		this.color = new Color( color );

		/**
		 * The light's intensity.
		 *
		 * @type {number}
		 * @default 1
		 */
		this.intensity = intensity;

	}

	copy( source, recursive ) {

		super.copy( source, recursive );

		this.color.copy( source.color );
		this.intensity = source.intensity;

		return this;

	}

	toJSON( meta ) {

		const data = super.toJSON( meta );

		data.object.color = this.color.getHex();
		data.object.intensity = this.intensity;

		return data;

	}

}

/**
 * A light source positioned directl