super-three 0.133.4 → 0.136.1

package/examples/jsm/loaders/LDrawLoader.js

@@ -7,14 +7,15 @@ import {
 	LineBasicMaterial,
 	LineSegments,
 	Loader,
+	Matrix3,
 	Matrix4,
 	Mesh,
-	MeshPhongMaterial,
 	MeshStandardMaterial,
 	ShaderMaterial,
 	UniformsLib,
 	UniformsUtils,
-	Vector3
+	Vector3,
+	Ray
 } from 'three';
 
 // Special surface finish tag types.
@@ -168,16 +169,45 @@ class LDrawConditionalLineMaterial extends ShaderMaterial {
 
 }
 
-function smoothNormals( faces, lineSegments ) {
+function generateFaceNormals( faces ) {
 
+	for ( let i = 0, l = faces.length; i < l; i ++ ) {
+
+		const face = faces[ i ];
+		const vertices = face.vertices;
+		const v0 = vertices[ 0 ];
+		const v1 = vertices[ 1 ];
+		const v2 = vertices[ 2 ];
+
+		_tempVec0.subVectors( v1, v0 );
+		_tempVec1.subVectors( v2, v1 );
+		face.faceNormal = new Vector3()
+			.crossVectors( _tempVec0, _tempVec1 )
+			.normalize();
+
+	}
+
+}
+
+const _ray = new Ray();
+function smoothNormals( faces, lineSegments, checkSubSegments = false ) {
+
+	// NOTE: 1e2 is pretty coarse but was chosen to quantize the resulting value because
+	// it allows edges to be smoothed as expected (see minifig arms).
+	// --
+	// And the vector values are initialize multiplied by 1 + 1e-10 to account for floating
+	// point errors on vertices along quantization boundaries. Ie after matrix multiplication
+	// vertices that should be merged might be set to "1.7" and "1.6999..." meaning they won't
+	// get merged. This added epsilon attempts to push these error values to the same quantized
+	// value for the sake of hashing. See "AT-ST mini" dishes. See mrdoob/three#23169.
+
+	const hashMultiplier = ( 1 + 1e-10 ) * 1e2;
 	function hashVertex( v ) {
 
-		// NOTE: 1e2 is pretty coarse but was chosen because it allows edges
-		// to be smoothed as expected (see minifig arms). The errors between edges
-		// could be due to matrix multiplication.
-		const x = ~ ~ ( v.x * 1e2 );
-		const y = ~ ~ ( v.y * 1e2 );
-		const z = ~ ~ ( v.z * 1e2 );
+		const x = ~ ~ ( v.x * hashMultiplier );
+		const y = ~ ~ ( v.y * hashMultiplier );
+		const z = ~ ~ ( v.z * hashMultiplier );
+
 		return `${ x },${ y },${ z }`;
 
 	}
@@ -188,7 +218,27 @@ function smoothNormals( faces, lineSegments ) {
 
 	}
 
+	// converts the two vertices to a ray with a normalized direction and origin of 0, 0, 0 projected
+	// onto the original line.
+	function toNormalizedRay( v0, v1, targetRay ) {
+
+		targetRay.direction.subVectors( v1, v0 ).normalize();
+
+		const scalar = v0.dot( targetRay.direction );
+		targetRay.origin.copy( v0 ).addScaledVector( targetRay.direction, - scalar );
+
+		return targetRay;
+
+	}
+
+	function hashRay( ray ) {
+
+		return hashEdge( ray.origin, ray.direction );
+
+	}
+
 	const hardEdges = new Set();
+	const hardEdgeRays = new Map();
 	const halfEdgeList = {};
 	const normals = [];
 
@@ -202,6 +252,43 @@ function smoothNormals( faces, lineSegments ) {
 		hardEdges.add( hashEdge( v0, v1 ) );
 		hardEdges.add( hashEdge( v1, v0 ) );
 
+		// only generate the hard edge ray map if we're checking subsegments because it's more expensive to check
+		// and requires more memory.
+		if ( checkSubSegments ) {
+
+			// add both ray directions to the map
+			const ray = toNormalizedRay( v0, v1, new Ray() );
+			const rh1 = hashRay( ray );
+			if ( ! hardEdgeRays.has( rh1 ) ) {
+
+				toNormalizedRay( v1, v0, ray );
+				const rh2 = hashRay( ray );
+
+				const info = {
+					ray,
+					distances: [],
+				};
+
+				hardEdgeRays.set( rh1, info );
+				hardEdgeRays.set( rh2, info );
+
+			}
+
+			// store both segments ends in min, max order in the distances array to check if a face edge is a
+			// subsegment later.
+			const info = hardEdgeRays.get( rh1 );
+			let d0 = info.ray.direction.dot( v0 );
+			let d1 = info.ray.direction.dot( v1 );
+			if ( d0 > d1 ) {
+
+				[ d0, d1 ] = [ d1, d0 ];
+
+			}
+
+			info.distances.push( d0, d1 );
+
+		}
+
 	}
 
 	// track the half edges associated with each triangle
@@ -219,7 +306,53 @@ function smoothNormals( faces, lineSegments ) {
 			const hash = hashEdge( v0, v1 );
 
 			// don't add the triangle if the edge is supposed to be hard
-			if ( hardEdges.has( hash ) ) continue;
+			if ( hardEdges.has( hash ) ) {
+
+				continue;
+
+			}
+
+			// if checking subsegments then check to see if this edge lies on a hard edge ray and whether its within any ray bounds
+			if ( checkSubSegments ) {
+
+				toNormalizedRay( v0, v1, _ray );
+
+				const rayHash = hashRay( _ray );
+				if ( hardEdgeRays.has( rayHash ) ) {
+
+					const info = hardEdgeRays.get( rayHash );
+					const { ray, distances } = info;
+					let d0 = ray.direction.dot( v0 );
+					let d1 = ray.direction.dot( v1 );
+
+					if ( d0 > d1 ) {
+
+						[ d0, d1 ] = [ d1, d0 ];
+
+					}
+
+					// return early if the face edge is found to be a subsegment of a line edge meaning the edge will have "hard" normals
+					let found = false;
+					for ( let i = 0, l = distances.length; i < l; i += 2 ) {
+
+						if ( d0 >= distances[ i ] && d1 <= distances[ i + 1 ] ) {
+
+							found = true;
+							break;
+
+						}
+
+					}
+
+					if ( found ) {
+
+						continue;
+
+					}
+
+				}
+
+			}
 
 			const info = {
 				index: index,
@@ -463,6 +596,12 @@ class LineParser {
 
 	}
 
+	getVector() {
+
+		return new Vector3( parseFloat( this.getToken() ), parseFloat( this.getToken() ), parseFloat( this.getToken() ) );
+
+	}
+
 	getRemainingString() {
 
 		return this.line.substring( this.currentCharIndex, this.lineLength );
@@ -489,1343 +628,1454 @@ class LineParser {
 
 }
 
-class LDrawFileCache {
+class LDrawParsedCache {
 
 	constructor( loader ) {
 
-		this.cache = {};
 		this.loader = loader;
+		this.cache = {};
 
 	}
 
-	setData( key, contents ) {
-
-		this.cache[ key.toLowerCase() ] = contents;
+	cloneResult( original ) {
 
-	}
+		const result = {};
 
-	async loadData( fileName ) {
+		// vertices are transformed and normals computed before being converted to geometry
+		// so these pieces must be cloned.
+		result.faces = original.faces.map( face => {
 
-		const key = fileName.toLowerCase();
-		if ( key in this.cache ) {
+			return {
+				colorCode: face.colorCode,
+				material: face.material,
+				vertices: face.vertices.map( v => v.clone() ),
+				normals: face.normals.map( () => null ),
+				faceNormal: null
+			};
 
-			return this.cache[ key ];
+		} );
 
-		}
+		result.conditionalSegments = original.conditionalSegments.map( face => {
 
-		this.cache[ fileName ] = new Promise( async ( resolve, reject ) => {
+			return {
+				colorCode: face.colorCode,
+				material: face.material,
+				vertices: face.vertices.map( v => v.clone() ),
+				controlPoints: face.controlPoints.map( v => v.clone() )
+			};
 
-			let triedLowerCase = false;
-			let locationState = FILE_LOCATION_AS_IS;
-			while ( locationState !== FILE_LOCATION_NOT_FOUND ) {
+		} );
 
-				let subobjectURL = fileName;
-				switch ( locationState ) {
+		result.lineSegments = original.lineSegments.map( face => {
 
-					case FILE_LOCATION_AS_IS:
-						locationState = locationState + 1;
-						break;
+			return {
+				colorCode: face.colorCode,
+				material: face.material,
+				vertices: face.vertices.map( v => v.clone() )
+			};
 
-					case FILE_LOCATION_TRY_PARTS:
-						subobjectURL = 'parts/' + subobjectURL;
-						locationState = locationState + 1;
-						break;
+		} );
 
-					case FILE_LOCATION_TRY_P:
-						subobjectURL = 'p/' + subobjectURL;
-						locationState = locationState + 1;
-						break;
+		// none if this is subsequently modified
+		result.type = original.type;
+		result.category = original.category;
+		result.keywords = original.keywords;
+		result.subobjects = original.subobjects;
+		result.totalFaces = original.totalFaces;
+		result.startingConstructionStep = original.startingConstructionStep;
+		result.materials = original.materials;
+		return result;
 
-					case FILE_LOCATION_TRY_MODELS:
-						subobjectURL = 'models/' + subobjectURL;
-						locationState = locationState + 1;
-						break;
+	}
 
-					case FILE_LOCATION_TRY_RELATIVE:
-						subobjectURL = fileName.substring( 0, fileName.lastIndexOf( '/' ) + 1 ) + subobjectURL;
-						locationState = locationState + 1;
-						break;
+	async fetchData( fileName ) {
 
-					case FILE_LOCATION_TRY_ABSOLUTE:
+		let triedLowerCase = false;
+		let locationState = FILE_LOCATION_AS_IS;
+		while ( locationState !== FILE_LOCATION_NOT_FOUND ) {
 
-						if ( triedLowerCase ) {
+			let subobjectURL = fileName;
+			switch ( locationState ) {
 
-							// Try absolute path
-							locationState = FILE_LOCATION_NOT_FOUND;
+				case FILE_LOCATION_AS_IS:
+					locationState = locationState + 1;
+					break;
 
-						} else {
+				case FILE_LOCATION_TRY_PARTS:
+					subobjectURL = 'parts/' + subobjectURL;
+					locationState = locationState + 1;
+					break;
 
-							// Next attempt is lower case
-							fileName = fileName.toLowerCase();
-							subobjectURL = fileName;
-							triedLowerCase = true;
-							locationState = FILE_LOCATION_AS_IS;
+				case FILE_LOCATION_TRY_P:
+					subobjectURL = 'p/' + subobjectURL;
+					locationState = locationState + 1;
+					break;
 
-						}
+				case FILE_LOCATION_TRY_MODELS:
+					subobjectURL = 'models/' + subobjectURL;
+					locationState = locationState + 1;
+					break;
 
-						break;
+				case FILE_LOCATION_TRY_RELATIVE:
+					subobjectURL = fileName.substring( 0, fileName.lastIndexOf( '/' ) + 1 ) + subobjectURL;
+					locationState = locationState + 1;
+					break;
 
-				}
+				case FILE_LOCATION_TRY_ABSOLUTE:
 
-				const loader = this.loader;
-				const fileLoader = new FileLoader( loader.manager );
-				fileLoader.setPath( loader.partsLibraryPath );
-				fileLoader.setRequestHeader( loader.requestHeader );
-				fileLoader.setWithCredentials( loader.withCredentials );
+					if ( triedLowerCase ) {
 
-				try {
+						// Try absolute path
+						locationState = FILE_LOCATION_NOT_FOUND;
 
-					const text = await fileLoader.loadAsync( subobjectURL );
-					this.setData( fileName, text );
-					resolve( text );
-					return;
+					} else {
 
-				} catch {
+						// Next attempt is lower case
+						fileName = fileName.toLowerCase();
+						subobjectURL = fileName;
+						triedLowerCase = true;
+						locationState = FILE_LOCATION_AS_IS;
 
-					continue;
+					}
 
-				}
+					break;
 
 			}
 
-			reject();
+			const loader = this.loader;
+			const fileLoader = new FileLoader( loader.manager );
+			fileLoader.setPath( loader.partsLibraryPath );
+			fileLoader.setRequestHeader( loader.requestHeader );
+			fileLoader.setWithCredentials( loader.withCredentials );
 
-		} );
+			try {
 
-		return this.cache[ fileName ];
+				const text = await fileLoader.loadAsync( subobjectURL );
+				return text;
 
-	}
+			} catch {
 
-}
+				continue;
 
-function sortByMaterial( a, b ) {
+			}
 
-	if ( a.colourCode === b.colourCode ) {
+		}
 
-		return 0;
+		throw new Error( 'LDrawLoader: Subobject "' + fileName + '" could not be loaded.' );
 
 	}
 
-	if ( a.colourCode < b.colourCode ) {
+	parse( text ) {
 
-		return - 1;
+		const loader = this.loader;
 
-	}
+		// final results
+		const faces = [];
+		const lineSegments = [];
+		const conditionalSegments = [];
+		const subobjects = [];
+		const materials = {};
 
-	return 1;
+		const getLocalMaterial = colorCode => {
 
-}
+			return colorCode in materials ? materials[ colorCode ] : null;
 
-function createObject( elements, elementSize, isConditionalSegments = false, totalElements = null ) {
+		};
 
-	// Creates a LineSegments (elementSize = 2) or a Mesh (elementSize = 3 )
-	// With per face / segment material, implemented with mesh groups and materials array
+		let type = 'Model';
+		let category = null;
+		let keywords = null;
+		let totalFaces = 0;
 
-	// Sort the faces or line segments by colour code to make later the mesh groups
-	elements.sort( sortByMaterial );
+		// split into lines
+		if ( text.indexOf( '\r\n' ) !== - 1 ) {
 
-	if ( totalElements === null ) {
+			// This is faster than String.split with regex that splits on both
+			text = text.replace( /\r\n/g, '\n' );
 
-		totalElements = elements.length;
+		}
 
-	}
+		const lines = text.split( '\n' );
+		const numLines = lines.length;
 
-	const positions = new Float32Array( elementSize * totalElements * 3 );
-	const normals = elementSize === 3 ? new Float32Array( elementSize * totalElements * 3 ) : null;
-	const materials = [];
+		let parsingEmbeddedFiles = false;
+		let currentEmbeddedFileName = null;
+		let currentEmbeddedText = null;
 
-	const quadArray = new Array( 6 );
-	const bufferGeometry = new BufferGeometry();
-	let prevMaterial = null;
-	let index0 = 0;
-	let numGroupVerts = 0;
-	let offset = 0;
+		let bfcCertified = false;
+		let bfcCCW = true;
+		let bfcInverted = false;
+		let bfcCull = true;
 
-	for ( let iElem = 0, nElem = elements.length; iElem < nElem; iElem ++ ) {
+		let startingConstructionStep = false;
 
-		const elem = elements[ iElem ];
-		let vertices = elem.vertices;
-		if ( vertices.length === 4 ) {
+		// Parse all line commands
+		for ( let lineIndex = 0; lineIndex < numLines; lineIndex ++ ) {
 
-			quadArray[ 0 ] = vertices[ 0 ];
-			quadArray[ 1 ] = vertices[ 1 ];
-			quadArray[ 2 ] = vertices[ 2 ];
-			quadArray[ 3 ] = vertices[ 0 ];
-			quadArray[ 4 ] = vertices[ 2 ];
-			quadArray[ 5 ] = vertices[ 3 ];
-			vertices = quadArray;
+			const line = lines[ lineIndex ];
 
-		}
+			if ( line.length === 0 ) continue;
 
-		for ( let j = 0, l = vertices.length; j < l; j ++ ) {
+			if ( parsingEmbeddedFiles ) {
 
-			const v = vertices[ j ];
-			const index = offset + j * 3;
-			positions[ index + 0 ] = v.x;
-			positions[ index + 1 ] = v.y;
-			positions[ index + 2 ] = v.z;
+				if ( line.startsWith( '0 FILE ' ) ) {
 
-		}
+					// Save previous embedded file in the cache
+					this.setData( currentEmbeddedFileName, currentEmbeddedText );
 
-		if ( elementSize === 3 ) {
+					// New embedded text file
+					currentEmbeddedFileName = line.substring( 7 );
+					currentEmbeddedText = '';
 
-			let elemNormals = elem.normals;
-			if ( elemNormals.length === 4 ) {
+				} else {
 
-				quadArray[ 0 ] = elemNormals[ 0 ];
-				quadArray[ 1 ] = elemNormals[ 1 ];
-				quadArray[ 2 ] = elemNormals[ 2 ];
-				quadArray[ 3 ] = elemNormals[ 0 ];
-				quadArray[ 4 ] = elemNormals[ 2 ];
-				quadArray[ 5 ] = elemNormals[ 3 ];
-				elemNormals = quadArray;
+					currentEmbeddedText += line + '\n';
 
-			}
+				}
 
-			for ( let j = 0, l = elemNormals.length; j < l; j ++ ) {
+				continue;
 
-				let n = elem.faceNormal;
-				if ( elemNormals[ j ] ) {
+			}
 
-					n = elemNormals[ j ].norm;
+			const lp = new LineParser( line, lineIndex + 1 );
+			lp.seekNonSpace();
 
-				}
+			if ( lp.isAtTheEnd() ) {
 
-				const index = offset + j * 3;
-				normals[ index + 0 ] = n.x;
-				normals[ index + 1 ] = n.y;
-				normals[ index + 2 ] = n.z;
+				// Empty line
+				continue;
 
 			}
 
-		}
+			// Parse the line type
+			const lineType = lp.getToken();
 
-		if ( prevMaterial !== elem.material ) {
+			let material;
+			let colorCode;
+			let segment;
+			let ccw;
+			let doubleSided;
+			let v0, v1, v2, v3, c0, c1;
 
-			if ( prevMaterial !== null ) {
+			switch ( lineType ) {
 
-				bufferGeometry.addGroup( index0, numGroupVerts, materials.length - 1 );
+				// Line type 0: Comment or META
+				case '0':
 
-			}
+					// Parse meta directive
+					const meta = lp.getToken();
 
-			materials.push( elem.material );
+					if ( meta ) {
 
-			prevMaterial = elem.material;
-			index0 = offset / 3;
-			numGroupVerts = vertices.length;
+						switch ( meta ) {
 
-		} else {
+							case '!LDRAW_ORG':
 
-			numGroupVerts += vertices.length;
+								type = lp.getToken();
+								break;
 
-		}
+							case '!COLOUR':
 
-		offset += 3 * vertices.length;
+								material = loader.parseColorMetaDirective( lp );
+								if ( material ) {
 
-	}
+									materials[ material.userData.code ] = material;
 
-	if ( numGroupVerts > 0 ) {
+								}	else {
 
-		bufferGeometry.addGroup( index0, Infinity, materials.length - 1 );
+									console.warn( 'LDrawLoader: Error parsing material' + lp.getLineNumberString() );
 
-	}
+								}
 
-	bufferGeometry.setAttribute( 'position', new BufferAttribute( positions, 3 ) );
+								break;
 
-	if ( normals !== null ) {
+							case '!CATEGORY':
 
-		bufferGeometry.setAttribute( 'normal', new BufferAttribute( normals, 3 ) );
+								category = lp.getToken();
+								break;
 
-	}
+							case '!KEYWORDS':
 
-	let object3d = null;
+								const newKeywords = lp.getRemainingString().split( ',' );
+								if ( newKeywords.length > 0 ) {
 
-	if ( elementSize === 2 ) {
+									if ( ! keywords ) {
 
-		object3d = new LineSegments( bufferGeometry, materials.length === 1 ? materials[ 0 ] : materials );
+										keywords = [];
 
-	} else if ( elementSize === 3 ) {
+									}
 
-		object3d = new Mesh( bufferGeometry, materials.length === 1 ? materials[ 0 ] : materials );
+									newKeywords.forEach( function ( keyword ) {
 
-	}
+										keywords.push( keyword.trim() );
 
-	if ( isConditionalSegments ) {
+									} );
 
-		object3d.isConditionalLine = true;
+								}
 
-		const controlArray0 = new Float32Array( elements.length * 3 * 2 );
-		const controlArray1 = new Float32Array( elements.length * 3 * 2 );
-		const directionArray = new Float32Array( elements.length * 3 * 2 );
-		for ( let i = 0, l = elements.length; i < l; i ++ ) {
+								break;
 
-			const os = elements[ i ];
-			const vertices = os.vertices;
-			const controlPoints = os.controlPoints;
-			const c0 = controlPoints[ 0 ];
-			const c1 = controlPoints[ 1 ];
-			const v0 = vertices[ 0 ];
-			const v1 = vertices[ 1 ];
-			const index = i * 3 * 2;
-			controlArray0[ index + 0 ] = c0.x;
-			controlArray0[ index + 1 ] = c0.y;
-			controlArray0[ index + 2 ] = c0.z;
-			controlArray0[ index + 3 ] = c0.x;
-			controlArray0[ index + 4 ] = c0.y;
-			controlArray0[ index + 5 ] = c0.z;
+							case 'FILE':
 
-			controlArray1[ index + 0 ] = c1.x;
-			controlArray1[ index + 1 ] = c1.y;
-			controlArray1[ index + 2 ] = c1.z;
-			controlArray1[ index + 3 ] = c1.x;
-			controlArray1[ index + 4 ] = c1.y;
-			controlArray1[ index + 5 ] = c1.z;
+								if ( lineIndex > 0 ) {
 
-			directionArray[ index + 0 ] = v1.x - v0.x;
-			directionArray[ index + 1 ] = v1.y - v0.y;
-			directionArray[ index + 2 ] = v1.z - v0.z;
-			directionArray[ index + 3 ] = v1.x - v0.x;
-			directionArray[ index + 4 ] = v1.y - v0.y;
-			directionArray[ index + 5 ] = v1.z - v0.z;
+									// Start embedded text files parsing
+									parsingEmbeddedFiles = true;
+									currentEmbeddedFileName = lp.getRemainingString();
+									currentEmbeddedText = '';
 
-		}
+									bfcCertified = false;
+									bfcCCW = true;
 
-		bufferGeometry.setAttribute( 'control0', new BufferAttribute( controlArray0, 3, false ) );
-		bufferGeometry.setAttribute( 'control1', new BufferAttribute( controlArray1, 3, false ) );
-		bufferGeometry.setAttribute( 'direction', new BufferAttribute( directionArray, 3, false ) );
+								}
 
-	}
+								break;
 
-	return object3d;
+							case 'BFC':
 
-}
+								// Changes to the backface culling state
+								while ( ! lp.isAtTheEnd() ) {
 
-//
+									const token = lp.getToken();
 
-class LDrawLoader extends Loader {
+									switch ( token ) {
 
-	constructor( manager ) {
+										case 'CERTIFY':
+										case 'NOCERTIFY':
 
-		super( manager );
+											bfcCertified = token === 'CERTIFY';
+											bfcCCW = true;
 
-		// Array of THREE.Material
-		this.materials = [];
+											break;
 
-		// Not using THREE.Cache here because it returns the previous HTML error response instead of calling onError()
-		// This also allows to handle the embedded text files ("0 FILE" lines)
-		this.cache = new LDrawFileCache( this );
+										case 'CW':
+										case 'CCW':
 
-		// This object is a map from file names to paths. It agilizes the paths search. If it is not set then files will be searched by trial and error.
-		this.fileMap = null;
+											bfcCCW = token === 'CCW';
 
-		this.rootParseScope = this.newParseScopeLevel();
+											break;
 
-		// Add default main triangle and line edge materials (used in pieces that can be coloured with a main color)
-		this.setMaterials( [
-			this.parseColourMetaDirective( new LineParser( 'Main_Colour CODE 16 VALUE #FF8080 EDGE #333333' ) ),
-			this.parseColourMetaDirective( new LineParser( 'Edge_Colour CODE 24 VALUE #A0A0A0 EDGE #333333' ) )
-		] );
+										case 'INVERTNEXT':
 
-		// If this flag is set to true, each subobject will be a Object.
-		// If not (the default), only one object which contains all the merged primitives will be created.
-		this.separateObjects = false;
+											bfcInverted = true;
 
-		// If this flag is set to true the vertex normals will be smoothed.
-		this.smoothNormals = true;
+											break;
 
-		// The path to load parts from the LDraw parts library from.
-		this.partsLibraryPath = '';
+										case 'CLIP':
+										case 'NOCLIP':
 
-	}
+											bfcCull = token === 'CLIP';
 
-	setPartsLibraryPath( path ) {
+											break;
 
-		this.partsLibraryPath = path;
-		return this;
+										default:
 
-	}
+											console.warn( 'THREE.LDrawLoader: BFC directive "' + token + '" is unknown.' );
 
-	async preloadMaterials( url ) {
+											break;
 
-		const fileLoader = new FileLoader( this.manager );
-		fileLoader.setPath( this.path );
-		fileLoader.setRequestHeader( this.requestHeader );
-		fileLoader.setWithCredentials( this.withCredentials );
+									}
 
-		const text = await fileLoader.loadAsync( url );
-		const colorLineRegex = /^0 !COLOUR/;
-		const lines = text.split( /[\n\r]/g );
-		const materials = [];
-		for ( let i = 0, l = lines.length; i < l; i ++ ) {
+								}
 
-			const line = lines[ i ];
-			if ( colorLineRegex.test( line ) ) {
+								break;
 
-				const directive = line.replace( colorLineRegex, '' );
-				const material = this.parseColourMetaDirective( new LineParser( directive ) );
-				materials.push( material );
+							case 'STEP':
 
-			}
+								startingConstructionStep = true;
 
-		}
+								break;
 
-		this.setMaterials( materials );
+							default:
+								// Other meta directives are not implemented
+								break;
 
-	}
+						}
 
-	load( url, onLoad, onProgress, onError ) {
+					}
 
-		if ( ! this.fileMap ) {
+					break;
 
-			this.fileMap = {};
+					// Line type 1: Sub-object file
+				case '1':
 
-		}
+					colorCode = lp.getToken();
+					material = getLocalMaterial( colorCode );
 
-		const fileLoader = new FileLoader( this.manager );
-		fileLoader.setPath( this.path );
-		fileLoader.setRequestHeader( this.requestHeader );
-		fileLoader.setWithCredentials( this.withCredentials );
-		fileLoader.load( url, text => {
+					const posX = parseFloat( lp.getToken() );
+					const posY = parseFloat( lp.getToken() );
+					const posZ = parseFloat( lp.getToken() );
+					const m0 = parseFloat( lp.getToken() );
+					const m1 = parseFloat( lp.getToken() );
+					const m2 = parseFloat( lp.getToken() );
+					const m3 = parseFloat( lp.getToken() );
+					const m4 = parseFloat( lp.getToken() );
+					const m5 = parseFloat( lp.getToken() );
+					const m6 = parseFloat( lp.getToken() );
+					const m7 = parseFloat( lp.getToken() );
+					const m8 = parseFloat( lp.getToken() );
 
-			this.processObject( text, null, url, this.rootParseScope )
-				.then( function ( result ) {
+					const matrix = new Matrix4().set(
+						m0, m1, m2, posX,
+						m3, m4, m5, posY,
+						m6, m7, m8, posZ,
+						0, 0, 0, 1
+					);
 
-					onLoad( result.groupObject );
+					let fileName = lp.getRemainingString().trim().replace( /\\/g, '/' );
 
-				} );
+					if ( loader.fileMap[ fileName ] ) {
 
-		}, onProgress, onError );
+						// Found the subobject path in the preloaded file path map
+						fileName = loader.fileMap[ fileName ];
 
-	}
+					} else {
 
-	parse( text, path, onLoad ) {
+						// Standardized subfolders
+						if ( fileName.startsWith( 's/' ) ) {
 
-		// Async parse.  This function calls onParse with the parsed THREE.Object3D as parameter
-		this.processObject( text, null, path, this.rootParseScope )
-			.then( function ( result ) {
+							fileName = 'parts/' + fileName;
 
-				onLoad( result.groupObject );
+						} else if ( fileName.startsWith( '48/' ) ) {
 
-			} );
+							fileName = 'p/' + fileName;
 
-	}
+						}
 
-	setMaterials( materials ) {
+					}
 
-		// Clears parse scopes stack, adds new scope with material library
-		this.rootParseScope = this.newParseScopeLevel( materials );
-		this.rootParseScope.isFromParse = false;
+					subobjects.push( {
+						material: material,
+						colorCode: colorCode,
+						matrix: matrix,
+						fileName: fileName,
+						inverted: bfcInverted,
+						startingConstructionStep: startingConstructionStep
+					} );
 
-		this.materials = materials;
+					bfcInverted = false;
 
-		return this;
+					break;
 
-	}
+					// Line type 2: Line segment
+				case '2':
 
-	setFileMap( fileMap ) {
+					colorCode = lp.getToken();
+					material = getLocalMaterial( colorCode );
+					v0 = lp.getVector();
+					v1 = lp.getVector();
 
-		this.fileMap = fileMap;
+					segment = {
+						material: material,
+						colorCode: colorCode,
+						vertices: [ v0, v1 ],
+					};
 
-		return this;
+					lineSegments.push( segment );
 
-	}
+					break;
 
-	newParseScopeLevel( materials = null, parentScope = null ) {
+					// Line type 5: Conditional Line segment
+				case '5':
 
-		// Adds a new scope level, assign materials to it and returns it
+					colorCode = lp.getToken();
+					material = getLocalMaterial( colorCode );
+					v0 = lp.getVector();
+					v1 = lp.getVector();
+					c0 = lp.getVector();
+					c1 = lp.getVector();
 
-		const matLib = {};
+					segment = {
+						material: material,
+						colorCode: colorCode,
+						vertices: [ v0, v1 ],
+						controlPoints: [ c0, c1 ],
+					};
 
-		if ( materials ) {
+					conditionalSegments.push( segment );
 
-			for ( let i = 0, n = materials.length; i < n; i ++ ) {
+					break;
 
-				const material = materials[ i ];
-				matLib[ material.userData.code ] = material;
+					// Line type 3: Triangle
+				case '3':
+
+					colorCode = lp.getToken();
+					material = getLocalMaterial( colorCode );
+					ccw = bfcCCW;
+					doubleSided = ! bfcCertified || ! bfcCull;
+
+					if ( ccw === true ) {
+
+						v0 = lp.getVector();
+						v1 = lp.getVector();
+						v2 = lp.getVector();
+
+					} else {
+
+						v2 = lp.getVector();
+						v1 = lp.getVector();
+						v0 = lp.getVector();
+
+					}
+
+					faces.push( {
+						material: material,
+						colorCode: colorCode,
+						faceNormal: null,
+						vertices: [ v0, v1, v2 ],
+						normals: [ null, null, null ],
+					} );
+					totalFaces ++;
+
+					if ( doubleSided === true ) {
+
+						faces.push( {
+							material: material,
+							colorCode: colorCode,
+							faceNormal: null,
+							vertices: [ v2, v1, v0 ],
+							normals: [ null, null, null ],
+						} );
+						totalFaces ++;
+
+					}
+
+					break;
+
+					// Line type 4: Quadrilateral
+				case '4':
+
+					colorCode = lp.getToken();
+					material = getLocalMaterial( colorCode );
+					ccw = bfcCCW;
+					doubleSided = ! bfcCertified || ! bfcCull;
+
+					if ( ccw === true ) {
+
+						v0 = lp.getVector();
+						v1 = lp.getVector();
+						v2 = lp.getVector();
+						v3 = lp.getVector();
+
+					} else {
+
+						v3 = lp.getVector();
+						v2 = lp.getVector();
+						v1 = lp.getVector();
+						v0 = lp.getVector();
+
+					}
+
+					// specifically place the triangle diagonal in the v0 and v1 slots so we can
+					// account for the doubling of vertices later when smoothing normals.
+					faces.push( {
+						material: material,
+						colorCode: colorCode,
+						faceNormal: null,
+						vertices: [ v0, v1, v2, v3 ],
+						normals: [ null, null, null, null ],
+					} );
+					totalFaces += 2;
+
+					if ( doubleSided === true ) {
+
+						faces.push( {
+							material: material,
+							colorCode: colorCode,
+							faceNormal: null,
+							vertices: [ v3, v2, v1, v0 ],
+							normals: [ null, null, null, null ],
+						} );
+						totalFaces += 2;
+
+					}
+
+					break;
+
+				default:
+					throw new Error( 'LDrawLoader: Unknown line type "' + lineType + '"' + lp.getLineNumberString() + '.' );
 
 			}
 
 		}
 
-		const newParseScope = {
+		if ( parsingEmbeddedFiles ) {
 
-			parentScope: parentScope,
-			lib: matLib,
-			url: null,
+			this.setData( currentEmbeddedFileName, currentEmbeddedText );
 
-			// Subobjects
-			subobjects: null,
-			numSubobjects: 0,
-			subobjectIndex: 0,
-			inverted: false,
-			category: null,
-			keywords: null,
+		}
 
-			// Current subobject
-			currentFileName: null,
-			mainColourCode: parentScope ? parentScope.mainColourCode : '16',
-			mainEdgeColourCode: parentScope ? parentScope.mainEdgeColourCode : '24',
-			currentMatrix: new Matrix4(),
-			matrix: new Matrix4(),
+		return {
+			faces,
+			conditionalSegments,
+			lineSegments,
+			type,
+			category,
+			keywords,
+			subobjects,
+			totalFaces,
+			startingConstructionStep,
+			materials
+		};
 
-			// If false, it is a root material scope previous to parse
-			isFromParse: true,
+	}
 
-			faces: null,
-			lineSegments: null,
-			conditionalSegments: null,
-			totalFaces: 0,
+	loadData( fileName ) {
 
-			// If true, this object is the start of a construction step
-			startingConstructionStep: false
-		};
+		const key = fileName.toLowerCase();
+		if ( ! ( key in this.cache ) ) {
 
-		return newParseScope;
+			this.cache[ key ] = this.fetchData( fileName ).then( text => {
+
+				return this.parse( text );
+
+			} );
+
+		}
+
+		return this.cache[ key ].then( result => {
+
+			return this.cloneResult( result );
+
+		} );
 
 	}
 
-	addMaterial( material, parseScope ) {
+	setData( fileName, text ) {
 
-		// Adds a material to the material library which is on top of the parse scopes stack. And also to the materials array
+		const key = fileName.toLowerCase();
+		this.cache[ key ] = Promise.resolve( this.parse( text ) );
 
-		const matLib = parseScope.lib;
+	}
+
+}
+
+function sortByMaterial( a, b ) {
+
+	if ( a.colorCode === b.colorCode ) {
+
+		return 0;
+
+	}
+
+	if ( a.colorCode < b.colorCode ) {
+
+		return - 1;
+
+	}
+
+	return 1;
+
+}
 
-		if ( ! matLib[ material.userData.code ] ) {
+function createObject( elements, elementSize, isConditionalSegments = false, totalElements = null ) {
 
-			this.materials.push( material );
+	// Creates a LineSegments (elementSize = 2) or a Mesh (elementSize = 3 )
+	// With per face / segment material, implemented with mesh groups and materials array
 
-		}
+	// Sort the faces or line segments by color code to make later the mesh groups
+	elements.sort( sortByMaterial );
 
-		matLib[ material.userData.code ] = material;
+	if ( totalElements === null ) {
 
-		return this;
+		totalElements = elements.length;
 
 	}
 
-	getMaterial( colourCode, parseScope = this.rootParseScope ) {
-
-		// Given a colour code search its material in the parse scopes stack
+	const positions = new Float32Array( elementSize * totalElements * 3 );
+	const normals = elementSize === 3 ? new Float32Array( elementSize * totalElements * 3 ) : null;
+	const materials = [];
 
-		if ( colourCode.startsWith( '0x2' ) ) {
+	const quadArray = new Array( 6 );
+	const bufferGeometry = new BufferGeometry();
+	let prevMaterial = null;
+	let index0 = 0;
+	let numGroupVerts = 0;
+	let offset = 0;
 
-			// Special 'direct' material value (RGB colour)
+	for ( let iElem = 0, nElem = elements.length; iElem < nElem; iElem ++ ) {
 
-			const colour = colourCode.substring( 3 );
+		const elem = elements[ iElem ];
+		let vertices = elem.vertices;
+		if ( vertices.length === 4 ) {
 
-			return this.parseColourMetaDirective( new LineParser( 'Direct_Color_' + colour + ' CODE -1 VALUE #' + colour + ' EDGE #' + colour + '' ) );
+			quadArray[ 0 ] = vertices[ 0 ];
+			quadArray[ 1 ] = vertices[ 1 ];
+			quadArray[ 2 ] = vertices[ 2 ];
+			quadArray[ 3 ] = vertices[ 0 ];
+			quadArray[ 4 ] = vertices[ 2 ];
+			quadArray[ 5 ] = vertices[ 3 ];
+			vertices = quadArray;
 
 		}
 
-		while ( parseScope ) {
+		for ( let j = 0, l = vertices.length; j < l; j ++ ) {
 
-			const material = parseScope.lib[ colourCode ];
+			const v = vertices[ j ];
+			const index = offset + j * 3;
+			positions[ index + 0 ] = v.x;
+			positions[ index + 1 ] = v.y;
+			positions[ index + 2 ] = v.z;
 
-			if ( material ) {
+		}
 
-				return material;
+		// create the normals array if this is a set of faces
+		if ( elementSize === 3 ) {
 
-			} else {
+			if ( ! elem.faceNormal ) {
 
-				parseScope = parseScope.parentScope;
+				const v0 = vertices[ 0 ];
+				const v1 = vertices[ 1 ];
+				const v2 = vertices[ 2 ];
+				_tempVec0.subVectors( v1, v0 );
+				_tempVec1.subVectors( v2, v1 );
+				elem.faceNormal = new Vector3()
+					.crossVectors( _tempVec0, _tempVec1 )
+					.normalize();
 
 			}
 
-		}
-
-		// Material was not found
-		return null;
-
-	}
-
-	parseColourMetaDirective( lineParser ) {
+			let elemNormals = elem.normals;
+			if ( elemNormals.length === 4 ) {
 
-		// Parses a colour definition and returns a THREE.Material
+				quadArray[ 0 ] = elemNormals[ 0 ];
+				quadArray[ 1 ] = elemNormals[ 1 ];
+				quadArray[ 2 ] = elemNormals[ 2 ];
+				quadArray[ 3 ] = elemNormals[ 0 ];
+				quadArray[ 4 ] = elemNormals[ 2 ];
+				quadArray[ 5 ] = elemNormals[ 3 ];
+				elemNormals = quadArray;
 
-		let code = null;
+			}
 
-		// Triangle and line colours
-		let colour = 0xFF00FF;
-		let edgeColour = 0xFF00FF;
+			for ( let j = 0, l = elemNormals.length; j < l; j ++ ) {
 
-		// Transparency
-		let alpha = 1;
-		let isTransparent = false;
-		// Self-illumination:
-		let luminance = 0;
+				// use face normal if a vertex normal is not provided
+				let n = elem.faceNormal;
+				if ( elemNormals[ j ] ) {
 
-		let finishType = FINISH_TYPE_DEFAULT;
+					n = elemNormals[ j ].norm;
 
-		let edgeMaterial = null;
+				}
 
-		const name = lineParser.getToken();
-		if ( ! name ) {
+				const index = offset + j * 3;
+				normals[ index + 0 ] = n.x;
+				normals[ index + 1 ] = n.y;
+				normals[ index + 2 ] = n.z;
 
-			throw 'LDrawLoader: Material name was expected after "!COLOUR tag' + lineParser.getLineNumberString() + '.';
+			}
 
 		}
 
-		// Parse tag tokens and their parameters
-		let token = null;
-		while ( true ) {
-
-			token = lineParser.getToken();
+		if ( prevMaterial !== elem.material ) {
 
-			if ( ! token ) {
+			if ( prevMaterial !== null ) {
 
-				break;
+				bufferGeometry.addGroup( index0, numGroupVerts, materials.length - 1 );
 
 			}
 
-			switch ( token.toUpperCase() ) {
-
-				case 'CODE':
+			const material = elem.material;
+			if ( elementSize === 3 ) {
 
-					code = lineParser.getToken();
-					break;
+				materials.push( material );
 
-				case 'VALUE':
+			} else if ( elementSize === 2 ) {
 
-					colour = lineParser.getToken();
-					if ( colour.startsWith( '0x' ) ) {
+				if ( isConditionalSegments ) {
 
-						colour = '#' + colour.substring( 2 );
+					materials.push( material.userData.edgeMaterial.userData.conditionalEdgeMaterial );
 
-					} else if ( ! colour.startsWith( '#' ) ) {
+				} else {
 
-						throw 'LDrawLoader: Invalid colour while parsing material' + lineParser.getLineNumberString() + '.';
+					materials.push( material.userData.edgeMaterial );
 
-					}
+				}
 
-					break;
+			}
 
-				case 'EDGE':
+			prevMaterial = elem.material;
+			index0 = offset / 3;
+			numGroupVerts = vertices.length;
 
-					edgeColour = lineParser.getToken();
-					if ( edgeColour.startsWith( '0x' ) ) {
+		} else {
 
-						edgeColour = '#' + edgeColour.substring( 2 );
+			numGroupVerts += vertices.length;
 
-					} else if ( ! edgeColour.startsWith( '#' ) ) {
+		}
 
-						// Try to see if edge colour is a colour code
-						edgeMaterial = this.getMaterial( edgeColour );
-						if ( ! edgeMaterial ) {
+		offset += 3 * vertices.length;
 
-							throw 'LDrawLoader: Invalid edge colour while parsing material' + lineParser.getLineNumberString() + '.';
+	}
 
-						}
+	if ( numGroupVerts > 0 ) {
 
-						// Get the edge material for this triangle material
-						edgeMaterial = edgeMaterial.userData.edgeMaterial;
+		bufferGeometry.addGroup( index0, Infinity, materials.length - 1 );
 
-					}
+	}
 
-					break;
+	bufferGeometry.setAttribute( 'position', new BufferAttribute( positions, 3 ) );
 
-				case 'ALPHA':
+	if ( normals !== null ) {
 
-					alpha = parseInt( lineParser.getToken() );
+		bufferGeometry.setAttribute( 'normal', new BufferAttribute( normals, 3 ) );
 
-					if ( isNaN( alpha ) ) {
+	}
 
-						throw 'LDrawLoader: Invalid alpha value in material definition' + lineParser.getLineNumberString() + '.';
+	let object3d = null;
 
-					}
+	if ( elementSize === 2 ) {
 
-					alpha = Math.max( 0, Math.min( 1, alpha / 255 ) );
+		object3d = new LineSegments( bufferGeometry, materials.length === 1 ? materials[ 0 ] : materials );
 
-					if ( alpha < 1 ) {
+	} else if ( elementSize === 3 ) {
 
-						isTransparent = true;
+		object3d = new Mesh( bufferGeometry, materials.length === 1 ? materials[ 0 ] : materials );
 
-					}
+	}
 
-					break;
+	if ( isConditionalSegments ) {
 
-				case 'LUMINANCE':
+		object3d.isConditionalLine = true;
 
-					luminance = parseInt( lineParser.getToken() );
+		const controlArray0 = new Float32Array( elements.length * 3 * 2 );
+		const controlArray1 = new Float32Array( elements.length * 3 * 2 );
+		const directionArray = new Float32Array( elements.length * 3 * 2 );
+		for ( let i = 0, l = elements.length; i < l; i ++ ) {
 
-					if ( isNaN( luminance ) ) {
+			const os = elements[ i ];
+			const vertices = os.vertices;
+			const controlPoints = os.controlPoints;
+			const c0 = controlPoints[ 0 ];
+			const c1 = controlPoints[ 1 ];
+			const v0 = vertices[ 0 ];
+			const v1 = vertices[ 1 ];
+			const index = i * 3 * 2;
+			controlArray0[ index + 0 ] = c0.x;
+			controlArray0[ index + 1 ] = c0.y;
+			controlArray0[ index + 2 ] = c0.z;
+			controlArray0[ index + 3 ] = c0.x;
+			controlArray0[ index + 4 ] = c0.y;
+			controlArray0[ index + 5 ] = c0.z;
 
-						throw 'LDrawLoader: Invalid luminance value in material definition' + LineParser.getLineNumberString() + '.';
+			controlArray1[ index + 0 ] = c1.x;
+			controlArray1[ index + 1 ] = c1.y;
+			controlArray1[ index + 2 ] = c1.z;
+			controlArray1[ index + 3 ] = c1.x;
+			controlArray1[ index + 4 ] = c1.y;
+			controlArray1[ index + 5 ] = c1.z;
 
-					}
+			directionArray[ index + 0 ] = v1.x - v0.x;
+			directionArray[ index + 1 ] = v1.y - v0.y;
+			directionArray[ index + 2 ] = v1.z - v0.z;
+			directionArray[ index + 3 ] = v1.x - v0.x;
+			directionArray[ index + 4 ] = v1.y - v0.y;
+			directionArray[ index + 5 ] = v1.z - v0.z;
 
-					luminance = Math.max( 0, Math.min( 1, luminance / 255 ) );
+		}
 
-					break;
+		bufferGeometry.setAttribute( 'control0', new BufferAttribute( controlArray0, 3, false ) );
+		bufferGeometry.setAttribute( 'control1', new BufferAttribute( controlArray1, 3, false ) );
+		bufferGeometry.setAttribute( 'direction', new BufferAttribute( directionArray, 3, false ) );
 
-				case 'CHROME':
-					finishType = FINISH_TYPE_CHROME;
-					break;
+	}
 
-				case 'PEARLESCENT':
-					finishType = FINISH_TYPE_PEARLESCENT;
-					break;
+	return object3d;
 
-				case 'RUBBER':
-					finishType = FINISH_TYPE_RUBBER;
-					break;
+}
 
-				case 'MATTE_METALLIC':
-					finishType = FINISH_TYPE_MATTE_METALLIC;
-					break;
+//
 
-				case 'METAL':
-					finishType = FINISH_TYPE_METAL;
-					break;
+const MAIN_COLOUR_CODE = '16';
+const MAIN_EDGE_COLOUR_CODE = '24';
 
-				case 'MATERIAL':
-					// Not implemented
-					lineParser.setToEnd();
-					break;
+class LDrawLoader extends Loader {
 
-				default:
-					throw 'LDrawLoader: Unknown token "' + token + '" while parsing material' + lineParser.getLineNumberString() + '.';
-					break;
+	constructor( manager ) {
 
-			}
+		super( manager );
 
-		}
+		// Array of THREE.Material
+		this.materials = [];
 
-		let material = null;
+		// Not using THREE.Cache here because it returns the previous HTML error response instead of calling onError()
+		// This also allows to handle the embedded text files ("0 FILE" lines)
+		this.parseCache = new LDrawParsedCache( this );
 
-		switch ( finishType ) {
+		// This object is a map from file names to paths. It agilizes the paths search. If it is not set then files will be searched by trial and error.
+		this.fileMap = {};
 
-			case FINISH_TYPE_DEFAULT:
+		this.rootParseScope = this.newParseScopeLevel();
 
-				material = new MeshStandardMaterial( { color: colour, roughness: 0.3, metalness: 0 } );
-				break;
+		// Add default main triangle and line edge materials (used in pieces that can be colored with a main color)
+		this.setMaterials( [
+			this.parseColorMetaDirective( new LineParser( 'Main_Colour CODE 16 VALUE #FF8080 EDGE #333333' ) ),
+			this.parseColorMetaDirective( new LineParser( 'Edge_Colour CODE 24 VALUE #A0A0A0 EDGE #333333' ) )
+		] );
 
-			case FINISH_TYPE_PEARLESCENT:
+		// If this flag is set to true the vertex normals will be smoothed.
+		this.smoothNormals = true;
 
-				// Try to imitate pearlescency by setting the specular to the complementary of the color, and low shininess
-				const specular = new Color( colour );
-				const hsl = specular.getHSL( { h: 0, s: 0, l: 0 } );
-				hsl.h = ( hsl.h + 0.5 ) % 1;
-				hsl.l = Math.min( 1, hsl.l + ( 1 - hsl.l ) * 0.7 );
-				specular.setHSL( hsl.h, hsl.s, hsl.l );
+		// The path to load parts from the LDraw parts library from.
+		this.partsLibraryPath = '';
 
-				material = new MeshPhongMaterial( { color: colour, specular: specular, shininess: 10, reflectivity: 0.3 } );
-				break;
+	}
 
-			case FINISH_TYPE_CHROME:
+	setPartsLibraryPath( path ) {
 
-				// Mirror finish surface
-				material = new MeshStandardMaterial( { color: colour, roughness: 0, metalness: 1 } );
-				break;
+		this.partsLibraryPath = path;
+		return this;
 
-			case FINISH_TYPE_RUBBER:
+	}
 
-				// Rubber finish
-				material = new MeshStandardMaterial( { color: colour, roughness: 0.9, metalness: 0 } );
-				break;
+	async preloadMaterials( url ) {
 
-			case FINISH_TYPE_MATTE_METALLIC:
+		const fileLoader = new FileLoader( this.manager );
+		fileLoader.setPath( this.path );
+		fileLoader.setRequestHeader( this.requestHeader );
+		fileLoader.setWithCredentials( this.withCredentials );
 
-				// Brushed metal finish
-				material = new MeshStandardMaterial( { color: colour, roughness: 0.8, metalness: 0.4 } );
-				break;
+		const text = await fileLoader.loadAsync( url );
+		const colorLineRegex = /^0 !COLOUR/;
+		const lines = text.split( /[\n\r]/g );
+		const materials = [];
+		for ( let i = 0, l = lines.length; i < l; i ++ ) {
 
-			case FINISH_TYPE_METAL:
+			const line = lines[ i ];
+			if ( colorLineRegex.test( line ) ) {
 
-				// Average metal finish
-				material = new MeshStandardMaterial( { color: colour, roughness: 0.2, metalness: 0.85 } );
-				break;
+				const directive = line.replace( colorLineRegex, '' );
+				const material = this.parseColorMetaDirective( new LineParser( directive ) );
+				materials.push( material );
 
-			default:
-				// Should not happen
-				break;
+			}
 
 		}
 
-		material.transparent = isTransparent;
-		material.premultipliedAlpha = true;
-		material.opacity = alpha;
-		material.depthWrite = ! isTransparent;
-
-		material.polygonOffset = true;
-		material.polygonOffsetFactor = 1;
+		this.setMaterials( materials );
 
-		if ( luminance !== 0 ) {
+	}
 
-			material.emissive.set( material.color ).multiplyScalar( luminance );
+	load( url, onLoad, onProgress, onError ) {
 
-		}
+		const fileLoader = new FileLoader( this.manager );
+		fileLoader.setPath( this.path );
+		fileLoader.setRequestHeader( this.requestHeader );
+		fileLoader.setWithCredentials( this.withCredentials );
+		fileLoader.load( url, text => {
 
-		if ( ! edgeMaterial ) {
+			const parsedInfo = this.parseCache.parse( text );
+			this.processObject( parsedInfo, null, url, this.rootParseScope )
+				.then( function ( result ) {
 
-			// This is the material used for edges
-			edgeMaterial = new LineBasicMaterial( {
-				color: edgeColour,
-				transparent: isTransparent,
-				opacity: alpha,
-				depthWrite: ! isTransparent
-			} );
-			edgeMaterial.userData.code = code;
-			edgeMaterial.name = name + ' - Edge';
+					onLoad( result.groupObject );
 
-			// This is the material used for conditional edges
-			edgeMaterial.userData.conditionalEdgeMaterial = new LDrawConditionalLineMaterial( {
+				} );
 
-				fog: true,
-				transparent: isTransparent,
-				depthWrite: ! isTransparent,
-				color: edgeColour,
-				opacity: alpha,
+		}, onProgress, onError );
 
-			} );
+	}
 
-		}
+	parse( text, path, onLoad ) {
 
-		material.userData.code = code;
-		material.name = name;
+		// Async parse. This function calls onParse with the parsed THREE.Object3D as parameter
+		const parsedInfo = this.parseCache.parse( text );
+		this.processObject( parsedInfo, null, path, this.rootParseScope )
+			.then( function ( result ) {
 
-		material.userData.edgeMaterial = edgeMaterial;
+				onLoad( result.groupObject );
 
-		return material;
+			} );
 
 	}
 
-	//
+	setMaterials( materials ) {
 
-	objectParse( text, parseScope ) {
+		// Clears parse scopes stack, adds new scope with material library
+		this.rootParseScope = this.newParseScopeLevel( materials );
+		this.rootParseScope.isFromParse = false;
 
-		// Retrieve data from the parent parse scope
-		const currentParseScope = parseScope;
-		const parentParseScope = currentParseScope.parentScope;
+		this.materials = materials;
 
-		// Main colour codes passed to this subobject (or default codes 16 and 24 if it is the root object)
-		const mainColourCode = currentParseScope.mainColourCode;
-		const mainEdgeColourCode = currentParseScope.mainEdgeColourCode;
+		return this;
 
+	}
 
-		// Parse result variables
-		let faces;
-		let lineSegments;
-		let conditionalSegments;
+	setFileMap( fileMap ) {
 
-		const subobjects = [];
+		this.fileMap = fileMap;
 
-		let category = null;
-		let keywords = null;
+		return this;
 
-		if ( text.indexOf( '\r\n' ) !== - 1 ) {
+	}
 
-			// This is faster than String.split with regex that splits on both
-			text = text.replace( /\r\n/g, '\n' );
+	newParseScopeLevel( materials = null, parentScope = null ) {
 
-		}
+		// Adds a new scope level, assign materials to it and returns it
 
-		const lines = text.split( '\n' );
-		const numLines = lines.length;
+		const matLib = {};
 
-		let parsingEmbeddedFiles = false;
-		let currentEmbeddedFileName = null;
-		let currentEmbeddedText = null;
+		if ( materials ) {
 
-		let bfcCertified = false;
-		let bfcCCW = true;
-		let bfcInverted = false;
-		let bfcCull = true;
-		let type = '';
+			for ( let i = 0, n = materials.length; i < n; i ++ ) {
 
-		let startingConstructionStep = false;
+				const material = materials[ i ];
+				matLib[ material.userData.code ] = material;
 
-		const scope = this;
-		function parseColourCode( lineParser, forEdge ) {
+			}
 
-			// Parses next colour code and returns a THREE.Material
+		}
 
-			let colourCode = lineParser.getToken();
+		const newParseScope = {
 
-			if ( ! forEdge && colourCode === '16' ) {
+			parentScope: parentScope,
+			lib: matLib,
+			url: null,
 
-				colourCode = mainColourCode;
+			// Subobjects
+			subobjects: null,
+			inverted: false,
+			category: null,
+			keywords: null,
 
-			}
+			// Current subobject
+			currentFileName: null,
+			mainColorCode: parentScope ? parentScope.mainColorCode : MAIN_COLOUR_CODE,
+			mainEdgeColorCode: parentScope ? parentScope.mainEdgeColorCode : MAIN_EDGE_COLOUR_CODE,
+			matrix: new Matrix4(),
+			type: 'Model',
+			groupObject: null,
 
-			if ( forEdge && colourCode === '24' ) {
+			// If false, it is a root material scope previous to parse
+			isFromParse: true,
 
-				colourCode = mainEdgeColourCode;
+			faces: [],
+			lineSegments: [],
+			conditionalSegments: [],
+			totalFaces: 0,
+			faceMaterials: new Set(),
 
-			}
+			// If true, this object is the start of a construction step
+			startingConstructionStep: false
+		};
 
-			const material = scope.getMaterial( colourCode, currentParseScope );
+		return newParseScope;
 
-			if ( ! material ) {
+	}
 
-				throw 'LDrawLoader: Unknown colour code "' + colourCode + '" is used' + lineParser.getLineNumberString() + ' but it was not defined previously.';
+	addMaterial( material, parseScope ) {
 
-			}
+		// Adds a material to the material library which is on top of the parse scopes stack. And also to the materials array
 
-			return material;
+		const matLib = parseScope.lib;
 
-		}
+		if ( ! matLib[ material.userData.code ] ) {
 
-		function parseVector( lp ) {
+			this.materials.push( material );
 
-			const v = new Vector3( parseFloat( lp.getToken() ), parseFloat( lp.getToken() ), parseFloat( lp.getToken() ) );
+		}
 
-			if ( ! scope.separateObjects ) {
+		matLib[ material.userData.code ] = material;
 
-				v.applyMatrix4( currentParseScope.currentMatrix );
+		return this;
 
-			}
+	}
 
-			return v;
+	getMaterial( colorCode, parseScope = this.rootParseScope ) {
 
-		}
+		// Given a color code search its material in the parse scopes stack
 
-		// Parse all line commands
-		for ( let lineIndex = 0; lineIndex < numLines; lineIndex ++ ) {
+		if ( colorCode.startsWith( '0x2' ) ) {
 
-			const line = lines[ lineIndex ];
+			// Special 'direct' material value (RGB color)
 
-			if ( line.length === 0 ) continue;
+			const color = colorCode.substring( 3 );
 
-			if ( parsingEmbeddedFiles ) {
+			return this.parseColorMetaDirective( new LineParser( 'Direct_Color_' + color + ' CODE -1 VALUE #' + color + ' EDGE #' + color + '' ) );
 
-				if ( line.startsWith( '0 FILE ' ) ) {
+		}
 
-					// Save previous embedded file in the cache
-					this.cache.setData( currentEmbeddedFileName.toLowerCase(), currentEmbeddedText );
+		while ( parseScope ) {
 
-					// New embedded text file
-					currentEmbeddedFileName = line.substring( 7 );
-					currentEmbeddedText = '';
+			const material = parseScope.lib[ colorCode ];
 
-				} else {
+			if ( material ) {
 
-					currentEmbeddedText += line + '\n';
+				return material;
 
-				}
+			} else {
 
-				continue;
+				parseScope = parseScope.parentScope;
 
 			}
 
-			const lp = new LineParser( line, lineIndex + 1 );
+		}
 
-			lp.seekNonSpace();
+		// Material was not found
+		return null;
 
-			if ( lp.isAtTheEnd() ) {
+	}
 
-				// Empty line
-				continue;
+	getMainMaterial() {
 
-			}
+		return this.getMaterial( MAIN_COLOUR_CODE );
+	}
 
-			// Parse the line type
-			const lineType = lp.getToken();
+	getMainEdgeMaterial() {
 
-			let material;
-			let segment;
-			let inverted;
-			let ccw;
-			let doubleSided;
-			let v0, v1, v2, v3, c0, c1, faceNormal;
+		return this.getMaterial( MAIN_EDGE_COLOUR_CODE );;
+	}
 
-			switch ( lineType ) {
+	parseColorMetaDirective( lineParser ) {
 
-				// Line type 0: Comment or META
-				case '0':
+		// Parses a color definition and returns a THREE.Material
 
-					// Parse meta directive
-					const meta = lp.getToken();
+		let code = null;
 
-					if ( meta ) {
+		// Triangle and line colors
+		let color = 0xFF00FF;
+		let edgeColor = 0xFF00FF;
 
-						switch ( meta ) {
+		// Transparency
+		let alpha = 1;
+		let isTransparent = false;
+		// Self-illumination:
+		let luminance = 0;
 
-							case '!LDRAW_ORG':
+		let finishType = FINISH_TYPE_DEFAULT;
 
-								type = lp.getToken();
+		let edgeMaterial = null;
 
-								currentParseScope.faces = [];
-								currentParseScope.lineSegments = [];
-								currentParseScope.conditionalSegments = [];
-								currentParseScope.type = type;
+		const name = lineParser.getToken();
+		if ( ! name ) {
 
-								const isRoot = ! parentParseScope.isFromParse;
-								if ( isRoot || scope.separateObjects && ! isPrimitiveType( type ) ) {
+			throw new Error( 'LDrawLoader: Material name was expected after "!COLOUR tag' + lineParser.getLineNumberString() + '.' );
 
-									currentParseScope.groupObject = new Group();
+		}
 
-									currentParseScope.groupObject.userData.startingConstructionStep = currentParseScope.startingConstructionStep;
+		// Parse tag tokens and their parameters
+		let token = null;
+		while ( true ) {
 
-								}
+			token = lineParser.getToken();
 
-								// If the scale of the object is negated then the triangle winding order
-								// needs to be flipped.
-								if (
-									currentParseScope.matrix.determinant() < 0 && (
-										scope.separateObjects && isPrimitiveType( type ) ||
-											! scope.separateObjects
-									) ) {
+			if ( ! token ) {
 
-									currentParseScope.inverted = ! currentParseScope.inverted;
+				break;
 
-								}
+			}
 
-								faces = currentParseScope.faces;
-								lineSegments = currentParseScope.lineSegments;
-								conditionalSegments = currentParseScope.conditionalSegments;
+			switch ( token.toUpperCase() ) {
 
-								break;
+				case 'CODE':
 
-							case '!COLOUR':
+					code = lineParser.getToken();
+					break;
 
-								material = this.parseColourMetaDirective( lp );
-								if ( material ) {
+				case 'VALUE':
 
-									this.addMaterial( material, parseScope );
+					color = lineParser.getToken();
+					if ( color.startsWith( '0x' ) ) {
 
-								}	else {
+						color = '#' + color.substring( 2 );
 
-									console.warn( 'LDrawLoader: Error parsing material' + lp.getLineNumberString() );
+					} else if ( ! color.startsWith( '#' ) ) {
 
-								}
+						throw new Error( 'LDrawLoader: Invalid color while parsing material' + lineParser.getLineNumberString() + '.' );
 
-								break;
+					}
 
-							case '!CATEGORY':
+					break;
 
-								category = lp.getToken();
-								break;
+				case 'EDGE':
 
-							case '!KEYWORDS':
+					edgeColor = lineParser.getToken();
+					if ( edgeColor.startsWith( '0x' ) ) {
 
-								const newKeywords = lp.getRemainingString().split( ',' );
-								if ( newKeywords.length > 0 ) {
+						edgeColor = '#' + edgeColor.substring( 2 );
 
-									if ( ! keywords ) {
+					} else if ( ! edgeColor.startsWith( '#' ) ) {
 
-										keywords = [];
+						// Try to see if edge color is a color code
+						edgeMaterial = this.getMaterial( edgeColor );
+						if ( ! edgeMaterial ) {
 
-									}
+							throw new Error( 'LDrawLoader: Invalid edge color while parsing material' + lineParser.getLineNumberString() + '.' );
 
-									newKeywords.forEach( function ( keyword ) {
+						}
 
-										keywords.push( keyword.trim() );
+						// Get the edge material for this triangle material
+						edgeMaterial = edgeMaterial.userData.edgeMaterial;
 
-									} );
+					}
 
-								}
+					break;
 
-								break;
+				case 'ALPHA':
 
-							case 'FILE':
+					alpha = parseInt( lineParser.getToken() );
 
-								if ( lineIndex > 0 ) {
+					if ( isNaN( alpha ) ) {
 
-									// Start embedded text files parsing
-									parsingEmbeddedFiles = true;
-									currentEmbeddedFileName = lp.getRemainingString();
-									currentEmbeddedText = '';
+						throw new Error( 'LDrawLoader: Invalid alpha value in material definition' + lineParser.getLineNumberString() + '.' );
 
-									bfcCertified = false;
-									bfcCCW = true;
+					}
 
-								}
+					alpha = Math.max( 0, Math.min( 1, alpha / 255 ) );
 
-								break;
+					if ( alpha < 1 ) {
+
+						isTransparent = true;
 
-							case 'BFC':
+					}
 
-								// Changes to the backface culling state
-								while ( ! lp.isAtTheEnd() ) {
+					break;
 
-									const token = lp.getToken();
+				case 'LUMINANCE':
 
-									switch ( token ) {
+					luminance = parseInt( lineParser.getToken() );
 
-										case 'CERTIFY':
-										case 'NOCERTIFY':
+					if ( isNaN( luminance ) ) {
 
-											bfcCertified = token === 'CERTIFY';
-											bfcCCW = true;
+						throw new Error( 'LDrawLoader: Invalid luminance value in material definition' + LineParser.getLineNumberString() + '.' );
 
-											break;
+					}
 
-										case 'CW':
-										case 'CCW':
+					luminance = Math.max( 0, Math.min( 1, luminance / 255 ) );
 
-											bfcCCW = token === 'CCW';
+					break;
 
-											break;
+				case 'CHROME':
+					finishType = FINISH_TYPE_CHROME;
+					break;
 
-										case 'INVERTNEXT':
+				case 'PEARLESCENT':
+					finishType = FINISH_TYPE_PEARLESCENT;
+					break;
 
-											bfcInverted = true;
+				case 'RUBBER':
+					finishType = FINISH_TYPE_RUBBER;
+					break;
 
-											break;
+				case 'MATTE_METALLIC':
+					finishType = FINISH_TYPE_MATTE_METALLIC;
+					break;
 
-										case 'CLIP':
-										case 'NOCLIP':
+				case 'METAL':
+					finishType = FINISH_TYPE_METAL;
+					break;
 
-											  bfcCull = token === 'CLIP';
+				case 'MATERIAL':
+					// Not implemented
+					lineParser.setToEnd();
+					break;
 
-											break;
+				default:
+					throw new Error( 'LDrawLoader: Unknown token "' + token + '" while parsing material' + lineParser.getLineNumberString() + '.' );
 
-										default:
+			}
 
-											console.warn( 'THREE.LDrawLoader: BFC directive "' + token + '" is unknown.' );
+		}
 
-											break;
+		let material = null;
 
-									}
+		switch ( finishType ) {
 
-								}
+			case FINISH_TYPE_DEFAULT:
 
-								break;
+				material = new MeshStandardMaterial( { color: color, roughness: 0.3, metalness: 0 } );
+				break;
 
-							case 'STEP':
+			case FINISH_TYPE_PEARLESCENT:
 
-								startingConstructionStep = true;
+				// Try to imitate pearlescency by making the surface glossy
+				material = new MeshStandardMaterial( { color: color, roughness: 0.3, metalness: 0.25 } );
+				break;
 
-								break;
+			case FINISH_TYPE_CHROME:
 
-							default:
-								// Other meta directives are not implemented
-								break;
+				// Mirror finish surface
+				material = new MeshStandardMaterial( { color: color, roughness: 0, metalness: 1 } );
+				break;
 
-						}
+			case FINISH_TYPE_RUBBER:
 
-					}
+				// Rubber finish
+				material = new MeshStandardMaterial( { color: color, roughness: 0.9, metalness: 0 } );
+				break;
 
-					break;
+			case FINISH_TYPE_MATTE_METALLIC:
 
-					// Line type 1: Sub-object file
-				case '1':
+				// Brushed metal finish
+				material = new MeshStandardMaterial( { color: color, roughness: 0.8, metalness: 0.4 } );
+				break;
 
-					material = parseColourCode( lp );
+			case FINISH_TYPE_METAL:
 
-					const posX = parseFloat( lp.getToken() );
-					const posY = parseFloat( lp.getToken() );
-					const posZ = parseFloat( lp.getToken() );
-					const m0 = parseFloat( lp.getToken() );
-					const m1 = parseFloat( lp.getToken() );
-					const m2 = parseFloat( lp.getToken() );
-					const m3 = parseFloat( lp.getToken() );
-					const m4 = parseFloat( lp.getToken() );
-					const m5 = parseFloat( lp.getToken() );
-					const m6 = parseFloat( lp.getToken() );
-					const m7 = parseFloat( lp.getToken() );
-					const m8 = parseFloat( lp.getToken() );
+				// Average metal finish
+				material = new MeshStandardMaterial( { color: color, roughness: 0.2, metalness: 0.85 } );
+				break;
 
-					const matrix = new Matrix4().set(
-						m0, m1, m2, posX,
-						m3, m4, m5, posY,
-						m6, m7, m8, posZ,
-						0, 0, 0, 1
-					);
+			default:
+				// Should not happen
+				break;
 
-					let fileName = lp.getRemainingString().trim().replace( /\\/g, '/' );
+		}
 
-					if ( scope.fileMap[ fileName ] ) {
+		material.transparent = isTransparent;
+		material.premultipliedAlpha = true;
+		material.opacity = alpha;
+		material.depthWrite = ! isTransparent;
 
-						// Found the subobject path in the preloaded file path map
-						fileName = scope.fileMap[ fileName ];
+		material.polygonOffset = true;
+		material.polygonOffsetFactor = 1;
 
-					} else {
+		if ( luminance !== 0 ) {
 
-						// Standardized subfolders
-						if ( fileName.startsWith( 's/' ) ) {
+			material.emissive.set( material.color ).multiplyScalar( luminance );
 
-							fileName = 'parts/' + fileName;
+		}
 
-						} else if ( fileName.startsWith( '48/' ) ) {
+		if ( ! edgeMaterial ) {
 
-							fileName = 'p/' + fileName;
+			// This is the material used for edges
+			edgeMaterial = new LineBasicMaterial( {
+				color: edgeColor,
+				transparent: isTransparent,
+				opacity: alpha,
+				depthWrite: ! isTransparent
+			} );
+			edgeMaterial.userData.code = code;
+			edgeMaterial.name = name + ' - Edge';
 
-						}
+			// This is the material used for conditional edges
+			edgeMaterial.userData.conditionalEdgeMaterial = new LDrawConditionalLineMaterial( {
 
-					}
+				fog: true,
+				transparent: isTransparent,
+				depthWrite: ! isTransparent,
+				color: edgeColor,
+				opacity: alpha,
 
-					subobjects.push( {
-						material: material,
-						matrix: matrix,
-						fileName: fileName,
-						inverted: bfcInverted !== currentParseScope.inverted,
-						startingConstructionStep: startingConstructionStep
-					} );
+			} );
 
-					bfcInverted = false;
+		}
 
-					break;
+		material.userData.code = code;
+		material.name = name;
 
-					// Line type 2: Line segment
-				case '2':
+		material.userData.edgeMaterial = edgeMaterial;
 
-					material = parseColourCode( lp, true );
-					v0 = parseVector( lp );
-					v1 = parseVector( lp );
+		return material;
 
-					segment = {
-						material: material.userData.edgeMaterial,
-						colourCode: material.userData.code,
-						v0: v0,
-						v1: v1,
+	}
 
-						vertices: [ v0, v1 ],
-					};
+	//
 
-					lineSegments.push( segment );
+	objectParse( info, parseScope ) {
 
-					break;
+		// Retrieve data from the parent parse scope
+		const currentParseScope = parseScope;
+		const parentParseScope = currentParseScope.parentScope;
 
-					// Line type 5: Conditional Line segment
-				case '5':
+		// Main color codes passed to this subobject (or default codes 16 and 24 if it is the root object)
+		const mainColorCode = currentParseScope.mainColorCode;
+		const mainEdgeColorCode = currentParseScope.mainEdgeColorCode;
 
-					material = parseColourCode( lp, true );
-					v0 = parseVector( lp );
-					v1 = parseVector( lp );
-					c0 = parseVector( lp );
-					c1 = parseVector( lp );
+		const parseColorCode = ( colorCode, forEdge ) => {
 
-					segment = {
-						material: material.userData.edgeMaterial.userData.conditionalEdgeMaterial,
-						colourCode: material.userData.code,
-						vertices: [ v0, v1 ],
-						controlPoints: [ c0, c1 ],
-					};
+			// Parses next color code and returns a THREE.Material
 
-					conditionalSegments.push( segment );
+			if ( ! forEdge && colorCode === MAIN_COLOUR_CODE ) {
 
-					break;
+				colorCode = mainColorCode;
 
-					// Line type 3: Triangle
-				case '3':
+			}
 
-					material = parseColourCode( lp );
+			if ( forEdge && colorCode === MAIN_EDGE_COLOUR_CODE ) {
 
-					inverted = currentParseScope.inverted;
-					ccw = bfcCCW !== inverted;
-					doubleSided = ! bfcCertified || ! bfcCull;
+				colorCode = mainEdgeColorCode;
 
-					if ( ccw === true ) {
+			}
 
-						v0 = parseVector( lp );
-						v1 = parseVector( lp );
-						v2 = parseVector( lp );
+			const material = this.getMaterial( colorCode, currentParseScope );
 
-					} else {
+			if ( ! material ) {
 
-						v2 = parseVector( lp );
-						v1 = parseVector( lp );
-						v0 = parseVector( lp );
+				throw new Error( 'LDrawLoader: Unknown color code "' + colorCode + '" is used but it was not defined previously.' );
 
-					}
+			}
 
-					_tempVec0.subVectors( v1, v0 );
-					_tempVec1.subVectors( v2, v1 );
-					faceNormal = new Vector3()
-						.crossVectors( _tempVec0, _tempVec1 )
-						.normalize();
+			return material;
 
-					faces.push( {
-						material: material,
-						colourCode: material.userData.code,
-						faceNormal: faceNormal,
-						vertices: [ v0, v1, v2 ],
-						normals: [ null, null, null ],
-					} );
-					currentParseScope.totalFaces ++;
+		};
 
-					if ( doubleSided === true ) {
+		const faces = info.faces;
+		const lineSegments = info.lineSegments;
+		const conditionalSegments = info.conditionalSegments;
+		const materials = info.materials;
+		if ( currentParseScope.inverted ) {
 
-						faces.push( {
-							material: material,
-							colourCode: material.userData.code,
-							faceNormal: faceNormal,
-							vertices: [ v2, v1, v0 ],
-							normals: [ null, null, null ],
-						} );
-						currentParseScope.totalFaces ++;
+			faces.reverse();
 
-					}
+		}
 
-					break;
+		for ( const colorCode in materials ) {
 
-					// Line type 4: Quadrilateral
-				case '4':
+			this.addMaterial( materials[ colorCode ], currentParseScope );
 
-					material = parseColourCode( lp );
+		}
 
-					inverted = currentParseScope.inverted;
-					ccw = bfcCCW !== inverted;
-					doubleSided = ! bfcCertified || ! bfcCull;
+		for ( let i = 0, l = faces.length; i < l; i ++ ) {
 
-					if ( ccw === true ) {
+			const face = faces[ i ];
+			if ( face.material === null ) {
 
-						v0 = parseVector( lp );
-						v1 = parseVector( lp );
-						v2 = parseVector( lp );
-						v3 = parseVector( lp );
+				face.material = parseColorCode( face.colorCode, false );
 
-					} else {
+			}
 
-						v3 = parseVector( lp );
-						v2 = parseVector( lp );
-						v1 = parseVector( lp );
-						v0 = parseVector( lp );
+		}
 
-					}
+		for ( let i = 0, l = lineSegments.length; i < l; i ++ ) {
 
-					_tempVec0.subVectors( v1, v0 );
-					_tempVec1.subVectors( v2, v1 );
-					faceNormal = new Vector3()
-						.crossVectors( _tempVec0, _tempVec1 )
-						.normalize();
+			const ls = lineSegments[ i ];
+			if ( ls.material === null ) {
 
-					// specifically place the triangle diagonal in the v0 and v1 slots so we can
-					// account for the doubling of vertices later when smoothing normals.
-					faces.push( {
-						material: material,
-						colourCode: material.userData.code,
-						faceNormal: faceNormal,
-						vertices: [ v0, v1, v2, v3 ],
-						normals: [ null, null, null, null ],
-					} );
-					currentParseScope.totalFaces += 2;
+				ls.material = parseColorCode( ls.colorCode, true );
 
-					if ( doubleSided === true ) {
+			}
 
-						faces.push( {
-							material: material,
-							colourCode: material.userData.code,
-							faceNormal: faceNormal,
-							vertices: [ v3, v2, v1, v0 ],
-							normals: [ null, null, null, null ],
-						} );
-						currentParseScope.totalFaces += 2;
+		}
 
-					}
+		for ( let i = 0, l = conditionalSegments.length; i < l; i ++ ) {
 
-					break;
+			const cs = conditionalSegments[ i ];
+			if ( cs.material === null ) {
 
-				default:
-					throw 'LDrawLoader: Unknown line type "' + lineType + '"' + lp.getLineNumberString() + '.';
-					break;
+				cs.material = parseColorCode( cs.colorCode, true );
 
 			}
 
 		}
 
-		if ( parsingEmbeddedFiles ) {
+		currentParseScope.faces = info.faces;
+		currentParseScope.conditionalSegments = info.conditionalSegments;
+		currentParseScope.lineSegments = info.lineSegments;
+		currentParseScope.category = info.category;
+		currentParseScope.keywords = info.keywords;
+		currentParseScope.subobjects = info.subobjects;
+		currentParseScope.type = info.type;
+		currentParseScope.totalFaces = info.totalFaces;
+
+		const isRoot = ! parentParseScope.isFromParse;
+		if ( isRoot || ! isPrimitiveType( info.type ) ) {
 
-			this.cache.setData( currentEmbeddedFileName.toLowerCase(), currentEmbeddedText );
+			currentParseScope.groupObject = new Group();
+			currentParseScope.groupObject.userData.startingConstructionStep = currentParseScope.startingConstructionStep;
 
 		}
 
-		currentParseScope.category = category;
-		currentParseScope.keywords = keywords;
-		currentParseScope.subobjects = subobjects;
-		currentParseScope.numSubobjects = subobjects.length;
-		currentParseScope.subobjectIndex = 0;
-
 	}
 
 	computeConstructionSteps( model ) {
@@ -1856,6 +2106,13 @@ class LDrawLoader extends Loader {
 
 	finalizeObject( subobjectParseScope ) {
 
+		// fail gracefully if an object could not be loaded
+		if ( subobjectParseScope === null ) {
+
+			return;
+
+		}
+
 		const parentParseScope = subobjectParseScope.parentScope;
 
 		// Smooth the normals if this is a part or if this is a case where the subpart
@@ -1864,19 +2121,23 @@ class LDrawLoader extends Loader {
 		const doSmooth =
 			isPartType( subobjectParseScope.type ) ||
 			(
-				! isPartType( subobjectParseScope.type ) &&
-				! isModelType( subobjectParseScope.type ) &&
+				isPrimitiveType( subobjectParseScope.type ) &&
 				isModelType( subobjectParseScope.parentScope.type )
 			);
 
 		if ( this.smoothNormals && doSmooth ) {
 
-			smoothNormals( subobjectParseScope.faces, subobjectParseScope.lineSegments );
+			generateFaceNormals( subobjectParseScope.faces );
+
+			// only check subsetgments if we have multiple materials in a single part because this seems to be the case where it's needed most --
+			// there may be cases where a single edge line crosses over polygon edges that are broken up by multiple materials.
+			const checkSubSegments = subobjectParseScope.faceMaterials.size > 1;
+			smoothNormals( subobjectParseScope.faces, subobjectParseScope.lineSegments, checkSubSegments );
 
 		}
 
 		const isRoot = ! parentParseScope.isFromParse;
-		if ( this.separateObjects && ! isPrimitiveType( subobjectParseScope.type ) || isRoot ) {
+		if ( ! isPrimitiveType( subobjectParseScope.type ) || isRoot ) {
 
 			const objGroup = subobjectParseScope.groupObject;
 
@@ -1911,26 +2172,24 @@ class LDrawLoader extends Loader {
 
 		} else {
 
-			const separateObjects = this.separateObjects;
 			const parentLineSegments = parentParseScope.lineSegments;
 			const parentConditionalSegments = parentParseScope.conditionalSegments;
 			const parentFaces = parentParseScope.faces;
+			const parentFaceMaterials = parentParseScope.faceMaterials;
 
 			const lineSegments = subobjectParseScope.lineSegments;
 			const conditionalSegments = subobjectParseScope.conditionalSegments;
 			const faces = subobjectParseScope.faces;
+			const faceMaterials = subobjectParseScope.faceMaterials;
+			const matrix = subobjectParseScope.matrix;
+			const matrixScaleInverted = matrix.determinant() < 0;
 
 			for ( let i = 0, l = lineSegments.length; i < l; i ++ ) {
 
 				const ls = lineSegments[ i ];
-
-				if ( separateObjects ) {
-
-					const vertices = ls.vertices;
-					vertices[ 0 ].applyMatrix4( subobjectParseScope.matrix );
-					vertices[ 1 ].applyMatrix4( subobjectParseScope.matrix );
-
-				}
+				const vertices = ls.vertices;
+				vertices[ 0 ].applyMatrix4( matrix );
+				vertices[ 1 ].applyMatrix4( matrix );
 
 				parentLineSegments.push( ls );
 
@@ -1939,17 +2198,12 @@ class LDrawLoader extends Loader {
 			for ( let i = 0, l = conditionalSegments.length; i < l; i ++ ) {
 
 				const os = conditionalSegments[ i ];
-
-				if ( separateObjects ) {
-
-					const vertices = os.vertices;
-					const controlPoints = os.controlPoints;
-					vertices[ 0 ].applyMatrix4( subobjectParseScope.matrix );
-					vertices[ 1 ].applyMatrix4( subobjectParseScope.matrix );
-					controlPoints[ 0 ].applyMatrix4( subobjectParseScope.matrix );
-					controlPoints[ 1 ].applyMatrix4( subobjectParseScope.matrix );
-
-				}
+				const vertices = os.vertices;
+				const controlPoints = os.controlPoints;
+				vertices[ 0 ].applyMatrix4( matrix );
+				vertices[ 1 ].applyMatrix4( matrix );
+				controlPoints[ 0 ].applyMatrix4( matrix );
+				controlPoints[ 1 ].applyMatrix4( matrix );
 
 				parentConditionalSegments.push( os );
 
@@ -1958,19 +2212,18 @@ class LDrawLoader extends Loader {
 			for ( let i = 0, l = faces.length; i < l; i ++ ) {
 
 				const tri = faces[ i ];
+				const vertices = tri.vertices;
+				for ( let i = 0, l = vertices.length; i < l; i ++ ) {
 
-				if ( separateObjects ) {
-
-					const vertices = tri.vertices;
-					for ( let i = 0, l = vertices.length; i < l; i ++ ) {
+					vertices[ i ].applyMatrix4( matrix );
 
-						vertices[ i ] = vertices[ i ].clone().applyMatrix4( subobjectParseScope.matrix );
+				}
 
-					}
+				// If the scale of the object is negated then the triangle winding order
+				// needs to be flipped.
+				if ( matrixScaleInverted !== subobjectParseScope.inverted ) {
 
-					_tempVec0.subVectors( vertices[ 1 ], vertices[ 0 ] );
-					_tempVec1.subVectors( vertices[ 2 ], vertices[ 1 ] );
-					tri.faceNormal.crossVectors( _tempVec0, _tempVec1 ).normalize();
+					vertices.reverse();
 
 				}
 
@@ -1979,41 +2232,48 @@ class LDrawLoader extends Loader {
 			}
 
 			parentParseScope.totalFaces += subobjectParseScope.totalFaces;
+			faceMaterials.forEach( material => parentFaceMaterials.add( material ) );
 
 		}
 
 	}
 
-	async processObject( text, subobject, url, parentScope ) {
+	async processObject( parsedInfo, subobject, url, parentScope ) {
 
 		const scope = this;
 
 		const parseScope = this.newParseScopeLevel( null, parentScope );
 		parseScope.url = url;
 
-		const parentParseScope = parseScope.parentScope;
-
 		// Set current matrix
 		if ( subobject ) {
 
-			parseScope.currentMatrix.multiplyMatrices( parentParseScope.currentMatrix, subobject.matrix );
 			parseScope.matrix.copy( subobject.matrix );
 			parseScope.inverted = subobject.inverted;
 			parseScope.startingConstructionStep = subobject.startingConstructionStep;
-			parseScope.mainColourCode = subobject.material.userData.code;
-			parseScope.mainEdgeColourCode = subobject.material.userData.edgeMaterial.userData.code;
 			parseScope.fileName = subobject.fileName;
+			if ( subobject.colorCode === MAIN_COLOUR_CODE && parentScope ) {
+
+				parseScope.mainColorCode = parentScope.mainColorCode;
+				parseScope.mainEdgeColorCode = parentScope.mainEdgeColorCode;
+
+			} else if ( subobject.colorCode !== MAIN_COLOUR_CODE ) {
+
+				parseScope.mainColorCode = subobject.colorCode;
+				parseScope.mainEdgeColorCode = subobject.colorCode;
+
+			}
 
 		}
 
 		// Parse the object
-		this.objectParse( text, parseScope );
+		this.objectParse( parsedInfo, parseScope );
 
 		const subobjects = parseScope.subobjects;
 		const promises = [];
 		for ( let i = 0, l = subobjects.length; i < l; i ++ ) {
 
-			promises.push( loadSubobject( parseScope.subobjects[ i ] ) );
+			promises.push( loadSubobject( subobjects[ i ] ) );
 
 		}
 
@@ -2027,7 +2287,7 @@ class LDrawLoader extends Loader {
 		}
 
 		// If it is root object then finalize this object and compute construction steps
-		if ( ! parentParseScope.isFromParse ) {
+		if ( ! parentScope.isFromParse ) {
 
 			this.finalizeObject( parseScope );
 			this.computeConstructionSteps( parseScope.groupObject );
@@ -2038,13 +2298,14 @@ class LDrawLoader extends Loader {
 
 		function loadSubobject( subobject ) {
 
-			return scope.cache.loadData( subobject.fileName ).then( function ( text ) {
+			return scope.parseCache.loadData( subobject.fileName ).then( function ( parsedInfo ) {
 
-				return scope.processObject( text, subobject, url, parseScope );
+				return scope.processObject( parsedInfo, subobject, url, parseScope );
 
-			} ).catch( function () {
+			} ).catch( function ( err ) {
 
-				console.warn( 'LDrawLoader: Subobject "' + subobject.fileName + '" could not be found.' );
+				console.warn( err );
+				return null;
 
 			} );