text: import {
  	UVMapping,
  	CubeReflectionMapping,
  	CubeRefractionMapping,
  	EquirectangularReflectionMapping,
  	EquirectangularRefractionMapping,
  	CubeUVReflectionMapping,
  	CubeUVRefractionMapping,
  
  	RepeatWrapping,
  	ClampToEdgeWrapping,
  	MirroredRepeatWrapping,
  
  	NearestFilter,
  	NearestMipmapNearestFilter,
  	NearestMipmapLinearFilter,
  	LinearFilter,
  	LinearMipmapNearestFilter,
  	LinearMipmapLinearFilter
  } from '../constants.js';
  import { BufferAttribute } from '../core/BufferAttribute.js';
  import { Color } from '../math/Color.js';
  import { Object3D } from '../core/Object3D.js';
  import { Group } from '../objects/Group.js';
  import { InstancedMesh } from '../objects/InstancedMesh.js';
  import { Sprite } from '../objects/Sprite.js';
  import { Points } from '../objects/Points.js';
  import { Line } from '../objects/Line.js';
  import { LineLoop } from '../objects/LineLoop.js';
  import { LineSegments } from '../objects/LineSegments.js';
  import { LOD } from '../objects/LOD.js';
  import { Mesh } from '../objects/Mesh.js';
  import { SkinnedMesh } from '../objects/SkinnedMesh.js';
  import { Bone } from '../objects/Bone.js';
  import { Skeleton } from '../objects/Skeleton.js';
  import { Shape } from '../extras/core/Shape.js';
  import { Fog } from '../scenes/Fog.js';
  import { FogExp2 } from '../scenes/FogExp2.js';
  import { HemisphereLight } from '../lights/HemisphereLight.js';
  import { SpotLight } from '../lights/SpotLight.js';
  import { PointLight } from '../lights/PointLight.js';
  import { DirectionalLight } from '../lights/DirectionalLight.js';
  import { AmbientLight } from '../lights/AmbientLight.js';
  import { RectAreaLight } from '../lights/RectAreaLight.js';
  import { LightProbe } from '../lights/LightProbe.js';
  import { OrthographicCamera } from '../cameras/OrthographicCamera.js';
  import { PerspectiveCamera } from '../cameras/PerspectiveCamera.js';
  import { Scene } from '../scenes/Scene.js';
  import { CubeTexture } from '../textures/CubeTexture.js';
  import { Texture } from '../textures/Texture.js';
  import { DataTexture } from '../textures/DataTexture.js';
  import { ImageLoader } from './ImageLoader.js';
  import { LoadingManager } from './LoadingManager.js';
  import { AnimationClip } from '../animation/AnimationClip.js';
  import { MaterialLoader } from './MaterialLoader.js';
  import { LoaderUtils } from './LoaderUtils.js';
  import { BufferGeometryLoader } from './BufferGeometryLoader.js';
  import { Loader } from './Loader.js';
  import { FileLoader } from './FileLoader.js';
  import * as Geometries from '../geometries/Geometries.js';
  import { getTypedArray } from '../utils.js';
  
  class ObjectLoader extends Loader {
  
  	constructor( manager ) {
  
  		super( manager );
  
  	}
  
  	load( url, onLoad, onProgress, onError ) {
  
  		const scope = this;
  
  		const path = ( this.path === '' ) ? LoaderUtils.extractUrlBase( url ) : this.path;
  		this.resourcePath = this.resourcePath || path;
  
  		const loader = new FileLoader( this.manager );
  		loader.setPath( this.path );
  		loader.setRequestHeader( this.requestHeader );
  		loader.setWithCredentials( this.withCredentials );
  		loader.load( url, function ( text ) {
  
  			let json = null;
  
  			try {
  
  				json = JSON.parse( text );
  
  			} catch ( error ) {
  
  				if ( onError !== undefined ) onError( error );
  
  				console.error( 'THREE:ObjectLoader: Can\'t parse ' + url + '.', error.message );
  
  				return;
  
  			}
  
  			const metadata = json.metadata;
  
  			if ( metadata === undefined || metadata.type === undefined || metadata.type.toLowerCase() === 'geometry' ) {
  
  				console.error( 'THREE.ObjectLoader: Can\'t load ' + url );
  				return;
  
  			}
  
  			scope.parse( json, onLoad );
  
  		}, onProgress, onError );
  
  	}
  
  	async loadAsync( url, onProgress ) {
  
  		const scope = this;
  
  		const path = ( this.path === '' ) ? LoaderUtils.extractUrlBase( url ) : this.path;
  		this.resourcePath = this.resourcePath || path;
  
  		const loader = new FileLoader( this.manager );
  		loader.setPath( this.path );
  		loader.setRequestHeader( this.requestHeader );
  		loader.setWithCredentials( this.withCredentials );
  
  		const text = await loader.loadAsync( url, onProgress );
  
  		const json = JSON.parse( text );
  
  		const metadata = json.metadata;
  
  		if ( metadata === undefined || metadata.type === undefined || metadata.type.toLowerCase() === 'geometry' ) {
  
  			throw new Error( 'THREE.ObjectLoader: Can\'t load ' + url );
  
  		}
  
  		return await scope.parseAsync( json );
  
  	}
  
  	parse( json, onLoad ) {
  
  		const animations = this.parseAnimations( json.animations );
  		const shapes = this.parseShapes( json.shapes );
  		const geometries = this.parseGeometries( json.geometries, shapes );
  
  		const images = this.parseImages( json.images, function () {
  
  			if ( onLoad !== undefined ) onLoad( object );
  
  		} );
  
  		const textures = this.parseTextures( json.textures, images );
  		const materials = this.parseMaterials( json.materials, textures );
  
  		const object = this.parseObject( json.object, geometries, materials, textures, animations );
  		const skeletons = this.parseSkeletons( json.skeletons, object );
  
  		this.bindSkeletons( object, skeletons );
  
  		//
  
  		if ( onLoad !== undefined ) {
  
  			let hasImages = false;
  
  			for ( const uuid in images ) {
  
  				if ( images[ uuid ] instanceof HTMLImageElement ) {
  
  					hasImages = true;
  					break;
  
  				}
  
  			}
  
  			if ( hasImages === false ) onLoad( object );
  
  		}
  
  		return object;
  
  	}
  
  	async parseAsync( json ) {
  
  		const animations = this.parseAnimations( json.animations );
  		const shapes = this.parseShapes( json.shapes );
  		const geometries = this.parseGeometries( json.geometries, shapes );
  
  		const images = await this.parseImagesAsync( json.images );
  
  		const textures = this.parseTextures( json.textures, images );
  		const materials = this.parseMaterials( json.materials, textures );
  
  		const object = this.parseObject( json.object, geometries, materials, textures, animations );
  		const skeletons = this.parseSkeletons( json.skeletons, object );
  
  		this.bindSkeletons( object, skeletons );
  
  		return object;
  
  	}
  
  	parseShapes( json ) {
  
  		const shapes = {};
  
  		if ( json !== undefined ) {
  
  			for ( let i = 0, l = json.length; i < l; i ++ ) {
  
  				const shape = new Shape().fromJSON( json[ i ] );
  
  				shapes[ shape.uuid ] = shape;
  
  			}
  
  		}
  
  		return shapes;
  
  	}
  
  	parseSkeletons( json, object ) {
  
  		const skeletons = {};
  		const bones = {};
  
  		// generate bone lookup table
  
  		object.traverse( function ( child ) {
  
  			if ( child.isBone ) bones[ child.uuid ] = child;
  
  		} );
  
  		// create skeletons
  
  		if ( json !== undefined ) {
  
  			for ( let i = 0, l = json.length; i < l; i ++ ) {
  
  				const skeleton = new Skeleton().fromJSON( json[ i ], bones );
  
  				skeletons[ skeleton.uuid ] = skeleton;
  
  			}
  
  		}
  
  		return skeletons;
  
  	}
  
  	parseGeometries( json, shapes ) {
  
  		const geometries = {};
  
  		if ( json !== undefined ) {
  
  			const bufferGeometryLoader = new BufferGeometryLoader();
  
  			for ( let i = 0, l = json.length; i < l; i ++ ) {
  
  				let geometry;
  				const data = json[ i ];
  
  				switch ( data.type ) {
  
  					case 'BufferGeometry':
  					case 'InstancedBufferGeometry':
  
  						geometry = bufferGeometryLoader.parse( data );
  
  						break;
  
  					case 'Geometry':
  
  						console.error( 'THREE.ObjectLoader: The legacy Geometry type is no longer supported.' );
  
  						break;
  
  					default:
  
  						if ( data.type in Geometries ) {
  
  							geometry = Geometries[ data.type ].fromJSON( data, shapes );
  
  						} else {
  
  							console.warn( `THREE.ObjectLoader: Unsupported geometry type "${ data.type }"` );
  
  						}
  
  				}
  
  				geometry.uuid = data.uuid;
  
  				if ( data.name !== undefined ) geometry.name = data.name;
  				if ( geometry.isBufferGeometry === true && data.userData !== undefined ) geometry.userData = data.userData;
  
  				geometries[ data.uuid ] = geometry;
  
  			}
  
  		}
  
  		return geometries;
  
  	}
  
  	parseMaterials( json, textures ) {
  
  		const cache = {}; // MultiMaterial
  		const materials = {};
  
  		if ( json !== undefined ) {
  
  			const loader = new MaterialLoader();
  			loader.setTextures( textures );
  
  			for ( let i = 0, l = json.length; i < l; i ++ ) {
  
  				const data = json[ i ];
  
  				if ( data.type === 'MultiMaterial' ) {
  
  					// Deprecated
  
  					const array = [];
  
  					for ( let j = 0; j < data.materials.length; j ++ ) {
  
  						const material = data.materials[ j ];
  
  						if ( cache[ material.uuid ] === undefined ) {
  
  							cache[ material.uuid ] = loader.parse( material );
  
  						}
  
  						array.push( cache[ material.uuid ] );
  
  					}
  
  					materials[ data.uuid ] = array;
  
  				} else {
  
  					if ( cache[ data.uuid ] === undefined ) {
  
  						cache[ data.uuid ] = loader.parse( data );
  
  					}
  
  					materials[ data.uuid ] = cache[ data.uuid ];
  
  				}
  
  			}
  
  		}
  
  		return materials;
  
  	}
  
  	parseAnimations( json ) {
  
  		const animations = {};
  
  		if ( json !== undefined ) {
  
  			for ( let i = 0; i < json.length; i ++ ) {
  
  				const data = json[ i ];
  
  				const clip = AnimationClip.parse( data );
  
  				animations[ clip.uuid ] = clip;
  
  			}
  
  		}
  
  		return animations;
  
  	}
  
  	parseImages( json, onLoad ) {
  
  		const scope = this;
  		const images = {};
  
  		let loader;
  
  		function loadImage( url ) {
  
  			scope.manager.itemStart( url );
  
  			return loader.load( url, function () {
  
  				scope.manager.itemEnd( url );
  
  			}, undefined, function () {
  
  				scope.manager.itemError( url );
  				scope.manager.itemEnd( url );
  
  			} );
  
  		}
  
  		function deserializeImage( image ) {
  
  			if ( typeof image === 'string' ) {
  
  				const url = image;
  
  				const path = /^(\/\/)|([a-z]+:(\/\/)?)/i.test( url ) ? url : scope.resourcePath + url;
  
  				return loadImage( path );
  
  			} else {
  
  				if ( image.data ) {
  
  					return {
  						data: getTypedArray( image.type, image.data ),
  						width: image.width,
  						height: image.height
  					};
  
  				} else {
  
  					return null;
  
  				}
  
  			}
  
  		}
  
  		if ( json !== undefined && json.length > 0 ) {
  
  			const manager = new LoadingManager( onLoad );
  
  			loader = new ImageLoader( manager );
  			loader.setCrossOrigin( this.crossOrigin );
  
  			for ( let i = 0, il = json.length; i < il; i ++ ) {
  
  				const image = json[ i ];
  				const url = image.url;
  
  				if ( Array.isArray( url ) ) {
  
  					// load array of images e.g CubeTexture
  
  					images[ image.uuid ] = [];
  
  					for ( let j = 0, jl = url.length; j < jl; j ++ ) {
  
  						const currentUrl = url[ j ];
  
  						const deserializedImage = deserializeImage( currentUrl );
  
  						if ( deserializedImage !== null ) {
  
  							if ( deserializedImage instanceof HTMLImageElement ) {
  
  								images[ image.uuid ].push( deserializedImage );
  
  							} else {
  
  								// special case: handle array of data textures for cube textures
  
  								images[ image.uuid ].push( new DataTexture( deserializedImage.data, deserializedImage.width, deserializedImage.height ) );
  
  							}
  
  						}
  
  					}
  
  				} else {
  
  					// load single image
  
  					const deserializedImage = deserializeImage( image.url );
  
  					if ( deserializedImage !== null ) {
  
  						images[ image.uuid ] = deserializedImage;
  
  					}
  
  				}
  
  			}
  
  		}
  
  		return images;
  
  	}
  
  	async parseImagesAsync( json ) {
  
  		const scope = this;
  		const images = {};
  
  		let loader;
  
  		async function deserializeImage( image ) {
  
  			if ( typeof image === 'string' ) {
  
  				const url = image;
  
  				const path = /^(\/\/)|([a-z]+:(\/\/)?)/i.test( url ) ? url : scope.resourcePath + url;
  
  				return await loader.loadAsync( path );
  
  			} else {
  
  				if ( image.data ) {
  
  					return {
  						data: getTypedArray( image.type, image.data ),
  						width: image.width,
  						height: image.height
  					};
  
  				} else {
  
  					return null;
  
  				}
  
  			}
  
  		}
  
  		if ( json !== undefined && json.length > 0 ) {
  
  			loader = new ImageLoader( this.manager );
  			loader.setCrossOrigin( this.crossOrigin );
  
  			for ( let i = 0, il = json.length; i < il; i ++ ) {
  
  				const image = json[ i ];
  				const url = image.url;
  
  				if ( Array.isArray( url ) ) {
  
  					// load array of images e.g CubeTexture
  
  					images[ image.uuid ] = [];
  
  					for ( let j = 0, jl = url.length; j < jl; j ++ ) {
  
  						const currentUrl = url[ j ];
  
  						const deserializedImage = await deserializeImage( currentUrl );
  
  						if ( deserializedImage !== null ) {
  
  							if ( deserializedImage instanceof HTMLImageElement ) {
  
  								images[ image.uuid ].push( deserializedImage );
  
  							} else {
  
  								// special case: handle array of data textures for cube textures
  
  								images[ image.uuid ].push( new DataTexture( deserializedImage.data, deserializedImage.width, deserializedImage.height ) );
  
  							}
  
  						}
  
  					}
  
  				} else {
  
  					// load single image
  
  					const deserializedImage = await deserializeImage( image.url );
  
  					if ( deserializedImage !== null ) {
  
  						images[ image.uuid ] = deserializedImage;
  
  					}
  
  				}
  
  			}
  
  		}
  
  		return images;
  
  	}
  
  	parseTextures( json, images ) {
  
  		function parseConstant( value, type ) {
  
  			if ( typeof value === 'number' ) return value;
  
  			console.warn( 'THREE.ObjectLoader.parseTexture: Constant should be in numeric form.', value );
  
  			return type[ value ];
  
  		}
  
  		const textures = {};
  
  		if ( json !== undefined ) {
  
  			for ( let i = 0, l = json.length; i < l; i ++ ) {
  
  				const data = json[ i ];
  
  				if ( data.image === undefined ) {
  
  					console.warn( 'THREE.ObjectLoader: No "image" specified for', data.uuid );
  
  				}
  
  				if ( images[ data.image ] === undefined ) {
  
  					console.warn( 'THREE.ObjectLoader: Undefined image', data.image );
  
  				}
  
  				let texture;
  				const image = images[ data.image ];
  
  				if ( Array.isArray( image ) ) {
  
  					texture = new CubeTexture( image );
  
  					if ( image.length === 6 ) texture.needsUpdate = true;
  
  				} else {
  
  					if ( image && image.data ) {
  
  						texture = new DataTexture( image.data, image.width, image.height );
  
  					} else {
  
  						texture = new Texture( image );
  
  					}
  
  					if ( image ) texture.needsUpdate = true; // textures can have undefined image data
  
  				}
  
  				texture.uuid = data.uuid;
  
  				if ( data.name !== undefined ) texture.name = data.name;
  
  				if ( data.mapping !== undefined ) texture.mapping = parseConstant( data.mapping, TEXTURE_MAPPING );
  
  				if ( data.offset !== undefined ) texture.offset.fromArray( data.offset );
  				if ( data.repeat !== undefined ) texture.repeat.fromArray( data.repeat );
  				if ( data.center !== undefined ) texture.center.fromArray( data.center );
  				if ( data.rotation !== undefined ) texture.rotation = data.rotation;
  
  				if ( data.wrap !== undefined ) {
  
  					texture.wrapS = parseConstant( data.wrap[ 0 ], TEXTURE_WRAPPING );
  					texture.wrapT = parseConstant( data.wrap[ 1 ], TEXTURE_WRAPPING );
  
  				}
  
  				if ( data.format !== undefined ) texture.format = data.format;
  				if ( data.type !== undefined ) texture.type = data.type;
  				if ( data.encoding !== undefined ) texture.encoding = data.encoding;
  
  				if ( data.minFilter !== undefined ) texture.minFilter = parseConstant( data.minFilter, TEXTURE_FILTER );
  				if ( data.magFilter !== undefined ) texture.magFilter = parseConstant( data.magFilter, TEXTURE_FILTER );
  				if ( data.anisotropy !== undefined ) texture.anisotropy = data.anisotropy;
  
  				if ( data.flipY !== undefined ) texture.flipY = data.flipY;
  
  				if ( data.premultiplyAlpha !== undefined ) texture.premultiplyAlpha = data.premultiplyAlpha;
  				if ( data.unpackAlignment !== undefined ) texture.unpackAlignment = data.unpackAlignment;
  
  				textures[ data.uuid ] = texture;
  
  			}
  
  		}
  
  		return textures;
  
  	}
  
  	parseObject( data, geometries, materials, textures, animations ) {
  
  		let object;
  
  		function getGeometry( name ) {
  
  			if ( geometries[ name ] === undefined ) {
  
  				console.warn( 'THREE.ObjectLoader: Undefined geometry', name );
  
  			}
  
  			return geometries[ name ];
  
  		}
  
  		function getMaterial( name ) {
  
  			if ( name === undefined ) return undefined;
  
  			if ( Array.isArray( name ) ) {
  
  				const array = [];
  
  				for ( let i = 0, l = name.length; i < l; i ++ ) {
  
  					const uuid = name[ i ];
  
  					if ( materials[ uuid ] === undefined ) {
  
  						console.warn( 'THREE.ObjectLoader: Undefined material', uuid );
  
  					}
  
  					array.push( materials[ uuid ] );
  
  				}
  
  				return array;
  
  			}
  
  			if ( materials[ name ] === undefined ) {
  
  				console.warn( 'THREE.ObjectLoader: Undefined material', name );
  
  			}
  
  			return materials[ name ];
  
  		}
  
  		function getTexture( uuid ) {
  
  			if ( textures[ uuid ] === undefined ) {
  
  				console.warn( 'THREE.ObjectLoader: Undefined texture', uuid );
  
  			}
  
  			return textures[ uuid ];
  
  		}
  
  		let geometry, material;
  
  		switch ( data.type ) {
  
  			case 'Scene':
  
  				object = new Scene();
  
  				if ( data.background !== undefined ) {
  
  					if ( Number.isInteger( data.background ) ) {
  
  						object.background = new Color( data.background );
  
  					} else {
  
  						object.background = getTexture( data.background );
  
  					}
  
  				}
  
  				if ( data.environment !== undefined ) {
  
  					object.environment = getTexture( data.environment );
  
  				}
  
  				if ( data.fog !== undefined ) {
  
  					if ( data.fog.type === 'Fog' ) {
  
  						object.fog = new Fog( data.fog.color, data.fog.near, data.fog.far );
  
  					} else if ( data.fog.type === 'FogExp2' ) {
  
  						object.fog = new FogExp2( data.fog.color, data.fog.density );
  
  					}
  
  				}
  
  				break;
  
  			case 'PerspectiveCamera':
  
  				object = new PerspectiveCamera( data.fov, data.aspect, data.near, data.far );
  
  				if ( data.focus !== undefined ) object.focus = data.focus;
  				if ( data.zoom !== undefined ) object.zoom = data.zoom;
  				if ( data.filmGauge !== undefined ) object.filmGauge = data.filmGauge;
  				if ( data.filmOffset !== undefined ) object.filmOffset = data.filmOffset;
  				if ( data.view !== undefined ) object.view = Object.assign( {}, data.view );
  
  				break;
  
  			case 'OrthographicCamera':
  
  				object = new OrthographicCamera( data.left, data.right, data.top, data.bottom, data.near, data.far );
  
  				if ( data.zoom !== undefined ) object.zoom = data.zoom;
  				if ( data.view !== undefined ) object.view = Object.assign( {}, data.view );
  
  				break;
  
  			case 'AmbientLight':
  
  				object = new AmbientLight( data.color, data.intensity );
  
  				break;
  
  			case 'DirectionalLight':
  
  				object = new DirectionalLight( data.color, data.intensity );
  
  				break;
  
  			case 'PointLight':
  
  				object = new PointLight( data.color, data.intensity, data.distance, data.decay );
  
  				break;
  
  			case 'RectAreaLight':
  
  				object = new RectAreaLight( data.color, data.intensity, data.width, data.height );
  
  				break;
  
  			case 'SpotLight':
  
  				object = new SpotLight( data.color, data.intensity, data.distance, data.angle, data.penumbra, data.decay );
  
  				break;
  
  			case 'HemisphereLight':
  
  				object = new HemisphereLight( data.color, data.groundColor, data.intensity );
  
  				break;
  
  			case 'LightProbe':
  
  				object = new LightProbe().fromJSON( data );
  
  				break;
  
  			case 'SkinnedMesh':
  
  				geometry = getGeometry( data.geometry );
  			 	material = getMaterial( data.material );
  
  				object = new SkinnedMesh( geometry, material );
  
  				if ( data.bindMode !== undefined ) object.bindMode = data.bindMode;
  				if ( data.bindMatrix !== undefined ) object.bindMatrix.fromArray( data.bindMatrix );
  				if ( data.skeleton !== undefined ) object.skeleton = data.skeleton;
  
  				break;
  
  			case 'Mesh':
  
  				geometry = getGeometry( data.geometry );
  				material = getMaterial( data.material );
  
  				object = new Mesh( geometry, material );
  
  				break;
  
  			case 'InstancedMesh':
  
  				geometry = getGeometry( data.geometry );
  				material = getMaterial( data.material );
  				const count = data.count;
  				const instanceMatrix = data.instanceMatrix;
  				const instanceColor = data.instanceColor;
  
  				object = new InstancedMesh( geometry, material, count );
  				object.instanceMatrix = new BufferAttribute( new Float32Array( instanceMatrix.array ), 16 );
  				if ( instanceColor !== undefined ) object.instanceColor = new BufferAttribute( new Float32Array( instanceColor.array ), instanceColor.itemSize );
  
  				break;
  
  			case 'LOD':
  
  				object = new LOD();
  
  				break;
  
  			case 'Line':
  
  				object = new Line( getGeometry( data.geometry ), getMaterial( data.material ) );
  
  				break;
  
  			case 'LineLoop':
  
  				object = new LineLoop( getGeometry( data.geometry ), getMaterial( data.material ) );
  
  				break;
  
  			case 'LineSegments':
  
  				object = new LineSegments( getGeometry( data.geometry ), getMaterial( data.material ) );
  
  				break;
  
  			case 'PointCloud':
  			case 'Points':
  
  				object = new Points( getGeometry( data.geometry ), getMaterial( data.material ) );
  
  				break;
  
  			case 'Sprite':
  
  				object = new Sprite( getMaterial( data.material ) );
  
  				break;
  
  			case 'Group':
  
  				object = new Group();
  
  				break;
  
  			case 'Bone':
  
  				object = new Bone();
  
  				break;
  
  			default:
  
  				object = new Object3D();
  
  		}
  
  		object.uuid = data.uuid;
  
  		if ( data.name !== undefined ) object.name = data.name;
  
  		if ( data.matrix !== undefined ) {
  
  			object.matrix.fromArray( data.matrix );
  
  			if ( data.matrixAutoUpdate !== undefined ) object.matrixAutoUpdate = data.matrixAutoUpdate;
  			if ( object.matrixAutoUpdate ) object.matrix.decompose( object.position, object.quaternion, object.scale );
  
  		} else {
  
  			if ( data.position !== undefined ) object.position.fromArray( data.position );
  			if ( data.rotation !== undefined ) object.rotation.fromArray( data.rotation );
  			if ( data.quaternion !== undefined ) object.quaternion.fromArray( data.quaternion );
  			if ( data.scale !== undefined ) object.scale.fromArray( data.scale );
  
  		}
  
  		if ( data.castShadow !== undefined ) object.castShadow = data.castShadow;
  		if ( data.receiveShadow !== undefined ) object.receiveShadow = data.receiveShadow;
  
  		if ( data.shadow ) {
  
  			if ( data.shadow.bias !== undefined ) object.shadow.bias = data.shadow.bias;
  			if ( data.shadow.normalBias !== undefined ) object.shadow.normalBias = data.shadow.normalBias;
  			if ( data.shadow.radius !== undefined ) object.shadow.radius = data.shadow.radius;
  			if ( data.shadow.mapSize !== undefined ) object.shadow.mapSize.fromArray( data.shadow.mapSize );
  			if ( data.shadow.camera !== undefined ) object.shadow.camera = this.parseObject( data.shadow.camera );
  
  		}
  
  		if ( data.visible !== undefined ) object.visible = data.visible;
  		if ( data.frustumCulled !== undefined ) object.frustumCulled = data.frustumCulled;
  		if ( data.renderOrder !== undefined ) object.renderOrder = data.renderOrder;
  		if ( data.userData !== undefined ) object.userData = data.userData;
  		if ( data.layers !== undefined ) object.layers.mask = data.layers;
  
  		if ( data.children !== undefined ) {
  
  			const children = data.children;
  
  			for ( let i = 0; i < children.length; i ++ ) {
  
  				object.add( this.parseObject( children[ i ], geometries, materials, textures, animations ) );
  
  			}
  
  		}
  
  		if ( data.animations !== undefined ) {
  
  			const objectAnimations = data.animations;
  
  			for ( let i = 0; i < objectAnimations.length; i ++ ) {
  
  				const uuid = objectAnimations[ i ];
  
  				object.animations.push( animations[ uuid ] );
  
  			}
  
  		}
  
  		if ( data.type === 'LOD' ) {
  
  			if ( data.autoUpdate !== undefined ) object.autoUpdate = data.autoUpdate;
  
  			const levels = data.levels;
  
  			for ( let l = 0; l < levels.length; l ++ ) {
  
  				const level = levels[ l ];
  				const child = object.getObjectByProperty( 'uuid', level.object );
  
  				if ( child !== undefined ) {
  
  					object.addLevel( child, level.distance );
  
  				}
  
  			}
  
  		}
  
  		return object;
  
  	}
  
  	bindSkeletons( object, skeletons ) {
  
  		if ( Object.keys( skeletons ).length === 0 ) return;
  
  		object.traverse( function ( child ) {
  
  			if ( child.isSkinnedMesh === true && child.skeleton !== undefined ) {
  
  				const skeleton = skeletons[ child.skeleton ];
  
  				if ( skeleton === undefined ) {
  
  					console.warn( 'THREE.ObjectLoader: No skeleton found with UUID:', child.skeleton );
  
  				} else {
  
  					child.bind( skeleton, child.bindMatrix );
  
  				}
  
  			}
  
  		} );
  
  	}
  
  	/* DEPRECATED */
  
  	setTexturePath( value ) {
  
  		console.warn( 'THREE.ObjectLoader: .setTexturePath() has been renamed to .setResourcePath().' );
  		return this.setResourcePath( value );
  
  	}
  
  }
  
  const TEXTURE_MAPPING = {
  	UVMapping: UVMapping,
  	CubeReflectionMapping: CubeReflectionMapping,
  	CubeRefractionMapping: CubeRefractionMapping,
  	EquirectangularReflectionMapping: EquirectangularReflectionMapping,
  	EquirectangularRefractionMapping: EquirectangularRefractionMapping,
  	CubeUVReflectionMapping: CubeUVReflectionMapping,
  	CubeUVRefractionMapping: CubeUVRefractionMapping
  };
  
  const TEXTURE_WRAPPING = {
  	RepeatWrapping: RepeatWrapping,
  	ClampToEdgeWrapping: ClampToEdgeWrapping,
  	MirroredRepeatWrapping: MirroredRepeatWrapping
  };
  
  const TEXTURE_FILTER = {
  	NearestFilter: NearestFilter,
  	NearestMipmapNearestFilter: NearestMipmapNearestFilter,
  	NearestMipmapLinearFilter: NearestMipmapLinearFilter,
  	LinearFilter: LinearFilter,
  	LinearMipmapNearestFilter: LinearMipmapNearestFilter,
  	LinearMipmapLinearFilter: LinearMipmapLinearFilter
  };
  
  export { ObjectLoader };
  