three-stdlib 2.7.0 → 2.8.1

package/loaders/LDrawLoader.js

@@ -1,4 +1,4 @@
-import { Vector3, Loader, FileLoader, Matrix4, MeshStandardMaterial, Color, MeshPhongMaterial, LineBasicMaterial, ShaderMaterial, UniformsUtils, UniformsLib, Group, BufferGeometry, Float32BufferAttribute, LineSegments, Mesh, BufferAttribute } from 'three';
+import { Vector3, Ray, Loader, FileLoader, MeshStandardMaterial, LineBasicMaterial, ShaderMaterial, UniformsUtils, UniformsLib, Color, BufferGeometry, BufferAttribute, LineSegments, Mesh, Matrix4, Group } from 'three';
 
 // Note: "MATERIAL" tag (e.g. GLITTER, SPECKLE) is not implemented
 
@@ -17,186 +17,335 @@ const FILE_LOCATION_TRY_MODELS = 3;
 const FILE_LOCATION_TRY_RELATIVE = 4;
 const FILE_LOCATION_TRY_ABSOLUTE = 5;
 const FILE_LOCATION_NOT_FOUND = 6;
-const conditionalLineVertShader =
-/* glsl */
-`
-	attribute vec3 control0;
-	attribute vec3 control1;
-	attribute vec3 direction;
-	varying float discardFlag;
-
-	#include <common>
-	#include <color_pars_vertex>
-	#include <fog_pars_vertex>
-	#include <logdepthbuf_pars_vertex>
-	#include <clipping_planes_pars_vertex>
-	void main() {
-		#include <color_vertex>
-
-		vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );
-		gl_Position = projectionMatrix * mvPosition;
-
-		// Transform the line segment ends and control points into camera clip space
-		vec4 c0 = projectionMatrix * modelViewMatrix * vec4( control0, 1.0 );
-		vec4 c1 = projectionMatrix * modelViewMatrix * vec4( control1, 1.0 );
-		vec4 p0 = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-		vec4 p1 = projectionMatrix * modelViewMatrix * vec4( position + direction, 1.0 );
-
-		c0.xy /= c0.w;
-		c1.xy /= c1.w;
-		p0.xy /= p0.w;
-		p1.xy /= p1.w;
-
-		// Get the direction of the segment and an orthogonal vector
-		vec2 dir = p1.xy - p0.xy;
-		vec2 norm = vec2( -dir.y, dir.x );
-
-		// Get control point directions from the line
-		vec2 c0dir = c0.xy - p1.xy;
-		vec2 c1dir = c1.xy - p1.xy;
-
-		// If the vectors to the controls points are pointed in different directions away
-		// from the line segment then the line should not be drawn.
-		float d0 = dot( normalize( norm ), normalize( c0dir ) );
-		float d1 = dot( normalize( norm ), normalize( c1dir ) );
-		discardFlag = float( sign( d0 ) != sign( d1 ) );
-
-		#include <logdepthbuf_vertex>
-		#include <clipping_planes_vertex>
-		#include <fog_vertex>
-	}
-	`;
-const conditionalLineFragShader =
-/* glsl */
-`
-	uniform vec3 diffuse;
-	uniform float opacity;
-	varying float discardFlag;
-
-	#include <common>
-	#include <color_pars_fragment>
-	#include <fog_pars_fragment>
-	#include <logdepthbuf_pars_fragment>
-	#include <clipping_planes_pars_fragment>
-	void main() {
-
-		if ( discardFlag > 0.5 ) discard;
-
-		#include <clipping_planes_fragment>
-		vec3 outgoingLight = vec3( 0.0 );
-		vec4 diffuseColor = vec4( diffuse, opacity );
-		#include <logdepthbuf_fragment>
-		#include <color_fragment>
-		outgoingLight = diffuseColor.rgb; // simple shader
-		gl_FragColor = vec4( outgoingLight, diffuseColor.a );
-		#include <tonemapping_fragment>
-		#include <encodings_fragment>
-		#include <fog_fragment>
-		#include <premultiplied_alpha_fragment>
-	}
-	`;
+const MAIN_COLOUR_CODE = '16';
+const MAIN_EDGE_COLOUR_CODE = '24';
 
 const _tempVec0 = new Vector3();
 
 const _tempVec1 = new Vector3();
 
-function smoothNormals(triangles, lineSegments) {
+class LDrawConditionalLineMaterial extends ShaderMaterial {
+  constructor(parameters) {
+    super({
+      uniforms: UniformsUtils.merge([UniformsLib.fog, {
+        diffuse: {
+          value: new Color()
+        },
+        opacity: {
+          value: 1.0
+        }
+      }]),
+      vertexShader:
+      /* glsl */
+      `
+        attribute vec3 control0;
+        attribute vec3 control1;
+        attribute vec3 direction;
+        varying float discardFlag;
+
+        #include <common>
+        #include <color_pars_vertex>
+        #include <fog_pars_vertex>
+        #include <logdepthbuf_pars_vertex>
+        #include <clipping_planes_pars_vertex>
+
+        void main() {
+          #include <color_vertex>
+
+          vec4 mvPosition = modelViewMatrix * vec4(position, 1.0);
+          gl_Position = projectionMatrix * mvPosition;
+
+          // Transform the line segment ends and control points into camera clip space
+          vec4 c0 = projectionMatrix * modelViewMatrix * vec4(control0, 1.0);
+          vec4 c1 = projectionMatrix * modelViewMatrix * vec4(control1, 1.0);
+          vec4 p0 = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+          vec4 p1 = projectionMatrix * modelViewMatrix * vec4(position + direction, 1.0);
+
+          c0.xy /= c0.w;
+          c1.xy /= c1.w;
+          p0.xy /= p0.w;
+          p1.xy /= p1.w;
+
+          // Get the direction of the segment and an orthogonal vector
+          vec2 dir = p1.xy - p0.xy;
+          vec2 norm = vec2(-dir.y, dir.x);
+
+          // Get control point directions from the line
+          vec2 c0dir = c0.xy - p1.xy;
+          vec2 c1dir = c1.xy - p1.xy;
+
+          // If the vectors to the controls points are pointed in different directions away
+          // from the line segment then the line should not be drawn.
+          float d0 = dot(normalize(norm), normalize(c0dir));
+          float d1 = dot(normalize(norm), normalize(c1dir));
+          discardFlag = float(sign(d0) != sign(d1));
+
+          #include <logdepthbuf_vertex>
+          #include <clipping_planes_vertex>
+          #include <fog_vertex>
+        }
+      `,
+      fragmentShader:
+      /* glsl */
+      `
+        uniform vec3 diffuse;
+        uniform float opacity;
+        varying float discardFlag;
+
+        #include <common>
+        #include <color_pars_fragment>
+        #include <fog_pars_fragment>
+        #include <logdepthbuf_pars_fragment>
+        #include <clipping_planes_pars_fragment>
+
+        void main() {
+          if (discardFlag > 0.5) discard;
+
+          #include <clipping_planes_fragment>
+          vec3 outgoingLight = vec3(0.0);
+          vec4 diffuseColor = vec4(diffuse, opacity);
+          #include <logdepthbuf_fragment>
+          #include <color_fragment>
+          outgoingLight = diffuseColor.rgb; // simple shader
+          gl_FragColor = vec4(outgoingLight, diffuseColor.a);
+          #include <tonemapping_fragment>
+          #include <encodings_fragment>
+          #include <fog_fragment>
+          #include <premultiplied_alpha_fragment>
+        }
+      `
+    });
+    Object.defineProperties(this, {
+      opacity: {
+        get: function () {
+          return this.uniforms.opacity.value;
+        },
+        set: function (value) {
+          this.uniforms.opacity.value = value;
+        }
+      },
+      color: {
+        get: function () {
+          return this.uniforms.diffuse.value;
+        }
+      }
+    });
+    this.setValues(parameters);
+    this.isLDrawConditionalLineMaterial = true;
+  }
+
+}
+
+class ConditionalLineSegments extends LineSegments {
+  constructor(geometry, material) {
+    super(geometry, material);
+    this.isConditionalLine = true;
+  }
+
+}
+
+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}`;
   }
 
   function hashEdge(v0, v1) {
     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 fullHalfEdgeList = {};
   const normals = []; // Save the list of hard edges by hash
 
   for (let i = 0, l = lineSegments.length; i < l; i++) {
     const ls = lineSegments[i];
-    const v0 = ls.v0;
-    const v1 = ls.v1;
+    const vertices = ls.vertices;
+    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 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
 
 
-  for (let i = 0, l = triangles.length; i < l; i++) {
-    const tri = triangles[i];
+  for (let i = 0, l = faces.length; i < l; i++) {
+    const tri = faces[i];
+    const vertices = tri.vertices;
+    const vertCount = vertices.length;
 
-    for (let i2 = 0, l2 = 3; i2 < l2; i2++) {
+    for (let i2 = 0; i2 < vertCount; i2++) {
       const index = i2;
-      const next = (i2 + 1) % 3;
-      const v0 = tri[`v${index}`];
-      const v1 = tri[`v${next}`];
+      const next = (i2 + 1) % vertCount;
+      const v0 = vertices[index];
+      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;
-      halfEdgeList[hash] = tri;
-      fullHalfEdgeList[hash] = tri;
+      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
+      };
+      halfEdgeList[hash] = info;
     }
-  } // NOTE: Some of the normals wind up being skewed in an unexpected way because
-  // quads provide more "influence" to some vertex normals than a triangle due to
-  // the fact that a quad is made up of two triangles and all triangles are weighted
-  // equally. To fix this quads could be tracked separately so their vertex normals
-  // are weighted appropriately or we could try only adding a normal direction
-  // once per normal.
-  // Iterate until we've tried to connect all triangles to share normals
+  } // Iterate until we've tried to connect all faces to share normals
 
 
   while (true) {
-    // Stop if there are no more triangles left
-    const halfEdges = Object.keys(halfEdgeList);
-    if (halfEdges.length === 0) break; // Exhaustively find all connected triangles
+    // Stop if there are no more faces left
+    let halfEdge = null;
 
-    let i = 0;
-    const queue = [fullHalfEdgeList[halfEdges[0]]];
+    for (const key in halfEdgeList) {
+      halfEdge = halfEdgeList[key];
+      break;
+    }
 
-    while (i < queue.length) {
-      // initialize all vertex normals in this triangle
-      const tri = queue[i];
-      i++;
-      const faceNormal = tri.faceNormal;
+    if (halfEdge === null) {
+      break;
+    } // Exhaustively find all connected faces
 
-      if (tri.n0 === null) {
-        tri.n0 = faceNormal.clone();
-        normals.push(tri.n0);
-      }
 
-      if (tri.n1 === null) {
-        tri.n1 = faceNormal.clone();
-        normals.push(tri.n1);
-      }
+    const queue = [halfEdge];
 
-      if (tri.n2 === null) {
-        tri.n2 = faceNormal.clone();
-        normals.push(tri.n2);
-      } // Check if any edge is connected to another triangle edge
+    while (queue.length > 0) {
+      // initialize all vertex normals in this triangle
+      const tri = queue.pop().tri;
+      const vertices = tri.vertices;
+      const vertNormals = tri.normals;
+      const faceNormal = tri.faceNormal; // Check if any edge is connected to another triangle edge
 
+      const vertCount = vertices.length;
 
-      for (let i2 = 0, l2 = 3; i2 < l2; i2++) {
+      for (let i2 = 0; i2 < vertCount; i2++) {
         const index = i2;
-        const next = (i2 + 1) % 3;
-        const v0 = tri[`v${index}`];
-        const v1 = tri[`v${next}`]; // delete this triangle from the list so it won't be found again
+        const next = (i2 + 1) % vertCount;
+        const v0 = vertices[index];
+        const v1 = vertices[next]; // delete this triangle from the list so it won't be found again
 
         const hash = hashEdge(v0, v1);
         delete halfEdgeList[hash];
         const reverseHash = hashEdge(v1, v0);
-        const otherTri = fullHalfEdgeList[reverseHash];
-
-        if (otherTri) {
-          // NOTE: If the angle between triangles is > 67.5 degrees then assume it's
+        const otherInfo = halfEdgeList[reverseHash];
+
+        if (otherInfo) {
+          const otherTri = otherInfo.tri;
+          const otherIndex = otherInfo.index;
+          const otherNormals = otherTri.normals;
+          const otherVertCount = otherNormals.length;
+          const otherFaceNormal = otherTri.faceNormal; // NOTE: If the angle between faces is > 67.5 degrees then assume it's
           // hard edge. There are some cases where the line segments do not line up exactly
           // with or span multiple triangle edges (see Lunar Vehicle wheels).
+
           if (Math.abs(otherTri.faceNormal.dot(tri.faceNormal)) < 0.25) {
             continue;
           } // if this triangle has already been traversed then it won't be in
@@ -205,33 +354,63 @@ function smoothNormals(triangles, lineSegments) {
 
 
           if (reverseHash in halfEdgeList) {
-            queue.push(otherTri);
+            queue.push(otherInfo);
             delete halfEdgeList[reverseHash];
-          } // Find the matching edge in this triangle and copy the normal vector over
+          } // share the first normal
+
 
+          const otherNext = (otherIndex + 1) % otherVertCount;
 
-          for (let i3 = 0, l3 = 3; i3 < l3; i3++) {
-            const otherIndex = i3;
-            const otherNext = (i3 + 1) % 3;
-            const otherV0 = otherTri[`v${otherIndex}`];
-            const otherV1 = otherTri[`v${otherNext}`];
-            const otherHash = hashEdge(otherV0, otherV1);
+          if (vertNormals[index] && otherNormals[otherNext] && vertNormals[index] !== otherNormals[otherNext]) {
+            otherNormals[otherNext].norm.add(vertNormals[index].norm);
+            vertNormals[index].norm = otherNormals[otherNext].norm;
+          }
 
-            if (otherHash === reverseHash) {
-              if (otherTri[`n${otherIndex}`] === null) {
-                const norm = tri[`n${next}`];
-                otherTri[`n${otherIndex}`] = norm;
-                norm.add(otherTri.faceNormal);
-              }
+          let sharedNormal1 = vertNormals[index] || otherNormals[otherNext];
 
-              if (otherTri[`n${otherNext}`] === null) {
-                const norm = tri[`n${index}`];
-                otherTri[`n${otherNext}`] = norm;
-                norm.add(otherTri.faceNormal);
-              }
+          if (sharedNormal1 === null) {
+            // it's possible to encounter an edge of a triangle that has already been traversed meaning
+            // both edges already have different normals defined and shared. To work around this we create
+            // a wrapper object so when those edges are merged the normals can be updated everywhere.
+            sharedNormal1 = {
+              norm: new Vector3()
+            };
+            normals.push(sharedNormal1.norm);
+          }
 
-              break;
-            }
+          if (vertNormals[index] === null) {
+            vertNormals[index] = sharedNormal1;
+            sharedNormal1.norm.add(faceNormal);
+          }
+
+          if (otherNormals[otherNext] === null) {
+            otherNormals[otherNext] = sharedNormal1;
+            sharedNormal1.norm.add(otherFaceNormal);
+          } // share the second normal
+
+
+          if (vertNormals[next] && otherNormals[otherIndex] && vertNormals[next] !== otherNormals[otherIndex]) {
+            otherNormals[otherIndex].norm.add(vertNormals[next].norm);
+            vertNormals[next].norm = otherNormals[otherIndex].norm;
+          }
+
+          let sharedNormal2 = vertNormals[next] || otherNormals[otherIndex];
+
+          if (sharedNormal2 === null) {
+            sharedNormal2 = {
+              norm: new Vector3()
+            };
+            normals.push(sharedNormal2.norm);
+          }
+
+          if (vertNormals[next] === null) {
+            vertNormals[next] = sharedNormal2;
+            sharedNormal2.norm.add(faceNormal);
+          }
+
+          if (otherNormals[otherIndex] === null) {
+            otherNormals[otherIndex] = sharedNormal2;
+            sharedNormal2.norm.add(otherFaceNormal);
           }
         }
       }
@@ -244,6 +423,10 @@ function smoothNormals(triangles, lineSegments) {
   }
 }
 
+function isPartType(type) {
+  return type === 'Part' || type === 'Unofficial_Part';
+}
+
 function isPrimitiveType(type) {
   return /primitive/i.test(type) || type === 'Subpart';
 }
@@ -287,6 +470,10 @@ class LineParser {
     return this.line.substring(pos0, pos1);
   }
 
+  getVector() {
+    return new Vector3(parseFloat(this.getToken()), parseFloat(this.getToken()), parseFloat(this.getToken()));
+  }
+
   getRemainingString() {
     return this.line.substring(this.currentCharIndex, this.lineLength);
   }
@@ -303,1193 +490,1351 @@ class LineParser {
     return this.lineNumber >= 0 ? ' at line ' + this.lineNumber : '';
   }
 
-}
+} // Fetches and parses an intermediate representation of LDraw parts files.
 
-function sortByMaterial(a, b) {
-  if (a.colourCode === b.colourCode) {
-    return 0;
+
+class LDrawParsedCache {
+  constructor(loader) {
+    this.loader = loader;
+    this._cache = {};
   }
 
-  if (a.colourCode < b.colourCode) {
-    return -1;
+  cloneResult(original) {
+    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 => {
+      return {
+        colorCode: face.colorCode,
+        material: face.material,
+        vertices: face.vertices.map(v => v.clone()),
+        normals: face.normals.map(() => null),
+        faceNormal: null
+      };
+    });
+    result.conditionalSegments = original.conditionalSegments.map(face => {
+      return {
+        colorCode: face.colorCode,
+        material: face.material,
+        vertices: face.vertices.map(v => v.clone()),
+        controlPoints: face.controlPoints.map(v => v.clone())
+      };
+    });
+    result.lineSegments = original.lineSegments.map(face => {
+      return {
+        colorCode: face.colorCode,
+        material: face.material,
+        vertices: face.vertices.map(v => v.clone())
+      };
+    }); // 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;
+    result.group = null;
+    return result;
   }
 
-  return 1;
-}
+  async fetchData(fileName) {
+    let triedLowerCase = false;
+    let locationState = FILE_LOCATION_AS_IS;
 
-function createObject(elements, elementSize, isConditionalSegments) {
-  // Creates a LineSegments (elementSize = 2) or a Mesh (elementSize = 3 )
-  // With per face / segment material, implemented with mesh groups and materials array
-  // Sort the triangles or line segments by colour code to make later the mesh groups
-  elements.sort(sortByMaterial);
-  const positions = [];
-  const normals = [];
-  const materials = [];
-  const bufferGeometry = new BufferGeometry();
-  let prevMaterial = null;
-  let index0 = 0;
-  let numGroupVerts = 0;
+    while (locationState !== FILE_LOCATION_NOT_FOUND) {
+      let subobjectURL = fileName;
 
-  for (let iElem = 0, nElem = elements.length; iElem < nElem; iElem++) {
-    const elem = elements[iElem];
-    const v0 = elem.v0;
-    const v1 = elem.v1; // Note that LDraw coordinate system is rotated 180 deg. in the X axis w.r.t. Three.js's one
+      switch (locationState) {
+        case FILE_LOCATION_AS_IS:
+          locationState = locationState + 1;
+          break;
 
-    positions.push(v0.x, v0.y, v0.z, v1.x, v1.y, v1.z);
+        case FILE_LOCATION_TRY_PARTS:
+          subobjectURL = 'parts/' + subobjectURL;
+          locationState = locationState + 1;
+          break;
 
-    if (elementSize === 3) {
-      positions.push(elem.v2.x, elem.v2.y, elem.v2.z);
-      const n0 = elem.n0 || elem.faceNormal;
-      const n1 = elem.n1 || elem.faceNormal;
-      const n2 = elem.n2 || elem.faceNormal;
-      normals.push(n0.x, n0.y, n0.z);
-      normals.push(n1.x, n1.y, n1.z);
-      normals.push(n2.x, n2.y, n2.z);
-    }
+        case FILE_LOCATION_TRY_P:
+          subobjectURL = 'p/' + subobjectURL;
+          locationState = locationState + 1;
+          break;
 
-    if (prevMaterial !== elem.material) {
-      if (prevMaterial !== null) {
-        bufferGeometry.addGroup(index0, numGroupVerts, materials.length - 1);
-      }
+        case FILE_LOCATION_TRY_MODELS:
+          subobjectURL = 'models/' + subobjectURL;
+          locationState = locationState + 1;
+          break;
 
-      materials.push(elem.material);
-      prevMaterial = elem.material;
-      index0 = iElem * elementSize;
-      numGroupVerts = elementSize;
-    } else {
-      numGroupVerts += elementSize;
-    }
-  }
+        case FILE_LOCATION_TRY_RELATIVE:
+          subobjectURL = fileName.substring(0, fileName.lastIndexOf('/') + 1) + subobjectURL;
+          locationState = locationState + 1;
+          break;
 
-  if (numGroupVerts > 0) {
-    bufferGeometry.addGroup(index0, Infinity, materials.length - 1);
-  }
+        case FILE_LOCATION_TRY_ABSOLUTE:
+          if (triedLowerCase) {
+            // Try absolute path
+            locationState = FILE_LOCATION_NOT_FOUND;
+          } else {
+            // Next attempt is lower case
+            fileName = fileName.toLowerCase();
+            subobjectURL = fileName;
+            triedLowerCase = true;
+            locationState = FILE_LOCATION_AS_IS;
+          }
 
-  bufferGeometry.setAttribute('position', new Float32BufferAttribute(positions, 3));
+          break;
+      }
 
-  if (elementSize === 3) {
-    bufferGeometry.setAttribute('normal', new Float32BufferAttribute(normals, 3));
-  }
+      const loader = this.loader;
+      const fileLoader = new FileLoader(loader.manager);
+      fileLoader.setPath(loader.partsLibraryPath);
+      fileLoader.setRequestHeader(loader.requestHeader);
+      fileLoader.setWithCredentials(loader.withCredentials);
 
-  let object3d = null;
+      try {
+        const text = await fileLoader.loadAsync(subobjectURL);
+        return text;
+      } catch {
+        continue;
+      }
+    }
 
-  if (elementSize === 2) {
-    object3d = new LineSegments(bufferGeometry, materials);
-  } else if (elementSize === 3) {
-    object3d = new Mesh(bufferGeometry, materials);
+    throw new Error('LDrawLoader: Subobject "' + fileName + '" could not be loaded.');
   }
 
-  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);
+  parse(text, fileName = null) {
+    const loader = this.loader; // final results
 
-    for (let i = 0, l = elements.length; i < l; i++) {
-      const os = elements[i];
-      const c0 = os.c0;
-      const c1 = os.c1;
-      const v0 = os.v0;
-      const v1 = os.v1;
-      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;
-    }
+    const faces = [];
+    const lineSegments = [];
+    const conditionalSegments = [];
+    const subobjects = [];
+    const materials = {};
 
-    bufferGeometry.setAttribute('control0', new BufferAttribute(controlArray0, 3, false));
-    bufferGeometry.setAttribute('control1', new BufferAttribute(controlArray1, 3, false));
-    bufferGeometry.setAttribute('direction', new BufferAttribute(directionArray, 3, false));
-  }
+    const getLocalMaterial = colorCode => {
+      return materials[colorCode] || null;
+    };
 
-  return object3d;
-} //
+    let type = 'Model';
+    let category = null;
+    let keywords = null;
+    let totalFaces = 0; // split into lines
 
+    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');
+    }
 
-class LDrawLoader extends Loader {
-  constructor(manager) {
-    super(manager); // This is a stack of 'parse scopes' with one level per subobject loaded file.
-    // Each level contains a material lib and also other runtime variables passed between parent and child subobjects
-    // When searching for a material code, the stack is read from top of the stack to bottom
-    // Each material library is an object map keyed by colour codes.
+    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
 
-    this.parseScopesStack = null; // Array of THREE.Material
+    for (let lineIndex = 0; lineIndex < numLines; lineIndex++) {
+      const line = lines[lineIndex];
+      if (line.length === 0) continue;
 
-    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 (parsingEmbeddedFiles) {
+        if (line.startsWith('0 FILE ')) {
+          // Save previous embedded file in the cache
+          this.setData(currentEmbeddedFileName, currentEmbeddedText); // New embedded text file
 
-    this.subobjectCache = {}; // 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.
+          currentEmbeddedFileName = line.substring(7);
+          currentEmbeddedText = '';
+        } else {
+          currentEmbeddedText += line + '\n';
+        }
 
-    this.fileMap = null; // Add default main triangle and line edge materials (used in piecess that can be coloured with a main color)
+        continue;
+      }
 
-    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.
+      const lp = new LineParser(line, lineIndex + 1);
+      lp.seekNonSpace();
 
-    this.separateObjects = false; // If this flag is set to true the vertex normals will be smoothed.
+      if (lp.isAtTheEnd()) {
+        // Empty line
+        continue;
+      } // Parse the line type
 
-    this.smoothNormals = true;
-  }
 
-  load(url, onLoad, onProgress, onError) {
-    if (!this.fileMap) {
-      this.fileMap = {};
-    }
+      const lineType = lp.getToken();
+      let material;
+      let colorCode;
+      let segment;
+      let ccw;
+      let doubleSided;
+      let v0, v1, v2, v3, c0, c1;
 
-    const scope = this;
-    const fileLoader = new FileLoader(this.manager);
-    fileLoader.setPath(this.path);
-    fileLoader.setRequestHeader(this.requestHeader);
-    fileLoader.setWithCredentials(this.withCredentials);
-    fileLoader.load(url, function (text) {
-      scope.processObject(text, onLoad, null, url);
-    }, onProgress, onError);
-  }
+      switch (lineType) {
+        // Line type 0: Comment or META
+        case '0':
+          // Parse meta directive
+          const meta = lp.getToken();
 
-  parse(text, path, onLoad) {
-    // Async parse.  This function calls onParse with the parsed THREE.Object3D as parameter
-    this.processObject(text, onLoad, null, path);
-  }
+          if (meta) {
+            switch (meta) {
+              case '!LDRAW_ORG':
+                type = lp.getToken();
+                break;
 
-  setMaterials(materials) {
-    // Clears parse scopes stack, adds new scope with material library
-    this.parseScopesStack = [];
-    this.newParseScopeLevel(materials);
-    this.getCurrentParseScope().isFromParse = false;
-    this.materials = materials;
-    return this;
-  }
+              case '!COLOUR':
+                material = loader.parseColorMetaDirective(lp);
 
-  setFileMap(fileMap) {
-    this.fileMap = fileMap;
-    return this;
-  }
+                if (material) {
+                  materials[material.userData.code] = material;
+                } else {
+                  console.warn('LDrawLoader: Error parsing material' + lp.getLineNumberString());
+                }
 
-  newParseScopeLevel(materials) {
-    // Adds a new scope level, assign materials to it and returns it
-    const matLib = {};
+                break;
 
-    if (materials) {
-      for (let i = 0, n = materials.length; i < n; i++) {
-        const material = materials[i];
-        matLib[material.userData.code] = material;
-      }
-    }
+              case '!CATEGORY':
+                category = lp.getToken();
+                break;
 
-    const topParseScope = this.getCurrentParseScope();
-    const newParseScope = {
-      lib: matLib,
-      url: null,
-      // Subobjects
-      subobjects: null,
-      numSubobjects: 0,
-      subobjectIndex: 0,
-      inverted: false,
-      category: null,
-      keywords: null,
-      // Current subobject
-      currentFileName: null,
-      mainColourCode: topParseScope ? topParseScope.mainColourCode : '16',
-      mainEdgeColourCode: topParseScope ? topParseScope.mainEdgeColourCode : '24',
-      currentMatrix: new Matrix4(),
-      matrix: new Matrix4(),
-      // If false, it is a root material scope previous to parse
-      isFromParse: true,
-      triangles: null,
-      lineSegments: null,
-      conditionalSegments: null,
-      // If true, this object is the start of a construction step
-      startingConstructionStep: false
-    };
-    this.parseScopesStack.push(newParseScope);
-    return newParseScope;
-  }
+              case '!KEYWORDS':
+                const newKeywords = lp.getRemainingString().split(',');
 
-  removeScopeLevel() {
-    this.parseScopesStack.pop();
-    return this;
-  }
+                if (newKeywords.length > 0) {
+                  if (!keywords) {
+                    keywords = [];
+                  }
 
-  addMaterial(material) {
-    // Adds a material to the material library which is on top of the parse scopes stack. And also to the materials array
-    const matLib = this.getCurrentParseScope().lib;
-
-    if (!matLib[material.userData.code]) {
-      this.materials.push(material);
-    }
-
-    matLib[material.userData.code] = material;
-    return this;
-  }
+                  newKeywords.forEach(function (keyword) {
+                    keywords.push(keyword.trim());
+                  });
+                }
 
-  getMaterial(colourCode) {
-    // Given a colour code search its material in the parse scopes stack
-    if (colourCode.startsWith('0x2')) {
-      // 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 + ''));
-    }
+                break;
 
-    for (let i = this.parseScopesStack.length - 1; i >= 0; i--) {
-      const material = this.parseScopesStack[i].lib[colourCode];
+              case 'FILE':
+                if (lineIndex > 0) {
+                  // Start embedded text files parsing
+                  parsingEmbeddedFiles = true;
+                  currentEmbeddedFileName = lp.getRemainingString();
+                  currentEmbeddedText = '';
+                  bfcCertified = false;
+                  bfcCCW = true;
+                }
 
-      if (material) {
-        return material;
-      }
-    } // Material was not found
+                break;
 
+              case 'BFC':
+                // Changes to the backface culling state
+                while (!lp.isAtTheEnd()) {
+                  const token = lp.getToken();
 
-    return null;
-  }
+                  switch (token) {
+                    case 'CERTIFY':
+                    case 'NOCERTIFY':
+                      bfcCertified = token === 'CERTIFY';
+                      bfcCCW = true;
+                      break;
 
-  getParentParseScope() {
-    if (this.parseScopesStack.length > 1) {
-      return this.parseScopesStack[this.parseScopesStack.length - 2];
-    }
+                    case 'CW':
+                    case 'CCW':
+                      bfcCCW = token === 'CCW';
+                      break;
 
-    return null;
-  }
+                    case 'INVERTNEXT':
+                      bfcInverted = true;
+                      break;
 
-  getCurrentParseScope() {
-    if (this.parseScopesStack.length > 0) {
-      return this.parseScopesStack[this.parseScopesStack.length - 1];
-    }
+                    case 'CLIP':
+                    case 'NOCLIP':
+                      bfcCull = token === 'CLIP';
+                      break;
 
-    return null;
-  }
+                    default:
+                      console.warn('THREE.LDrawLoader: BFC directive "' + token + '" is unknown.');
+                      break;
+                  }
+                }
 
-  parseColourMetaDirective(lineParser) {
-    // Parses a colour definition and returns a THREE.Material or null if error
-    let code = null; // Triangle and line colours
+                break;
 
-    let colour = 0xff00ff;
-    let edgeColour = 0xff00ff; // Transparency
+              case 'STEP':
+                startingConstructionStep = true;
+                break;
+            }
+          }
 
-    let alpha = 1;
-    let isTransparent = false; // Self-illumination:
+          break;
+        // Line type 1: Sub-object file
 
-    let luminance = 0;
-    let finishType = FINISH_TYPE_DEFAULT;
-    let canHaveEnvMap = true;
-    let edgeMaterial = null;
-    const name = lineParser.getToken();
+        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 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, '/');
 
-    if (!name) {
-      throw 'LDrawLoader: Material name was expected after "!COLOUR tag' + lineParser.getLineNumberString() + '.';
-    } // Parse tag tokens and their parameters
+          if (loader.fileMap[fileName]) {
+            // Found the subobject path in the preloaded file path map
+            fileName = loader.fileMap[fileName];
+          } else {
+            // Standardized subfolders
+            if (fileName.startsWith('s/')) {
+              fileName = 'parts/' + fileName;
+            } else if (fileName.startsWith('48/')) {
+              fileName = 'p/' + fileName;
+            }
+          }
 
+          subobjects.push({
+            material: material,
+            colorCode: colorCode,
+            matrix: matrix,
+            fileName: fileName,
+            inverted: bfcInverted,
+            startingConstructionStep: startingConstructionStep
+          });
+          bfcInverted = false;
+          break;
+        // Line type 2: Line segment
 
-    let token = null;
+        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
 
-    while (true) {
-      token = lineParser.getToken();
+        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
 
-      if (!token) {
-        break;
-      }
+        case '3':
+          colorCode = lp.getToken();
+          material = getLocalMaterial(colorCode);
+          ccw = bfcCCW;
+          doubleSided = !bfcCertified || !bfcCull;
 
-      switch (token.toUpperCase()) {
-        case 'CODE':
-          code = lineParser.getToken();
-          break;
+          if (ccw === true) {
+            v0 = lp.getVector();
+            v1 = lp.getVector();
+            v2 = lp.getVector();
+          } else {
+            v2 = lp.getVector();
+            v1 = lp.getVector();
+            v0 = lp.getVector();
+          }
 
-        case 'VALUE':
-          colour = lineParser.getToken();
+          faces.push({
+            material: material,
+            colorCode: colorCode,
+            faceNormal: null,
+            vertices: [v0, v1, v2],
+            normals: [null, null, null]
+          });
+          totalFaces++;
 
-          if (colour.startsWith('0x')) {
-            colour = '#' + colour.substring(2);
-          } else if (!colour.startsWith('#')) {
-            throw 'LDrawLoader: Invalid colour while parsing material' + lineParser.getLineNumberString() + '.';
+          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 'EDGE':
-          edgeColour = lineParser.getToken();
+        case '4':
+          colorCode = lp.getToken();
+          material = getLocalMaterial(colorCode);
+          ccw = bfcCCW;
+          doubleSided = !bfcCertified || !bfcCull;
 
-          if (edgeColour.startsWith('0x')) {
-            edgeColour = '#' + edgeColour.substring(2);
-          } else if (!edgeColour.startsWith('#')) {
-            // Try to see if edge colour is a colour code
-            edgeMaterial = this.getMaterial(edgeColour);
+          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.
 
-            if (!edgeMaterial) {
-              throw 'LDrawLoader: Invalid edge colour while parsing material' + lineParser.getLineNumberString() + '.';
-            } // Get the edge material for this triangle material
 
+          faces.push({
+            material: material,
+            colorCode: colorCode,
+            faceNormal: null,
+            vertices: [v0, v1, v2, v3],
+            normals: [null, null, null, null]
+          });
+          totalFaces += 2;
 
-            edgeMaterial = edgeMaterial.userData.edgeMaterial;
+          if (doubleSided === true) {
+            faces.push({
+              material: material,
+              colorCode: colorCode,
+              faceNormal: null,
+              vertices: [v3, v2, v1, v0],
+              normals: [null, null, null, null]
+            });
+            totalFaces += 2;
           }
 
           break;
 
-        case 'ALPHA':
-          alpha = parseInt(lineParser.getToken());
+        default:
+          throw new Error('LDrawLoader: Unknown line type "' + lineType + '"' + lp.getLineNumberString() + '.');
+      }
+    }
 
-          if (isNaN(alpha)) {
-            throw 'LDrawLoader: Invalid alpha value in material definition' + lineParser.getLineNumberString() + '.';
-          }
+    if (parsingEmbeddedFiles) {
+      this.setData(currentEmbeddedFileName, currentEmbeddedText);
+    }
 
-          alpha = Math.max(0, Math.min(1, alpha / 255));
+    return {
+      faces,
+      conditionalSegments,
+      lineSegments,
+      type,
+      category,
+      keywords,
+      subobjects,
+      totalFaces,
+      startingConstructionStep,
+      materials,
+      fileName,
+      group: null
+    };
+  } // returns an (optionally cloned) instance of the data
 
-          if (alpha < 1) {
-            isTransparent = true;
-          }
 
-          break;
+  getData(fileName, clone = true) {
+    const key = fileName.toLowerCase();
+    const result = this._cache[key];
 
-        case 'LUMINANCE':
-          luminance = parseInt(lineParser.getToken());
+    if (result === null || result instanceof Promise) {
+      return null;
+    }
 
-          if (isNaN(luminance)) {
-            throw 'LDrawLoader: Invalid luminance value in material definition' + LineParser.getLineNumberString() + '.';
-          }
+    if (clone) {
+      return this.cloneResult(result);
+    } else {
+      return result;
+    }
+  } // kicks off a fetch and parse of the requested data if it hasn't already been loaded. Returns when
+  // the data is ready to use and can be retrieved synchronously with "getData".
 
-          luminance = Math.max(0, Math.min(1, luminance / 255));
-          break;
 
-        case 'CHROME':
-          finishType = FINISH_TYPE_CHROME;
-          break;
+  async ensureDataLoaded(fileName) {
+    const key = fileName.toLowerCase();
 
-        case 'PEARLESCENT':
-          finishType = FINISH_TYPE_PEARLESCENT;
-          break;
+    if (!(key in this._cache)) {
+      // replace the promise with a copy of the parsed data for immediate processing
+      this._cache[key] = this.fetchData(fileName).then(text => {
+        const info = this.parse(text, fileName);
+        this._cache[key] = info;
+        return info;
+      });
+    }
 
-        case 'RUBBER':
-          finishType = FINISH_TYPE_RUBBER;
-          break;
+    await this._cache[key];
+  } // sets the data in the cache from parsed data
 
-        case 'MATTE_METALLIC':
-          finishType = FINISH_TYPE_MATTE_METALLIC;
-          break;
 
-        case 'METAL':
-          finishType = FINISH_TYPE_METAL;
-          break;
+  setData(fileName, text) {
+    const key = fileName.toLowerCase();
+    this._cache[key] = this.parse(text, fileName);
+  }
 
-        case 'MATERIAL':
-          // Not implemented
-          lineParser.setToEnd();
-          break;
+} // returns the material for an associated color code. If the color code is 16 for a face or 24 for
+// an edge then the passthroughColorCode is used.
 
-        default:
-          throw 'LDrawLoader: Unknown token "' + token + '" while parsing material' + lineParser.getLineNumberString() + '.';
-      }
-    }
 
-    let material = null;
+function getMaterialFromCode(colorCode, parentColorCode, materialHierarchy, forEdge) {
+  const isPassthrough = !forEdge && colorCode === MAIN_COLOUR_CODE || forEdge && colorCode === MAIN_EDGE_COLOUR_CODE;
 
-    switch (finishType) {
-      case FINISH_TYPE_DEFAULT:
-        material = new MeshStandardMaterial({
-          color: colour,
-          roughness: 0.3,
-          envMapIntensity: 0.3,
-          metalness: 0
-        });
-        break;
+  if (isPassthrough) {
+    colorCode = parentColorCode;
+  }
 
-      case FINISH_TYPE_PEARLESCENT:
-        // 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);
-        material = new MeshPhongMaterial({
-          color: colour,
-          specular: specular,
-          shininess: 10,
-          reflectivity: 0.3
-        });
-        break;
+  return materialHierarchy[colorCode] || null;
+} // Class used to parse and build LDraw parts as three.js objects and cache them if they're a "Part" type.
 
-      case FINISH_TYPE_CHROME:
-        // Mirror finish surface
-        material = new MeshStandardMaterial({
-          color: colour,
-          roughness: 0,
-          metalness: 1
-        });
-        break;
 
-      case FINISH_TYPE_RUBBER:
-        // Rubber finish
-        material = new MeshStandardMaterial({
-          color: colour,
-          roughness: 0.9,
-          metalness: 0
-        });
-        canHaveEnvMap = false;
-        break;
+class LDrawPartsGeometryCache {
+  constructor(loader) {
+    this.loader = loader;
+    this.parseCache = new LDrawParsedCache(loader);
+    this._cache = {};
+  } // Convert the given file information into a mesh by processing subobjects.
 
-      case FINISH_TYPE_MATTE_METALLIC:
-        // Brushed metal finish
-        material = new MeshStandardMaterial({
-          color: colour,
-          roughness: 0.8,
-          metalness: 0.4
-        });
-        break;
 
-      case FINISH_TYPE_METAL:
-        // Average metal finish
-        material = new MeshStandardMaterial({
-          color: colour,
-          roughness: 0.2,
-          metalness: 0.85
-        });
-        break;
-    }
+  async processIntoMesh(info) {
+    const loader = this.loader;
+    const parseCache = this.parseCache;
+    const faceMaterials = new Set(); // Processes the part subobject information to load child parts and merge geometry onto part
+    // piece object.
 
-    material.transparent = isTransparent;
-    material.premultipliedAlpha = true;
-    material.opacity = alpha;
-    material.depthWrite = !isTransparent;
-    material.polygonOffset = true;
-    material.polygonOffsetFactor = 1;
-    material.userData.canHaveEnvMap = canHaveEnvMap;
+    const processInfoSubobjects = async (info, subobject = null) => {
+      const subobjects = info.subobjects;
+      const promises = []; // Trigger load of all subobjects. If a subobject isn't a primitive then load it as a separate
+      // group which lets instruction steps apply correctly.
 
-    if (luminance !== 0) {
-      material.emissive.set(material.color).multiplyScalar(luminance);
-    }
+      for (let i = 0, l = subobjects.length; i < l; i++) {
+        const subobject = subobjects[i];
+        const promise = parseCache.ensureDataLoaded(subobject.fileName).then(() => {
+          const subobjectInfo = parseCache.getData(subobject.fileName, false);
 
-    if (!edgeMaterial) {
-      // 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';
-      edgeMaterial.userData.canHaveEnvMap = false; // This is the material used for conditional edges
-
-      edgeMaterial.userData.conditionalEdgeMaterial = new ShaderMaterial({
-        vertexShader: conditionalLineVertShader,
-        fragmentShader: conditionalLineFragShader,
-        uniforms: UniformsUtils.merge([UniformsLib.fog, {
-          diffuse: {
-            value: new Color(edgeColour)
-          },
-          opacity: {
-            value: alpha
+          if (!isPrimitiveType(subobjectInfo.type)) {
+            return this.loadModel(subobject.fileName).catch(error => {
+              console.warn(error);
+              return null;
+            });
           }
-        }]),
-        fog: true,
-        transparent: isTransparent,
-        depthWrite: !isTransparent
-      });
-      edgeMaterial.userData.conditionalEdgeMaterial.userData.canHaveEnvMap = false;
-    }
 
-    material.userData.code = code;
-    material.name = name;
-    material.userData.edgeMaterial = edgeMaterial;
-    return material;
-  } //
+          return processInfoSubobjects(parseCache.getData(subobject.fileName), subobject);
+        });
+        promises.push(promise);
+      }
 
+      const group = new Group();
+      group.userData.category = info.category;
+      group.userData.keywords = info.keywords;
+      info.group = group;
+      const subobjectInfos = await Promise.all(promises);
+
+      for (let i = 0, l = subobjectInfos.length; i < l; i++) {
+        const subobject = info.subobjects[i];
+        const subobjectInfo = subobjectInfos[i];
+
+        if (subobjectInfo === null) {
+          // the subobject failed to load
+          continue;
+        } // if the subobject was loaded as a separate group then apply the parent scopes materials
+
+
+        if (subobjectInfo.isGroup) {
+          const subobjectGroup = subobjectInfo;
+          subobject.matrix.decompose(subobjectGroup.position, subobjectGroup.quaternion, subobjectGroup.scale);
+          subobjectGroup.userData.startingConstructionStep = subobject.startingConstructionStep;
+          subobjectGroup.name = subobject.fileName;
+          loader.applyMaterialsToMesh(subobjectGroup, subobject.colorCode, info.materials);
+          group.add(subobjectGroup);
+          continue;
+        } // add the subobject group if it has children in case it has both children and primitives
+
+
+        if (subobjectInfo.group.children.length) {
+          group.add(subobjectInfo.group);
+        } // transform the primitives into the local space of the parent piece and append them to
+        // to the parent primitives list.
+
+
+        const parentLineSegments = info.lineSegments;
+        const parentConditionalSegments = info.conditionalSegments;
+        const parentFaces = info.faces;
+        const lineSegments = subobjectInfo.lineSegments;
+        const conditionalSegments = subobjectInfo.conditionalSegments;
+        const faces = subobjectInfo.faces;
+        const matrix = subobject.matrix;
+        const inverted = subobject.inverted;
+        const matrixScaleInverted = matrix.determinant() < 0;
+        const colorCode = subobject.colorCode;
+        const lineColorCode = colorCode === MAIN_COLOUR_CODE ? MAIN_EDGE_COLOUR_CODE : colorCode;
 
-  objectParse(text) {
-    // Retrieve data from the parent parse scope
-    const parentParseScope = this.getParentParseScope(); // Main colour codes passed to this subobject (or default codes 16 and 24 if it is the root object)
+        for (let i = 0, l = lineSegments.length; i < l; i++) {
+          const ls = lineSegments[i];
+          const vertices = ls.vertices;
+          vertices[0].applyMatrix4(matrix);
+          vertices[1].applyMatrix4(matrix);
+          ls.colorCode = ls.colorCode === MAIN_EDGE_COLOUR_CODE ? lineColorCode : ls.colorCode;
+          ls.material = ls.material || getMaterialFromCode(ls.colorCode, ls.colorCode, info.materials, true);
+          parentLineSegments.push(ls);
+        }
 
-    const mainColourCode = parentParseScope.mainColourCode;
-    const mainEdgeColourCode = parentParseScope.mainEdgeColourCode;
-    const currentParseScope = this.getCurrentParseScope(); // Parse result variables
+        for (let i = 0, l = conditionalSegments.length; i < l; i++) {
+          const os = conditionalSegments[i];
+          const vertices = os.vertices;
+          const controlPoints = os.controlPoints;
+          vertices[0].applyMatrix4(matrix);
+          vertices[1].applyMatrix4(matrix);
+          controlPoints[0].applyMatrix4(matrix);
+          controlPoints[1].applyMatrix4(matrix);
+          os.colorCode = os.colorCode === MAIN_EDGE_COLOUR_CODE ? lineColorCode : os.colorCode;
+          os.material = os.material || getMaterialFromCode(os.colorCode, os.colorCode, info.materials, true);
+          parentConditionalSegments.push(os);
+        }
 
-    let triangles;
-    let lineSegments;
-    let conditionalSegments;
-    const subobjects = [];
-    let category = null;
-    let keywords = null;
+        for (let i = 0, l = faces.length; i < l; i++) {
+          const tri = faces[i];
+          const vertices = tri.vertices;
 
-    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');
-    }
+          for (let i = 0, l = vertices.length; i < l; i++) {
+            vertices[i].applyMatrix4(matrix);
+          }
 
-    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;
+          tri.colorCode = tri.colorCode === MAIN_COLOUR_CODE ? colorCode : tri.colorCode;
+          tri.material = tri.material || getMaterialFromCode(tri.colorCode, colorCode, info.materials, false);
+          faceMaterials.add(tri.colorCode); // If the scale of the object is negated then the triangle winding order
+          // needs to be flipped.
 
-    function parseColourCode(lineParser, forEdge) {
-      // Parses next colour code and returns a THREE.Material
-      let colourCode = lineParser.getToken();
+          if (matrixScaleInverted !== inverted) {
+            vertices.reverse();
+          }
 
-      if (!forEdge && colourCode === '16') {
-        colourCode = mainColourCode;
-      }
+          parentFaces.push(tri);
+        }
 
-      if (forEdge && colourCode === '24') {
-        colourCode = mainEdgeColourCode;
-      }
+        info.totalFaces += subobjectInfo.totalFaces;
+      } // Apply the parent subobjects pass through material code to this object. This is done several times due
+      // to material scoping.
 
-      const material = scope.getMaterial(colourCode);
 
-      if (!material) {
-        throw 'LDrawLoader: Unknown colour code "' + colourCode + '" is used' + lineParser.getLineNumberString() + ' but it was not defined previously.';
+      if (subobject) {
+        loader.applyMaterialsToMesh(group, subobject.colorCode, info.materials);
       }
 
-      return material;
+      return info;
+    }; // Track material use to see if we need to use the normal smooth slow path for hard edges.
+
+
+    for (let i = 0, l = info.faces; i < l; i++) {
+      faceMaterials.add(info.faces[i].colorCode);
     }
 
-    function parseVector(lp) {
-      const v = new Vector3(parseFloat(lp.getToken()), parseFloat(lp.getToken()), parseFloat(lp.getToken()));
+    await processInfoSubobjects(info);
 
-      if (!scope.separateObjects) {
-        v.applyMatrix4(currentParseScope.currentMatrix);
-      }
+    if (loader.smoothNormals) {
+      const checkSubSegments = faceMaterials.size > 1;
+      generateFaceNormals(info.faces);
+      smoothNormals(info.faces, info.lineSegments, checkSubSegments);
+    } // Add the primitive objects and metadata.
 
-      return v;
-    } // Parse all line commands
 
+    const group = info.group;
 
-    for (let lineIndex = 0; lineIndex < numLines; lineIndex++) {
-      const line = lines[lineIndex];
-      if (line.length === 0) continue;
+    if (info.faces.length > 0) {
+      group.add(createObject(info.faces, 3, false, info.totalFaces));
+    }
 
-      if (parsingEmbeddedFiles) {
-        if (line.startsWith('0 FILE ')) {
-          // Save previous embedded file in the cache
-          this.subobjectCache[currentEmbeddedFileName.toLowerCase()] = currentEmbeddedText; // New embedded text file
+    if (info.lineSegments.length > 0) {
+      group.add(createObject(info.lineSegments, 2));
+    }
 
-          currentEmbeddedFileName = line.substring(7);
-          currentEmbeddedText = '';
-        } else {
-          currentEmbeddedText += line + '\n';
-        }
+    if (info.conditionalSegments.length > 0) {
+      group.add(createObject(info.conditionalSegments, 2, true));
+    }
 
-        continue;
-      }
+    return group;
+  }
 
-      const lp = new LineParser(line, lineIndex + 1);
-      lp.seekNonSpace();
+  hasCachedModel(fileName) {
+    return fileName !== null && fileName.toLowerCase() in this._cache;
+  }
 
-      if (lp.isAtTheEnd()) {
-        // Empty line
-        continue;
-      } // Parse the line type
+  async getCachedModel(fileName) {
+    if (fileName !== null && this.hasCachedModel(fileName)) {
+      const key = fileName.toLowerCase();
+      const group = await this._cache[key];
+      return group.clone();
+    } else {
+      return null;
+    }
+  } // Loads and parses the model with the given file name. Returns a cached copy if available.
 
 
-      const lineType = lp.getToken();
-      let material;
-      let segment;
-      let inverted;
-      let ccw;
-      let doubleSided;
-      let v0, v1, v2, v3, faceNormal;
+  async loadModel(fileName) {
+    const parseCache = this.parseCache;
+    const key = fileName.toLowerCase();
 
-      switch (lineType) {
-        // Line type 0: Comment or META
-        case '0':
-          // Parse meta directive
-          const meta = lp.getToken();
+    if (this.hasCachedModel(fileName)) {
+      // Return cached model if available.
+      return this.getCachedModel(fileName);
+    } else {
+      // Otherwise parse a new model.
+      // Ensure the file data is loaded and pre parsed.
+      await parseCache.ensureDataLoaded(fileName);
+      const info = parseCache.getData(fileName);
+      const promise = this.processIntoMesh(info); // Now that the file has loaded it's possible that another part parse has been waiting in parallel
+      // so check the cache again to see if it's been added since the last async operation so we don't
+      // do unnecessary work.
 
-          if (meta) {
-            switch (meta) {
-              case '!LDRAW_ORG':
-                type = lp.getToken();
-                currentParseScope.triangles = [];
-                currentParseScope.lineSegments = [];
-                currentParseScope.conditionalSegments = [];
-                currentParseScope.type = type;
-                const isRoot = !parentParseScope.isFromParse;
+      if (this.hasCachedModel(fileName)) {
+        return this.getCachedModel(fileName);
+      } // Cache object if it's a part so it can be reused later.
 
-                if (isRoot || scope.separateObjects && !isPrimitiveType(type)) {
-                  currentParseScope.groupObject = new Group();
-                  currentParseScope.groupObject.userData.startingConstructionStep = currentParseScope.startingConstructionStep;
-                } // If the scale of the object is negated then the triangle winding order
-                // needs to be flipped.
 
+      if (isPartType(info.type)) {
+        this._cache[key] = promise;
+      } // return a copy
 
-                if (currentParseScope.matrix.determinant() < 0 && (scope.separateObjects && isPrimitiveType(type) || !scope.separateObjects)) {
-                  currentParseScope.inverted = !currentParseScope.inverted;
-                }
 
-                triangles = currentParseScope.triangles;
-                lineSegments = currentParseScope.lineSegments;
-                conditionalSegments = currentParseScope.conditionalSegments;
-                break;
+      const group = await promise;
+      return group.clone();
+    }
+  } // parses the given model text into a renderable object. Returns cached copy if available.
 
-              case '!COLOUR':
-                material = this.parseColourMetaDirective(lp);
 
-                if (material) {
-                  this.addMaterial(material);
-                } else {
-                  console.warn('LDrawLoader: Error parsing material' + lp.getLineNumberString());
-                }
+  async parseModel(text) {
+    const parseCache = this.parseCache;
+    const info = parseCache.parse(text);
 
-                break;
+    if (isPartType(info.type) && this.hasCachedModel(info.fileName)) {
+      return this.getCachedModel(info.fileName);
+    }
 
-              case '!CATEGORY':
-                category = lp.getToken();
-                break;
+    return this.processIntoMesh(info);
+  }
 
-              case '!KEYWORDS':
-                const newKeywords = lp.getRemainingString().split(',');
+}
 
-                if (newKeywords.length > 0) {
-                  if (!keywords) {
-                    keywords = [];
-                  }
+function sortByMaterial(a, b) {
+  if (a.colorCode === b.colorCode) {
+    return 0;
+  }
 
-                  newKeywords.forEach(function (keyword) {
-                    keywords.push(keyword.trim());
-                  });
-                }
+  if (a.colorCode < b.colorCode) {
+    return -1;
+  }
 
-                break;
+  return 1;
+}
 
-              case 'FILE':
-                if (lineIndex > 0) {
-                  // Start embedded text files parsing
-                  parsingEmbeddedFiles = true;
-                  currentEmbeddedFileName = lp.getRemainingString();
-                  currentEmbeddedText = '';
-                  bfcCertified = false;
-                  bfcCCW = true;
-                }
+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
+  // Sort the faces or line segments by color code to make later the mesh groups
+  elements.sort(sortByMaterial);
 
-                break;
+  if (totalElements === null) {
+    totalElements = elements.length;
+  }
 
-              case 'BFC':
-                // Changes to the backface culling state
-                while (!lp.isAtTheEnd()) {
-                  const token = lp.getToken();
+  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 BufferGeometry();
+  let prevMaterial = null;
+  let index0 = 0;
+  let numGroupVerts = 0;
+  let offset = 0;
 
-                  switch (token) {
-                    case 'CERTIFY':
-                    case 'NOCERTIFY':
-                      bfcCertified = token === 'CERTIFY';
-                      bfcCCW = true;
-                      break;
+  for (let iElem = 0, nElem = elements.length; iElem < nElem; iElem++) {
+    const elem = elements[iElem];
+    let vertices = elem.vertices;
+
+    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;
+    }
 
-                    case 'CW':
-                    case 'CCW':
-                      bfcCCW = token === 'CCW';
-                      break;
+    for (let j = 0, l = vertices.length; j < l; j++) {
+      const v = vertices[j];
+      const index = offset + j * 3;
+      positions[index + 0] = v.x;
+      positions[index + 1] = v.y;
+      positions[index + 2] = v.z;
+    } // create the normals array if this is a set of faces
 
-                    case 'INVERTNEXT':
-                      bfcInverted = true;
-                      break;
 
-                    case 'CLIP':
-                    case 'NOCLIP':
-                      bfcCull = token === 'CLIP';
-                      break;
+    if (elementSize === 3) {
+      if (!elem.faceNormal) {
+        const v0 = vertices[0];
+        const v1 = vertices[1];
+        const v2 = vertices[2];
 
-                    default:
-                      console.warn('THREE.LDrawLoader: BFC directive "' + token + '" is unknown.');
-                      break;
-                  }
-                }
+        _tempVec0.subVectors(v1, v0);
 
-                break;
+        _tempVec1.subVectors(v2, v1);
 
-              case 'STEP':
-                startingConstructionStep = true;
-                break;
-            }
-          }
+        elem.faceNormal = new Vector3().crossVectors(_tempVec0, _tempVec1).normalize();
+      }
 
-          break;
-        // Line type 1: Sub-object file
+      let elemNormals = elem.normals;
 
-        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 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, '/');
+      if (elemNormals.length === 4) {
+        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;
+      }
 
-          if (scope.fileMap[fileName]) {
-            // Found the subobject path in the preloaded file path map
-            fileName = scope.fileMap[fileName];
-          } else {
-            // Standardized subfolders
-            if (fileName.startsWith('s/')) {
-              fileName = 'parts/' + fileName;
-            } else if (fileName.startsWith('48/')) {
-              fileName = 'p/' + fileName;
+      for (let j = 0, l = elemNormals.length; j < l; j++) {
+        // use face normal if a vertex normal is not provided
+        let n = elem.faceNormal;
+
+        if (elemNormals[j]) {
+          n = elemNormals[j].norm;
+        }
+
+        const index = offset + j * 3;
+        normals[index + 0] = n.x;
+        normals[index + 1] = n.y;
+        normals[index + 2] = n.z;
+      }
+    }
+
+    if (prevMaterial !== elem.colorCode) {
+      if (prevMaterial !== null) {
+        bufferGeometry.addGroup(index0, numGroupVerts, materials.length - 1);
+      }
+
+      const material = elem.material;
+
+      if (material !== null) {
+        if (elementSize === 3) {
+          materials.push(material);
+        } else if (elementSize === 2) {
+          if (material !== null) {
+            if (isConditionalSegments) {
+              materials.push(material.userData.edgeMaterial.userData.conditionalEdgeMaterial);
+            } else {
+              materials.push(material.userData.edgeMaterial);
             }
+          } else {
+            materials.push(null);
           }
+        }
+      } else {
+        // If a material has not been made available yet then keep the color code string in the material array
+        // to save the spot for the material once a parent scopes materials are being applied to the object.
+        materials.push(elem.colorCode);
+      }
 
-          subobjects.push({
-            material: material,
-            matrix: matrix,
-            fileName: fileName,
-            originalFileName: fileName,
-            locationState: FILE_LOCATION_AS_IS,
-            url: null,
-            triedLowerCase: false,
-            inverted: bfcInverted !== currentParseScope.inverted,
-            startingConstructionStep: startingConstructionStep
-          });
-          bfcInverted = false;
-          break;
-        // Line type 2: Line segment
+      prevMaterial = elem.colorCode;
+      index0 = offset / 3;
+      numGroupVerts = vertices.length;
+    } else {
+      numGroupVerts += vertices.length;
+    }
 
-        case '2':
-          material = parseColourCode(lp, true);
-          segment = {
-            material: material.userData.edgeMaterial,
-            colourCode: material.userData.code,
-            v0: parseVector(lp),
-            v1: parseVector(lp)
-          };
-          lineSegments.push(segment);
-          break;
-        // Line type 5: Conditional Line segment
+    offset += 3 * vertices.length;
+  }
 
-        case '5':
-          material = parseColourCode(lp, true);
-          segment = {
-            material: material.userData.edgeMaterial.userData.conditionalEdgeMaterial,
-            colourCode: material.userData.code,
-            v0: parseVector(lp),
-            v1: parseVector(lp),
-            c0: parseVector(lp),
-            c1: parseVector(lp)
-          };
-          conditionalSegments.push(segment);
-          break;
-        // Line type 3: Triangle
+  if (numGroupVerts > 0) {
+    bufferGeometry.addGroup(index0, Infinity, materials.length - 1);
+  }
 
-        case '3':
-          material = parseColourCode(lp);
-          inverted = currentParseScope.inverted;
-          ccw = bfcCCW !== inverted;
-          doubleSided = !bfcCertified || !bfcCull;
+  bufferGeometry.setAttribute('position', new BufferAttribute(positions, 3));
 
-          if (ccw === true) {
-            v0 = parseVector(lp);
-            v1 = parseVector(lp);
-            v2 = parseVector(lp);
-          } else {
-            v2 = parseVector(lp);
-            v1 = parseVector(lp);
-            v0 = parseVector(lp);
-          }
+  if (normals !== null) {
+    bufferGeometry.setAttribute('normal', new BufferAttribute(normals, 3));
+  }
 
-          _tempVec0.subVectors(v1, v0);
+  let object3d = null;
 
-          _tempVec1.subVectors(v2, v1);
+  if (elementSize === 2) {
+    if (isConditionalSegments) {
+      object3d = new ConditionalLineSegments(bufferGeometry, materials.length === 1 ? materials[0] : materials);
+    } else {
+      object3d = new LineSegments(bufferGeometry, materials.length === 1 ? materials[0] : materials);
+    }
+  } else if (elementSize === 3) {
+    object3d = new Mesh(bufferGeometry, materials.length === 1 ? materials[0] : materials);
+  }
 
-          faceNormal = new Vector3().crossVectors(_tempVec0, _tempVec1).normalize();
-          triangles.push({
-            material: material,
-            colourCode: material.userData.code,
-            v0: v0,
-            v1: v1,
-            v2: v2,
-            faceNormal: faceNormal,
-            n0: null,
-            n1: null,
-            n2: null
-          });
+  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);
 
-          if (doubleSided === true) {
-            triangles.push({
-              material: material,
-              colourCode: material.userData.code,
-              v0: v0,
-              v1: v2,
-              v2: v1,
-              faceNormal: faceNormal,
-              n0: null,
-              n1: null,
-              n2: null
-            });
-          }
+    for (let i = 0, l = elements.length; i < l; i++) {
+      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;
+    }
+
+    bufferGeometry.setAttribute('control0', new BufferAttribute(controlArray0, 3, false));
+    bufferGeometry.setAttribute('control1', new BufferAttribute(controlArray1, 3, false));
+    bufferGeometry.setAttribute('direction', new BufferAttribute(directionArray, 3, false));
+  }
+
+  return object3d;
+} //
+
+
+class LDrawLoader extends Loader {
+  constructor(manager) {
+    super(manager); // Array of THREE.Material
+
+    this.materials = [];
+    this.materialLibrary = {}; // This also allows to handle the embedded text files ("0 FILE" lines)
+
+    this.partsCache = new LDrawPartsGeometryCache(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 = {}; // Initializes the materials library with default materials
+
+    this.setMaterials([]); // If this flag is set to true the vertex normals will be smoothed.
+
+    this.smoothNormals = true; // The path to load parts from the LDraw parts library from.
+
+    this.partsLibraryPath = '';
+  }
+
+  setPartsLibraryPath(path) {
+    this.partsLibraryPath = path;
+    return this;
+  }
+
+  async preloadMaterials(url) {
+    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)) {
+        const directive = line.replace(colorLineRegex, '');
+        const material = this.parseColorMetaDirective(new LineParser(directive));
+        materials.push(material);
+      }
+    }
 
-          break;
-        // Line type 4: Quadrilateral
+    this.setMaterials(materials);
+  }
 
-        case '4':
-          material = parseColourCode(lp);
-          inverted = currentParseScope.inverted;
-          ccw = bfcCCW !== inverted;
-          doubleSided = !bfcCertified || !bfcCull;
+  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 => {
+      this.partsCache.parseModel(text, this.materialLibrary).then(group => {
+        this.applyMaterialsToMesh(group, MAIN_COLOUR_CODE, this.materialLibrary, true);
+        this.computeConstructionSteps(group);
+        onLoad(group);
+      }).catch(onError);
+    }, onProgress, onError);
+  }
 
-          if (ccw === true) {
-            v0 = parseVector(lp);
-            v1 = parseVector(lp);
-            v2 = parseVector(lp);
-            v3 = parseVector(lp);
-          } else {
-            v3 = parseVector(lp);
-            v2 = parseVector(lp);
-            v1 = parseVector(lp);
-            v0 = parseVector(lp);
-          }
+  parse(text, onLoad) {
+    this.partsCache.parseModel(text, this.materialLibrary).then(group => {
+      this.computeConstructionSteps(group);
+      onLoad(group);
+    });
+  }
 
-          _tempVec0.subVectors(v1, v0);
+  setMaterials(materials) {
+    this.materialLibrary = {};
+    this.materials = [];
 
-          _tempVec1.subVectors(v2, v1);
+    for (let i = 0, l = materials.length; i < l; i++) {
+      this.addMaterial(materials[i]);
+    } // Add default main triangle and line edge materials (used in pieces that can be colored with a main color)
 
-          faceNormal = new Vector3().crossVectors(_tempVec0, _tempVec1).normalize();
-          triangles.push({
-            material: material,
-            colourCode: material.userData.code,
-            v0: v0,
-            v1: v1,
-            v2: v2,
-            faceNormal: faceNormal,
-            n0: null,
-            n1: null,
-            n2: null
-          });
-          triangles.push({
-            material: material,
-            colourCode: material.userData.code,
-            v0: v0,
-            v1: v2,
-            v2: v3,
-            faceNormal: faceNormal,
-            n0: null,
-            n1: null,
-            n2: null
-          });
 
-          if (doubleSided === true) {
-            triangles.push({
-              material: material,
-              colourCode: material.userData.code,
-              v0: v0,
-              v1: v2,
-              v2: v1,
-              faceNormal: faceNormal,
-              n0: null,
-              n1: null,
-              n2: null
-            });
-            triangles.push({
-              material: material,
-              colourCode: material.userData.code,
-              v0: v0,
-              v1: v3,
-              v2: v2,
-              faceNormal: faceNormal,
-              n0: null,
-              n1: null,
-              n2: null
-            });
-          }
+    this.addMaterial(this.parseColorMetaDirective(new LineParser('Main_Colour CODE 16 VALUE #FF8080 EDGE #333333')));
+    this.addMaterial(this.parseColorMetaDirective(new LineParser('Edge_Colour CODE 24 VALUE #A0A0A0 EDGE #333333')));
+    return this;
+  }
 
-          break;
+  setFileMap(fileMap) {
+    this.fileMap = fileMap;
+    return this;
+  }
 
-        default:
-          throw 'LDrawLoader: Unknown line type "' + lineType + '"' + lp.getLineNumberString() + '.';
-      }
-    }
+  addMaterial(material) {
+    // Adds a material to the material library which is on top of the parse scopes stack. And also to the materials array
+    const matLib = this.materialLibrary;
 
-    if (parsingEmbeddedFiles) {
-      this.subobjectCache[currentEmbeddedFileName.toLowerCase()] = currentEmbeddedText;
+    if (!matLib[material.userData.code]) {
+      this.materials.push(material);
+      matLib[material.userData.code] = material;
     }
 
-    currentParseScope.category = category;
-    currentParseScope.keywords = keywords;
-    currentParseScope.subobjects = subobjects;
-    currentParseScope.numSubobjects = subobjects.length;
-    currentParseScope.subobjectIndex = 0;
+    return this;
   }
 
-  computeConstructionSteps(model) {
-    // Sets userdata.constructionStep number in Group objects and userData.numConstructionSteps number in the root Group object.
-    let stepNumber = 0;
-    model.traverse(c => {
-      if (c.isGroup) {
-        if (c.userData.startingConstructionStep) {
-          stepNumber++;
-        }
+  getMaterial(colorCode) {
+    if (colorCode.startsWith('0x2')) {
+      // 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 + ''));
+    }
 
-        c.userData.constructionStep = stepNumber;
+    return this.materialLibrary[colorCode] || null;
+  } // Applies the appropriate materials to a prebuilt hierarchy of geometry. Assumes that color codes are present
+  // in the material array if they need to be filled in.
+
+
+  applyMaterialsToMesh(group, parentColorCode, materialHierarchy, finalMaterialPass = false) {
+    // find any missing materials as indicated by a color code string and replace it with a material from the current material lib
+    const loader = this;
+    const parentIsPassthrough = parentColorCode === MAIN_COLOUR_CODE;
+    group.traverse(c => {
+      if (c.isMesh || c.isLineSegments) {
+        if (Array.isArray(c.material)) {
+          for (let i = 0, l = c.material.length; i < l; i++) {
+            if (!c.material[i].isMaterial) {
+              c.material[i] = getMaterial(c, c.material[i]);
+            }
+          }
+        } else if (!c.material.isMaterial) {
+          c.material = getMaterial(c, c.material);
+        }
+      }
+    }); // Returns the appropriate material for the object (line or face) given color code. If the code is "pass through"
+    // (24 for lines, 16 for edges) then the pass through color code is used. If that is also pass through then it's
+    // simply returned for the subsequent material application.
+
+    function getMaterial(c, colorCode) {
+      // if our parent is a passthrough color code and we don't have the current material color available then
+      // return early.
+      if (parentIsPassthrough && !(colorCode in materialHierarchy) && !finalMaterialPass) {
+        return colorCode;
       }
-    });
-    model.userData.numConstructionSteps = stepNumber + 1;
-  }
 
-  processObject(text, onProcessed, subobject, url) {
-    const scope = this;
-    const parseScope = scope.newParseScopeLevel();
-    parseScope.url = url;
-    const parentParseScope = scope.getParentParseScope(); // Set current matrix
+      const forEdge = c.isLineSegments || c.isConditionalLine;
+      const isPassthrough = !forEdge && colorCode === MAIN_COLOUR_CODE || forEdge && colorCode === MAIN_EDGE_COLOUR_CODE;
 
-    if (subobject) {
-      parseScope.currentMatrix.multiplyMatrices(parentParseScope.currentMatrix, subobject.matrix);
-      parseScope.matrix.copy(subobject.matrix);
-      parseScope.inverted = subobject.inverted;
-      parseScope.startingConstructionStep = subobject.startingConstructionStep;
-    } // Add to cache
+      if (isPassthrough) {
+        colorCode = parentColorCode;
+      }
 
+      let material = null;
 
-    let currentFileName = parentParseScope.currentFileName;
+      if (colorCode in materialHierarchy) {
+        material = materialHierarchy[colorCode];
+      } else if (finalMaterialPass) {
+        // see if we can get the final material from from the "getMaterial" function which will attempt to
+        // parse the "direct" colors
+        material = loader.getMaterial(colorCode);
 
-    if (currentFileName !== null) {
-      currentFileName = parentParseScope.currentFileName.toLowerCase();
-    }
+        if (material === null) {
+          // otherwise throw an error if this is final opportunity to set the material
+          throw new Error(`LDrawLoader: Material properties for code ${colorCode} not available.`);
+        }
+      } else {
+        return colorCode;
+      }
 
-    if (scope.subobjectCache[currentFileName] === undefined) {
-      scope.subobjectCache[currentFileName] = text;
-    } // Parse the object (returns a Group)
+      if (c.isLineSegments) {
+        material = material.userData.edgeMaterial;
 
+        if (c.isConditionalLine) {
+          material = material.userData.conditionalEdgeMaterial;
+        }
+      }
 
-    scope.objectParse(text);
-    let finishedCount = 0;
-    onSubobjectFinish();
+      return material;
+    }
+  }
 
-    function onSubobjectFinish() {
-      finishedCount++;
+  getMainMaterial() {
+    return this.getMaterial(MAIN_COLOUR_CODE);
+  }
 
-      if (finishedCount === parseScope.subobjects.length + 1) {
-        finalizeObject();
-      } else {
-        // Once the previous subobject has finished we can start processing the next one in the list.
-        // The subobject processing shares scope in processing so it's important that they be loaded serially
-        // to avoid race conditions.
-        // Promise.resolve is used as an approach to asynchronously schedule a task _before_ this frame ends to
-        // avoid stack overflow exceptions when loading many subobjects from the cache. RequestAnimationFrame
-        // will work but causes the load to happen after the next frame which causes the load to take significantly longer.
-        const subobject = parseScope.subobjects[parseScope.subobjectIndex];
-        Promise.resolve().then(function () {
-          loadSubobject(subobject);
-        });
-        parseScope.subobjectIndex++;
-      }
-    }
+  getMainEdgeMaterial() {
+    return this.getMaterial(MAIN_EDGE_COLOUR_CODE);
+  }
 
-    function finalizeObject() {
-      if (scope.smoothNormals && parseScope.type === 'Part') {
-        smoothNormals(parseScope.triangles, parseScope.lineSegments);
-      }
+  parseColorMetaDirective(lineParser) {
+    // Parses a color definition and returns a THREE.Material
+    let code = null; // Triangle and line colors
 
-      const isRoot = !parentParseScope.isFromParse;
+    let color = 0xff00ff;
+    let edgeColor = 0xff00ff; // Transparency
 
-      if (scope.separateObjects && !isPrimitiveType(parseScope.type) || isRoot) {
-        const objGroup = parseScope.groupObject;
+    let alpha = 1;
+    let isTransparent = false; // Self-illumination:
 
-        if (parseScope.triangles.length > 0) {
-          objGroup.add(createObject(parseScope.triangles, 3));
-        }
+    let luminance = 0;
+    let finishType = FINISH_TYPE_DEFAULT;
+    let edgeMaterial = null;
+    const name = lineParser.getToken();
 
-        if (parseScope.lineSegments.length > 0) {
-          objGroup.add(createObject(parseScope.lineSegments, 2));
-        }
+    if (!name) {
+      throw new Error('LDrawLoader: Material name was expected after "!COLOUR tag' + lineParser.getLineNumberString() + '.');
+    } // Parse tag tokens and their parameters
 
-        if (parseScope.conditionalSegments.length > 0) {
-          objGroup.add(createObject(parseScope.conditionalSegments, 2, true));
-        }
 
-        if (parentParseScope.groupObject) {
-          objGroup.name = parseScope.fileName;
-          objGroup.userData.category = parseScope.category;
-          objGroup.userData.keywords = parseScope.keywords;
-          parseScope.matrix.decompose(objGroup.position, objGroup.quaternion, objGroup.scale);
-          parentParseScope.groupObject.add(objGroup);
-        }
-      } else {
-        const separateObjects = scope.separateObjects;
-        const parentLineSegments = parentParseScope.lineSegments;
-        const parentConditionalSegments = parentParseScope.conditionalSegments;
-        const parentTriangles = parentParseScope.triangles;
-        const lineSegments = parseScope.lineSegments;
-        const conditionalSegments = parseScope.conditionalSegments;
-        const triangles = parseScope.triangles;
+    let token = null;
 
-        for (let i = 0, l = lineSegments.length; i < l; i++) {
-          const ls = lineSegments[i];
+    while (true) {
+      token = lineParser.getToken();
 
-          if (separateObjects) {
-            ls.v0.applyMatrix4(parseScope.matrix);
-            ls.v1.applyMatrix4(parseScope.matrix);
-          }
+      if (!token) {
+        break;
+      }
 
-          parentLineSegments.push(ls);
-        }
+      switch (token.toUpperCase()) {
+        case 'CODE':
+          code = lineParser.getToken();
+          break;
 
-        for (let i = 0, l = conditionalSegments.length; i < l; i++) {
-          const os = conditionalSegments[i];
+        case 'VALUE':
+          color = lineParser.getToken();
 
-          if (separateObjects) {
-            os.v0.applyMatrix4(parseScope.matrix);
-            os.v1.applyMatrix4(parseScope.matrix);
-            os.c0.applyMatrix4(parseScope.matrix);
-            os.c1.applyMatrix4(parseScope.matrix);
+          if (color.startsWith('0x')) {
+            color = '#' + color.substring(2);
+          } else if (!color.startsWith('#')) {
+            throw new Error('LDrawLoader: Invalid color while parsing material' + lineParser.getLineNumberString() + '.');
           }
 
-          parentConditionalSegments.push(os);
-        }
+          break;
 
-        for (let i = 0, l = triangles.length; i < l; i++) {
-          const tri = triangles[i];
+        case 'EDGE':
+          edgeColor = lineParser.getToken();
 
-          if (separateObjects) {
-            tri.v0 = tri.v0.clone().applyMatrix4(parseScope.matrix);
-            tri.v1 = tri.v1.clone().applyMatrix4(parseScope.matrix);
-            tri.v2 = tri.v2.clone().applyMatrix4(parseScope.matrix);
+          if (edgeColor.startsWith('0x')) {
+            edgeColor = '#' + edgeColor.substring(2);
+          } else if (!edgeColor.startsWith('#')) {
+            // Try to see if edge color is a color code
+            edgeMaterial = this.getMaterial(edgeColor);
 
-            _tempVec0.subVectors(tri.v1, tri.v0);
+            if (!edgeMaterial) {
+              throw new Error('LDrawLoader: Invalid edge color while parsing material' + lineParser.getLineNumberString() + '.');
+            } // Get the edge material for this triangle material
 
-            _tempVec1.subVectors(tri.v2, tri.v1);
 
-            tri.faceNormal.crossVectors(_tempVec0, _tempVec1).normalize();
+            edgeMaterial = edgeMaterial.userData.edgeMaterial;
           }
 
-          parentTriangles.push(tri);
-        }
-      }
-
-      scope.removeScopeLevel(); // If it is root object, compute construction steps
+          break;
 
-      if (!parentParseScope.isFromParse) {
-        scope.computeConstructionSteps(parseScope.groupObject);
-      }
+        case 'ALPHA':
+          alpha = parseInt(lineParser.getToken());
 
-      if (onProcessed) {
-        onProcessed(parseScope.groupObject);
-      }
-    }
+          if (isNaN(alpha)) {
+            throw new Error('LDrawLoader: Invalid alpha value in material definition' + lineParser.getLineNumberString() + '.');
+          }
 
-    function loadSubobject(subobject) {
-      parseScope.mainColourCode = subobject.material.userData.code;
-      parseScope.mainEdgeColourCode = subobject.material.userData.edgeMaterial.userData.code;
-      parseScope.currentFileName = subobject.originalFileName; // If subobject was cached previously, use the cached one
+          alpha = Math.max(0, Math.min(1, alpha / 255));
 
-      const cached = scope.subobjectCache[subobject.originalFileName.toLowerCase()];
+          if (alpha < 1) {
+            isTransparent = true;
+          }
 
-      if (cached) {
-        scope.processObject(cached, function (subobjectGroup) {
-          onSubobjectLoaded(subobjectGroup, subobject);
-          onSubobjectFinish();
-        }, subobject, url);
-        return;
-      } // Adjust file name to locate the subobject file path in standard locations (always under directory scope.path)
-      // Update also subobject.locationState for the next try if this load fails.
+          break;
 
+        case 'LUMINANCE':
+          luminance = parseInt(lineParser.getToken());
 
-      let subobjectURL = subobject.fileName;
-      let newLocationState = FILE_LOCATION_NOT_FOUND;
+          if (isNaN(luminance)) {
+            throw new Error('LDrawLoader: Invalid luminance value in material definition' + LineParser.getLineNumberString() + '.');
+          }
 
-      switch (subobject.locationState) {
-        case FILE_LOCATION_AS_IS:
-          newLocationState = subobject.locationState + 1;
+          luminance = Math.max(0, Math.min(1, luminance / 255));
           break;
 
-        case FILE_LOCATION_TRY_PARTS:
-          subobjectURL = 'parts/' + subobjectURL;
-          newLocationState = subobject.locationState + 1;
+        case 'CHROME':
+          finishType = FINISH_TYPE_CHROME;
           break;
 
-        case FILE_LOCATION_TRY_P:
-          subobjectURL = 'p/' + subobjectURL;
-          newLocationState = subobject.locationState + 1;
+        case 'PEARLESCENT':
+          finishType = FINISH_TYPE_PEARLESCENT;
           break;
 
-        case FILE_LOCATION_TRY_MODELS:
-          subobjectURL = 'models/' + subobjectURL;
-          newLocationState = subobject.locationState + 1;
+        case 'RUBBER':
+          finishType = FINISH_TYPE_RUBBER;
           break;
 
-        case FILE_LOCATION_TRY_RELATIVE:
-          subobjectURL = url.substring(0, url.lastIndexOf('/') + 1) + subobjectURL;
-          newLocationState = subobject.locationState + 1;
+        case 'MATTE_METALLIC':
+          finishType = FINISH_TYPE_MATTE_METALLIC;
           break;
 
-        case FILE_LOCATION_TRY_ABSOLUTE:
-          if (subobject.triedLowerCase) {
-            // Try absolute path
-            newLocationState = FILE_LOCATION_NOT_FOUND;
-          } else {
-            // Next attempt is lower case
-            subobject.fileName = subobject.fileName.toLowerCase();
-            subobjectURL = subobject.fileName;
-            subobject.triedLowerCase = true;
-            newLocationState = FILE_LOCATION_AS_IS;
-          }
+        case 'METAL':
+          finishType = FINISH_TYPE_METAL;
+          break;
 
+        case 'MATERIAL':
+          // Not implemented
+          lineParser.setToEnd();
           break;
 
-        case FILE_LOCATION_NOT_FOUND:
-          // All location possibilities have been tried, give up loading this object
-          console.warn('LDrawLoader: Subobject "' + subobject.originalFileName + '" could not be found.');
-          return;
+        default:
+          throw new Error('LDrawLoader: Unknown token "' + token + '" while parsing material' + lineParser.getLineNumberString() + '.');
       }
+    }
+
+    let material = null;
+
+    switch (finishType) {
+      case FINISH_TYPE_DEFAULT:
+        material = new MeshStandardMaterial({
+          color: color,
+          roughness: 0.3,
+          metalness: 0
+        });
+        break;
+
+      case FINISH_TYPE_PEARLESCENT:
+        // Try to imitate pearlescency by making the surface glossy
+        material = new MeshStandardMaterial({
+          color: color,
+          roughness: 0.3,
+          metalness: 0.25
+        });
+        break;
+
+      case FINISH_TYPE_CHROME:
+        // 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;
+
+      case FINISH_TYPE_MATTE_METALLIC:
+        // Brushed metal finish
+        material = new MeshStandardMaterial({
+          color: color,
+          roughness: 0.8,
+          metalness: 0.4
+        });
+        break;
 
-      subobject.locationState = newLocationState;
-      subobject.url = subobjectURL; // Load the subobject
-      // Use another file loader here so we can keep track of the subobject information
-      // and use it when processing the next model.
-
-      const fileLoader = new FileLoader(scope.manager);
-      fileLoader.setPath(scope.path);
-      fileLoader.setRequestHeader(scope.requestHeader);
-      fileLoader.setWithCredentials(scope.withCredentials);
-      fileLoader.load(subobjectURL, function (text) {
-        scope.processObject(text, function (subobjectGroup) {
-          onSubobjectLoaded(subobjectGroup, subobject);
-          onSubobjectFinish();
-        }, subobject, url);
-      }, undefined, function (err) {
-        onSubobjectError(err, subobject);
-      }, subobject);
+      case FINISH_TYPE_METAL:
+        // Average metal finish
+        material = new MeshStandardMaterial({
+          color: color,
+          roughness: 0.2,
+          metalness: 0.85
+        });
+        break;
     }
 
-    function onSubobjectLoaded(subobjectGroup, subobject) {
-      if (subobjectGroup === null) {
-        // Try to reload
-        loadSubobject(subobject);
-        return;
-      }
+    material.transparent = isTransparent;
+    material.premultipliedAlpha = true;
+    material.opacity = alpha;
+    material.depthWrite = !isTransparent;
+    material.polygonOffset = true;
+    material.polygonOffsetFactor = 1;
 
-      scope.fileMap[subobject.originalFileName] = subobject.url;
+    if (luminance !== 0) {
+      material.emissive.set(material.color).multiplyScalar(luminance);
     }
 
-    function onSubobjectError(err, subobject) {
-      // Retry download from a different default possible location
-      loadSubobject(subobject);
+    if (!edgeMaterial) {
+      // 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
+      });
     }
+
+    material.userData.code = code;
+    material.name = name;
+    material.userData.edgeMaterial = edgeMaterial;
+    this.addMaterial(material);
+    return material;
+  }
+
+  computeConstructionSteps(model) {
+    // Sets userdata.constructionStep number in Group objects and userData.numConstructionSteps number in the root Group object.
+    let stepNumber = 0;
+    model.traverse(c => {
+      if (c.isGroup) {
+        if (c.userData.startingConstructionStep) {
+          stepNumber++;
+        }
+
+        c.userData.constructionStep = stepNumber;
+      }
+    });
+    model.userData.numConstructionSteps = stepNumber + 1;
   }
 
 }