super-three 0.147.1 → 0.154.0

package/examples/js/loaders/LWOLoader.js

@@ -1,901 +0,0 @@
-( function () {
-
-	/**
- * @version 1.1.1
- *
- * @desc Load files in LWO3 and LWO2 format on Three.js
- *
- * LWO3 format specification:
- *  https://static.lightwave3d.com/sdk/2019/html/filefmts/lwo3.html
- *
- * LWO2 format specification:
- *  https://static.lightwave3d.com/sdk/2019/html/filefmts/lwo2.html
- *
- **/
-	let _lwoTree;
-	class LWOLoader extends THREE.Loader {
-
-		constructor( manager, parameters = {} ) {
-
-			super( manager );
-			this.resourcePath = parameters.resourcePath !== undefined ? parameters.resourcePath : '';
-
-		}
-		load( url, onLoad, onProgress, onError ) {
-
-			const scope = this;
-			const path = scope.path === '' ? extractParentUrl( url, 'Objects' ) : scope.path;
-
-			// give the mesh a default name based on the filename
-			const modelName = url.split( path ).pop().split( '.' )[ 0 ];
-			const loader = new THREE.FileLoader( this.manager );
-			loader.setPath( scope.path );
-			loader.setResponseType( 'arraybuffer' );
-			loader.load( url, function ( buffer ) {
-
-				// console.time( 'Total parsing: ' );
-
-				try {
-
-					onLoad( scope.parse( buffer, path, modelName ) );
-
-				} catch ( e ) {
-
-					if ( onError ) {
-
-						onError( e );
-
-					} else {
-
-						console.error( e );
-
-					}
-
-					scope.manager.itemError( url );
-
-				}
-
-				// console.timeEnd( 'Total parsing: ' );
-
-			}, onProgress, onError );
-
-		}
-		parse( iffBuffer, path, modelName ) {
-
-			_lwoTree = new THREE.IFFParser().parse( iffBuffer );
-
-			// console.log( 'lwoTree', lwoTree );
-
-			const textureLoader = new THREE.TextureLoader( this.manager ).setPath( this.resourcePath || path ).setCrossOrigin( this.crossOrigin );
-			return new LWOTreeParser( textureLoader ).parse( modelName );
-
-		}
-
-	}
-
-	// Parse the lwoTree object
-	class LWOTreeParser {
-
-		constructor( textureLoader ) {
-
-			this.textureLoader = textureLoader;
-
-		}
-		parse( modelName ) {
-
-			this.materials = new MaterialParser( this.textureLoader ).parse();
-			this.defaultLayerName = modelName;
-			this.meshes = this.parseLayers();
-			return {
-				materials: this.materials,
-				meshes: this.meshes
-			};
-
-		}
-		parseLayers() {
-
-			// array of all meshes for building hierarchy
-			const meshes = [];
-
-			// final array containing meshes with scene graph hierarchy set up
-			const finalMeshes = [];
-			const geometryParser = new GeometryParser();
-			const scope = this;
-			_lwoTree.layers.forEach( function ( layer ) {
-
-				const geometry = geometryParser.parse( layer.geometry, layer );
-				const mesh = scope.parseMesh( geometry, layer );
-				meshes[ layer.number ] = mesh;
-				if ( layer.parent === - 1 ) finalMeshes.push( mesh ); else meshes[ layer.parent ].add( mesh );
-
-			} );
-			this.applyPivots( finalMeshes );
-			return finalMeshes;
-
-		}
-		parseMesh( geometry, layer ) {
-
-			let mesh;
-			const materials = this.getMaterials( geometry.userData.matNames, layer.geometry.type );
-			this.duplicateUVs( geometry, materials );
-			if ( layer.geometry.type === 'points' ) mesh = new THREE.Points( geometry, materials ); else if ( layer.geometry.type === 'lines' ) mesh = new THREE.LineSegments( geometry, materials ); else mesh = new THREE.Mesh( geometry, materials );
-			if ( layer.name ) mesh.name = layer.name; else mesh.name = this.defaultLayerName + '_layer_' + layer.number;
-			mesh.userData.pivot = layer.pivot;
-			return mesh;
-
-		}
-
-		// TODO: may need to be reversed in z to convert LWO to three.js coordinates
-		applyPivots( meshes ) {
-
-			meshes.forEach( function ( mesh ) {
-
-				mesh.traverse( function ( child ) {
-
-					const pivot = child.userData.pivot;
-					child.position.x += pivot[ 0 ];
-					child.position.y += pivot[ 1 ];
-					child.position.z += pivot[ 2 ];
-					if ( child.parent ) {
-
-						const parentPivot = child.parent.userData.pivot;
-						child.position.x -= parentPivot[ 0 ];
-						child.position.y -= parentPivot[ 1 ];
-						child.position.z -= parentPivot[ 2 ];
-
-					}
-
-				} );
-
-			} );
-
-		}
-		getMaterials( namesArray, type ) {
-
-			const materials = [];
-			const scope = this;
-			namesArray.forEach( function ( name, i ) {
-
-				materials[ i ] = scope.getMaterialByName( name );
-
-			} );
-
-			// convert materials to line or point mats if required
-			if ( type === 'points' || type === 'lines' ) {
-
-				materials.forEach( function ( mat, i ) {
-
-					const spec = {
-						color: mat.color
-					};
-					if ( type === 'points' ) {
-
-						spec.size = 0.1;
-						spec.map = mat.map;
-						materials[ i ] = new THREE.PointsMaterial( spec );
-
-					} else if ( type === 'lines' ) {
-
-						materials[ i ] = new THREE.LineBasicMaterial( spec );
-
-					}
-
-				} );
-
-			}
-
-			// if there is only one material, return that directly instead of array
-			const filtered = materials.filter( Boolean );
-			if ( filtered.length === 1 ) return filtered[ 0 ];
-			return materials;
-
-		}
-		getMaterialByName( name ) {
-
-			return this.materials.filter( function ( m ) {
-
-				return m.name === name;
-
-			} )[ 0 ];
-
-		}
-
-		// If the material has an aoMap, duplicate UVs
-		duplicateUVs( geometry, materials ) {
-
-			let duplicateUVs = false;
-			if ( ! Array.isArray( materials ) ) {
-
-				if ( materials.aoMap ) duplicateUVs = true;
-
-			} else {
-
-				materials.forEach( function ( material ) {
-
-					if ( material.aoMap ) duplicateUVs = true;
-
-				} );
-
-			}
-
-			if ( ! duplicateUVs ) return;
-			geometry.setAttribute( 'uv2', new THREE.BufferAttribute( geometry.attributes.uv.array, 2 ) );
-
-		}
-
-	}
-	class MaterialParser {
-
-		constructor( textureLoader ) {
-
-			this.textureLoader = textureLoader;
-
-		}
-		parse() {
-
-			const materials = [];
-			this.textures = {};
-			for ( const name in _lwoTree.materials ) {
-
-				if ( _lwoTree.format === 'LWO3' ) {
-
-					materials.push( this.parseMaterial( _lwoTree.materials[ name ], name, _lwoTree.textures ) );
-
-				} else if ( _lwoTree.format === 'LWO2' ) {
-
-					materials.push( this.parseMaterialLwo2( _lwoTree.materials[ name ], name, _lwoTree.textures ) );
-
-				}
-
-			}
-
-			return materials;
-
-		}
-		parseMaterial( materialData, name, textures ) {
-
-			let params = {
-				name: name,
-				side: this.getSide( materialData.attributes ),
-				flatShading: this.getSmooth( materialData.attributes )
-			};
-			const connections = this.parseConnections( materialData.connections, materialData.nodes );
-			const maps = this.parseTextureNodes( connections.maps );
-			this.parseAttributeImageMaps( connections.attributes, textures, maps, materialData.maps );
-			const attributes = this.parseAttributes( connections.attributes, maps );
-			this.parseEnvMap( connections, maps, attributes );
-			params = Object.assign( maps, params );
-			params = Object.assign( params, attributes );
-			const materialType = this.getMaterialType( connections.attributes );
-			if ( materialType !== THREE.MeshPhongMaterial ) delete params.refractionRatio; // PBR materials do not support "refractionRatio"
-
-			return new materialType( params );
-
-		}
-		parseMaterialLwo2( materialData, name /*, textures*/ ) {
-
-			let params = {
-				name: name,
-				side: this.getSide( materialData.attributes ),
-				flatShading: this.getSmooth( materialData.attributes )
-			};
-			const attributes = this.parseAttributes( materialData.attributes, {} );
-			params = Object.assign( params, attributes );
-			return new THREE.MeshPhongMaterial( params );
-
-		}
-
-		// Note: converting from left to right handed coords by switching x -> -x in vertices, and
-		// then switching mat THREE.FrontSide -> THREE.BackSide
-		// NB: this means that THREE.FrontSide and THREE.BackSide have been switched!
-		getSide( attributes ) {
-
-			if ( ! attributes.side ) return THREE.BackSide;
-			switch ( attributes.side ) {
-
-				case 0:
-				case 1:
-					return THREE.BackSide;
-				case 2:
-					return THREE.FrontSide;
-				case 3:
-					return THREE.DoubleSide;
-
-			}
-
-		}
-		getSmooth( attributes ) {
-
-			if ( ! attributes.smooth ) return true;
-			return ! attributes.smooth;
-
-		}
-		parseConnections( connections, nodes ) {
-
-			const materialConnections = {
-				maps: {}
-			};
-			const inputName = connections.inputName;
-			const inputNodeName = connections.inputNodeName;
-			const nodeName = connections.nodeName;
-			const scope = this;
-			inputName.forEach( function ( name, index ) {
-
-				if ( name === 'Material' ) {
-
-					const matNode = scope.getNodeByRefName( inputNodeName[ index ], nodes );
-					materialConnections.attributes = matNode.attributes;
-					materialConnections.envMap = matNode.fileName;
-					materialConnections.name = inputNodeName[ index ];
-
-				}
-
-			} );
-			nodeName.forEach( function ( name, index ) {
-
-				if ( name === materialConnections.name ) {
-
-					materialConnections.maps[ inputName[ index ] ] = scope.getNodeByRefName( inputNodeName[ index ], nodes );
-
-				}
-
-			} );
-			return materialConnections;
-
-		}
-		getNodeByRefName( refName, nodes ) {
-
-			for ( const name in nodes ) {
-
-				if ( nodes[ name ].refName === refName ) return nodes[ name ];
-
-			}
-
-		}
-		parseTextureNodes( textureNodes ) {
-
-			const maps = {};
-			for ( const name in textureNodes ) {
-
-				const node = textureNodes[ name ];
-				const path = node.fileName;
-				if ( ! path ) return;
-				const texture = this.loadTexture( path );
-				if ( node.widthWrappingMode !== undefined ) texture.wrapS = this.getWrappingType( node.widthWrappingMode );
-				if ( node.heightWrappingMode !== undefined ) texture.wrapT = this.getWrappingType( node.heightWrappingMode );
-				switch ( name ) {
-
-					case 'Color':
-						maps.map = texture;
-						break;
-					case 'Roughness':
-						maps.roughnessMap = texture;
-						maps.roughness = 1;
-						break;
-					case 'Specular':
-						maps.specularMap = texture;
-						maps.specular = 0xffffff;
-						break;
-					case 'Luminous':
-						maps.emissiveMap = texture;
-						maps.emissive = 0x808080;
-						break;
-					case 'Luminous THREE.Color':
-						maps.emissive = 0x808080;
-						break;
-					case 'Metallic':
-						maps.metalnessMap = texture;
-						maps.metalness = 1;
-						break;
-					case 'Transparency':
-					case 'Alpha':
-						maps.alphaMap = texture;
-						maps.transparent = true;
-						break;
-					case 'Normal':
-						maps.normalMap = texture;
-						if ( node.amplitude !== undefined ) maps.normalScale = new THREE.Vector2( node.amplitude, node.amplitude );
-						break;
-					case 'Bump':
-						maps.bumpMap = texture;
-						break;
-
-				}
-
-			}
-
-			// LWO BSDF materials can have both spec and rough, but this is not valid in three
-			if ( maps.roughnessMap && maps.specularMap ) delete maps.specularMap;
-			return maps;
-
-		}
-
-		// maps can also be defined on individual material attributes, parse those here
-		// This occurs on Standard (Phong) surfaces
-		parseAttributeImageMaps( attributes, textures, maps ) {
-
-			for ( const name in attributes ) {
-
-				const attribute = attributes[ name ];
-				if ( attribute.maps ) {
-
-					const mapData = attribute.maps[ 0 ];
-					const path = this.getTexturePathByIndex( mapData.imageIndex, textures );
-					if ( ! path ) return;
-					const texture = this.loadTexture( path );
-					if ( mapData.wrap !== undefined ) texture.wrapS = this.getWrappingType( mapData.wrap.w );
-					if ( mapData.wrap !== undefined ) texture.wrapT = this.getWrappingType( mapData.wrap.h );
-					switch ( name ) {
-
-						case 'Color':
-							maps.map = texture;
-							break;
-						case 'Diffuse':
-							maps.aoMap = texture;
-							break;
-						case 'Roughness':
-							maps.roughnessMap = texture;
-							maps.roughness = 1;
-							break;
-						case 'Specular':
-							maps.specularMap = texture;
-							maps.specular = 0xffffff;
-							break;
-						case 'Luminosity':
-							maps.emissiveMap = texture;
-							maps.emissive = 0x808080;
-							break;
-						case 'Metallic':
-							maps.metalnessMap = texture;
-							maps.metalness = 1;
-							break;
-						case 'Transparency':
-						case 'Alpha':
-							maps.alphaMap = texture;
-							maps.transparent = true;
-							break;
-						case 'Normal':
-							maps.normalMap = texture;
-							break;
-						case 'Bump':
-							maps.bumpMap = texture;
-							break;
-
-					}
-
-				}
-
-			}
-
-		}
-		parseAttributes( attributes, maps ) {
-
-			const params = {};
-
-			// don't use color data if color map is present
-			if ( attributes.Color && ! maps.map ) {
-
-				params.color = new THREE.Color().fromArray( attributes.Color.value );
-
-			} else params.color = new THREE.Color();
-			if ( attributes.Transparency && attributes.Transparency.value !== 0 ) {
-
-				params.opacity = 1 - attributes.Transparency.value;
-				params.transparent = true;
-
-			}
-
-			if ( attributes[ 'Bump Height' ] ) params.bumpScale = attributes[ 'Bump Height' ].value * 0.1;
-			this.parsePhysicalAttributes( params, attributes, maps );
-			this.parseStandardAttributes( params, attributes, maps );
-			this.parsePhongAttributes( params, attributes, maps );
-			return params;
-
-		}
-		parsePhysicalAttributes( params, attributes /*, maps*/ ) {
-
-			if ( attributes.Clearcoat && attributes.Clearcoat.value > 0 ) {
-
-				params.clearcoat = attributes.Clearcoat.value;
-				if ( attributes[ 'Clearcoat Gloss' ] ) {
-
-					params.clearcoatRoughness = 0.5 * ( 1 - attributes[ 'Clearcoat Gloss' ].value );
-
-				}
-
-			}
-
-		}
-		parseStandardAttributes( params, attributes, maps ) {
-
-			if ( attributes.Luminous ) {
-
-				params.emissiveIntensity = attributes.Luminous.value;
-				if ( attributes[ 'Luminous THREE.Color' ] && ! maps.emissive ) {
-
-					params.emissive = new THREE.Color().fromArray( attributes[ 'Luminous THREE.Color' ].value );
-
-				} else {
-
-					params.emissive = new THREE.Color( 0x808080 );
-
-				}
-
-			}
-
-			if ( attributes.Roughness && ! maps.roughnessMap ) params.roughness = attributes.Roughness.value;
-			if ( attributes.Metallic && ! maps.metalnessMap ) params.metalness = attributes.Metallic.value;
-
-		}
-		parsePhongAttributes( params, attributes, maps ) {
-
-			if ( attributes[ 'Refraction Index' ] ) params.refractionRatio = 0.98 / attributes[ 'Refraction Index' ].value;
-			if ( attributes.Diffuse ) params.color.multiplyScalar( attributes.Diffuse.value );
-			if ( attributes.Reflection ) {
-
-				params.reflectivity = attributes.Reflection.value;
-				params.combine = THREE.AddOperation;
-
-			}
-
-			if ( attributes.Luminosity ) {
-
-				params.emissiveIntensity = attributes.Luminosity.value;
-				if ( ! maps.emissiveMap && ! maps.map ) {
-
-					params.emissive = params.color;
-
-				} else {
-
-					params.emissive = new THREE.Color( 0x808080 );
-
-				}
-
-			}
-
-			// parse specular if there is no roughness - we will interpret the material as 'Phong' in this case
-			if ( ! attributes.Roughness && attributes.Specular && ! maps.specularMap ) {
-
-				if ( attributes[ 'Color Highlight' ] ) {
-
-					params.specular = new THREE.Color().setScalar( attributes.Specular.value ).lerp( params.color.clone().multiplyScalar( attributes.Specular.value ), attributes[ 'Color Highlight' ].value );
-
-				} else {
-
-					params.specular = new THREE.Color().setScalar( attributes.Specular.value );
-
-				}
-
-			}
-
-			if ( params.specular && attributes.Glossiness ) params.shininess = 7 + Math.pow( 2, attributes.Glossiness.value * 12 + 2 );
-
-		}
-		parseEnvMap( connections, maps, attributes ) {
-
-			if ( connections.envMap ) {
-
-				const envMap = this.loadTexture( connections.envMap );
-				if ( attributes.transparent && attributes.opacity < 0.999 ) {
-
-					envMap.mapping = THREE.EquirectangularRefractionMapping;
-
-					// Reflectivity and refraction mapping don't work well together in Phong materials
-					if ( attributes.reflectivity !== undefined ) {
-
-						delete attributes.reflectivity;
-						delete attributes.combine;
-
-					}
-
-					if ( attributes.metalness !== undefined ) {
-
-						attributes.metalness = 1; // For most transparent materials metalness should be set to 1 if not otherwise defined. If set to 0 no refraction will be visible
-
-					}
-
-					attributes.opacity = 1; // transparency fades out refraction, forcing opacity to 1 ensures a closer visual match to the material in Lightwave.
-
-				} else envMap.mapping = THREE.EquirectangularReflectionMapping;
-				maps.envMap = envMap;
-
-			}
-
-		}
-
-		// get texture defined at top level by its index
-		getTexturePathByIndex( index ) {
-
-			let fileName = '';
-			if ( ! _lwoTree.textures ) return fileName;
-			_lwoTree.textures.forEach( function ( texture ) {
-
-				if ( texture.index === index ) fileName = texture.fileName;
-
-			} );
-			return fileName;
-
-		}
-		loadTexture( path ) {
-
-			if ( ! path ) return null;
-			const texture = this.textureLoader.load( path, undefined, undefined, function () {
-
-				console.warn( 'LWOLoader: non-standard resource hierarchy. Use \`resourcePath\` parameter to specify root content directory.' );
-
-			} );
-			return texture;
-
-		}
-
-		// 0 = Reset, 1 = Repeat, 2 = Mirror, 3 = Edge
-		getWrappingType( num ) {
-
-			switch ( num ) {
-
-				case 0:
-					console.warn( 'LWOLoader: "Reset" texture wrapping type is not supported in three.js' );
-					return THREE.ClampToEdgeWrapping;
-				case 1:
-					return THREE.RepeatWrapping;
-				case 2:
-					return THREE.MirroredRepeatWrapping;
-				case 3:
-					return THREE.ClampToEdgeWrapping;
-
-			}
-
-		}
-		getMaterialType( nodeData ) {
-
-			if ( nodeData.Clearcoat && nodeData.Clearcoat.value > 0 ) return THREE.MeshPhysicalMaterial;
-			if ( nodeData.Roughness ) return THREE.MeshStandardMaterial;
-			return THREE.MeshPhongMaterial;
-
-		}
-
-	}
-	class GeometryParser {
-
-		parse( geoData, layer ) {
-
-			const geometry = new THREE.BufferGeometry();
-			geometry.setAttribute( 'position', new THREE.Float32BufferAttribute( geoData.points, 3 ) );
-			const indices = this.splitIndices( geoData.vertexIndices, geoData.polygonDimensions );
-			geometry.setIndex( indices );
-			this.parseGroups( geometry, geoData );
-			geometry.computeVertexNormals();
-			this.parseUVs( geometry, layer, indices );
-			this.parseMorphTargets( geometry, layer, indices );
-
-			// TODO: z may need to be reversed to account for coordinate system change
-			geometry.translate( - layer.pivot[ 0 ], - layer.pivot[ 1 ], - layer.pivot[ 2 ] );
-
-			// let userData = geometry.userData;
-			// geometry = geometry.toNonIndexed()
-			// geometry.userData = userData;
-
-			return geometry;
-
-		}
-
-		// split quads into tris
-		splitIndices( indices, polygonDimensions ) {
-
-			const remappedIndices = [];
-			let i = 0;
-			polygonDimensions.forEach( function ( dim ) {
-
-				if ( dim < 4 ) {
-
-					for ( let k = 0; k < dim; k ++ ) remappedIndices.push( indices[ i + k ] );
-
-				} else if ( dim === 4 ) {
-
-					remappedIndices.push( indices[ i ], indices[ i + 1 ], indices[ i + 2 ], indices[ i ], indices[ i + 2 ], indices[ i + 3 ] );
-
-				} else if ( dim > 4 ) {
-
-					for ( let k = 1; k < dim - 1; k ++ ) {
-
-						remappedIndices.push( indices[ i ], indices[ i + k ], indices[ i + k + 1 ] );
-
-					}
-
-					console.warn( 'LWOLoader: polygons with greater than 4 sides are not supported' );
-
-				}
-
-				i += dim;
-
-			} );
-			return remappedIndices;
-
-		}
-
-		// NOTE: currently ignoring poly indices and assuming that they are intelligently ordered
-		parseGroups( geometry, geoData ) {
-
-			const tags = _lwoTree.tags;
-			const matNames = [];
-			let elemSize = 3;
-			if ( geoData.type === 'lines' ) elemSize = 2;
-			if ( geoData.type === 'points' ) elemSize = 1;
-			const remappedIndices = this.splitMaterialIndices( geoData.polygonDimensions, geoData.materialIndices );
-			let indexNum = 0; // create new indices in numerical order
-			const indexPairs = {}; // original indices mapped to numerical indices
-
-			let prevMaterialIndex;
-			let materialIndex;
-			let prevStart = 0;
-			let currentCount = 0;
-			for ( let i = 0; i < remappedIndices.length; i += 2 ) {
-
-				materialIndex = remappedIndices[ i + 1 ];
-				if ( i === 0 ) matNames[ indexNum ] = tags[ materialIndex ];
-				if ( prevMaterialIndex === undefined ) prevMaterialIndex = materialIndex;
-				if ( materialIndex !== prevMaterialIndex ) {
-
-					let currentIndex;
-					if ( indexPairs[ tags[ prevMaterialIndex ] ] ) {
-
-						currentIndex = indexPairs[ tags[ prevMaterialIndex ] ];
-
-					} else {
-
-						currentIndex = indexNum;
-						indexPairs[ tags[ prevMaterialIndex ] ] = indexNum;
-						matNames[ indexNum ] = tags[ prevMaterialIndex ];
-						indexNum ++;
-
-					}
-
-					geometry.addGroup( prevStart, currentCount, currentIndex );
-					prevStart += currentCount;
-					prevMaterialIndex = materialIndex;
-					currentCount = 0;
-
-				}
-
-				currentCount += elemSize;
-
-			}
-
-			// the loop above doesn't add the last group, do that here.
-			if ( geometry.groups.length > 0 ) {
-
-				let currentIndex;
-				if ( indexPairs[ tags[ materialIndex ] ] ) {
-
-					currentIndex = indexPairs[ tags[ materialIndex ] ];
-
-				} else {
-
-					currentIndex = indexNum;
-					indexPairs[ tags[ materialIndex ] ] = indexNum;
-					matNames[ indexNum ] = tags[ materialIndex ];
-
-				}
-
-				geometry.addGroup( prevStart, currentCount, currentIndex );
-
-			}
-
-			// Mat names from TAGS chunk, used to build up an array of materials for this geometry
-			geometry.userData.matNames = matNames;
-
-		}
-		splitMaterialIndices( polygonDimensions, indices ) {
-
-			const remappedIndices = [];
-			polygonDimensions.forEach( function ( dim, i ) {
-
-				if ( dim <= 3 ) {
-
-					remappedIndices.push( indices[ i * 2 ], indices[ i * 2 + 1 ] );
-
-				} else if ( dim === 4 ) {
-
-					remappedIndices.push( indices[ i * 2 ], indices[ i * 2 + 1 ], indices[ i * 2 ], indices[ i * 2 + 1 ] );
-
-				} else {
-
-					// ignore > 4 for now
-					for ( let k = 0; k < dim - 2; k ++ ) {
-
-						remappedIndices.push( indices[ i * 2 ], indices[ i * 2 + 1 ] );
-
-					}
-
-				}
-
-			} );
-			return remappedIndices;
-
-		}
-
-		// UV maps:
-		// 1: are defined via index into an array of points, not into a geometry
-		// - the geometry is also defined by an index into this array, but the indexes may not match
-		// 2: there can be any number of UV maps for a single geometry. Here these are combined,
-		// 	with preference given to the first map encountered
-		// 3: UV maps can be partial - that is, defined for only a part of the geometry
-		// 4: UV maps can be VMAP or VMAD (discontinuous, to allow for seams). In practice, most
-		// UV maps are defined as partially VMAP and partially VMAD
-		// VMADs are currently not supported
-		parseUVs( geometry, layer ) {
-
-			// start by creating a UV map set to zero for the whole geometry
-			const remappedUVs = Array.from( Array( geometry.attributes.position.count * 2 ), function () {
-
-				return 0;
-
-			} );
-			for ( const name in layer.uvs ) {
-
-				const uvs = layer.uvs[ name ].uvs;
-				const uvIndices = layer.uvs[ name ].uvIndices;
-				uvIndices.forEach( function ( i, j ) {
-
-					remappedUVs[ i * 2 ] = uvs[ j * 2 ];
-					remappedUVs[ i * 2 + 1 ] = uvs[ j * 2 + 1 ];
-
-				} );
-
-			}
-
-			geometry.setAttribute( 'uv', new THREE.Float32BufferAttribute( remappedUVs, 2 ) );
-
-		}
-		parseMorphTargets( geometry, layer ) {
-
-			let num = 0;
-			for ( const name in layer.morphTargets ) {
-
-				const remappedPoints = geometry.attributes.position.array.slice();
-				if ( ! geometry.morphAttributes.position ) geometry.morphAttributes.position = [];
-				const morphPoints = layer.morphTargets[ name ].points;
-				const morphIndices = layer.morphTargets[ name ].indices;
-				const type = layer.morphTargets[ name ].type;
-				morphIndices.forEach( function ( i, j ) {
-
-					if ( type === 'relative' ) {
-
-						remappedPoints[ i * 3 ] += morphPoints[ j * 3 ];
-						remappedPoints[ i * 3 + 1 ] += morphPoints[ j * 3 + 1 ];
-						remappedPoints[ i * 3 + 2 ] += morphPoints[ j * 3 + 2 ];
-
-					} else {
-
-						remappedPoints[ i * 3 ] = morphPoints[ j * 3 ];
-						remappedPoints[ i * 3 + 1 ] = morphPoints[ j * 3 + 1 ];
-						remappedPoints[ i * 3 + 2 ] = morphPoints[ j * 3 + 2 ];
-
-					}
-
-				} );
-				geometry.morphAttributes.position[ num ] = new THREE.Float32BufferAttribute( remappedPoints, 3 );
-				geometry.morphAttributes.position[ num ].name = name;
-				num ++;
-
-			}
-
-			geometry.morphTargetsRelative = false;
-
-		}
-
-	}
-
-	// ************** UTILITY FUNCTIONS **************
-
-	function extractParentUrl( url, dir ) {
-
-		const index = url.indexOf( dir );
-		if ( index === - 1 ) return './';
-		return url.slice( 0, index );
-
-	}
-
-	THREE.LWOLoader = LWOLoader;
-
-} )();