opal-js_wrap-three 0.1.1 → 0.1.2

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

@@ -0,0 +1,673 @@
+(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.OBJLoader = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.OBJLoader = void 0;
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  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 _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); }
+
+  // o object_name | g group_name
+  var _object_pattern = /^[og]\s*(.+)?/; // mtllib file_reference
+
+  var _material_library_pattern = /^mtllib /; // usemtl material_name
+
+  var _material_use_pattern = /^usemtl /; // usemap map_name
+
+  var _map_use_pattern = /^usemap /;
+
+  var _vA = new _three.Vector3();
+
+  var _vB = new _three.Vector3();
+
+  var _vC = new _three.Vector3();
+
+  var _ab = new _three.Vector3();
+
+  var _cb = new _three.Vector3();
+
+  function ParserState() {
+    var state = {
+      objects: [],
+      object: {},
+      vertices: [],
+      normals: [],
+      colors: [],
+      uvs: [],
+      materials: {},
+      materialLibraries: [],
+      startObject: function startObject(name, fromDeclaration) {
+        // If the current object (initial from reset) is not from a g/o declaration in the parsed
+        // file. We need to use it for the first parsed g/o to keep things in sync.
+        if (this.object && this.object.fromDeclaration === false) {
+          this.object.name = name;
+          this.object.fromDeclaration = fromDeclaration !== false;
+          return;
+        }
+
+        var previousMaterial = this.object && typeof this.object.currentMaterial === 'function' ? this.object.currentMaterial() : undefined;
+
+        if (this.object && typeof this.object._finalize === 'function') {
+          this.object._finalize(true);
+        }
+
+        this.object = {
+          name: name || '',
+          fromDeclaration: fromDeclaration !== false,
+          geometry: {
+            vertices: [],
+            normals: [],
+            colors: [],
+            uvs: [],
+            hasUVIndices: false
+          },
+          materials: [],
+          smooth: true,
+          startMaterial: function startMaterial(name, libraries) {
+            var previous = this._finalize(false); // New usemtl declaration overwrites an inherited material, except if faces were declared
+            // after the material, then it must be preserved for proper MultiMaterial continuation.
+
+
+            if (previous && (previous.inherited || previous.groupCount <= 0)) {
+              this.materials.splice(previous.index, 1);
+            }
+
+            var material = {
+              index: this.materials.length,
+              name: name || '',
+              mtllib: Array.isArray(libraries) && libraries.length > 0 ? libraries[libraries.length - 1] : '',
+              smooth: previous !== undefined ? previous.smooth : this.smooth,
+              groupStart: previous !== undefined ? previous.groupEnd : 0,
+              groupEnd: -1,
+              groupCount: -1,
+              inherited: false,
+              clone: function clone(index) {
+                var cloned = {
+                  index: typeof index === 'number' ? index : this.index,
+                  name: this.name,
+                  mtllib: this.mtllib,
+                  smooth: this.smooth,
+                  groupStart: 0,
+                  groupEnd: -1,
+                  groupCount: -1,
+                  inherited: false
+                };
+                cloned.clone = this.clone.bind(cloned);
+                return cloned;
+              }
+            };
+            this.materials.push(material);
+            return material;
+          },
+          currentMaterial: function currentMaterial() {
+            if (this.materials.length > 0) {
+              return this.materials[this.materials.length - 1];
+            }
+
+            return undefined;
+          },
+          _finalize: function _finalize(end) {
+            var lastMultiMaterial = this.currentMaterial();
+
+            if (lastMultiMaterial && lastMultiMaterial.groupEnd === -1) {
+              lastMultiMaterial.groupEnd = this.geometry.vertices.length / 3;
+              lastMultiMaterial.groupCount = lastMultiMaterial.groupEnd - lastMultiMaterial.groupStart;
+              lastMultiMaterial.inherited = false;
+            } // Ignore objects tail materials if no face declarations followed them before a new o/g started.
+
+
+            if (end && this.materials.length > 1) {
+              for (var mi = this.materials.length - 1; mi >= 0; mi--) {
+                if (this.materials[mi].groupCount <= 0) {
+                  this.materials.splice(mi, 1);
+                }
+              }
+            } // Guarantee at least one empty material, this makes the creation later more straight forward.
+
+
+            if (end && this.materials.length === 0) {
+              this.materials.push({
+                name: '',
+                smooth: this.smooth
+              });
+            }
+
+            return lastMultiMaterial;
+          }
+        }; // Inherit previous objects material.
+        // Spec tells us that a declared material must be set to all objects until a new material is declared.
+        // If a usemtl declaration is encountered while this new object is being parsed, it will
+        // overwrite the inherited material. Exception being that there was already face declarations
+        // to the inherited material, then it will be preserved for proper MultiMaterial continuation.
+
+        if (previousMaterial && previousMaterial.name && typeof previousMaterial.clone === 'function') {
+          var declared = previousMaterial.clone(0);
+          declared.inherited = true;
+          this.object.materials.push(declared);
+        }
+
+        this.objects.push(this.object);
+      },
+      finalize: function finalize() {
+        if (this.object && typeof this.object._finalize === 'function') {
+          this.object._finalize(true);
+        }
+      },
+      parseVertexIndex: function parseVertexIndex(value, len) {
+        var index = parseInt(value, 10);
+        return (index >= 0 ? index - 1 : index + len / 3) * 3;
+      },
+      parseNormalIndex: function parseNormalIndex(value, len) {
+        var index = parseInt(value, 10);
+        return (index >= 0 ? index - 1 : index + len / 3) * 3;
+      },
+      parseUVIndex: function parseUVIndex(value, len) {
+        var index = parseInt(value, 10);
+        return (index >= 0 ? index - 1 : index + len / 2) * 2;
+      },
+      addVertex: function addVertex(a, b, c) {
+        var src = this.vertices;
+        var dst = this.object.geometry.vertices;
+        dst.push(src[a + 0], src[a + 1], src[a + 2]);
+        dst.push(src[b + 0], src[b + 1], src[b + 2]);
+        dst.push(src[c + 0], src[c + 1], src[c + 2]);
+      },
+      addVertexPoint: function addVertexPoint(a) {
+        var src = this.vertices;
+        var dst = this.object.geometry.vertices;
+        dst.push(src[a + 0], src[a + 1], src[a + 2]);
+      },
+      addVertexLine: function addVertexLine(a) {
+        var src = this.vertices;
+        var dst = this.object.geometry.vertices;
+        dst.push(src[a + 0], src[a + 1], src[a + 2]);
+      },
+      addNormal: function addNormal(a, b, c) {
+        var src = this.normals;
+        var dst = this.object.geometry.normals;
+        dst.push(src[a + 0], src[a + 1], src[a + 2]);
+        dst.push(src[b + 0], src[b + 1], src[b + 2]);
+        dst.push(src[c + 0], src[c + 1], src[c + 2]);
+      },
+      addFaceNormal: function addFaceNormal(a, b, c) {
+        var src = this.vertices;
+        var dst = this.object.geometry.normals;
+
+        _vA.fromArray(src, a);
+
+        _vB.fromArray(src, b);
+
+        _vC.fromArray(src, c);
+
+        _cb.subVectors(_vC, _vB);
+
+        _ab.subVectors(_vA, _vB);
+
+        _cb.cross(_ab);
+
+        _cb.normalize();
+
+        dst.push(_cb.x, _cb.y, _cb.z);
+        dst.push(_cb.x, _cb.y, _cb.z);
+        dst.push(_cb.x, _cb.y, _cb.z);
+      },
+      addColor: function addColor(a, b, c) {
+        var src = this.colors;
+        var dst = this.object.geometry.colors;
+        if (src[a] !== undefined) dst.push(src[a + 0], src[a + 1], src[a + 2]);
+        if (src[b] !== undefined) dst.push(src[b + 0], src[b + 1], src[b + 2]);
+        if (src[c] !== undefined) dst.push(src[c + 0], src[c + 1], src[c + 2]);
+      },
+      addUV: function addUV(a, b, c) {
+        var src = this.uvs;
+        var dst = this.object.geometry.uvs;
+        dst.push(src[a + 0], src[a + 1]);
+        dst.push(src[b + 0], src[b + 1]);
+        dst.push(src[c + 0], src[c + 1]);
+      },
+      addDefaultUV: function addDefaultUV() {
+        var dst = this.object.geometry.uvs;
+        dst.push(0, 0);
+        dst.push(0, 0);
+        dst.push(0, 0);
+      },
+      addUVLine: function addUVLine(a) {
+        var src = this.uvs;
+        var dst = this.object.geometry.uvs;
+        dst.push(src[a + 0], src[a + 1]);
+      },
+      addFace: function addFace(a, b, c, ua, ub, uc, na, nb, nc) {
+        var vLen = this.vertices.length;
+        var ia = this.parseVertexIndex(a, vLen);
+        var ib = this.parseVertexIndex(b, vLen);
+        var ic = this.parseVertexIndex(c, vLen);
+        this.addVertex(ia, ib, ic);
+        this.addColor(ia, ib, ic); // normals
+
+        if (na !== undefined && na !== '') {
+          var nLen = this.normals.length;
+          ia = this.parseNormalIndex(na, nLen);
+          ib = this.parseNormalIndex(nb, nLen);
+          ic = this.parseNormalIndex(nc, nLen);
+          this.addNormal(ia, ib, ic);
+        } else {
+          this.addFaceNormal(ia, ib, ic);
+        } // uvs
+
+
+        if (ua !== undefined && ua !== '') {
+          var uvLen = this.uvs.length;
+          ia = this.parseUVIndex(ua, uvLen);
+          ib = this.parseUVIndex(ub, uvLen);
+          ic = this.parseUVIndex(uc, uvLen);
+          this.addUV(ia, ib, ic);
+          this.object.geometry.hasUVIndices = true;
+        } else {
+          // add placeholder values (for inconsistent face definitions)
+          this.addDefaultUV();
+        }
+      },
+      addPointGeometry: function addPointGeometry(vertices) {
+        this.object.geometry.type = 'Points';
+        var vLen = this.vertices.length;
+
+        for (var vi = 0, l = vertices.length; vi < l; vi++) {
+          var index = this.parseVertexIndex(vertices[vi], vLen);
+          this.addVertexPoint(index);
+          this.addColor(index);
+        }
+      },
+      addLineGeometry: function addLineGeometry(vertices, uvs) {
+        this.object.geometry.type = 'Line';
+        var vLen = this.vertices.length;
+        var uvLen = this.uvs.length;
+
+        for (var vi = 0, l = vertices.length; vi < l; vi++) {
+          this.addVertexLine(this.parseVertexIndex(vertices[vi], vLen));
+        }
+
+        for (var uvi = 0, _l = uvs.length; uvi < _l; uvi++) {
+          this.addUVLine(this.parseUVIndex(uvs[uvi], uvLen));
+        }
+      }
+    };
+    state.startObject('', false);
+    return state;
+  } //
+
+
+  var OBJLoader = /*#__PURE__*/function (_Loader) {
+    _inherits(OBJLoader, _Loader);
+
+    var _super = _createSuper(OBJLoader);
+
+    function OBJLoader(manager) {
+      var _this;
+
+      _classCallCheck(this, OBJLoader);
+
+      _this = _super.call(this, manager);
+      _this.materials = null;
+      return _this;
+    }
+
+    _createClass(OBJLoader, [{
+      key: "load",
+      value: function load(url, onLoad, onProgress, onError) {
+        var scope = this;
+        var loader = new _three.FileLoader(this.manager);
+        loader.setPath(this.path);
+        loader.setRequestHeader(this.requestHeader);
+        loader.setWithCredentials(this.withCredentials);
+        loader.load(url, function (text) {
+          try {
+            onLoad(scope.parse(text));
+          } catch (e) {
+            if (onError) {
+              onError(e);
+            } else {
+              console.error(e);
+            }
+
+            scope.manager.itemError(url);
+          }
+        }, onProgress, onError);
+      }
+    }, {
+      key: "setMaterials",
+      value: function setMaterials(materials) {
+        this.materials = materials;
+        return this;
+      }
+    }, {
+      key: "parse",
+      value: function parse(text) {
+        var state = new ParserState();
+
+        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');
+        }
+
+        if (text.indexOf('\\\n') !== -1) {
+          // join lines separated by a line continuation character (\)
+          text = text.replace(/\\\n/g, '');
+        }
+
+        var lines = text.split('\n');
+        var line = '',
+            lineFirstChar = '';
+        var lineLength = 0;
+        var result = []; // Faster to just trim left side of the line. Use if available.
+
+        var trimLeft = typeof ''.trimLeft === 'function';
+
+        for (var i = 0, l = lines.length; i < l; i++) {
+          line = lines[i];
+          line = trimLeft ? line.trimLeft() : line.trim();
+          lineLength = line.length;
+          if (lineLength === 0) continue;
+          lineFirstChar = line.charAt(0); // @todo invoke passed in handler if any
+
+          if (lineFirstChar === '#') continue;
+
+          if (lineFirstChar === 'v') {
+            var data = line.split(/\s+/);
+
+            switch (data[0]) {
+              case 'v':
+                state.vertices.push(parseFloat(data[1]), parseFloat(data[2]), parseFloat(data[3]));
+
+                if (data.length >= 7) {
+                  state.colors.push(parseFloat(data[4]), parseFloat(data[5]), parseFloat(data[6]));
+                } else {
+                  // if no colors are defined, add placeholders so color and vertex indices match
+                  state.colors.push(undefined, undefined, undefined);
+                }
+
+                break;
+
+              case 'vn':
+                state.normals.push(parseFloat(data[1]), parseFloat(data[2]), parseFloat(data[3]));
+                break;
+
+              case 'vt':
+                state.uvs.push(parseFloat(data[1]), parseFloat(data[2]));
+                break;
+            }
+          } else if (lineFirstChar === 'f') {
+            var lineData = line.substr(1).trim();
+            var vertexData = lineData.split(/\s+/);
+            var faceVertices = []; // Parse the face vertex data into an easy to work with format
+
+            for (var j = 0, jl = vertexData.length; j < jl; j++) {
+              var vertex = vertexData[j];
+
+              if (vertex.length > 0) {
+                var vertexParts = vertex.split('/');
+                faceVertices.push(vertexParts);
+              }
+            } // Draw an edge between the first vertex and all subsequent vertices to form an n-gon
+
+
+            var v1 = faceVertices[0];
+
+            for (var _j = 1, _jl = faceVertices.length - 1; _j < _jl; _j++) {
+              var v2 = faceVertices[_j];
+              var v3 = faceVertices[_j + 1];
+              state.addFace(v1[0], v2[0], v3[0], v1[1], v2[1], v3[1], v1[2], v2[2], v3[2]);
+            }
+          } else if (lineFirstChar === 'l') {
+            var lineParts = line.substring(1).trim().split(' ');
+            var lineVertices = [];
+            var lineUVs = [];
+
+            if (line.indexOf('/') === -1) {
+              lineVertices = lineParts;
+            } else {
+              for (var li = 0, llen = lineParts.length; li < llen; li++) {
+                var parts = lineParts[li].split('/');
+                if (parts[0] !== '') lineVertices.push(parts[0]);
+                if (parts[1] !== '') lineUVs.push(parts[1]);
+              }
+            }
+
+            state.addLineGeometry(lineVertices, lineUVs);
+          } else if (lineFirstChar === 'p') {
+            var _lineData = line.substr(1).trim();
+
+            var pointData = _lineData.split(' ');
+
+            state.addPointGeometry(pointData);
+          } else if ((result = _object_pattern.exec(line)) !== null) {
+            // o object_name
+            // or
+            // g group_name
+            // WORKAROUND: https://bugs.chromium.org/p/v8/issues/detail?id=2869
+            // let name = result[ 0 ].substr( 1 ).trim();
+            var name = (' ' + result[0].substr(1).trim()).substr(1);
+            state.startObject(name);
+          } else if (_material_use_pattern.test(line)) {
+            // material
+            state.object.startMaterial(line.substring(7).trim(), state.materialLibraries);
+          } else if (_material_library_pattern.test(line)) {
+            // mtl file
+            state.materialLibraries.push(line.substring(7).trim());
+          } else if (_map_use_pattern.test(line)) {
+            // the line is parsed but ignored since the loader assumes textures are defined MTL files
+            // (according to https://www.okino.com/conv/imp_wave.htm, 'usemap' is the old-style Wavefront texture reference method)
+            console.warn('THREE.OBJLoader: Rendering identifier "usemap" not supported. Textures must be defined in MTL files.');
+          } else if (lineFirstChar === 's') {
+            result = line.split(' '); // smooth shading
+            // @todo Handle files that have varying smooth values for a set of faces inside one geometry,
+            // but does not define a usemtl for each face set.
+            // This should be detected and a dummy material created (later MultiMaterial and geometry groups).
+            // This requires some care to not create extra material on each smooth value for "normal" obj files.
+            // where explicit usemtl defines geometry groups.
+            // Example asset: examples/models/obj/cerberus/Cerberus.obj
+
+            /*
+            	 * http://paulbourke.net/dataformats/obj/
+            	 * or
+            	 * http://www.cs.utah.edu/~boulos/cs3505/obj_spec.pdf
+            	 *
+            	 * From chapter "Grouping" Syntax explanation "s group_number":
+            	 * "group_number is the smoothing group number. To turn off smoothing groups, use a value of 0 or off.
+            	 * Polygonal elements use group numbers to put elements in different smoothing groups. For free-form
+            	 * surfaces, smoothing groups are either turned on or off; there is no difference between values greater
+            	 * than 0."
+            	 */
+
+            if (result.length > 1) {
+              var value = result[1].trim().toLowerCase();
+              state.object.smooth = value !== '0' && value !== 'off';
+            } else {
+              // ZBrush can produce "s" lines #11707
+              state.object.smooth = true;
+            }
+
+            var material = state.object.currentMaterial();
+            if (material) material.smooth = state.object.smooth;
+          } else {
+            // Handle null terminated files without exception
+            if (line === '\0') continue;
+            console.warn('THREE.OBJLoader: Unexpected line: "' + line + '"');
+          }
+        }
+
+        state.finalize();
+        var container = new _three.Group();
+        container.materialLibraries = [].concat(state.materialLibraries);
+        var hasPrimitives = !(state.objects.length === 1 && state.objects[0].geometry.vertices.length === 0);
+
+        if (hasPrimitives === true) {
+          for (var _i = 0, _l2 = state.objects.length; _i < _l2; _i++) {
+            var object = state.objects[_i];
+            var geometry = object.geometry;
+            var materials = object.materials;
+            var isLine = geometry.type === 'Line';
+            var isPoints = geometry.type === 'Points';
+            var hasVertexColors = false; // Skip o/g line declarations that did not follow with any faces
+
+            if (geometry.vertices.length === 0) continue;
+            var buffergeometry = new _three.BufferGeometry();
+            buffergeometry.setAttribute('position', new _three.Float32BufferAttribute(geometry.vertices, 3));
+
+            if (geometry.normals.length > 0) {
+              buffergeometry.setAttribute('normal', new _three.Float32BufferAttribute(geometry.normals, 3));
+            }
+
+            if (geometry.colors.length > 0) {
+              hasVertexColors = true;
+              buffergeometry.setAttribute('color', new _three.Float32BufferAttribute(geometry.colors, 3));
+            }
+
+            if (geometry.hasUVIndices === true) {
+              buffergeometry.setAttribute('uv', new _three.Float32BufferAttribute(geometry.uvs, 2));
+            } // Create materials
+
+
+            var createdMaterials = [];
+
+            for (var mi = 0, miLen = materials.length; mi < miLen; mi++) {
+              var sourceMaterial = materials[mi];
+              var materialHash = sourceMaterial.name + '_' + sourceMaterial.smooth + '_' + hasVertexColors;
+              var _material = state.materials[materialHash];
+
+              if (this.materials !== null) {
+                _material = this.materials.create(sourceMaterial.name); // mtl etc. loaders probably can't create line materials correctly, copy properties to a line material.
+
+                if (isLine && _material && !(_material instanceof _three.LineBasicMaterial)) {
+                  var materialLine = new _three.LineBasicMaterial();
+
+                  _three.Material.prototype.copy.call(materialLine, _material);
+
+                  materialLine.color.copy(_material.color);
+                  _material = materialLine;
+                } else if (isPoints && _material && !(_material instanceof _three.PointsMaterial)) {
+                  var materialPoints = new _three.PointsMaterial({
+                    size: 10,
+                    sizeAttenuation: false
+                  });
+
+                  _three.Material.prototype.copy.call(materialPoints, _material);
+
+                  materialPoints.color.copy(_material.color);
+                  materialPoints.map = _material.map;
+                  _material = materialPoints;
+                }
+              }
+
+              if (_material === undefined) {
+                if (isLine) {
+                  _material = new _three.LineBasicMaterial();
+                } else if (isPoints) {
+                  _material = new _three.PointsMaterial({
+                    size: 1,
+                    sizeAttenuation: false
+                  });
+                } else {
+                  _material = new _three.MeshPhongMaterial();
+                }
+
+                _material.name = sourceMaterial.name;
+                _material.flatShading = sourceMaterial.smooth ? false : true;
+                _material.vertexColors = hasVertexColors;
+                state.materials[materialHash] = _material;
+              }
+
+              createdMaterials.push(_material);
+            } // Create mesh
+
+
+            var mesh = void 0;
+
+            if (createdMaterials.length > 1) {
+              for (var _mi = 0, _miLen = materials.length; _mi < _miLen; _mi++) {
+                var _sourceMaterial = materials[_mi];
+                buffergeometry.addGroup(_sourceMaterial.groupStart, _sourceMaterial.groupCount, _mi);
+              }
+
+              if (isLine) {
+                mesh = new _three.LineSegments(buffergeometry, createdMaterials);
+              } else if (isPoints) {
+                mesh = new _three.Points(buffergeometry, createdMaterials);
+              } else {
+                mesh = new _three.Mesh(buffergeometry, createdMaterials);
+              }
+            } else {
+              if (isLine) {
+                mesh = new _three.LineSegments(buffergeometry, createdMaterials[0]);
+              } else if (isPoints) {
+                mesh = new _three.Points(buffergeometry, createdMaterials[0]);
+              } else {
+                mesh = new _three.Mesh(buffergeometry, createdMaterials[0]);
+              }
+            }
+
+            mesh.name = object.name;
+            container.add(mesh);
+          }
+        } else {
+          // if there is only the default parser state object with no geometry data, interpret data as point cloud
+          if (state.vertices.length > 0) {
+            var _material2 = new _three.PointsMaterial({
+              size: 1,
+              sizeAttenuation: false
+            });
+
+            var _buffergeometry = new _three.BufferGeometry();
+
+            _buffergeometry.setAttribute('position', new _three.Float32BufferAttribute(state.vertices, 3));
+
+            if (state.colors.length > 0 && state.colors[0] !== undefined) {
+              _buffergeometry.setAttribute('color', new _three.Float32BufferAttribute(state.colors, 3));
+
+              _material2.vertexColors = true;
+            }
+
+            var points = new _three.Points(_buffergeometry, _material2);
+            container.add(points);
+          }
+        }
+
+        return container;
+      }
+    }]);
+
+    return OBJLoader;
+  }(_three.Loader);
+
+  _exports.OBJLoader = OBJLoader;
+});