opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/loaders/LDrawLoader.js

@@ -0,0 +1,1737 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three);
+    global.LDrawLoader = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.LDrawLoader = void 0;
+
+  function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+  function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  // Special surface finish tag types.
+  // Note: "MATERIAL" tag (e.g. GLITTER, SPECKLE) is not implemented
+  var FINISH_TYPE_DEFAULT = 0;
+  var FINISH_TYPE_CHROME = 1;
+  var FINISH_TYPE_PEARLESCENT = 2;
+  var FINISH_TYPE_RUBBER = 3;
+  var FINISH_TYPE_MATTE_METALLIC = 4;
+  var FINISH_TYPE_METAL = 5; // State machine to search a subobject path.
+  // The LDraw standard establishes these various possible subfolders.
+
+  var FILE_LOCATION_AS_IS = 0;
+  var FILE_LOCATION_TRY_PARTS = 1;
+  var FILE_LOCATION_TRY_P = 2;
+  var FILE_LOCATION_TRY_MODELS = 3;
+  var FILE_LOCATION_TRY_RELATIVE = 4;
+  var FILE_LOCATION_TRY_ABSOLUTE = 5;
+  var FILE_LOCATION_NOT_FOUND = 6;
+
+  var _tempVec0 = new _three.Vector3();
+
+  var _tempVec1 = new _three.Vector3();
+
+  var LDrawConditionalLineMaterial = /*#__PURE__*/function (_ShaderMaterial) {
+    _inherits(LDrawConditionalLineMaterial, _ShaderMaterial);
+
+    var _super = _createSuper(LDrawConditionalLineMaterial);
+
+    function LDrawConditionalLineMaterial(parameters) {
+      var _this;
+
+      _classCallCheck(this, LDrawConditionalLineMaterial);
+
+      _this = _super.call(this, {
+        uniforms: _three.UniformsUtils.merge([_three.UniformsLib.fog, {
+          diffuse: {
+            value: new _three.Color()
+          },
+          opacity: {
+            value: 1.0
+          }
+        }]),
+        vertexShader:
+        /* glsl */
+        "\n\t\t\t\tattribute vec3 control0;\n\t\t\t\tattribute vec3 control1;\n\t\t\t\tattribute vec3 direction;\n\t\t\t\tvarying float discardFlag;\n\n\t\t\t\t#include <common>\n\t\t\t\t#include <color_pars_vertex>\n\t\t\t\t#include <fog_pars_vertex>\n\t\t\t\t#include <logdepthbuf_pars_vertex>\n\t\t\t\t#include <clipping_planes_pars_vertex>\n\t\t\t\tvoid main() {\n\t\t\t\t\t#include <color_vertex>\n\n\t\t\t\t\tvec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );\n\t\t\t\t\tgl_Position = projectionMatrix * mvPosition;\n\n\t\t\t\t\t// Transform the line segment ends and control points into camera clip space\n\t\t\t\t\tvec4 c0 = projectionMatrix * modelViewMatrix * vec4( control0, 1.0 );\n\t\t\t\t\tvec4 c1 = projectionMatrix * modelViewMatrix * vec4( control1, 1.0 );\n\t\t\t\t\tvec4 p0 = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n\t\t\t\t\tvec4 p1 = projectionMatrix * modelViewMatrix * vec4( position + direction, 1.0 );\n\n\t\t\t\t\tc0.xy /= c0.w;\n\t\t\t\t\tc1.xy /= c1.w;\n\t\t\t\t\tp0.xy /= p0.w;\n\t\t\t\t\tp1.xy /= p1.w;\n\n\t\t\t\t\t// Get the direction of the segment and an orthogonal vector\n\t\t\t\t\tvec2 dir = p1.xy - p0.xy;\n\t\t\t\t\tvec2 norm = vec2( -dir.y, dir.x );\n\n\t\t\t\t\t// Get control point directions from the line\n\t\t\t\t\tvec2 c0dir = c0.xy - p1.xy;\n\t\t\t\t\tvec2 c1dir = c1.xy - p1.xy;\n\n\t\t\t\t\t// If the vectors to the controls points are pointed in different directions away\n\t\t\t\t\t// from the line segment then the line should not be drawn.\n\t\t\t\t\tfloat d0 = dot( normalize( norm ), normalize( c0dir ) );\n\t\t\t\t\tfloat d1 = dot( normalize( norm ), normalize( c1dir ) );\n\t\t\t\t\tdiscardFlag = float( sign( d0 ) != sign( d1 ) );\n\n\t\t\t\t\t#include <logdepthbuf_vertex>\n\t\t\t\t\t#include <clipping_planes_vertex>\n\t\t\t\t\t#include <fog_vertex>\n\t\t\t\t}\n\t\t\t",
+        fragmentShader:
+        /* glsl */
+        "\n\t\t\tuniform vec3 diffuse;\n\t\t\tuniform float opacity;\n\t\t\tvarying float discardFlag;\n\n\t\t\t#include <common>\n\t\t\t#include <color_pars_fragment>\n\t\t\t#include <fog_pars_fragment>\n\t\t\t#include <logdepthbuf_pars_fragment>\n\t\t\t#include <clipping_planes_pars_fragment>\n\t\t\tvoid main() {\n\n\t\t\t\tif ( discardFlag > 0.5 ) discard;\n\n\t\t\t\t#include <clipping_planes_fragment>\n\t\t\t\tvec3 outgoingLight = vec3( 0.0 );\n\t\t\t\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t\t\t\t#include <logdepthbuf_fragment>\n\t\t\t\t#include <color_fragment>\n\t\t\t\toutgoingLight = diffuseColor.rgb; // simple shader\n\t\t\t\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t\t\t\t#include <tonemapping_fragment>\n\t\t\t\t#include <encodings_fragment>\n\t\t\t\t#include <fog_fragment>\n\t\t\t\t#include <premultiplied_alpha_fragment>\n\t\t\t}\n\t\t\t"
+      });
+      Object.defineProperties(_assertThisInitialized(_this), {
+        opacity: {
+          get: function get() {
+            return this.uniforms.opacity.value;
+          },
+          set: function set(value) {
+            this.uniforms.opacity.value = value;
+          }
+        },
+        color: {
+          get: function get() {
+            return this.uniforms.diffuse.value;
+          }
+        }
+      });
+
+      _this.setValues(parameters);
+
+      _this.isLDrawConditionalLineMaterial = true;
+      return _this;
+    }
+
+    return _createClass(LDrawConditionalLineMaterial);
+  }(_three.ShaderMaterial);
+
+  function smoothNormals(faces, lineSegments) {
+    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.
+      var x = ~~(v.x * 1e2);
+      var y = ~~(v.y * 1e2);
+      var z = ~~(v.z * 1e2);
+      return "".concat(x, ",").concat(y, ",").concat(z);
+    }
+
+    function hashEdge(v0, v1) {
+      return "".concat(hashVertex(v0), "_").concat(hashVertex(v1));
+    }
+
+    var hardEdges = new Set();
+    var halfEdgeList = {};
+    var normals = []; // Save the list of hard edges by hash
+
+    for (var i = 0, l = lineSegments.length; i < l; i++) {
+      var ls = lineSegments[i];
+      var vertices = ls.vertices;
+      var v0 = vertices[0];
+      var v1 = vertices[1];
+      hardEdges.add(hashEdge(v0, v1));
+      hardEdges.add(hashEdge(v1, v0));
+    } // track the half edges associated with each triangle
+
+
+    for (var _i = 0, _l = faces.length; _i < _l; _i++) {
+      var tri = faces[_i];
+      var _vertices = tri.vertices;
+      var vertCount = _vertices.length;
+
+      for (var i2 = 0; i2 < vertCount; i2++) {
+        var index = i2;
+        var next = (i2 + 1) % vertCount;
+        var _v = _vertices[index];
+        var _v2 = _vertices[next];
+        var hash = hashEdge(_v, _v2); // don't add the triangle if the edge is supposed to be hard
+
+        if (hardEdges.has(hash)) continue;
+        var info = {
+          index: index,
+          tri: tri
+        };
+        halfEdgeList[hash] = info;
+      }
+    } // Iterate until we've tried to connect all faces to share normals
+
+
+    while (true) {
+      // Stop if there are no more faces left
+      var halfEdge = null;
+
+      for (var key in halfEdgeList) {
+        halfEdge = halfEdgeList[key];
+        break;
+      }
+
+      if (halfEdge === null) {
+        break;
+      } // Exhaustively find all connected faces
+
+
+      var queue = [halfEdge];
+
+      while (queue.length > 0) {
+        // initialize all vertex normals in this triangle
+        var _tri = queue.pop().tri;
+        var _vertices2 = _tri.vertices;
+        var vertNormals = _tri.normals;
+        var faceNormal = _tri.faceNormal; // Check if any edge is connected to another triangle edge
+
+        var _vertCount = _vertices2.length;
+
+        for (var _i2 = 0; _i2 < _vertCount; _i2++) {
+          var _index = _i2;
+
+          var _next = (_i2 + 1) % _vertCount;
+
+          var _v3 = _vertices2[_index];
+          var _v4 = _vertices2[_next]; // delete this triangle from the list so it won't be found again
+
+          var _hash = hashEdge(_v3, _v4);
+
+          delete halfEdgeList[_hash];
+          var reverseHash = hashEdge(_v4, _v3);
+          var otherInfo = halfEdgeList[reverseHash];
+
+          if (otherInfo) {
+            var otherTri = otherInfo.tri;
+            var otherIndex = otherInfo.index;
+            var otherNormals = otherTri.normals;
+            var otherVertCount = otherNormals.length;
+            var 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
+            // the halfEdgeList. If it has not then add it to the queue and delete
+            // it so it won't be found again.
+
+
+            if (reverseHash in halfEdgeList) {
+              queue.push(otherInfo);
+              delete halfEdgeList[reverseHash];
+            } // share the first normal
+
+
+            var otherNext = (otherIndex + 1) % otherVertCount;
+
+            if (vertNormals[_index] && otherNormals[otherNext] && vertNormals[_index] !== otherNormals[otherNext]) {
+              otherNormals[otherNext].norm.add(vertNormals[_index].norm);
+              vertNormals[_index].norm = otherNormals[otherNext].norm;
+            }
+
+            var sharedNormal1 = vertNormals[_index] || otherNormals[otherNext];
+
+            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 _three.Vector3()
+              };
+              normals.push(sharedNormal1.norm);
+            }
+
+            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;
+            }
+
+            var sharedNormal2 = vertNormals[_next] || otherNormals[otherIndex];
+
+            if (sharedNormal2 === null) {
+              sharedNormal2 = {
+                norm: new _three.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);
+            }
+          }
+        }
+      }
+    } // The normals of each face have been added up so now we average them by normalizing the vector.
+
+
+    for (var _i3 = 0, _l2 = normals.length; _i3 < _l2; _i3++) {
+      normals[_i3].normalize();
+    }
+  }
+
+  function isPartType(type) {
+    return type === 'Part';
+  }
+
+  function isModelType(type) {
+    return type === 'Model' || type === 'Unofficial_Model';
+  }
+
+  function isPrimitiveType(type) {
+    return /primitive/i.test(type) || type === 'Subpart';
+  }
+
+  var LineParser = /*#__PURE__*/function () {
+    function LineParser(line, lineNumber) {
+      _classCallCheck(this, LineParser);
+
+      this.line = line;
+      this.lineLength = line.length;
+      this.currentCharIndex = 0;
+      this.currentChar = ' ';
+      this.lineNumber = lineNumber;
+    }
+
+    _createClass(LineParser, [{
+      key: "seekNonSpace",
+      value: function seekNonSpace() {
+        while (this.currentCharIndex < this.lineLength) {
+          this.currentChar = this.line.charAt(this.currentCharIndex);
+
+          if (this.currentChar !== ' ' && this.currentChar !== '\t') {
+            return;
+          }
+
+          this.currentCharIndex++;
+        }
+      }
+    }, {
+      key: "getToken",
+      value: function getToken() {
+        var pos0 = this.currentCharIndex++; // Seek space
+
+        while (this.currentCharIndex < this.lineLength) {
+          this.currentChar = this.line.charAt(this.currentCharIndex);
+
+          if (this.currentChar === ' ' || this.currentChar === '\t') {
+            break;
+          }
+
+          this.currentCharIndex++;
+        }
+
+        var pos1 = this.currentCharIndex;
+        this.seekNonSpace();
+        return this.line.substring(pos0, pos1);
+      }
+    }, {
+      key: "getRemainingString",
+      value: function getRemainingString() {
+        return this.line.substring(this.currentCharIndex, this.lineLength);
+      }
+    }, {
+      key: "isAtTheEnd",
+      value: function isAtTheEnd() {
+        return this.currentCharIndex >= this.lineLength;
+      }
+    }, {
+      key: "setToEnd",
+      value: function setToEnd() {
+        this.currentCharIndex = this.lineLength;
+      }
+    }, {
+      key: "getLineNumberString",
+      value: function getLineNumberString() {
+        return this.lineNumber >= 0 ? ' at line ' + this.lineNumber : '';
+      }
+    }]);
+
+    return LineParser;
+  }();
+
+  var LDrawFileCache = /*#__PURE__*/function () {
+    function LDrawFileCache(loader) {
+      _classCallCheck(this, LDrawFileCache);
+
+      this.cache = {};
+      this.loader = loader;
+    }
+
+    _createClass(LDrawFileCache, [{
+      key: "setData",
+      value: function setData(key, contents) {
+        this.cache[key.toLowerCase()] = contents;
+      }
+    }, {
+      key: "loadData",
+      value: function () {
+        var _loadData = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(fileName) {
+          var _this2 = this;
+
+          var key;
+          return regeneratorRuntime.wrap(function _callee2$(_context2) {
+            while (1) {
+              switch (_context2.prev = _context2.next) {
+                case 0:
+                  key = fileName.toLowerCase();
+
+                  if (!(key in this.cache)) {
+                    _context2.next = 3;
+                    break;
+                  }
+
+                  return _context2.abrupt("return", this.cache[key]);
+
+                case 3:
+                  this.cache[fileName] = new Promise( /*#__PURE__*/function () {
+                    var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(resolve, reject) {
+                      var triedLowerCase, locationState, subobjectURL, loader, fileLoader, text;
+                      return regeneratorRuntime.wrap(function _callee$(_context) {
+                        while (1) {
+                          switch (_context.prev = _context.next) {
+                            case 0:
+                              triedLowerCase = false;
+                              locationState = FILE_LOCATION_AS_IS;
+
+                            case 2:
+                              if (!(locationState !== FILE_LOCATION_NOT_FOUND)) {
+                                _context.next = 42;
+                                break;
+                              }
+
+                              subobjectURL = fileName;
+                              _context.t0 = locationState;
+                              _context.next = _context.t0 === FILE_LOCATION_AS_IS ? 7 : _context.t0 === FILE_LOCATION_TRY_PARTS ? 9 : _context.t0 === FILE_LOCATION_TRY_P ? 12 : _context.t0 === FILE_LOCATION_TRY_MODELS ? 15 : _context.t0 === FILE_LOCATION_TRY_RELATIVE ? 18 : _context.t0 === FILE_LOCATION_TRY_ABSOLUTE ? 21 : 23;
+                              break;
+
+                            case 7:
+                              locationState = locationState + 1;
+                              return _context.abrupt("break", 23);
+
+                            case 9:
+                              subobjectURL = 'parts/' + subobjectURL;
+                              locationState = locationState + 1;
+                              return _context.abrupt("break", 23);
+
+                            case 12:
+                              subobjectURL = 'p/' + subobjectURL;
+                              locationState = locationState + 1;
+                              return _context.abrupt("break", 23);
+
+                            case 15:
+                              subobjectURL = 'models/' + subobjectURL;
+                              locationState = locationState + 1;
+                              return _context.abrupt("break", 23);
+
+                            case 18:
+                              subobjectURL = fileName.substring(0, fileName.lastIndexOf('/') + 1) + subobjectURL;
+                              locationState = locationState + 1;
+                              return _context.abrupt("break", 23);
+
+                            case 21:
+                              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;
+                              }
+
+                              return _context.abrupt("break", 23);
+
+                            case 23:
+                              loader = _this2.loader;
+                              fileLoader = new _three.FileLoader(loader.manager);
+                              fileLoader.setPath(loader.partsLibraryPath);
+                              fileLoader.setRequestHeader(loader.requestHeader);
+                              fileLoader.setWithCredentials(loader.withCredentials);
+                              _context.prev = 28;
+                              _context.next = 31;
+                              return fileLoader.loadAsync(subobjectURL);
+
+                            case 31:
+                              text = _context.sent;
+
+                              _this2.setData(fileName, text);
+
+                              resolve(text);
+                              return _context.abrupt("return");
+
+                            case 37:
+                              _context.prev = 37;
+                              _context.t1 = _context["catch"](28);
+                              return _context.abrupt("continue", 2);
+
+                            case 40:
+                              _context.next = 2;
+                              break;
+
+                            case 42:
+                              reject();
+
+                            case 43:
+                            case "end":
+                              return _context.stop();
+                          }
+                        }
+                      }, _callee, null, [[28, 37]]);
+                    }));
+
+                    return function (_x2, _x3) {
+                      return _ref.apply(this, arguments);
+                    };
+                  }());
+                  return _context2.abrupt("return", this.cache[fileName]);
+
+                case 5:
+                case "end":
+                  return _context2.stop();
+              }
+            }
+          }, _callee2, this);
+        }));
+
+        function loadData(_x) {
+          return _loadData.apply(this, arguments);
+        }
+
+        return loadData;
+      }()
+    }]);
+
+    return LDrawFileCache;
+  }();
+
+  function sortByMaterial(a, b) {
+    if (a.colourCode === b.colourCode) {
+      return 0;
+    }
+
+    if (a.colourCode < b.colourCode) {
+      return -1;
+    }
+
+    return 1;
+  }
+
+  function createObject(elements, elementSize) {
+    var isConditionalSegments = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    var totalElements = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 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 colour code to make later the mesh groups
+    elements.sort(sortByMaterial);
+
+    if (totalElements === null) {
+      totalElements = elements.length;
+    }
+
+    var positions = new Float32Array(elementSize * totalElements * 3);
+    var normals = elementSize === 3 ? new Float32Array(elementSize * totalElements * 3) : null;
+    var materials = [];
+    var quadArray = new Array(6);
+    var bufferGeometry = new _three.BufferGeometry();
+    var prevMaterial = null;
+    var index0 = 0;
+    var numGroupVerts = 0;
+    var offset = 0;
+
+    for (var iElem = 0, nElem = elements.length; iElem < nElem; iElem++) {
+      var elem = elements[iElem];
+      var 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;
+      }
+
+      for (var j = 0, l = vertices.length; j < l; j++) {
+        var v = vertices[j];
+        var index = offset + j * 3;
+        positions[index + 0] = v.x;
+        positions[index + 1] = v.y;
+        positions[index + 2] = v.z;
+      }
+
+      if (elementSize === 3) {
+        var elemNormals = elem.normals;
+
+        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;
+        }
+
+        for (var _j = 0, _l3 = elemNormals.length; _j < _l3; _j++) {
+          var n = elem.faceNormal;
+
+          if (elemNormals[_j]) {
+            n = elemNormals[_j].norm;
+          }
+
+          var _index2 = offset + _j * 3;
+
+          normals[_index2 + 0] = n.x;
+          normals[_index2 + 1] = n.y;
+          normals[_index2 + 2] = n.z;
+        }
+      }
+
+      if (prevMaterial !== elem.material) {
+        if (prevMaterial !== null) {
+          bufferGeometry.addGroup(index0, numGroupVerts, materials.length - 1);
+        }
+
+        materials.push(elem.material);
+        prevMaterial = elem.material;
+        index0 = offset / 3;
+        numGroupVerts = vertices.length;
+      } else {
+        numGroupVerts += vertices.length;
+      }
+
+      offset += 3 * vertices.length;
+    }
+
+    if (numGroupVerts > 0) {
+      bufferGeometry.addGroup(index0, Infinity, materials.length - 1);
+    }
+
+    bufferGeometry.setAttribute('position', new _three.BufferAttribute(positions, 3));
+
+    if (normals !== null) {
+      bufferGeometry.setAttribute('normal', new _three.BufferAttribute(normals, 3));
+    }
+
+    var object3d = null;
+
+    if (elementSize === 2) {
+      object3d = new _three.LineSegments(bufferGeometry, materials.length === 1 ? materials[0] : materials);
+    } else if (elementSize === 3) {
+      object3d = new _three.Mesh(bufferGeometry, materials.length === 1 ? materials[0] : materials);
+    }
+
+    if (isConditionalSegments) {
+      object3d.isConditionalLine = true;
+      var controlArray0 = new Float32Array(elements.length * 3 * 2);
+      var controlArray1 = new Float32Array(elements.length * 3 * 2);
+      var directionArray = new Float32Array(elements.length * 3 * 2);
+
+      for (var i = 0, _l4 = elements.length; i < _l4; i++) {
+        var os = elements[i];
+        var _vertices3 = os.vertices;
+        var controlPoints = os.controlPoints;
+        var c0 = controlPoints[0];
+        var c1 = controlPoints[1];
+        var v0 = _vertices3[0];
+        var v1 = _vertices3[1];
+
+        var _index3 = i * 3 * 2;
+
+        controlArray0[_index3 + 0] = c0.x;
+        controlArray0[_index3 + 1] = c0.y;
+        controlArray0[_index3 + 2] = c0.z;
+        controlArray0[_index3 + 3] = c0.x;
+        controlArray0[_index3 + 4] = c0.y;
+        controlArray0[_index3 + 5] = c0.z;
+        controlArray1[_index3 + 0] = c1.x;
+        controlArray1[_index3 + 1] = c1.y;
+        controlArray1[_index3 + 2] = c1.z;
+        controlArray1[_index3 + 3] = c1.x;
+        controlArray1[_index3 + 4] = c1.y;
+        controlArray1[_index3 + 5] = c1.z;
+        directionArray[_index3 + 0] = v1.x - v0.x;
+        directionArray[_index3 + 1] = v1.y - v0.y;
+        directionArray[_index3 + 2] = v1.z - v0.z;
+        directionArray[_index3 + 3] = v1.x - v0.x;
+        directionArray[_index3 + 4] = v1.y - v0.y;
+        directionArray[_index3 + 5] = v1.z - v0.z;
+      }
+
+      bufferGeometry.setAttribute('control0', new _three.BufferAttribute(controlArray0, 3, false));
+      bufferGeometry.setAttribute('control1', new _three.BufferAttribute(controlArray1, 3, false));
+      bufferGeometry.setAttribute('direction', new _three.BufferAttribute(directionArray, 3, false));
+    }
+
+    return object3d;
+  } //
+
+
+  var LDrawLoader = /*#__PURE__*/function (_Loader) {
+    _inherits(LDrawLoader, _Loader);
+
+    var _super2 = _createSuper(LDrawLoader);
+
+    function LDrawLoader(manager) {
+      var _this3;
+
+      _classCallCheck(this, LDrawLoader);
+
+      _this3 = _super2.call(this, manager); // Array of THREE.Material
+
+      _this3.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)
+
+      _this3.cache = new LDrawFileCache(_assertThisInitialized(_this3)); // 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.
+
+      _this3.fileMap = null;
+      _this3.rootParseScope = _this3.newParseScopeLevel(); // Add default main triangle and line edge materials (used in pieces that can be coloured with a main color)
+
+      _this3.setMaterials([_this3.parseColourMetaDirective(new LineParser('Main_Colour CODE 16 VALUE #FF8080 EDGE #333333')), _this3.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.
+
+
+      _this3.separateObjects = false; // If this flag is set to true the vertex normals will be smoothed.
+
+      _this3.smoothNormals = true; // The path to load parts from the LDraw parts library from.
+
+      _this3.partsLibraryPath = '';
+      return _this3;
+    }
+
+    _createClass(LDrawLoader, [{
+      key: "setPartsLibraryPath",
+      value: function setPartsLibraryPath(path) {
+        this.partsLibraryPath = path;
+        return this;
+      }
+    }, {
+      key: "preloadMaterials",
+      value: function () {
+        var _preloadMaterials = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee3(url) {
+          var fileLoader, text, colorLineRegex, lines, materials, i, l, line, directive, material;
+          return regeneratorRuntime.wrap(function _callee3$(_context3) {
+            while (1) {
+              switch (_context3.prev = _context3.next) {
+                case 0:
+                  fileLoader = new _three.FileLoader(this.manager);
+                  fileLoader.setPath(this.path);
+                  fileLoader.setRequestHeader(this.requestHeader);
+                  fileLoader.setWithCredentials(this.withCredentials);
+                  _context3.next = 6;
+                  return fileLoader.loadAsync(url);
+
+                case 6:
+                  text = _context3.sent;
+                  colorLineRegex = /^0 !COLOUR/;
+                  lines = text.split(/[\n\r]/g);
+                  materials = [];
+
+                  for (i = 0, l = lines.length; i < l; i++) {
+                    line = lines[i];
+
+                    if (colorLineRegex.test(line)) {
+                      directive = line.replace(colorLineRegex, '');
+                      material = this.parseColourMetaDirective(new LineParser(directive));
+                      materials.push(material);
+                    }
+                  }
+
+                  this.setMaterials(materials);
+
+                case 12:
+                case "end":
+                  return _context3.stop();
+              }
+            }
+          }, _callee3, this);
+        }));
+
+        function preloadMaterials(_x4) {
+          return _preloadMaterials.apply(this, arguments);
+        }
+
+        return preloadMaterials;
+      }()
+    }, {
+      key: "load",
+      value: function load(url, onLoad, onProgress, onError) {
+        var _this4 = this;
+
+        if (!this.fileMap) {
+          this.fileMap = {};
+        }
+
+        var fileLoader = new _three.FileLoader(this.manager);
+        fileLoader.setPath(this.path);
+        fileLoader.setRequestHeader(this.requestHeader);
+        fileLoader.setWithCredentials(this.withCredentials);
+        fileLoader.load(url, function (text) {
+          _this4.processObject(text, null, url, _this4.rootParseScope).then(function (result) {
+            onLoad(result.groupObject);
+          });
+        }, onProgress, onError);
+      }
+    }, {
+      key: "parse",
+      value: function parse(text, path, onLoad) {
+        // Async parse.  This function calls onParse with the parsed THREE.Object3D as parameter
+        this.processObject(text, null, path, this.rootParseScope).then(function (result) {
+          onLoad(result.groupObject);
+        });
+      }
+    }, {
+      key: "setMaterials",
+      value: function setMaterials(materials) {
+        // Clears parse scopes stack, adds new scope with material library
+        this.rootParseScope = this.newParseScopeLevel(materials);
+        this.rootParseScope.isFromParse = false;
+        this.materials = materials;
+        return this;
+      }
+    }, {
+      key: "setFileMap",
+      value: function setFileMap(fileMap) {
+        this.fileMap = fileMap;
+        return this;
+      }
+    }, {
+      key: "newParseScopeLevel",
+      value: function newParseScopeLevel() {
+        var materials = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+        var parentScope = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+        // Adds a new scope level, assign materials to it and returns it
+        var matLib = {};
+
+        if (materials) {
+          for (var i = 0, n = materials.length; i < n; i++) {
+            var material = materials[i];
+            matLib[material.userData.code] = material;
+          }
+        }
+
+        var newParseScope = {
+          parentScope: parentScope,
+          lib: matLib,
+          url: null,
+          // Subobjects
+          subobjects: null,
+          numSubobjects: 0,
+          subobjectIndex: 0,
+          inverted: false,
+          category: null,
+          keywords: null,
+          // Current subobject
+          currentFileName: null,
+          mainColourCode: parentScope ? parentScope.mainColourCode : '16',
+          mainEdgeColourCode: parentScope ? parentScope.mainEdgeColourCode : '24',
+          currentMatrix: new _three.Matrix4(),
+          matrix: new _three.Matrix4(),
+          // If false, it is a root material scope previous to parse
+          isFromParse: true,
+          faces: null,
+          lineSegments: null,
+          conditionalSegments: null,
+          totalFaces: 0,
+          // If true, this object is the start of a construction step
+          startingConstructionStep: false
+        };
+        return newParseScope;
+      }
+    }, {
+      key: "addMaterial",
+      value: function addMaterial(material, parseScope) {
+        // Adds a material to the material library which is on top of the parse scopes stack. And also to the materials array
+        var matLib = parseScope.lib;
+
+        if (!matLib[material.userData.code]) {
+          this.materials.push(material);
+        }
+
+        matLib[material.userData.code] = material;
+        return this;
+      }
+    }, {
+      key: "getMaterial",
+      value: function getMaterial(colourCode) {
+        var parseScope = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.rootParseScope;
+
+        // Given a colour code search its material in the parse scopes stack
+        if (colourCode.startsWith('0x2')) {
+          // Special 'direct' material value (RGB colour)
+          var colour = colourCode.substring(3);
+          return this.parseColourMetaDirective(new LineParser('Direct_Color_' + colour + ' CODE -1 VALUE #' + colour + ' EDGE #' + colour + ''));
+        }
+
+        while (parseScope) {
+          var material = parseScope.lib[colourCode];
+
+          if (material) {
+            return material;
+          } else {
+            parseScope = parseScope.parentScope;
+          }
+        } // Material was not found
+
+
+        return null;
+      }
+    }, {
+      key: "parseColourMetaDirective",
+      value: function parseColourMetaDirective(lineParser) {
+        // Parses a colour definition and returns a THREE.Material
+        var code = null; // Triangle and line colours
+
+        var colour = 0xFF00FF;
+        var edgeColour = 0xFF00FF; // Transparency
+
+        var alpha = 1;
+        var isTransparent = false; // Self-illumination:
+
+        var luminance = 0;
+        var finishType = FINISH_TYPE_DEFAULT;
+        var edgeMaterial = null;
+        var name = lineParser.getToken();
+
+        if (!name) {
+          throw 'LDrawLoader: Material name was expected after "!COLOUR tag' + lineParser.getLineNumberString() + '.';
+        } // Parse tag tokens and their parameters
+
+
+        var token = null;
+
+        while (true) {
+          token = lineParser.getToken();
+
+          if (!token) {
+            break;
+          }
+
+          switch (token.toUpperCase()) {
+            case 'CODE':
+              code = lineParser.getToken();
+              break;
+
+            case 'VALUE':
+              colour = lineParser.getToken();
+
+              if (colour.startsWith('0x')) {
+                colour = '#' + colour.substring(2);
+              } else if (!colour.startsWith('#')) {
+                throw 'LDrawLoader: Invalid colour while parsing material' + lineParser.getLineNumberString() + '.';
+              }
+
+              break;
+
+            case 'EDGE':
+              edgeColour = lineParser.getToken();
+
+              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 (!edgeMaterial) {
+                  throw 'LDrawLoader: Invalid edge colour while parsing material' + lineParser.getLineNumberString() + '.';
+                } // Get the edge material for this triangle material
+
+
+                edgeMaterial = edgeMaterial.userData.edgeMaterial;
+              }
+
+              break;
+
+            case 'ALPHA':
+              alpha = parseInt(lineParser.getToken());
+
+              if (isNaN(alpha)) {
+                throw 'LDrawLoader: Invalid alpha value in material definition' + lineParser.getLineNumberString() + '.';
+              }
+
+              alpha = Math.max(0, Math.min(1, alpha / 255));
+
+              if (alpha < 1) {
+                isTransparent = true;
+              }
+
+              break;
+
+            case 'LUMINANCE':
+              luminance = parseInt(lineParser.getToken());
+
+              if (isNaN(luminance)) {
+                throw 'LDrawLoader: Invalid luminance value in material definition' + LineParser.getLineNumberString() + '.';
+              }
+
+              luminance = Math.max(0, Math.min(1, luminance / 255));
+              break;
+
+            case 'CHROME':
+              finishType = FINISH_TYPE_CHROME;
+              break;
+
+            case 'PEARLESCENT':
+              finishType = FINISH_TYPE_PEARLESCENT;
+              break;
+
+            case 'RUBBER':
+              finishType = FINISH_TYPE_RUBBER;
+              break;
+
+            case 'MATTE_METALLIC':
+              finishType = FINISH_TYPE_MATTE_METALLIC;
+              break;
+
+            case 'METAL':
+              finishType = FINISH_TYPE_METAL;
+              break;
+
+            case 'MATERIAL':
+              // Not implemented
+              lineParser.setToEnd();
+              break;
+
+            default:
+              throw 'LDrawLoader: Unknown token "' + token + '" while parsing material' + lineParser.getLineNumberString() + '.';
+              break;
+          }
+        }
+
+        var material = null;
+
+        switch (finishType) {
+          case FINISH_TYPE_DEFAULT:
+            material = new _three.MeshStandardMaterial({
+              color: colour,
+              roughness: 0.3,
+              metalness: 0
+            });
+            break;
+
+          case FINISH_TYPE_PEARLESCENT:
+            // Try to imitate pearlescency by setting the specular to the complementary of the color, and low shininess
+            var specular = new _three.Color(colour);
+            var 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 _three.MeshPhongMaterial({
+              color: colour,
+              specular: specular,
+              shininess: 10,
+              reflectivity: 0.3
+            });
+            break;
+
+          case FINISH_TYPE_CHROME:
+            // Mirror finish surface
+            material = new _three.MeshStandardMaterial({
+              color: colour,
+              roughness: 0,
+              metalness: 1
+            });
+            break;
+
+          case FINISH_TYPE_RUBBER:
+            // Rubber finish
+            material = new _three.MeshStandardMaterial({
+              color: colour,
+              roughness: 0.9,
+              metalness: 0
+            });
+            break;
+
+          case FINISH_TYPE_MATTE_METALLIC:
+            // Brushed metal finish
+            material = new _three.MeshStandardMaterial({
+              color: colour,
+              roughness: 0.8,
+              metalness: 0.4
+            });
+            break;
+
+          case FINISH_TYPE_METAL:
+            // Average metal finish
+            material = new _three.MeshStandardMaterial({
+              color: colour,
+              roughness: 0.2,
+              metalness: 0.85
+            });
+            break;
+
+          default:
+            // Should not happen
+            break;
+        }
+
+        material.transparent = isTransparent;
+        material.premultipliedAlpha = true;
+        material.opacity = alpha;
+        material.depthWrite = !isTransparent;
+        material.polygonOffset = true;
+        material.polygonOffsetFactor = 1;
+
+        if (luminance !== 0) {
+          material.emissive.set(material.color).multiplyScalar(luminance);
+        }
+
+        if (!edgeMaterial) {
+          // This is the material used for edges
+          edgeMaterial = new _three.LineBasicMaterial({
+            color: edgeColour,
+            transparent: isTransparent,
+            opacity: alpha,
+            depthWrite: !isTransparent
+          });
+          edgeMaterial.userData.code = code;
+          edgeMaterial.name = name + ' - Edge'; // This is the material used for conditional edges
+
+          edgeMaterial.userData.conditionalEdgeMaterial = new LDrawConditionalLineMaterial({
+            fog: true,
+            transparent: isTransparent,
+            depthWrite: !isTransparent,
+            color: edgeColour,
+            opacity: alpha
+          });
+        }
+
+        material.userData.code = code;
+        material.name = name;
+        material.userData.edgeMaterial = edgeMaterial;
+        return material;
+      } //
+
+    }, {
+      key: "objectParse",
+      value: function objectParse(text, parseScope) {
+        // Retrieve data from the parent parse scope
+        var currentParseScope = parseScope;
+        var parentParseScope = currentParseScope.parentScope; // Main colour codes passed to this subobject (or default codes 16 and 24 if it is the root object)
+
+        var mainColourCode = currentParseScope.mainColourCode;
+        var mainEdgeColourCode = currentParseScope.mainEdgeColourCode; // Parse result variables
+
+        var faces;
+        var lineSegments;
+        var conditionalSegments;
+        var subobjects = [];
+        var category = null;
+        var keywords = null;
+
+        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');
+        }
+
+        var lines = text.split('\n');
+        var numLines = lines.length;
+        var parsingEmbeddedFiles = false;
+        var currentEmbeddedFileName = null;
+        var currentEmbeddedText = null;
+        var bfcCertified = false;
+        var bfcCCW = true;
+        var bfcInverted = false;
+        var bfcCull = true;
+        var type = '';
+        var startingConstructionStep = false;
+        var scope = this;
+
+        function parseColourCode(lineParser, forEdge) {
+          // Parses next colour code and returns a THREE.Material
+          var colourCode = lineParser.getToken();
+
+          if (!forEdge && colourCode === '16') {
+            colourCode = mainColourCode;
+          }
+
+          if (forEdge && colourCode === '24') {
+            colourCode = mainEdgeColourCode;
+          }
+
+          var material = scope.getMaterial(colourCode, currentParseScope);
+
+          if (!material) {
+            throw 'LDrawLoader: Unknown colour code "' + colourCode + '" is used' + lineParser.getLineNumberString() + ' but it was not defined previously.';
+          }
+
+          return material;
+        }
+
+        function parseVector(lp) {
+          var v = new _three.Vector3(parseFloat(lp.getToken()), parseFloat(lp.getToken()), parseFloat(lp.getToken()));
+
+          if (!scope.separateObjects) {
+            v.applyMatrix4(currentParseScope.currentMatrix);
+          }
+
+          return v;
+        } // Parse all line commands
+
+
+        for (var lineIndex = 0; lineIndex < numLines; lineIndex++) {
+          var line = lines[lineIndex];
+          if (line.length === 0) continue;
+
+          if (parsingEmbeddedFiles) {
+            if (line.startsWith('0 FILE ')) {
+              // Save previous embedded file in the cache
+              this.cache.setData(currentEmbeddedFileName.toLowerCase(), currentEmbeddedText); // New embedded text file
+
+              currentEmbeddedFileName = line.substring(7);
+              currentEmbeddedText = '';
+            } else {
+              currentEmbeddedText += line + '\n';
+            }
+
+            continue;
+          }
+
+          var lp = new LineParser(line, lineIndex + 1);
+          lp.seekNonSpace();
+
+          if (lp.isAtTheEnd()) {
+            // Empty line
+            continue;
+          } // Parse the line type
+
+
+          var lineType = lp.getToken();
+          var material = void 0;
+          var segment = void 0;
+          var inverted = void 0;
+          var ccw = void 0;
+          var doubleSided = void 0;
+          var v0 = void 0,
+              v1 = void 0,
+              v2 = void 0,
+              v3 = void 0,
+              c0 = void 0,
+              c1 = void 0,
+              faceNormal = void 0;
+
+          switch (lineType) {
+            // Line type 0: Comment or META
+            case '0':
+              // Parse meta directive
+              var meta = lp.getToken();
+
+              if (meta) {
+                switch (meta) {
+                  case '!LDRAW_ORG':
+                    type = lp.getToken();
+                    currentParseScope.faces = [];
+                    currentParseScope.lineSegments = [];
+                    currentParseScope.conditionalSegments = [];
+                    currentParseScope.type = type;
+                    var isRoot = !parentParseScope.isFromParse;
+
+                    if (isRoot || scope.separateObjects && !isPrimitiveType(type)) {
+                      currentParseScope.groupObject = new _three.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 (currentParseScope.matrix.determinant() < 0 && (scope.separateObjects && isPrimitiveType(type) || !scope.separateObjects)) {
+                      currentParseScope.inverted = !currentParseScope.inverted;
+                    }
+
+                    faces = currentParseScope.faces;
+                    lineSegments = currentParseScope.lineSegments;
+                    conditionalSegments = currentParseScope.conditionalSegments;
+                    break;
+
+                  case '!COLOUR':
+                    material = this.parseColourMetaDirective(lp);
+
+                    if (material) {
+                      this.addMaterial(material, parseScope);
+                    } else {
+                      console.warn('LDrawLoader: Error parsing material' + lp.getLineNumberString());
+                    }
+
+                    break;
+
+                  case '!CATEGORY':
+                    category = lp.getToken();
+                    break;
+
+                  case '!KEYWORDS':
+                    var newKeywords = lp.getRemainingString().split(',');
+
+                    if (newKeywords.length > 0) {
+                      if (!keywords) {
+                        keywords = [];
+                      }
+
+                      newKeywords.forEach(function (keyword) {
+                        keywords.push(keyword.trim());
+                      });
+                    }
+
+                    break;
+
+                  case 'FILE':
+                    if (lineIndex > 0) {
+                      // Start embedded text files parsing
+                      parsingEmbeddedFiles = true;
+                      currentEmbeddedFileName = lp.getRemainingString();
+                      currentEmbeddedText = '';
+                      bfcCertified = false;
+                      bfcCCW = true;
+                    }
+
+                    break;
+
+                  case 'BFC':
+                    // Changes to the backface culling state
+                    while (!lp.isAtTheEnd()) {
+                      var token = lp.getToken();
+
+                      switch (token) {
+                        case 'CERTIFY':
+                        case 'NOCERTIFY':
+                          bfcCertified = token === 'CERTIFY';
+                          bfcCCW = true;
+                          break;
+
+                        case 'CW':
+                        case 'CCW':
+                          bfcCCW = token === 'CCW';
+                          break;
+
+                        case 'INVERTNEXT':
+                          bfcInverted = true;
+                          break;
+
+                        case 'CLIP':
+                        case 'NOCLIP':
+                          bfcCull = token === 'CLIP';
+                          break;
+
+                        default:
+                          console.warn('THREE.LDrawLoader: BFC directive "' + token + '" is unknown.');
+                          break;
+                      }
+                    }
+
+                    break;
+
+                  case 'STEP':
+                    startingConstructionStep = true;
+                    break;
+
+                  default:
+                    // Other meta directives are not implemented
+                    break;
+                }
+              }
+
+              break;
+            // Line type 1: Sub-object file
+
+            case '1':
+              material = parseColourCode(lp);
+              var posX = parseFloat(lp.getToken());
+              var posY = parseFloat(lp.getToken());
+              var posZ = parseFloat(lp.getToken());
+              var m0 = parseFloat(lp.getToken());
+              var m1 = parseFloat(lp.getToken());
+              var m2 = parseFloat(lp.getToken());
+              var m3 = parseFloat(lp.getToken());
+              var m4 = parseFloat(lp.getToken());
+              var m5 = parseFloat(lp.getToken());
+              var m6 = parseFloat(lp.getToken());
+              var m7 = parseFloat(lp.getToken());
+              var m8 = parseFloat(lp.getToken());
+              var matrix = new _three.Matrix4().set(m0, m1, m2, posX, m3, m4, m5, posY, m6, m7, m8, posZ, 0, 0, 0, 1);
+              var fileName = lp.getRemainingString().trim().replace(/\\/g, '/');
+
+              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;
+                }
+              }
+
+              subobjects.push({
+                material: material,
+                matrix: matrix,
+                fileName: fileName,
+                inverted: bfcInverted !== currentParseScope.inverted,
+                startingConstructionStep: startingConstructionStep
+              });
+              bfcInverted = false;
+              break;
+            // Line type 2: Line segment
+
+            case '2':
+              material = parseColourCode(lp, true);
+              v0 = parseVector(lp);
+              v1 = parseVector(lp);
+              segment = {
+                material: material.userData.edgeMaterial,
+                colourCode: material.userData.code,
+                v0: v0,
+                v1: v1,
+                vertices: [v0, v1]
+              };
+              lineSegments.push(segment);
+              break;
+            // Line type 5: Conditional Line segment
+
+            case '5':
+              material = parseColourCode(lp, true);
+              v0 = parseVector(lp);
+              v1 = parseVector(lp);
+              c0 = parseVector(lp);
+              c1 = parseVector(lp);
+              segment = {
+                material: material.userData.edgeMaterial.userData.conditionalEdgeMaterial,
+                colourCode: material.userData.code,
+                vertices: [v0, v1],
+                controlPoints: [c0, c1]
+              };
+              conditionalSegments.push(segment);
+              break;
+            // Line type 3: Triangle
+
+            case '3':
+              material = parseColourCode(lp);
+              inverted = currentParseScope.inverted;
+              ccw = bfcCCW !== inverted;
+              doubleSided = !bfcCertified || !bfcCull;
+
+              if (ccw === true) {
+                v0 = parseVector(lp);
+                v1 = parseVector(lp);
+                v2 = parseVector(lp);
+              } else {
+                v2 = parseVector(lp);
+                v1 = parseVector(lp);
+                v0 = parseVector(lp);
+              }
+
+              _tempVec0.subVectors(v1, v0);
+
+              _tempVec1.subVectors(v2, v1);
+
+              faceNormal = new _three.Vector3().crossVectors(_tempVec0, _tempVec1).normalize();
+              faces.push({
+                material: material,
+                colourCode: material.userData.code,
+                faceNormal: faceNormal,
+                vertices: [v0, v1, v2],
+                normals: [null, null, null]
+              });
+              currentParseScope.totalFaces++;
+
+              if (doubleSided === true) {
+                faces.push({
+                  material: material,
+                  colourCode: material.userData.code,
+                  faceNormal: faceNormal,
+                  vertices: [v2, v1, v0],
+                  normals: [null, null, null]
+                });
+                currentParseScope.totalFaces++;
+              }
+
+              break;
+            // Line type 4: Quadrilateral
+
+            case '4':
+              material = parseColourCode(lp);
+              inverted = currentParseScope.inverted;
+              ccw = bfcCCW !== inverted;
+              doubleSided = !bfcCertified || !bfcCull;
+
+              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);
+              }
+
+              _tempVec0.subVectors(v1, v0);
+
+              _tempVec1.subVectors(v2, v1);
+
+              faceNormal = new _three.Vector3().crossVectors(_tempVec0, _tempVec1).normalize(); // specifically place the triangle diagonal in the v0 and v1 slots so we can
+              // account for the doubling of vertices later when smoothing normals.
+
+              faces.push({
+                material: material,
+                colourCode: material.userData.code,
+                faceNormal: faceNormal,
+                vertices: [v0, v1, v2, v3],
+                normals: [null, null, null, null]
+              });
+              currentParseScope.totalFaces += 2;
+
+              if (doubleSided === true) {
+                faces.push({
+                  material: material,
+                  colourCode: material.userData.code,
+                  faceNormal: faceNormal,
+                  vertices: [v3, v2, v1, v0],
+                  normals: [null, null, null, null]
+                });
+                currentParseScope.totalFaces += 2;
+              }
+
+              break;
+
+            default:
+              throw 'LDrawLoader: Unknown line type "' + lineType + '"' + lp.getLineNumberString() + '.';
+              break;
+          }
+        }
+
+        if (parsingEmbeddedFiles) {
+          this.cache.setData(currentEmbeddedFileName.toLowerCase(), currentEmbeddedText);
+        }
+
+        currentParseScope.category = category;
+        currentParseScope.keywords = keywords;
+        currentParseScope.subobjects = subobjects;
+        currentParseScope.numSubobjects = subobjects.length;
+        currentParseScope.subobjectIndex = 0;
+      }
+    }, {
+      key: "computeConstructionSteps",
+      value: function computeConstructionSteps(model) {
+        // Sets userdata.constructionStep number in Group objects and userData.numConstructionSteps number in the root Group object.
+        var stepNumber = 0;
+        model.traverse(function (c) {
+          if (c.isGroup) {
+            if (c.userData.startingConstructionStep) {
+              stepNumber++;
+            }
+
+            c.userData.constructionStep = stepNumber;
+          }
+        });
+        model.userData.numConstructionSteps = stepNumber + 1;
+      }
+    }, {
+      key: "finalizeObject",
+      value: function finalizeObject(subobjectParseScope) {
+        var parentParseScope = subobjectParseScope.parentScope; // Smooth the normals if this is a part or if this is a case where the subpart
+        // is added directly into the parent model (meaning it will never get smoothed by
+        // being added to a part)
+
+        var doSmooth = isPartType(subobjectParseScope.type) || !isPartType(subobjectParseScope.type) && !isModelType(subobjectParseScope.type) && isModelType(subobjectParseScope.parentScope.type);
+
+        if (this.smoothNormals && doSmooth) {
+          smoothNormals(subobjectParseScope.faces, subobjectParseScope.lineSegments);
+        }
+
+        var isRoot = !parentParseScope.isFromParse;
+
+        if (this.separateObjects && !isPrimitiveType(subobjectParseScope.type) || isRoot) {
+          var objGroup = subobjectParseScope.groupObject;
+
+          if (subobjectParseScope.faces.length > 0) {
+            objGroup.add(createObject(subobjectParseScope.faces, 3, false, subobjectParseScope.totalFaces));
+          }
+
+          if (subobjectParseScope.lineSegments.length > 0) {
+            objGroup.add(createObject(subobjectParseScope.lineSegments, 2));
+          }
+
+          if (subobjectParseScope.conditionalSegments.length > 0) {
+            objGroup.add(createObject(subobjectParseScope.conditionalSegments, 2, true));
+          }
+
+          if (parentParseScope.groupObject) {
+            objGroup.name = subobjectParseScope.fileName;
+            objGroup.userData.category = subobjectParseScope.category;
+            objGroup.userData.keywords = subobjectParseScope.keywords;
+            subobjectParseScope.matrix.decompose(objGroup.position, objGroup.quaternion, objGroup.scale);
+            parentParseScope.groupObject.add(objGroup);
+          }
+        } else {
+          var separateObjects = this.separateObjects;
+          var parentLineSegments = parentParseScope.lineSegments;
+          var parentConditionalSegments = parentParseScope.conditionalSegments;
+          var parentFaces = parentParseScope.faces;
+          var lineSegments = subobjectParseScope.lineSegments;
+          var conditionalSegments = subobjectParseScope.conditionalSegments;
+          var faces = subobjectParseScope.faces;
+
+          for (var i = 0, l = lineSegments.length; i < l; i++) {
+            var ls = lineSegments[i];
+
+            if (separateObjects) {
+              var vertices = ls.vertices;
+              vertices[0].applyMatrix4(subobjectParseScope.matrix);
+              vertices[1].applyMatrix4(subobjectParseScope.matrix);
+            }
+
+            parentLineSegments.push(ls);
+          }
+
+          for (var _i4 = 0, _l5 = conditionalSegments.length; _i4 < _l5; _i4++) {
+            var os = conditionalSegments[_i4];
+
+            if (separateObjects) {
+              var _vertices4 = os.vertices;
+              var controlPoints = os.controlPoints;
+
+              _vertices4[0].applyMatrix4(subobjectParseScope.matrix);
+
+              _vertices4[1].applyMatrix4(subobjectParseScope.matrix);
+
+              controlPoints[0].applyMatrix4(subobjectParseScope.matrix);
+              controlPoints[1].applyMatrix4(subobjectParseScope.matrix);
+            }
+
+            parentConditionalSegments.push(os);
+          }
+
+          for (var _i5 = 0, _l6 = faces.length; _i5 < _l6; _i5++) {
+            var tri = faces[_i5];
+
+            if (separateObjects) {
+              var _vertices5 = tri.vertices;
+
+              for (var _i6 = 0, _l7 = _vertices5.length; _i6 < _l7; _i6++) {
+                _vertices5[_i6] = _vertices5[_i6].clone().applyMatrix4(subobjectParseScope.matrix);
+              }
+
+              _tempVec0.subVectors(_vertices5[1], _vertices5[0]);
+
+              _tempVec1.subVectors(_vertices5[2], _vertices5[1]);
+
+              tri.faceNormal.crossVectors(_tempVec0, _tempVec1).normalize();
+            }
+
+            parentFaces.push(tri);
+          }
+
+          parentParseScope.totalFaces += subobjectParseScope.totalFaces;
+        }
+      }
+    }, {
+      key: "processObject",
+      value: function () {
+        var _processObject = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee4(text, subobject, url, parentScope) {
+          var scope, parseScope, parentParseScope, subobjects, promises, i, l, subobjectScopes, _i7, _l8, loadSubobject;
+
+          return regeneratorRuntime.wrap(function _callee4$(_context4) {
+            while (1) {
+              switch (_context4.prev = _context4.next) {
+                case 0:
+                  loadSubobject = function _loadSubobject(subobject) {
+                    return scope.cache.loadData(subobject.fileName).then(function (text) {
+                      return scope.processObject(text, subobject, url, parseScope);
+                    }).catch(function () {
+                      console.warn('LDrawLoader: Subobject "' + subobject.fileName + '" could not be found.');
+                    });
+                  };
+
+                  scope = this;
+                  parseScope = this.newParseScopeLevel(null, parentScope);
+                  parseScope.url = url;
+                  parentParseScope = parseScope.parentScope; // Set current matrix
+
+                  if (subobject) {
+                    parseScope.currentMatrix.multiplyMatrices(parentParseScope.currentMatrix, subobject.matrix);
+                    parseScope.matrix.copy(subobject.matrix);
+                    parseScope.inverted = subobject.inverted;
+                    parseScope.startingConstructionStep = subobject.startingConstructionStep;
+                    parseScope.mainColourCode = subobject.material.userData.code;
+                    parseScope.mainEdgeColourCode = subobject.material.userData.edgeMaterial.userData.code;
+                    parseScope.fileName = subobject.fileName;
+                  } // Parse the object
+
+
+                  this.objectParse(text, parseScope);
+                  subobjects = parseScope.subobjects;
+                  promises = [];
+
+                  for (i = 0, l = subobjects.length; i < l; i++) {
+                    promises.push(loadSubobject(parseScope.subobjects[i]));
+                  } // Kick off of the downloads in parallel but process all the subobjects
+                  // in order so all the assembly instructions are correct
+
+
+                  _context4.next = 12;
+                  return Promise.all(promises);
+
+                case 12:
+                  subobjectScopes = _context4.sent;
+
+                  for (_i7 = 0, _l8 = subobjectScopes.length; _i7 < _l8; _i7++) {
+                    this.finalizeObject(subobjectScopes[_i7]);
+                  } // If it is root object then finalize this object and compute construction steps
+
+
+                  if (!parentParseScope.isFromParse) {
+                    this.finalizeObject(parseScope);
+                    this.computeConstructionSteps(parseScope.groupObject);
+                  }
+
+                  return _context4.abrupt("return", parseScope);
+
+                case 16:
+                case "end":
+                  return _context4.stop();
+              }
+            }
+          }, _callee4, this);
+        }));
+
+        function processObject(_x5, _x6, _x7, _x8) {
+          return _processObject.apply(this, arguments);
+        }
+
+        return processObject;
+      }()
+    }]);
+
+    return LDrawLoader;
+  }(_three.Loader);
+
+  _exports.LDrawLoader = LDrawLoader;
+});