super-three 0.136.0 → 0.136.1

package/examples/js/loaders/LDrawLoader.js

@@ -142,16 +142,45 @@
 
 	}
 
-	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 THREE.Vector3().crossVectors( _tempVec0, _tempVec1 ).normalize();
+
+		}
+
+	}
+
+	const _ray = new THREE.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}`;
 
 		}
@@ -160,9 +189,27 @@
 
 			return `${hashVertex( v0 )}_${hashVertex( v1 )}`;
 
+		} // 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 = []; // Save the list of hard edges by hash
 
@@ -173,7 +220,43 @@
 			const v0 = vertices[ 0 ];
 			const v1 = vertices[ 1 ];
 			hardEdges.add( hashEdge( v0, v1 ) );
-			hardEdges.add( hashEdge( v1, v0 ) );
+			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 THREE.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
 
@@ -192,7 +275,58 @@
 				const v1 = vertices[ next ];
 				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,
 					tri: tri
@@ -433,6 +567,12 @@
 
 		}
 
+		getVector() {
+
+			return new THREE.Vector3( parseFloat( this.getToken() ), parseFloat( this.getToken() ), parseFloat( this.getToken() ) );
+
+		}
+
 		getRemainingString() {
 
 			return this.line.substring( this.currentCharIndex, this.lineLength );
@@ -459,1239 +599,1368 @@
 
 	}
 
-	class LDrawFileCache {
+	class LDrawParsedCache {
 
 		constructor( loader ) {
 
-			this.cache = {};
 			this.loader = loader;
+			this.cache = {};
 
 		}
 
-		setData( key, contents ) {
+		cloneResult( original ) {
 
-			this.cache[ key.toLowerCase() ] = contents;
+			const result = {}; // vertices are transformed and normals computed before being converted to geometry
+			// so these pieces must be cloned.
 
-		}
+			result.faces = original.faces.map( face => {
 
-		async loadData( fileName ) {
+				return {
+					colorCode: face.colorCode,
+					material: face.material,
+					vertices: face.vertices.map( v => v.clone() ),
+					normals: face.normals.map( () => null ),
+					faceNormal: null
+				};
 
-			const key = fileName.toLowerCase();
+			} );
+			result.conditionalSegments = original.conditionalSegments.map( face => {
 
-			if ( key in this.cache ) {
+				return {
+					colorCode: face.colorCode,
+					material: face.material,
+					vertices: face.vertices.map( v => v.clone() ),
+					controlPoints: face.controlPoints.map( v => v.clone() )
+				};
 
-				return this.cache[ key ];
+			} );
+			result.lineSegments = original.lineSegments.map( face => {
 
-			}
+				return {
+					colorCode: face.colorCode,
+					material: face.material,
+					vertices: face.vertices.map( v => v.clone() )
+				};
 
-			this.cache[ fileName ] = new Promise( async ( resolve, reject ) => {
+			} ); // none if this is subsequently modified
 
-				let triedLowerCase = false;
-				let locationState = FILE_LOCATION_AS_IS;
+			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;
 
-				while ( locationState !== FILE_LOCATION_NOT_FOUND ) {
+		}
 
-					let subobjectURL = fileName;
+		async fetchData( fileName ) {
 
-					switch ( locationState ) {
+			let triedLowerCase = false;
+			let locationState = FILE_LOCATION_AS_IS;
 
-						case FILE_LOCATION_AS_IS:
-							locationState = locationState + 1;
-							break;
+			while ( locationState !== FILE_LOCATION_NOT_FOUND ) {
 
-						case FILE_LOCATION_TRY_PARTS:
-							subobjectURL = 'parts/' + subobjectURL;
-							locationState = locationState + 1;
-							break;
+				let subobjectURL = fileName;
 
-						case FILE_LOCATION_TRY_P:
-							subobjectURL = 'p/' + subobjectURL;
-							locationState = locationState + 1;
-							break;
+				switch ( locationState ) {
 
-						case FILE_LOCATION_TRY_MODELS:
-							subobjectURL = 'models/' + subobjectURL;
-							locationState = locationState + 1;
-							break;
+					case FILE_LOCATION_AS_IS:
+						locationState = locationState + 1;
+						break;
 
-						case FILE_LOCATION_TRY_RELATIVE:
-							subobjectURL = fileName.substring( 0, fileName.lastIndexOf( '/' ) + 1 ) + subobjectURL;
-							locationState = locationState + 1;
-							break;
+					case FILE_LOCATION_TRY_PARTS:
+						subobjectURL = 'parts/' + subobjectURL;
+						locationState = locationState + 1;
+						break;
 
-						case FILE_LOCATION_TRY_ABSOLUTE:
-							if ( triedLowerCase ) {
+					case FILE_LOCATION_TRY_P:
+						subobjectURL = 'p/' + subobjectURL;
+						locationState = locationState + 1;
+						break;
 
-								// Try absolute path
-								locationState = FILE_LOCATION_NOT_FOUND;
+					case FILE_LOCATION_TRY_MODELS:
+						subobjectURL = 'models/' + subobjectURL;
+						locationState = locationState + 1;
+						break;
 
-							} else {
+					case FILE_LOCATION_TRY_RELATIVE:
+						subobjectURL = fileName.substring( 0, fileName.lastIndexOf( '/' ) + 1 ) + 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_ABSOLUTE:
+						if ( triedLowerCase ) {
 
-							}
+							// Try absolute path
+							locationState = FILE_LOCATION_NOT_FOUND;
 
-							break;
+						} else {
 
-					}
+							// Next attempt is lower case
+							fileName = fileName.toLowerCase();
+							subobjectURL = fileName;
+							triedLowerCase = true;
+							locationState = FILE_LOCATION_AS_IS;
+
+						}
 
-					const loader = this.loader;
-					const fileLoader = new THREE.FileLoader( loader.manager );
-					fileLoader.setPath( loader.partsLibraryPath );
-					fileLoader.setRequestHeader( loader.requestHeader );
-					fileLoader.setWithCredentials( loader.withCredentials );
+						break;
+
+				}
 
-					try {
+				const loader = this.loader;
+				const fileLoader = new THREE.FileLoader( loader.manager );
+				fileLoader.setPath( loader.partsLibraryPath );
+				fileLoader.setRequestHeader( loader.requestHeader );
+				fileLoader.setWithCredentials( loader.withCredentials );
 
-						const text = await fileLoader.loadAsync( subobjectURL );
-						this.setData( fileName, text );
-						resolve( text );
-						return;
+				try {
 
-					} catch {
+					const text = await fileLoader.loadAsync( subobjectURL );
+					return text;
 
-						continue;
+				} catch {
 
-					}
+					continue;
 
 				}
 
-				reject();
+			}
 
-			} );
-			return this.cache[ fileName ];
+			throw new Error( 'LDrawLoader: Subobject "' + fileName + '" could not be loaded.' );
 
 		}
 
-	}
-
-	function sortByMaterial( a, b ) {
+		parse( text ) {
 
-		if ( a.colourCode === b.colourCode ) {
+			const loader = this.loader; // final results
 
-			return 0;
+			const faces = [];
+			const lineSegments = [];
+			const conditionalSegments = [];
+			const subobjects = [];
+			const materials = {};
 
-		}
+			const getLocalMaterial = colorCode => {
 
-		if ( a.colourCode < b.colourCode ) {
+				return colorCode in materials ? materials[ colorCode ] : null;
 
-			return - 1;
+			};
 
-		}
+			let type = 'Model';
+			let category = null;
+			let keywords = null;
+			let totalFaces = 0; // split into lines
 
-		return 1;
+			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' );
 
-	function createObject( elements, elementSize, isConditionalSegments = false, totalElements = null ) {
+			}
 
-		// Creates a THREE.LineSegments (elementSize = 2) or a THREE.Mesh (elementSize = 3 )
-		// With per face / segment material, implemented with mesh groups and materials array
-		// Sort the faces or line segments by colour code to make later the mesh groups
-		elements.sort( sortByMaterial );
+			const lines = text.split( '\n' );
+			const numLines = lines.length;
+			let parsingEmbeddedFiles = false;
+			let currentEmbeddedFileName = null;
+			let currentEmbeddedText = null;
+			let bfcCertified = false;
+			let bfcCCW = true;
+			let bfcInverted = false;
+			let bfcCull = true;
+			let startingConstructionStep = false; // Parse all line commands
 
-		if ( totalElements === null ) {
+			for ( let lineIndex = 0; lineIndex < numLines; lineIndex ++ ) {
 
-			totalElements = elements.length;
+				const line = lines[ lineIndex ];
+				if ( line.length === 0 ) continue;
 
-		}
+				if ( parsingEmbeddedFiles ) {
 
-		const positions = new Float32Array( elementSize * totalElements * 3 );
-		const normals = elementSize === 3 ? new Float32Array( elementSize * totalElements * 3 ) : null;
-		const materials = [];
-		const quadArray = new Array( 6 );
-		const bufferGeometry = new THREE.BufferGeometry();
-		let prevMaterial = null;
-		let index0 = 0;
-		let numGroupVerts = 0;
-		let offset = 0;
+					if ( line.startsWith( '0 FILE ' ) ) {
 
-		for ( let iElem = 0, nElem = elements.length; iElem < nElem; iElem ++ ) {
+						// Save previous embedded file in the cache
+						this.setData( currentEmbeddedFileName, currentEmbeddedText ); // New embedded text file
 
-			const elem = elements[ iElem ];
-			let vertices = elem.vertices;
+						currentEmbeddedFileName = line.substring( 7 );
+						currentEmbeddedText = '';
 
-			if ( vertices.length === 4 ) {
+					} else {
 
-				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;
+						currentEmbeddedText += line + '\n';
 
-			}
+					}
 
-			for ( let j = 0, l = vertices.length; j < l; j ++ ) {
+					continue;
 
-				const v = vertices[ j ];
-				const index = offset + j * 3;
-				positions[ index + 0 ] = v.x;
-				positions[ index + 1 ] = v.y;
-				positions[ index + 2 ] = v.z;
+				}
 
-			}
+				const lp = new LineParser( line, lineIndex + 1 );
+				lp.seekNonSpace();
 
-			if ( elementSize === 3 ) {
+				if ( lp.isAtTheEnd() ) {
 
-				let elemNormals = elem.normals;
+					// Empty line
+					continue;
 
-				if ( elemNormals.length === 4 ) {
+				} // Parse the line type
 
-					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;
 
-				}
+				const lineType = lp.getToken();
+				let material;
+				let colorCode;
+				let segment;
+				let ccw;
+				let doubleSided;
+				let v0, v1, v2, v3, c0, c1;
 
-				for ( let j = 0, l = elemNormals.length; j < l; j ++ ) {
+				switch ( lineType ) {
 
-					let n = elem.faceNormal;
+					// Line type 0: Comment or META
+					case '0':
+						// Parse meta directive
+						const meta = lp.getToken();
 
-					if ( elemNormals[ j ] ) {
+						if ( meta ) {
 
-						n = elemNormals[ j ].norm;
+							switch ( meta ) {
 
-					}
+								case '!LDRAW_ORG':
+									type = lp.getToken();
+									break;
 
-					const index = offset + j * 3;
-					normals[ index + 0 ] = n.x;
-					normals[ index + 1 ] = n.y;
-					normals[ index + 2 ] = n.z;
+								case '!COLOUR':
+									material = loader.parseColorMetaDirective( lp );
 
-				}
+									if ( material ) {
 
-			}
+										materials[ material.userData.code ] = material;
 
-			if ( prevMaterial !== elem.material ) {
+									} else {
 
-				if ( prevMaterial !== null ) {
+										console.warn( 'LDrawLoader: Error parsing material' + lp.getLineNumberString() );
 
-					bufferGeometry.addGroup( index0, numGroupVerts, materials.length - 1 );
+									}
 
-				}
+									break;
 
-				materials.push( elem.material );
-				prevMaterial = elem.material;
-				index0 = offset / 3;
-				numGroupVerts = vertices.length;
+								case '!CATEGORY':
+									category = lp.getToken();
+									break;
 
-			} else {
+								case '!KEYWORDS':
+									const newKeywords = lp.getRemainingString().split( ',' );
 
-				numGroupVerts += vertices.length;
+									if ( newKeywords.length > 0 ) {
 
-			}
+										if ( ! keywords ) {
 
-			offset += 3 * vertices.length;
+											keywords = [];
 
-		}
+										}
 
-		if ( numGroupVerts > 0 ) {
+										newKeywords.forEach( function ( keyword ) {
 
-			bufferGeometry.addGroup( index0, Infinity, materials.length - 1 );
+											keywords.push( keyword.trim() );
 
-		}
+										} );
 
-		bufferGeometry.setAttribute( 'position', new THREE.BufferAttribute( positions, 3 ) );
+									}
 
-		if ( normals !== null ) {
+									break;
 
-			bufferGeometry.setAttribute( 'normal', new THREE.BufferAttribute( normals, 3 ) );
+								case 'FILE':
+									if ( lineIndex > 0 ) {
 
-		}
+										// Start embedded text files parsing
+										parsingEmbeddedFiles = true;
+										currentEmbeddedFileName = lp.getRemainingString();
+										currentEmbeddedText = '';
+										bfcCertified = false;
+										bfcCCW = true;
 
-		let object3d = null;
+									}
 
-		if ( elementSize === 2 ) {
+									break;
 
-			object3d = new THREE.LineSegments( bufferGeometry, materials.length === 1 ? materials[ 0 ] : materials );
+								case 'BFC':
+									// Changes to the backface culling state
+									while ( ! lp.isAtTheEnd() ) {
 
-		} else if ( elementSize === 3 ) {
+										const token = lp.getToken();
 
-			object3d = new THREE.Mesh( bufferGeometry, materials.length === 1 ? materials[ 0 ] : materials );
+										switch ( token ) {
 
-		}
+											case 'CERTIFY':
+											case 'NOCERTIFY':
+												bfcCertified = token === 'CERTIFY';
+												bfcCCW = true;
+												break;
 
-		if ( isConditionalSegments ) {
+											case 'CW':
+											case 'CCW':
+												bfcCCW = token === 'CCW';
+												break;
 
-			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 );
+											case 'INVERTNEXT':
+												bfcInverted = true;
+												break;
 
-			for ( let i = 0, l = elements.length; i < l; i ++ ) {
+											case 'CLIP':
+											case 'NOCLIP':
+												bfcCull = token === 'CLIP';
+												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;
-				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;
+											default:
+												console.warn( 'THREE.LDrawLoader: BFC directive "' + token + '" is unknown.' );
+												break;
 
-			}
+										}
 
-			bufferGeometry.setAttribute( 'control0', new THREE.BufferAttribute( controlArray0, 3, false ) );
-			bufferGeometry.setAttribute( 'control1', new THREE.BufferAttribute( controlArray1, 3, false ) );
-			bufferGeometry.setAttribute( 'direction', new THREE.BufferAttribute( directionArray, 3, false ) );
+									}
 
-		}
+									break;
 
-		return object3d;
+								case 'STEP':
+									startingConstructionStep = true;
+									break;
 
-	} //
+								default:
+									// Other meta directives are not implemented
+									break;
 
+							}
 
-	class LDrawLoader extends THREE.Loader {
+						}
 
-		constructor( manager ) {
+						break;
+						// Line type 1: Sub-object file
 
-			super( manager ); // Array of THREE.Material
+					case '1':
+						colorCode = lp.getToken();
+						material = getLocalMaterial( colorCode );
+						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() );
+						const matrix = new THREE.Matrix4().set( m0, m1, m2, posX, m3, m4, m5, posY, m6, m7, m8, posZ, 0, 0, 0, 1 );
+						let fileName = lp.getRemainingString().trim().replace( /\\/g, '/' );
 
-			this.materials = []; // 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)
+						if ( loader.fileMap[ fileName ] ) {
 
-			this.cache = new LDrawFileCache( this ); // 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.
+							// Found the subobject path in the preloaded file path map
+							fileName = loader.fileMap[ fileName ];
 
-			this.fileMap = null;
-			this.rootParseScope = this.newParseScopeLevel(); // Add default main triangle and line edge materials (used in pieces that can be coloured with a main color)
+						} else {
 
-			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' ) ) ] ); // 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.
+							// Standardized subfolders
+							if ( fileName.startsWith( 's/' ) ) {
 
-			this.separateObjects = false; // If this flag is set to true the vertex normals will be smoothed.
+								fileName = 'parts/' + fileName;
 
-			this.smoothNormals = true; // The path to load parts from the LDraw parts library from.
+							} else if ( fileName.startsWith( '48/' ) ) {
 
-			this.partsLibraryPath = '';
+								fileName = 'p/' + fileName;
 
-		}
+							}
 
-		setPartsLibraryPath( path ) {
+						}
 
-			this.partsLibraryPath = path;
-			return this;
+						subobjects.push( {
+							material: material,
+							colorCode: colorCode,
+							matrix: matrix,
+							fileName: fileName,
+							inverted: bfcInverted,
+							startingConstructionStep: startingConstructionStep
+						} );
+						bfcInverted = false;
+						break;
+						// Line type 2: Line segment
 
-		}
+					case '2':
+						colorCode = lp.getToken();
+						material = getLocalMaterial( colorCode );
+						v0 = lp.getVector();
+						v1 = lp.getVector();
+						segment = {
+							material: material,
+							colorCode: colorCode,
+							vertices: [ v0, v1 ]
+						};
+						lineSegments.push( segment );
+						break;
+						// Line type 5: Conditional Line segment
 
-		async preloadMaterials( url ) {
+					case '5':
+						colorCode = lp.getToken();
+						material = getLocalMaterial( colorCode );
+						v0 = lp.getVector();
+						v1 = lp.getVector();
+						c0 = lp.getVector();
+						c1 = lp.getVector();
+						segment = {
+							material: material,
+							colorCode: colorCode,
+							vertices: [ v0, v1 ],
+							controlPoints: [ c0, c1 ]
+						};
+						conditionalSegments.push( segment );
+						break;
+						// Line type 3: Triangle
 
-			const fileLoader = new THREE.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 = [];
+					case '3':
+						colorCode = lp.getToken();
+						material = getLocalMaterial( colorCode );
+						ccw = bfcCCW;
+						doubleSided = ! bfcCertified || ! bfcCull;
 
-			for ( let i = 0, l = lines.length; i < l; i ++ ) {
+						if ( ccw === true ) {
 
-				const line = lines[ i ];
+							v0 = lp.getVector();
+							v1 = lp.getVector();
+							v2 = lp.getVector();
 
-				if ( colorLineRegex.test( line ) ) {
+						} else {
 
-					const directive = line.replace( colorLineRegex, '' );
-					const material = this.parseColourMetaDirective( new LineParser( directive ) );
-					materials.push( material );
+							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() + '.' );
 
 				}
 
 			}
 
-			this.setMaterials( materials );
+			if ( parsingEmbeddedFiles ) {
+
+				this.setData( currentEmbeddedFileName, currentEmbeddedText );
+
+			}
+
+			return {
+				faces,
+				conditionalSegments,
+				lineSegments,
+				type,
+				category,
+				keywords,
+				subobjects,
+				totalFaces,
+				startingConstructionStep,
+				materials
+			};
 
 		}
 
-		load( url, onLoad, onProgress, onError ) {
+		loadData( fileName ) {
+
+			const key = fileName.toLowerCase();
 
-			if ( ! this.fileMap ) {
+			if ( ! ( key in this.cache ) ) {
 
-				this.fileMap = {};
+				this.cache[ key ] = this.fetchData( fileName ).then( text => {
+
+					return this.parse( text );
+
+				} );
 
 			}
 
-			const fileLoader = new THREE.FileLoader( this.manager );
-			fileLoader.setPath( this.path );
-			fileLoader.setRequestHeader( this.requestHeader );
-			fileLoader.setWithCredentials( this.withCredentials );
-			fileLoader.load( url, text => {
+			return this.cache[ key ].then( result => {
 
-				this.processObject( text, null, url, this.rootParseScope ).then( function ( result ) {
+				return this.cloneResult( result );
 
-					onLoad( result.groupObject );
+			} );
 
-				} );
+		}
 
-			}, onProgress, onError );
+		setData( fileName, text ) {
+
+			const key = fileName.toLowerCase();
+			this.cache[ key ] = Promise.resolve( this.parse( text ) );
 
 		}
 
-		parse( text, path, onLoad ) {
+	}
 
-			// Async parse.  This function calls onParse with the parsed THREE.Object3D as parameter
-			this.processObject( text, null, path, this.rootParseScope ).then( function ( result ) {
+	function sortByMaterial( a, b ) {
 
-				onLoad( result.groupObject );
+		if ( a.colorCode === b.colorCode ) {
 
-			} );
+			return 0;
 
 		}
 
-		setMaterials( materials ) {
+		if ( a.colorCode < b.colorCode ) {
 
-			// Clears parse scopes stack, adds new scope with material library
-			this.rootParseScope = this.newParseScopeLevel( materials );
-			this.rootParseScope.isFromParse = false;
-			this.materials = materials;
-			return this;
+			return - 1;
 
 		}
 
-		setFileMap( fileMap ) {
+		return 1;
 
-			this.fileMap = fileMap;
-			return this;
+	}
 
-		}
+	function createObject( elements, elementSize, isConditionalSegments = false, totalElements = null ) {
 
-		newParseScopeLevel( materials = null, parentScope = null ) {
+		// Creates a THREE.LineSegments (elementSize = 2) or a THREE.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 );
 
-			// Adds a new scope level, assign materials to it and returns it
-			const matLib = {};
+		if ( totalElements === null ) {
 
-			if ( materials ) {
+			totalElements = elements.length;
 
-				for ( let i = 0, n = materials.length; i < n; i ++ ) {
+		}
 
-					const material = materials[ i ];
-					matLib[ material.userData.code ] = material;
+		const positions = new Float32Array( elementSize * totalElements * 3 );
+		const normals = elementSize === 3 ? new Float32Array( elementSize * totalElements * 3 ) : null;
+		const materials = [];
+		const quadArray = new Array( 6 );
+		const bufferGeometry = new THREE.BufferGeometry();
+		let prevMaterial = null;
+		let index0 = 0;
+		let numGroupVerts = 0;
+		let offset = 0;
 
-				}
+		for ( let iElem = 0, nElem = elements.length; iElem < nElem; iElem ++ ) {
 
-			}
+			const elem = elements[ iElem ];
+			let vertices = elem.vertices;
 
-			const newParseScope = {
-				parentScope: parentScope,
-				lib: matLib,
-				url: null,
-				// 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 THREE.Matrix4(),
-				matrix: new THREE.Matrix4(),
-				type: 'Model',
-				groupObject: null,
-				// If false, it is a root material scope previous to parse
-				isFromParse: true,
-				faces: [],
-				lineSegments: [],
-				conditionalSegments: [],
-				totalFaces: 0,
-				// If true, this object is the start of a construction step
-				startingConstructionStep: false
-			};
-			return newParseScope;
+			if ( vertices.length === 4 ) {
+
+				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;
 
-		}
+			}
 
-		addMaterial( material, parseScope ) {
+			for ( let j = 0, l = vertices.length; j < l; j ++ ) {
 
-			// Adds a material to the material library which is on top of the parse scopes stack. And also to the materials array
-			const matLib = parseScope.lib;
+				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 ( ! matLib[ material.userData.code ] ) {
+			} // create the normals array if this is a set of faces
 
-				this.materials.push( material );
 
-			}
+			if ( elementSize === 3 ) {
 
-			matLib[ material.userData.code ] = material;
-			return this;
+				if ( ! elem.faceNormal ) {
 
-		}
+					const v0 = vertices[ 0 ];
+					const v1 = vertices[ 1 ];
+					const v2 = vertices[ 2 ];
 
-		getMaterial( colourCode, parseScope = this.rootParseScope ) {
+					_tempVec0.subVectors( v1, v0 );
 
-			// Given a colour code search its material in the parse scopes stack
-			if ( colourCode.startsWith( '0x2' ) ) {
+					_tempVec1.subVectors( v2, v1 );
 
-				// Special 'direct' material value (RGB colour)
-				const colour = colourCode.substring( 3 );
-				return this.parseColourMetaDirective( new LineParser( 'Direct_Color_' + colour + ' CODE -1 VALUE #' + colour + ' EDGE #' + colour + '' ) );
+					elem.faceNormal = new THREE.Vector3().crossVectors( _tempVec0, _tempVec1 ).normalize();
 
-			}
+				}
 
-			while ( parseScope ) {
+				let elemNormals = elem.normals;
 
-				const material = parseScope.lib[ colourCode ];
+				if ( elemNormals.length === 4 ) {
 
-				if ( 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;
 
-					return material;
+				}
 
-				} else {
+				for ( let j = 0, l = elemNormals.length; j < l; j ++ ) {
 
-					parseScope = parseScope.parentScope;
+					// use face normal if a vertex normal is not provided
+					let n = elem.faceNormal;
 
-				}
+					if ( elemNormals[ j ] ) {
 
-			} // Material was not found
+						n = elemNormals[ j ].norm;
 
+					}
 
-			return null;
+					const index = offset + j * 3;
+					normals[ index + 0 ] = n.x;
+					normals[ index + 1 ] = n.y;
+					normals[ index + 2 ] = n.z;
 
-		}
+				}
 
-		parseColourMetaDirective( lineParser ) {
+			}
 
-			// Parses a colour definition and returns a THREE.Material
-			let code = null; // Triangle and line colours
+			if ( prevMaterial !== elem.material ) {
 
-			let colour = 0xFF00FF;
-			let edgeColour = 0xFF00FF; // Transparency
+				if ( prevMaterial !== null ) {
 
-			let alpha = 1;
-			let isTransparent = false; // Self-illumination:
+					bufferGeometry.addGroup( index0, numGroupVerts, materials.length - 1 );
 
-			let luminance = 0;
-			let finishType = FINISH_TYPE_DEFAULT;
-			let edgeMaterial = null;
-			const name = lineParser.getToken();
+				}
 
-			if ( ! name ) {
+				const material = elem.material;
 
-				throw 'LDrawLoader: Material name was expected after "!COLOUR tag' + lineParser.getLineNumberString() + '.';
+				if ( elementSize === 3 ) {
 
-			} // Parse tag tokens and their parameters
+					materials.push( material );
 
+				} else if ( elementSize === 2 ) {
 
-			let token = null;
+					if ( isConditionalSegments ) {
 
-			while ( true ) {
+						materials.push( material.userData.edgeMaterial.userData.conditionalEdgeMaterial );
 
-				token = lineParser.getToken();
+					} else {
 
-				if ( ! token ) {
+						materials.push( material.userData.edgeMaterial );
 
-					break;
+					}
 
 				}
 
-				switch ( token.toUpperCase() ) {
+				prevMaterial = elem.material;
+				index0 = offset / 3;
+				numGroupVerts = vertices.length;
 
-					case 'CODE':
-						code = lineParser.getToken();
-						break;
+			} else {
 
-					case 'VALUE':
-						colour = lineParser.getToken();
+				numGroupVerts += vertices.length;
 
-						if ( colour.startsWith( '0x' ) ) {
+			}
 
-							colour = '#' + colour.substring( 2 );
+			offset += 3 * vertices.length;
 
-						} else if ( ! colour.startsWith( '#' ) ) {
+		}
 
-							throw 'LDrawLoader: Invalid colour while parsing material' + lineParser.getLineNumberString() + '.';
+		if ( numGroupVerts > 0 ) {
 
-						}
+			bufferGeometry.addGroup( index0, Infinity, materials.length - 1 );
 
-						break;
+		}
 
-					case 'EDGE':
-						edgeColour = lineParser.getToken();
+		bufferGeometry.setAttribute( 'position', new THREE.BufferAttribute( positions, 3 ) );
 
-						if ( edgeColour.startsWith( '0x' ) ) {
+		if ( normals !== null ) {
 
-							edgeColour = '#' + edgeColour.substring( 2 );
+			bufferGeometry.setAttribute( 'normal', new THREE.BufferAttribute( normals, 3 ) );
 
-						} else if ( ! edgeColour.startsWith( '#' ) ) {
+		}
 
-							// Try to see if edge colour is a colour code
-							edgeMaterial = this.getMaterial( edgeColour );
+		let object3d = null;
 
-							if ( ! edgeMaterial ) {
+		if ( elementSize === 2 ) {
 
-								throw 'LDrawLoader: Invalid edge colour while parsing material' + lineParser.getLineNumberString() + '.';
+			object3d = new THREE.LineSegments( bufferGeometry, materials.length === 1 ? materials[ 0 ] : materials );
 
-							} // Get the edge material for this triangle material
+		} else if ( elementSize === 3 ) {
 
+			object3d = new THREE.Mesh( bufferGeometry, materials.length === 1 ? materials[ 0 ] : materials );
 
-							edgeMaterial = edgeMaterial.userData.edgeMaterial;
+		}
 
-						}
+		if ( isConditionalSegments ) {
 
-						break;
+			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 );
 
-					case 'ALPHA':
-						alpha = parseInt( lineParser.getToken() );
+			for ( let i = 0, l = elements.length; i < l; i ++ ) {
 
-						if ( isNaN( alpha ) ) {
+				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;
+				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;
 
-							throw 'LDrawLoader: Invalid alpha value in material definition' + lineParser.getLineNumberString() + '.';
+			}
 
-						}
+			bufferGeometry.setAttribute( 'control0', new THREE.BufferAttribute( controlArray0, 3, false ) );
+			bufferGeometry.setAttribute( 'control1', new THREE.BufferAttribute( controlArray1, 3, false ) );
+			bufferGeometry.setAttribute( 'direction', new THREE.BufferAttribute( directionArray, 3, false ) );
 
-						alpha = Math.max( 0, Math.min( 1, alpha / 255 ) );
+		}
 
-						if ( alpha < 1 ) {
+		return object3d;
 
-							isTransparent = true;
+	} //
 
-						}
 
-						break;
+	class LDrawLoader extends THREE.Loader {
 
-					case 'LUMINANCE':
-						luminance = parseInt( lineParser.getToken() );
+		constructor( manager ) {
 
-						if ( isNaN( luminance ) ) {
+			super( manager ); // Array of THREE.Material
+
+			this.materials = []; // 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)
 
-							throw 'LDrawLoader: Invalid luminance value in material definition' + LineParser.getLineNumberString() + '.';
+			this.parseCache = new LDrawParsedCache( this ); // 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 = {};
+			this.rootParseScope = this.newParseScopeLevel(); // Add default main triangle and line edge materials (used in pieces that can be colored with a main color)
 
-						luminance = Math.max( 0, Math.min( 1, luminance / 255 ) );
-						break;
+			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' ) ) ] ); // If this flag is set to true the vertex normals will be smoothed.
 
-					case 'CHROME':
-						finishType = FINISH_TYPE_CHROME;
-						break;
+			this.smoothNormals = true; // The path to load parts from the LDraw parts library from.
 
-					case 'PEARLESCENT':
-						finishType = FINISH_TYPE_PEARLESCENT;
-						break;
+			this.partsLibraryPath = '';
 
-					case 'RUBBER':
-						finishType = FINISH_TYPE_RUBBER;
-						break;
+		}
 
-					case 'MATTE_METALLIC':
-						finishType = FINISH_TYPE_MATTE_METALLIC;
-						break;
+		setPartsLibraryPath( path ) {
 
-					case 'METAL':
-						finishType = FINISH_TYPE_METAL;
-						break;
+			this.partsLibraryPath = path;
+			return this;
 
-					case 'MATERIAL':
-						// Not implemented
-						lineParser.setToEnd();
-						break;
+		}
 
-					default:
-						throw 'LDrawLoader: Unknown token "' + token + '" while parsing material' + lineParser.getLineNumberString() + '.';
-						break;
+		async preloadMaterials( url ) {
+
+			const fileLoader = new THREE.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 ) ) {
+
+					const directive = line.replace( colorLineRegex, '' );
+					const material = this.parseColorMetaDirective( new LineParser( directive ) );
+					materials.push( material );
 
 				}
 
 			}
 
-			let material = null;
-
-			switch ( finishType ) {
+			this.setMaterials( materials );
 
-				case FINISH_TYPE_DEFAULT:
-					material = new THREE.MeshStandardMaterial( {
-						color: colour,
-						roughness: 0.3,
-						metalness: 0
-					} );
-					break;
+		}
 
-				case FINISH_TYPE_PEARLESCENT:
-					// Try to imitate pearlescency by making the surface glossy
-					material = new THREE.MeshStandardMaterial( {
-						color: colour,
-						roughness: 0.3,
-						metalness: 0.25
-					} );
-					break;
+		load( url, onLoad, onProgress, onError ) {
 
-				case FINISH_TYPE_CHROME:
-					// Mirror finish surface
-					material = new THREE.MeshStandardMaterial( {
-						color: colour,
-						roughness: 0,
-						metalness: 1
-					} );
-					break;
+			const fileLoader = new THREE.FileLoader( this.manager );
+			fileLoader.setPath( this.path );
+			fileLoader.setRequestHeader( this.requestHeader );
+			fileLoader.setWithCredentials( this.withCredentials );
+			fileLoader.load( url, text => {
 
-				case FINISH_TYPE_RUBBER:
-					// Rubber finish
-					material = new THREE.MeshStandardMaterial( {
-						color: colour,
-						roughness: 0.9,
-						metalness: 0
-					} );
-					break;
+				const parsedInfo = this.parseCache.parse( text );
+				this.processObject( parsedInfo, null, url, this.rootParseScope ).then( function ( result ) {
 
-				case FINISH_TYPE_MATTE_METALLIC:
-					// Brushed metal finish
-					material = new THREE.MeshStandardMaterial( {
-						color: colour,
-						roughness: 0.8,
-						metalness: 0.4
-					} );
-					break;
+					onLoad( result.groupObject );
 
-				case FINISH_TYPE_METAL:
-					// Average metal finish
-					material = new THREE.MeshStandardMaterial( {
-						color: colour,
-						roughness: 0.2,
-						metalness: 0.85
-					} );
-					break;
+				} );
 
-				default:
-					// Should not happen
-					break;
+			}, onProgress, onError );
 
-			}
+		}
 
-			material.transparent = isTransparent;
-			material.premultipliedAlpha = true;
-			material.opacity = alpha;
-			material.depthWrite = ! isTransparent;
-			material.polygonOffset = true;
-			material.polygonOffsetFactor = 1;
+		parse( text, path, onLoad ) {
 
-			if ( luminance !== 0 ) {
+			// 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.emissive.set( material.color ).multiplyScalar( luminance );
+				onLoad( result.groupObject );
 
-			}
+			} );
 
-			if ( ! edgeMaterial ) {
+		}
 
-				// This is the material used for edges
-				edgeMaterial = new THREE.LineBasicMaterial( {
-					color: edgeColour,
-					transparent: isTransparent,
-					opacity: alpha,
-					depthWrite: ! isTransparent
-				} );
-				edgeMaterial.userData.code = code;
-				edgeMaterial.name = name + ' - Edge'; // This is the material used for conditional edges
+		setMaterials( materials ) {
 
-				edgeMaterial.userData.conditionalEdgeMaterial = new LDrawConditionalLineMaterial( {
-					fog: true,
-					transparent: isTransparent,
-					depthWrite: ! isTransparent,
-					color: edgeColour,
-					opacity: alpha
-				} );
+			// Clears parse scopes stack, adds new scope with material library
+			this.rootParseScope = this.newParseScopeLevel( materials );
+			this.rootParseScope.isFromParse = false;
+			this.materials = materials;
+			return this;
 
-			}
+		}
 
-			material.userData.code = code;
-			material.name = name;
-			material.userData.edgeMaterial = edgeMaterial;
-			return material;
+		setFileMap( fileMap ) {
 
-		} //
+			this.fileMap = fileMap;
+			return this;
 
+		}
 
-		objectParse( text, parseScope ) {
+		newParseScopeLevel( materials = null, parentScope = null ) {
 
-			// Retrieve data from the parent parse scope
-			const currentParseScope = parseScope;
-			const parentParseScope = currentParseScope.parentScope; // Main colour codes passed to this subobject (or default codes 16 and 24 if it is the root object)
+			// Adds a new scope level, assign materials to it and returns it
+			const matLib = {};
 
-			const mainColourCode = currentParseScope.mainColourCode;
-			const mainEdgeColourCode = currentParseScope.mainEdgeColourCode; // Parse result variables
+			if ( materials ) {
 
-			let faces;
-			let lineSegments;
-			let conditionalSegments;
-			const subobjects = [];
-			let category = null;
-			let keywords = null;
+				for ( let i = 0, n = materials.length; i < n; i ++ ) {
 
-			if ( text.indexOf( '\r\n' ) !== - 1 ) {
+					const material = materials[ i ];
+					matLib[ material.userData.code ] = material;
 
-				// This is faster than String.split with regex that splits on both
-				text = text.replace( /\r\n/g, '\n' );
+				}
 
 			}
 
-			const lines = text.split( '\n' );
-			const numLines = lines.length;
-			let parsingEmbeddedFiles = false;
-			let currentEmbeddedFileName = null;
-			let currentEmbeddedText = null;
-			let bfcCertified = false;
-			let bfcCCW = true;
-			let bfcInverted = false;
-			let bfcCull = true;
-			let type = '';
-			let startingConstructionStep = false;
-			const scope = this;
+			const newParseScope = {
+				parentScope: parentScope,
+				lib: matLib,
+				url: null,
+				// Subobjects
+				subobjects: null,
+				numSubobjects: 0,
+				subobjectIndex: 0,
+				inverted: false,
+				category: null,
+				keywords: null,
+				// Current subobject
+				currentFileName: null,
+				mainColorCode: parentScope ? parentScope.mainColorCode : '16',
+				mainEdgeColorCode: parentScope ? parentScope.mainEdgeColorCode : '24',
+				matrix: new THREE.Matrix4(),
+				type: 'Model',
+				groupObject: null,
+				// If false, it is a root material scope previous to parse
+				isFromParse: true,
+				faces: [],
+				lineSegments: [],
+				conditionalSegments: [],
+				totalFaces: 0,
+				faceMaterials: new Set(),
+				// If true, this object is the start of a construction step
+				startingConstructionStep: false
+			};
+			return newParseScope;
 
-			function parseColourCode( lineParser, forEdge ) {
+		}
 
-				// Parses next colour code and returns a THREE.Material
-				let colourCode = lineParser.getToken();
+		addMaterial( material, parseScope ) {
 
-				if ( ! forEdge && colourCode === '16' ) {
+			// Adds a material to the material library which is on top of the parse scopes stack. And also to the materials array
+			const matLib = parseScope.lib;
 
-					colourCode = mainColourCode;
+			if ( ! matLib[ material.userData.code ] ) {
 
-				}
+				this.materials.push( material );
 
-				if ( forEdge && colourCode === '24' ) {
+			}
 
-					colourCode = mainEdgeColourCode;
+			matLib[ material.userData.code ] = material;
+			return this;
 
-				}
+		}
 
-				const material = scope.getMaterial( colourCode, currentParseScope );
+		getMaterial( colorCode, parseScope = this.rootParseScope ) {
 
-				if ( ! material ) {
+			// Given a color code search its material in the parse scopes stack
+			if ( colorCode.startsWith( '0x2' ) ) {
 
-					throw 'LDrawLoader: Unknown colour code "' + colourCode + '" is used' + lineParser.getLineNumberString() + ' but it was not defined previously.';
+				// Special 'direct' material value (RGB color)
+				const color = colorCode.substring( 3 );
+				return this.parseColorMetaDirective( new LineParser( 'Direct_Color_' + color + ' CODE -1 VALUE #' + color + ' EDGE #' + color + '' ) );
 
-				}
+			}
 
-				return material;
+			while ( parseScope ) {
 
-			}
+				const material = parseScope.lib[ colorCode ];
 
-			function parseVector( lp ) {
+				if ( material ) {
 
-				const v = new THREE.Vector3( parseFloat( lp.getToken() ), parseFloat( lp.getToken() ), parseFloat( lp.getToken() ) );
+					return material;
 
-				if ( ! scope.separateObjects ) {
+				} else {
 
-					v.applyMatrix4( currentParseScope.currentMatrix );
+					parseScope = parseScope.parentScope;
 
 				}
 
-				return v;
+			} // Material was not found
 
-			} // Parse all line commands
 
+			return null;
 
-			for ( let lineIndex = 0; lineIndex < numLines; lineIndex ++ ) {
+		}
 
-				const line = lines[ lineIndex ];
-				if ( line.length === 0 ) continue;
+		parseColorMetaDirective( lineParser ) {
 
-				if ( parsingEmbeddedFiles ) {
+			// Parses a color definition and returns a THREE.Material
+			let code = null; // Triangle and line colors
 
-					if ( line.startsWith( '0 FILE ' ) ) {
+			let color = 0xFF00FF;
+			let edgeColor = 0xFF00FF; // Transparency
 
-						// Save previous embedded file in the cache
-						this.cache.setData( currentEmbeddedFileName.toLowerCase(), currentEmbeddedText ); // New embedded text file
+			let alpha = 1;
+			let isTransparent = false; // Self-illumination:
 
-						currentEmbeddedFileName = line.substring( 7 );
-						currentEmbeddedText = '';
+			let luminance = 0;
+			let finishType = FINISH_TYPE_DEFAULT;
+			let edgeMaterial = null;
+			const name = lineParser.getToken();
 
-					} else {
+			if ( ! name ) {
 
-						currentEmbeddedText += line + '\n';
+				throw new Error( 'LDrawLoader: Material name was expected after "!COLOUR tag' + lineParser.getLineNumberString() + '.' );
 
-					}
+			} // Parse tag tokens and their parameters
 
-					continue;
+
+			let token = null;
+
+			while ( true ) {
+
+				token = lineParser.getToken();
+
+				if ( ! token ) {
+
+					break;
 
 				}
 
-				const lp = new LineParser( line, lineIndex + 1 );
-				lp.seekNonSpace();
+				switch ( token.toUpperCase() ) {
 
-				if ( lp.isAtTheEnd() ) {
+					case 'CODE':
+						code = lineParser.getToken();
+						break;
 
-					// Empty line
-					continue;
+					case 'VALUE':
+						color = lineParser.getToken();
 
-				} // Parse the line type
+						if ( color.startsWith( '0x' ) ) {
 
+							color = '#' + color.substring( 2 );
 
-				const lineType = lp.getToken();
-				let material;
-				let segment;
-				let inverted;
-				let ccw;
-				let doubleSided;
-				let v0, v1, v2, v3, c0, c1, faceNormal;
+						} else if ( ! color.startsWith( '#' ) ) {
 
-				switch ( lineType ) {
+							throw new Error( 'LDrawLoader: Invalid color while parsing material' + lineParser.getLineNumberString() + '.' );
 
-					// Line type 0: Comment or META
-					case '0':
-						// Parse meta directive
-						const meta = lp.getToken();
+						}
 
-						if ( meta ) {
+						break;
 
-							switch ( meta ) {
+					case 'EDGE':
+						edgeColor = lineParser.getToken();
 
-								case '!LDRAW_ORG':
-									type = lp.getToken();
-									currentParseScope.type = type; // If the scale of the object is negated then the triangle winding order
-									// needs to be flipped.
+						if ( edgeColor.startsWith( '0x' ) ) {
 
-									if ( currentParseScope.matrix.determinant() < 0 && ( scope.separateObjects && isPrimitiveType( type ) || ! scope.separateObjects ) ) {
+							edgeColor = '#' + edgeColor.substring( 2 );
 
-										currentParseScope.inverted = ! currentParseScope.inverted;
+						} else if ( ! edgeColor.startsWith( '#' ) ) {
 
-									}
+							// Try to see if edge color is a color code
+							edgeMaterial = this.getMaterial( edgeColor );
 
-									faces = currentParseScope.faces;
-									lineSegments = currentParseScope.lineSegments;
-									conditionalSegments = currentParseScope.conditionalSegments;
-									break;
+							if ( ! edgeMaterial ) {
 
-								case '!COLOUR':
-									material = this.parseColourMetaDirective( lp );
+								throw new Error( 'LDrawLoader: Invalid edge color while parsing material' + lineParser.getLineNumberString() + '.' );
 
-									if ( material ) {
+							} // Get the edge material for this triangle material
 
-										this.addMaterial( material, parseScope );
 
-									} else {
+							edgeMaterial = edgeMaterial.userData.edgeMaterial;
 
-										console.warn( 'LDrawLoader: Error parsing material' + lp.getLineNumberString() );
+						}
 
-									}
+						break;
 
-									break;
+					case 'ALPHA':
+						alpha = parseInt( lineParser.getToken() );
 
-								case '!CATEGORY':
-									category = lp.getToken();
-									break;
+						if ( isNaN( alpha ) ) {
 
-								case '!KEYWORDS':
-									const newKeywords = lp.getRemainingString().split( ',' );
+							throw new Error( 'LDrawLoader: Invalid alpha value in material definition' + lineParser.getLineNumberString() + '.' );
 
-									if ( newKeywords.length > 0 ) {
+						}
 
-										if ( ! keywords ) {
+						alpha = Math.max( 0, Math.min( 1, alpha / 255 ) );
 
-											keywords = [];
+						if ( alpha < 1 ) {
 
-										}
+							isTransparent = true;
 
-										newKeywords.forEach( function ( keyword ) {
+						}
 
-											keywords.push( keyword.trim() );
+						break;
 
-										} );
+					case 'LUMINANCE':
+						luminance = parseInt( lineParser.getToken() );
 
-									}
+						if ( isNaN( luminance ) ) {
 
-									break;
+							throw new Error( 'LDrawLoader: Invalid luminance value in material definition' + LineParser.getLineNumberString() + '.' );
 
-								case 'FILE':
-									if ( lineIndex > 0 ) {
+						}
 
-										// Start embedded text files parsing
-										parsingEmbeddedFiles = true;
-										currentEmbeddedFileName = lp.getRemainingString();
-										currentEmbeddedText = '';
-										bfcCertified = false;
-										bfcCCW = true;
+						luminance = Math.max( 0, Math.min( 1, luminance / 255 ) );
+						break;
+
+					case 'CHROME':
+						finishType = FINISH_TYPE_CHROME;
+						break;
+
+					case 'PEARLESCENT':
+						finishType = FINISH_TYPE_PEARLESCENT;
+						break;
+
+					case 'RUBBER':
+						finishType = FINISH_TYPE_RUBBER;
+						break;
 
-									}
+					case 'MATTE_METALLIC':
+						finishType = FINISH_TYPE_MATTE_METALLIC;
+						break;
 
-									break;
+					case 'METAL':
+						finishType = FINISH_TYPE_METAL;
+						break;
 
-								case 'BFC':
-									// Changes to the backface culling state
-									while ( ! lp.isAtTheEnd() ) {
+					case 'MATERIAL':
+						// Not implemented
+						lineParser.setToEnd();
+						break;
 
-										const token = lp.getToken();
+					default:
+						throw new Error( 'LDrawLoader: Unknown token "' + token + '" while parsing material' + lineParser.getLineNumberString() + '.' );
 
-										switch ( token ) {
+				}
 
-											case 'CERTIFY':
-											case 'NOCERTIFY':
-												bfcCertified = token === 'CERTIFY';
-												bfcCCW = true;
-												break;
+			}
 
-											case 'CW':
-											case 'CCW':
-												bfcCCW = token === 'CCW';
-												break;
+			let material = null;
 
-											case 'INVERTNEXT':
-												bfcInverted = true;
-												break;
+			switch ( finishType ) {
 
-											case 'CLIP':
-											case 'NOCLIP':
-												bfcCull = token === 'CLIP';
-												break;
+				case FINISH_TYPE_DEFAULT:
+					material = new THREE.MeshStandardMaterial( {
+						color: color,
+						roughness: 0.3,
+						metalness: 0
+					} );
+					break;
 
-											default:
-												console.warn( 'THREE.LDrawLoader: BFC directive "' + token + '" is unknown.' );
-												break;
+				case FINISH_TYPE_PEARLESCENT:
+					// Try to imitate pearlescency by making the surface glossy
+					material = new THREE.MeshStandardMaterial( {
+						color: color,
+						roughness: 0.3,
+						metalness: 0.25
+					} );
+					break;
 
-										}
+				case FINISH_TYPE_CHROME:
+					// Mirror finish surface
+					material = new THREE.MeshStandardMaterial( {
+						color: color,
+						roughness: 0,
+						metalness: 1
+					} );
+					break;
 
-									}
+				case FINISH_TYPE_RUBBER:
+					// Rubber finish
+					material = new THREE.MeshStandardMaterial( {
+						color: color,
+						roughness: 0.9,
+						metalness: 0
+					} );
+					break;
 
-									break;
+				case FINISH_TYPE_MATTE_METALLIC:
+					// Brushed metal finish
+					material = new THREE.MeshStandardMaterial( {
+						color: color,
+						roughness: 0.8,
+						metalness: 0.4
+					} );
+					break;
 
-								case 'STEP':
-									startingConstructionStep = true;
-									break;
+				case FINISH_TYPE_METAL:
+					// Average metal finish
+					material = new THREE.MeshStandardMaterial( {
+						color: color,
+						roughness: 0.2,
+						metalness: 0.85
+					} );
+					break;
 
-								default:
-									// Other meta directives are not implemented
-									break;
+				default:
+					// Should not happen
+					break;
 
-							}
+			}
 
-						}
+			material.transparent = isTransparent;
+			material.premultipliedAlpha = true;
+			material.opacity = alpha;
+			material.depthWrite = ! isTransparent;
+			material.polygonOffset = true;
+			material.polygonOffsetFactor = 1;
 
-						break;
-						// Line type 1: Sub-object file
+			if ( luminance !== 0 ) {
 
-					case '1':
-						material = parseColourCode( lp );
-						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() );
-						const matrix = new THREE.Matrix4().set( m0, m1, m2, posX, m3, m4, m5, posY, m6, m7, m8, posZ, 0, 0, 0, 1 );
-						let fileName = lp.getRemainingString().trim().replace( /\\/g, '/' );
+				material.emissive.set( material.color ).multiplyScalar( luminance );
 
-						if ( scope.fileMap[ fileName ] ) {
+			}
 
-							// Found the subobject path in the preloaded file path map
-							fileName = scope.fileMap[ fileName ];
+			if ( ! edgeMaterial ) {
 
-						} else {
+				// This is the material used for edges
+				edgeMaterial = new THREE.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
 
-							// Standardized subfolders
-							if ( fileName.startsWith( 's/' ) ) {
+				edgeMaterial.userData.conditionalEdgeMaterial = new LDrawConditionalLineMaterial( {
+					fog: true,
+					transparent: isTransparent,
+					depthWrite: ! isTransparent,
+					color: edgeColor,
+					opacity: alpha
+				} );
 
-								fileName = 'parts/' + fileName;
+			}
 
-							} else if ( fileName.startsWith( '48/' ) ) {
+			material.userData.code = code;
+			material.name = name;
+			material.userData.edgeMaterial = edgeMaterial;
+			return material;
 
-								fileName = 'p/' + fileName;
+		} //
 
-							}
 
-						}
+		objectParse( info, parseScope ) {
 
-						subobjects.push( {
-							material: material,
-							matrix: matrix,
-							fileName: fileName,
-							inverted: bfcInverted !== currentParseScope.inverted,
-							startingConstructionStep: startingConstructionStep
-						} );
-						bfcInverted = false;
-						break;
-						// Line type 2: Line segment
+			// Retrieve data from the parent parse scope
+			const currentParseScope = parseScope;
+			const parentParseScope = currentParseScope.parentScope; // Main color codes passed to this subobject (or default codes 16 and 24 if it is the root object)
 
-					case '2':
-						material = parseColourCode( lp, true );
-						v0 = parseVector( lp );
-						v1 = parseVector( lp );
-						segment = {
-							material: material.userData.edgeMaterial,
-							colourCode: material.userData.code,
-							v0: v0,
-							v1: v1,
-							vertices: [ v0, v1 ]
-						};
-						lineSegments.push( segment );
-						break;
-						// Line type 5: Conditional Line segment
+			const mainColorCode = currentParseScope.mainColorCode;
+			const mainEdgeColorCode = currentParseScope.mainEdgeColorCode;
 
-					case '5':
-						material = parseColourCode( lp, true );
-						v0 = parseVector( lp );
-						v1 = parseVector( lp );
-						c0 = parseVector( lp );
-						c1 = parseVector( lp );
-						segment = {
-							material: material.userData.edgeMaterial.userData.conditionalEdgeMaterial,
-							colourCode: material.userData.code,
-							vertices: [ v0, v1 ],
-							controlPoints: [ c0, c1 ]
-						};
-						conditionalSegments.push( segment );
-						break;
-						// Line type 3: Triangle
+			const parseColorCode = ( colorCode, forEdge ) => {
 
-					case '3':
-						material = parseColourCode( lp );
-						inverted = currentParseScope.inverted;
-						ccw = bfcCCW !== inverted;
-						doubleSided = ! bfcCertified || ! bfcCull;
+				// Parses next color code and returns a THREE.Material
+				if ( ! forEdge && colorCode === '16' ) {
 
-						if ( ccw === true ) {
+					colorCode = mainColorCode;
 
-							v0 = parseVector( lp );
-							v1 = parseVector( lp );
-							v2 = parseVector( lp );
+				}
 
-						} else {
+				if ( forEdge && colorCode === '24' ) {
 
-							v2 = parseVector( lp );
-							v1 = parseVector( lp );
-							v0 = parseVector( lp );
+					colorCode = mainEdgeColorCode;
 
-						}
+				}
 
-						_tempVec0.subVectors( v1, v0 );
+				const material = this.getMaterial( colorCode, currentParseScope );
 
-						_tempVec1.subVectors( v2, v1 );
+				if ( ! material ) {
 
-						faceNormal = new THREE.Vector3().crossVectors( _tempVec0, _tempVec1 ).normalize();
-						faces.push( {
-							material: material,
-							colourCode: material.userData.code,
-							faceNormal: faceNormal,
-							vertices: [ v0, v1, v2 ],
-							normals: [ null, null, null ]
-						} );
-						currentParseScope.totalFaces ++;
+					throw new Error( 'LDrawLoader: Unknown color code "' + colorCode + '" is used but it was not defined previously.' );
 
-						if ( doubleSided === true ) {
+				}
 
-							faces.push( {
-								material: material,
-								colourCode: material.userData.code,
-								faceNormal: faceNormal,
-								vertices: [ v2, v1, v0 ],
-								normals: [ null, null, null ]
-							} );
-							currentParseScope.totalFaces ++;
+				return material;
 
-						}
+			};
 
-						break;
-						// Line type 4: Quadrilateral
+			const faces = info.faces;
+			const lineSegments = info.lineSegments;
+			const conditionalSegments = info.conditionalSegments;
+			const materials = info.materials;
 
-					case '4':
-						material = parseColourCode( lp );
-						inverted = currentParseScope.inverted;
-						ccw = bfcCCW !== inverted;
-						doubleSided = ! bfcCertified || ! bfcCull;
+			if ( currentParseScope.inverted ) {
 
-						if ( ccw === true ) {
+				faces.reverse();
 
-							v0 = parseVector( lp );
-							v1 = parseVector( lp );
-							v2 = parseVector( lp );
-							v3 = parseVector( lp );
+			}
 
-						} else {
+			for ( const colorCode in materials ) {
 
-							v3 = parseVector( lp );
-							v2 = parseVector( lp );
-							v1 = parseVector( lp );
-							v0 = parseVector( lp );
+				this.addMaterial( materials[ colorCode ], currentParseScope );
 
-						}
+			}
 
-						_tempVec0.subVectors( v1, v0 );
+			for ( let i = 0, l = faces.length; i < l; i ++ ) {
 
-						_tempVec1.subVectors( v2, v1 );
+				const face = faces[ i ];
 
-						faceNormal = new THREE.Vector3().crossVectors( _tempVec0, _tempVec1 ).normalize(); // specifically place the triangle diagonal in the v0 and v1 slots so we can
-						// account for the doubling of vertices later when smoothing normals.
+				if ( face.material === null ) {
 
-						faces.push( {
-							material: material,
-							colourCode: material.userData.code,
-							faceNormal: faceNormal,
-							vertices: [ v0, v1, v2, v3 ],
-							normals: [ null, null, null, null ]
-						} );
-						currentParseScope.totalFaces += 2;
+					face.material = parseColorCode( face.colorCode, false );
 
-						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 = lineSegments.length; i < l; i ++ ) {
 
-						break;
+				const ls = lineSegments[ i ];
 
-					default:
-						throw 'LDrawLoader: Unknown line type "' + lineType + '"' + lp.getLineNumberString() + '.';
-						break;
+				if ( ls.material === null ) {
+
+					ls.material = parseColorCode( ls.colorCode, true );
 
 				}
 
 			}
 
-			if ( parsingEmbeddedFiles ) {
+			for ( let i = 0, l = conditionalSegments.length; i < l; i ++ ) {
 
-				this.cache.setData( currentEmbeddedFileName.toLowerCase(), currentEmbeddedText );
+				const cs = conditionalSegments[ i ];
+
+				if ( cs.material === null ) {
+
+					cs.material = parseColorCode( cs.colorCode, true );
+
+				}
 
 			}
 
-			currentParseScope.category = category;
-			currentParseScope.keywords = keywords;
-			currentParseScope.subobjects = subobjects;
-			currentParseScope.numSubobjects = subobjects.length;
+			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.numSubobjects = info.subobjects.length;
 			currentParseScope.subobjectIndex = 0;
+			currentParseScope.type = info.type;
+			currentParseScope.totalFaces = info.totalFaces;
 			const isRoot = ! parentParseScope.isFromParse;
 
-			if ( isRoot || scope.separateObjects && ! isPrimitiveType( type ) ) {
+			if ( isRoot || ! isPrimitiveType( info.type ) ) {
 
 				currentParseScope.groupObject = new THREE.Group();
 				currentParseScope.groupObject.userData.startingConstructionStep = currentParseScope.startingConstructionStep;
@@ -1736,17 +2005,21 @@
 			// is added directly into the parent model (meaning it will never get smoothed by
 			// being added to a part)
 
-			const doSmooth = isPartType( subobjectParseScope.type ) || ! isPartType( subobjectParseScope.type ) && ! isModelType( subobjectParseScope.type ) && isModelType( subobjectParseScope.parentScope.type );
+			const doSmooth = isPartType( 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;
 
@@ -1780,26 +2053,23 @@
 
 			} 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 );
 
 				}
@@ -1807,18 +2077,12 @@
 				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 );
 
 				}
@@ -1826,22 +2090,19 @@
 				for ( let i = 0, l = faces.length; i < l; i ++ ) {
 
 					const tri = faces[ i ];
+					const vertices = tri.vertices;
 
-					if ( separateObjects ) {
-
-						const vertices = tri.vertices;
+					for ( let i = 0, l = vertices.length; i < l; i ++ ) {
 
-						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.
 
-						}
-
-						_tempVec0.subVectors( vertices[ 1 ], vertices[ 0 ] );
 
-						_tempVec1.subVectors( vertices[ 2 ], vertices[ 1 ] );
+					if ( matrixScaleInverted !== subobjectParseScope.inverted ) {
 
-						tri.faceNormal.crossVectors( _tempVec0, _tempVec1 ).normalize();
+						vertices.reverse();
 
 					}
 
@@ -1850,12 +2111,13 @@
 				}
 
 				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 );
@@ -1864,18 +2126,28 @@
 
 			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 === '16' && parseScope.parentScope ) {
+
+					const parentScope = parseScope.parentScope;
+					parseScope.mainColorCode = parentScope.mainColorCode;
+					parseScope.mainEdgeColorCode = parentScope.mainEdgeColorCode;
+
+				} else if ( subobject.colorCode !== '16' ) {
+
+					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 = [];
 
@@ -1907,13 +2179,13 @@
 
 			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;
 
 				} );