@loaders.gl/obj 3.1.0-alpha.2 → 3.1.0-beta.1

package/dist/es5/bundle.js

@@ -0,0 +1,7 @@
+"use strict";
+
+const moduleExports = require('./index');
+
+globalThis.loaders = globalThis.loaders || {};
+module.exports = Object.assign(globalThis.loaders, moduleExports);
+//# sourceMappingURL=bundle.js.map

package/dist/es5/bundle.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/bundle.ts"],"names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"mappings":";;AACA,MAAMA,aAAa,GAAGC,OAAO,CAAC,SAAD,CAA7B;;AACAC,UAAU,CAACC,OAAX,GAAqBD,UAAU,CAACC,OAAX,IAAsB,EAA3C;AACAC,MAAM,CAACC,OAAP,GAAiBC,MAAM,CAACC,MAAP,CAAcL,UAAU,CAACC,OAAzB,EAAkCH,aAAlC,CAAjB","sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"file":"bundle.js"}

package/dist/es5/index.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "OBJWorkerLoader", {
+  enumerable: true,
+  get: function () {
+    return _objLoader.OBJLoader;
+  }
+});
+exports._typecheckOBJLoader = exports.OBJLoader = void 0;
+
+var _loadObj = _interopRequireDefault(require("./lib/load-obj"));
+
+var _objLoader = require("./obj-loader");
+
+const OBJLoader = { ..._objLoader.OBJLoader,
+  parse: async (arrayBuffer, options) => (0, _loadObj.default)(new TextDecoder().decode(arrayBuffer), options),
+  parseTextSync: _loadObj.default
+};
+exports.OBJLoader = OBJLoader;
+const _typecheckOBJLoader = OBJLoader;
+exports._typecheckOBJLoader = _typecheckOBJLoader;
+//# sourceMappingURL=index.js.map

package/dist/es5/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/index.ts"],"names":["OBJLoader","OBJWorkerLoader","parse","arrayBuffer","options","TextDecoder","decode","parseTextSync","loadOBJ","_typecheckOBJLoader"],"mappings":";;;;;;;;;;;;;;;AACA;;AACA;;AASO,MAAMA,SAAS,GAAG,EACvB,GAAGC,oBADoB;AAEvBC,EAAAA,KAAK,EAAE,OAAOC,WAAP,EAAoBC,OAApB,KAAgC,sBAAQ,IAAIC,WAAJ,GAAkBC,MAAlB,CAAyBH,WAAzB,CAAR,EAA+CC,OAA/C,CAFhB;AAGvBG,EAAAA,aAAa,EAAEC;AAHQ,CAAlB;;AAMA,MAAMC,mBAAqC,GAAGT,SAA9C","sourcesContent":["import type {LoaderWithParser} from '@loaders.gl/loader-utils';\nimport loadOBJ from './lib/load-obj';\nimport {OBJLoader as OBJWorkerLoader} from './obj-loader';\n\n// OBJLoader\n\nexport {OBJWorkerLoader};\n\n/**\n * Loader for the OBJ geometry format\n */\nexport const OBJLoader = {\n  ...OBJWorkerLoader,\n  parse: async (arrayBuffer, options) => loadOBJ(new TextDecoder().decode(arrayBuffer), options),\n  parseTextSync: loadOBJ\n};\n\nexport const _typecheckOBJLoader: LoaderWithParser = OBJLoader;\n"],"file":"index.js"}

package/dist/es5/lib/get-obj-schema.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getOBJSchema = getOBJSchema;
+
+var _schema = require("@loaders.gl/schema");
+
+function getOBJSchema(attributes, metadata = {}) {
+  let metadataMap;
+
+  for (const key in metadata) {
+    metadataMap = metadataMap || new Map();
+
+    if (key !== 'value') {
+      metadataMap.set(key, JSON.stringify(metadata[key]));
+    }
+  }
+
+  const fields = [];
+
+  for (const attributeName in attributes) {
+    const attribute = attributes[attributeName];
+    const field = getArrowFieldFromAttribute(attributeName, attribute);
+    fields.push(field);
+  }
+
+  return new _schema.Schema(fields, metadataMap);
+}
+
+function getArrowFieldFromAttribute(attributeName, attribute) {
+  const metadataMap = new Map();
+
+  for (const key in attribute) {
+    if (key !== 'value') {
+      metadataMap.set(key, JSON.stringify(attribute[key]));
+    }
+  }
+
+  const type = (0, _schema.getArrowTypeFromTypedArray)(attribute.value);
+  const isSingleValue = !('size' in attribute) || attribute.size === 1;
+  return isSingleValue ? new _schema.Field(attributeName, type, false, metadataMap) : new _schema.Field(attributeName, new _schema.FixedSizeList(attribute.size, new _schema.Field('value', type)), false, metadataMap);
+}
+//# sourceMappingURL=get-obj-schema.js.map

package/dist/es5/lib/get-obj-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/get-obj-schema.ts"],"names":["getOBJSchema","attributes","metadata","metadataMap","key","Map","set","JSON","stringify","fields","attributeName","attribute","field","getArrowFieldFromAttribute","push","Schema","type","value","isSingleValue","size","Field","FixedSizeList"],"mappings":";;;;;;;AAAA;;AAEO,SAASA,YAAT,CAAsBC,UAAtB,EAAkCC,QAAQ,GAAG,EAA7C,EAAiD;AACtD,MAAIC,WAAJ;;AACA,OAAK,MAAMC,GAAX,IAAkBF,QAAlB,EAA4B;AAC1BC,IAAAA,WAAW,GAAGA,WAAW,IAAI,IAAIE,GAAJ,EAA7B;;AACA,QAAID,GAAG,KAAK,OAAZ,EAAqB;AACnBD,MAAAA,WAAW,CAACG,GAAZ,CAAgBF,GAAhB,EAAqBG,IAAI,CAACC,SAAL,CAAeN,QAAQ,CAACE,GAAD,CAAvB,CAArB;AACD;AACF;;AAED,QAAMK,MAAe,GAAG,EAAxB;;AACA,OAAK,MAAMC,aAAX,IAA4BT,UAA5B,EAAwC;AACtC,UAAMU,SAAS,GAAGV,UAAU,CAACS,aAAD,CAA5B;AACA,UAAME,KAAK,GAAGC,0BAA0B,CAACH,aAAD,EAAgBC,SAAhB,CAAxC;AACAF,IAAAA,MAAM,CAACK,IAAP,CAAYF,KAAZ;AACD;;AACD,SAAO,IAAIG,cAAJ,CAAWN,MAAX,EAAmBN,WAAnB,CAAP;AACD;;AAED,SAASU,0BAAT,CAAoCH,aAApC,EAAmDC,SAAnD,EAA8D;AAC5D,QAAMR,WAAW,GAAG,IAAIE,GAAJ,EAApB;;AACA,OAAK,MAAMD,GAAX,IAAkBO,SAAlB,EAA6B;AAC3B,QAAIP,GAAG,KAAK,OAAZ,EAAqB;AACnBD,MAAAA,WAAW,CAACG,GAAZ,CAAgBF,GAAhB,EAAqBG,IAAI,CAACC,SAAL,CAAeG,SAAS,CAACP,GAAD,CAAxB,CAArB;AACD;AACF;;AAED,QAAMY,IAAI,GAAG,wCAA2BL,SAAS,CAACM,KAArC,CAAb;AACA,QAAMC,aAAa,GAAG,EAAE,UAAUP,SAAZ,KAA0BA,SAAS,CAACQ,IAAV,KAAmB,CAAnE;AACA,SAAOD,aAAa,GAChB,IAAIE,aAAJ,CAAUV,aAAV,EAAyBM,IAAzB,EAA+B,KAA/B,EAAsCb,WAAtC,CADgB,GAEhB,IAAIiB,aAAJ,CACAV,aADA,EAEA,IAAIW,qBAAJ,CAAkBV,SAAS,CAACQ,IAA5B,EAAkC,IAAIC,aAAJ,CAAU,OAAV,EAAmBJ,IAAnB,CAAlC,CAFA,EAGA,KAHA,EAIAb,WAJA,CAFJ;AAQD","sourcesContent":["import {Schema, Field, FixedSizeList, getArrowTypeFromTypedArray} from '@loaders.gl/schema';\n\nexport function getOBJSchema(attributes, metadata = {}) {\n  let metadataMap;\n  for (const key in metadata) {\n    metadataMap = metadataMap || new Map();\n    if (key !== 'value') {\n      metadataMap.set(key, JSON.stringify(metadata[key]));\n    }\n  }\n\n  const fields: Field[] = [];\n  for (const attributeName in attributes) {\n    const attribute = attributes[attributeName];\n    const field = getArrowFieldFromAttribute(attributeName, attribute);\n    fields.push(field);\n  }\n  return new Schema(fields, metadataMap);\n}\n\nfunction getArrowFieldFromAttribute(attributeName, attribute) {\n  const metadataMap = new Map();\n  for (const key in attribute) {\n    if (key !== 'value') {\n      metadataMap.set(key, JSON.stringify(attribute[key]));\n    }\n  }\n\n  const type = getArrowTypeFromTypedArray(attribute.value);\n  const isSingleValue = !('size' in attribute) || attribute.size === 1;\n  return isSingleValue\n    ? new Field(attributeName, type, false, metadataMap)\n    : new Field(\n      attributeName,\n      new FixedSizeList(attribute.size, new Field('value', type)),\n      false,\n      metadataMap\n    );\n}\n"],"file":"get-obj-schema.js"}

package/dist/es5/lib/load-obj.js

@@ -0,0 +1,104 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = loadOBJ;
+
+var _schema = require("@loaders.gl/schema");
+
+var _parseObj = _interopRequireDefault(require("./parse-obj"));
+
+var _getObjSchema = require("./get-obj-schema");
+
+function loadOBJ(text, options) {
+  const {
+    meshes
+  } = (0, _parseObj.default)(text);
+  const vertexCount = meshes.reduce((s, mesh) => s + mesh.header.vertexCount, 0);
+  const attributes = mergeAttributes(meshes, vertexCount);
+  const header = {
+    vertexCount,
+    boundingBox: (0, _schema.getMeshBoundingBox)(attributes)
+  };
+  const schema = (0, _getObjSchema.getOBJSchema)(attributes, {
+    mode: 4,
+    boundingBox: header.boundingBox
+  });
+  return {
+    loaderData: {
+      header: {}
+    },
+    schema,
+    header,
+    mode: 4,
+    attributes
+  };
+}
+
+function mergeAttributes(meshes, vertexCount) {
+  const positions = new Float32Array(vertexCount * 3);
+  let normals;
+  let colors;
+  let uvs;
+  let i = 0;
+
+  for (const mesh of meshes) {
+    const {
+      POSITION,
+      NORMAL,
+      COLOR_0,
+      TEXCOORD_0
+    } = mesh.attributes;
+    positions.set(POSITION.value, i * 3);
+
+    if (NORMAL) {
+      normals = normals || new Float32Array(vertexCount * 3);
+      normals.set(NORMAL.value, i * 3);
+    }
+
+    if (COLOR_0) {
+      colors = colors || new Float32Array(vertexCount * 3);
+      colors.set(COLOR_0.value, i * 3);
+    }
+
+    if (TEXCOORD_0) {
+      uvs = uvs || new Float32Array(vertexCount * 2);
+      uvs.set(TEXCOORD_0.value, i * 2);
+    }
+
+    i += POSITION.value.length / 3;
+  }
+
+  const attributes = {};
+  attributes.POSITION = {
+    value: positions,
+    size: 3
+  };
+
+  if (normals) {
+    attributes.NORMAL = {
+      value: normals,
+      size: 3
+    };
+  }
+
+  if (colors) {
+    attributes.COLOR_0 = {
+      value: colors,
+      size: 3
+    };
+  }
+
+  if (uvs) {
+    attributes.TEXCOORD_0 = {
+      value: uvs,
+      size: 2
+    };
+  }
+
+  return attributes;
+}
+//# sourceMappingURL=load-obj.js.map

package/dist/es5/lib/load-obj.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/load-obj.ts"],"names":["loadOBJ","text","options","meshes","vertexCount","reduce","s","mesh","header","attributes","mergeAttributes","boundingBox","schema","mode","loaderData","positions","Float32Array","normals","colors","uvs","i","POSITION","NORMAL","COLOR_0","TEXCOORD_0","set","value","length","size"],"mappings":"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","sourcesContent":["import type {MeshAttributes} from '@loaders.gl/schema';\nimport {getMeshBoundingBox} from '@loaders.gl/schema';\nimport parseOBJ from './parse-obj';\nimport {getOBJSchema} from './get-obj-schema';\n\nexport default function loadOBJ(text, options) {\n  const {meshes} = parseOBJ(text);\n\n  // @ts-expect-error\n  const vertexCount = meshes.reduce((s, mesh) => s + mesh.header.vertexCount, 0);\n  // TODO - render objects separately\n  const attributes = mergeAttributes(meshes, vertexCount);\n\n  const header = {\n    vertexCount,\n    // @ts-ignore Need to export Attributes type\n    boundingBox: getMeshBoundingBox(attributes)\n  };\n\n  const schema = getOBJSchema(attributes, {\n    mode: 4,\n    boundingBox: header.boundingBox\n  });\n\n  return {\n    // Data return by this loader implementation\n    loaderData: {\n      header: {}\n    },\n\n    // Normalised data\n    schema,\n    header,\n    mode: 4, // TRIANGLES\n\n    attributes\n  };\n}\n\n// eslint-disable-next-line max-statements\nfunction mergeAttributes(meshes, vertexCount) {\n  const positions = new Float32Array(vertexCount * 3);\n  let normals;\n  let colors;\n  let uvs;\n  let i = 0;\n\n  for (const mesh of meshes) {\n    const {POSITION, NORMAL, COLOR_0, TEXCOORD_0} = mesh.attributes;\n\n    positions.set(POSITION.value, i * 3);\n\n    if (NORMAL) {\n      normals = normals || new Float32Array(vertexCount * 3);\n      normals.set(NORMAL.value, i * 3);\n    }\n    if (COLOR_0) {\n      colors = colors || new Float32Array(vertexCount * 3);\n      colors.set(COLOR_0.value, i * 3);\n    }\n    if (TEXCOORD_0) {\n      uvs = uvs || new Float32Array(vertexCount * 2);\n      uvs.set(TEXCOORD_0.value, i * 2);\n    }\n\n    i += POSITION.value.length / 3;\n  }\n\n  const attributes: MeshAttributes = {};\n  attributes.POSITION = {value: positions, size: 3};\n\n  if (normals) {\n    attributes.NORMAL = {value: normals, size: 3};\n  }\n  if (colors) {\n    attributes.COLOR_0 = {value: colors, size: 3};\n  }\n  if (uvs) {\n    attributes.TEXCOORD_0 = {value: uvs, size: 2};\n  }\n\n  return attributes;\n}\n"],"file":"load-obj.js"}

package/dist/es5/lib/obj-types.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=obj-types.js.map

package/dist/es5/lib/parse-obj.js

@@ -0,0 +1,466 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const OBJECT_RE = /^[og]\s*(.+)?/;
+const MATERIAL_RE = /^mtllib /;
+const MATERIAL_USE_RE = /^usemtl /;
+
+class MeshMaterial {
+  constructor({
+    index,
+    name = '',
+    mtllib,
+    smooth,
+    groupStart
+  }) {
+    this.index = index;
+    this.name = name;
+    this.mtllib = mtllib;
+    this.smooth = smooth;
+    this.groupStart = groupStart;
+    this.groupEnd = -1;
+    this.groupCount = -1;
+    this.inherited = false;
+  }
+
+  clone(index = this.index) {
+    return new MeshMaterial({
+      index,
+      name: this.name,
+      mtllib: this.mtllib,
+      smooth: this.smooth,
+      groupStart: 0
+    });
+  }
+
+}
+
+class MeshObject {
+  constructor(name = '') {
+    this.name = name;
+    this.geometry = {
+      vertices: [],
+      normals: [],
+      colors: [],
+      uvs: []
+    };
+    this.materials = [];
+    this.smooth = true;
+    this.fromDeclaration = null;
+  }
+
+  startMaterial(name, libraries) {
+    const previous = this._finalize(false);
+
+    if (previous && (previous.inherited || previous.groupCount <= 0)) {
+      this.materials.splice(previous.index, 1);
+    }
+
+    const material = new MeshMaterial({
+      index: this.materials.length,
+      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
+    });
+    this.materials.push(material);
+    return material;
+  }
+
+  currentMaterial() {
+    if (this.materials.length > 0) {
+      return this.materials[this.materials.length - 1];
+    }
+
+    return undefined;
+  }
+
+  _finalize(end) {
+    const lastMultiMaterial = this.currentMaterial();
+
+    if (lastMultiMaterial && lastMultiMaterial.groupEnd === -1) {
+      lastMultiMaterial.groupEnd = this.geometry.vertices.length / 3;
+      lastMultiMaterial.groupCount = lastMultiMaterial.groupEnd - lastMultiMaterial.groupStart;
+      lastMultiMaterial.inherited = false;
+    }
+
+    if (end && this.materials.length > 1) {
+      for (let mi = this.materials.length - 1; mi >= 0; mi--) {
+        if (this.materials[mi].groupCount <= 0) {
+          this.materials.splice(mi, 1);
+        }
+      }
+    }
+
+    if (end && this.materials.length === 0) {
+      this.materials.push({
+        name: '',
+        smooth: this.smooth
+      });
+    }
+
+    return lastMultiMaterial;
+  }
+
+}
+
+class ParserState {
+  constructor() {
+    this.objects = [];
+    this.object = null;
+    this.vertices = [];
+    this.normals = [];
+    this.colors = [];
+    this.uvs = [];
+    this.materialLibraries = [];
+    this.startObject('', false);
+  }
+
+  startObject(name, fromDeclaration = true) {
+    if (this.object && !this.object.fromDeclaration) {
+      this.object.name = name;
+      this.object.fromDeclaration = fromDeclaration;
+      return;
+    }
+
+    const 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 = new MeshObject(name);
+    this.object.fromDeclaration = fromDeclaration;
+
+    if (previousMaterial && previousMaterial.name && typeof previousMaterial.clone === 'function') {
+      const declared = previousMaterial.clone(0);
+      declared.inherited = true;
+      this.object.materials.push(declared);
+    }
+
+    this.objects.push(this.object);
+  }
+
+  finalize() {
+    if (this.object && typeof this.object._finalize === 'function') {
+      this.object._finalize(true);
+    }
+  }
+
+  parseVertexIndex(value, len) {
+    const index = parseInt(value);
+    return (index >= 0 ? index - 1 : index + len / 3) * 3;
+  }
+
+  parseNormalIndex(value, len) {
+    const index = parseInt(value);
+    return (index >= 0 ? index - 1 : index + len / 3) * 3;
+  }
+
+  parseUVIndex(value, len) {
+    const index = parseInt(value);
+    return (index >= 0 ? index - 1 : index + len / 2) * 2;
+  }
+
+  addVertex(a, b, c) {
+    const src = this.vertices;
+    const 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(a) {
+    const src = this.vertices;
+    const dst = this.object.geometry.vertices;
+    dst.push(src[a + 0], src[a + 1], src[a + 2]);
+  }
+
+  addVertexLine(a) {
+    const src = this.vertices;
+    const dst = this.object.geometry.vertices;
+    dst.push(src[a + 0], src[a + 1], src[a + 2]);
+  }
+
+  addNormal(a, b, c) {
+    const src = this.normals;
+    const 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]);
+  }
+
+  addColor(a, b, c) {
+    const src = this.colors;
+    const dst = this.object.geometry.colors;
+    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]);
+  }
+
+  addUV(a, b, c) {
+    const src = this.uvs;
+    const 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]);
+  }
+
+  addUVLine(a) {
+    const src = this.uvs;
+    const dst = this.object.geometry.uvs;
+    dst.push(src[a + 0], src[a + 1]);
+  }
+
+  addFace(a, b, c, ua, ub, uc, na, nb, nc) {
+    const vLen = this.vertices.length;
+    let ia = this.parseVertexIndex(a, vLen);
+    let ib = this.parseVertexIndex(b, vLen);
+    let ic = this.parseVertexIndex(c, vLen);
+    this.addVertex(ia, ib, ic);
+
+    if (ua !== undefined && ua !== '') {
+      const uvLen = this.uvs.length;
+      ia = this.parseUVIndex(ua, uvLen);
+      ib = this.parseUVIndex(ub, uvLen);
+      ic = this.parseUVIndex(uc, uvLen);
+      this.addUV(ia, ib, ic);
+    }
+
+    if (na !== undefined && na !== '') {
+      const nLen = this.normals.length;
+      ia = this.parseNormalIndex(na, nLen);
+      ib = na === nb ? ia : this.parseNormalIndex(nb, nLen);
+      ic = na === nc ? ia : this.parseNormalIndex(nc, nLen);
+      this.addNormal(ia, ib, ic);
+    }
+
+    if (this.colors.length > 0) {
+      this.addColor(ia, ib, ic);
+    }
+  }
+
+  addPointGeometry(vertices) {
+    this.object.geometry.type = 'Points';
+    const vLen = this.vertices.length;
+
+    for (const vertex of vertices) {
+      this.addVertexPoint(this.parseVertexIndex(vertex, vLen));
+    }
+  }
+
+  addLineGeometry(vertices, uvs) {
+    this.object.geometry.type = 'Line';
+    const vLen = this.vertices.length;
+    const uvLen = this.uvs.length;
+
+    for (const vertex of vertices) {
+      this.addVertexLine(this.parseVertexIndex(vertex, vLen));
+    }
+
+    for (const uv of uvs) {
+      this.addUVLine(this.parseUVIndex(uv, uvLen));
+    }
+  }
+
+}
+
+var _default = text => {
+  const state = new ParserState();
+
+  if (text.indexOf('\r\n') !== -1) {
+    text = text.replace(/\r\n/g, '\n');
+  }
+
+  if (text.indexOf('\\\n') !== -1) {
+    text = text.replace(/\\\n/g, '');
+  }
+
+  const lines = text.split('\n');
+  let line = '';
+  let lineFirstChar = '';
+  let lineLength = 0;
+  let result = [];
+  const trimLeft = typeof ''.trimLeft === 'function';
+
+  for (let 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);
+    if (lineFirstChar === '#') continue;
+
+    if (lineFirstChar === 'v') {
+      const data = line.split(/\s+/);
+
+      switch (data[0]) {
+        case 'v':
+          state.vertices.push(parseFloat(data[1]), parseFloat(data[2]), parseFloat(data[3]));
+
+          if (data.length === 8) {
+            state.colors.push(parseFloat(data[4]), parseFloat(data[5]), parseFloat(data[6]));
+          }
+
+          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;
+
+        default:
+      }
+    } else if (lineFirstChar === 'f') {
+      const lineData = line.substr(1).trim();
+      const vertexData = lineData.split(/\s+/);
+      const faceVertices = [];
+
+      for (let j = 0, jl = vertexData.length; j < jl; j++) {
+        const vertex = vertexData[j];
+
+        if (vertex.length > 0) {
+          const vertexParts = vertex.split('/');
+          faceVertices.push(vertexParts);
+        }
+      }
+
+      const v1 = faceVertices[0];
+
+      for (let j = 1, jl = faceVertices.length - 1; j < jl; j++) {
+        const v2 = faceVertices[j];
+        const 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') {
+      const lineParts = line.substring(1).trim().split(' ');
+      let lineVertices;
+      const lineUVs = [];
+
+      if (line.indexOf('/') === -1) {
+        lineVertices = lineParts;
+      } else {
+        lineVertices = [];
+
+        for (let li = 0, llen = lineParts.length; li < llen; li++) {
+          const 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') {
+      const lineData = line.substr(1).trim();
+      const pointData = lineData.split(' ');
+      state.addPointGeometry(pointData);
+    } else if ((result = OBJECT_RE.exec(line)) !== null) {
+      const name = (' ' + result[0].substr(1).trim()).substr(1);
+      state.startObject(name);
+    } else if (MATERIAL_USE_RE.test(line)) {
+      state.object.startMaterial(line.substring(7).trim(), state.materialLibraries);
+    } else if (MATERIAL_RE.test(line)) {
+      state.materialLibraries.push(line.substring(7).trim());
+    } else if (lineFirstChar === 's') {
+      result = line.split(' ');
+
+      if (result.length > 1) {
+        const value = result[1].trim().toLowerCase();
+        state.object.smooth = value !== '0' && value !== 'off';
+      } else {
+        state.object.smooth = true;
+      }
+
+      const material = state.object.currentMaterial();
+      if (material) material.smooth = state.object.smooth;
+    } else {
+      if (line === '\0') continue;
+      throw new Error("Unexpected line: \"".concat(line, "\""));
+    }
+  }
+
+  state.finalize();
+  const meshes = [];
+  const materials = [];
+
+  for (const object of state.objects) {
+    const {
+      geometry
+    } = object;
+    if (geometry.vertices.length === 0) continue;
+    const mesh = {
+      header: {
+        vertexCount: geometry.vertices.length / 3
+      },
+      attributes: {}
+    };
+
+    switch (geometry.type) {
+      case 'Points':
+        mesh.mode = 0;
+        break;
+
+      case 'Line':
+        mesh.mode = 1;
+        break;
+
+      default:
+        mesh.mode = 4;
+        break;
+    }
+
+    mesh.attributes.POSITION = {
+      value: new Float32Array(geometry.vertices),
+      size: 3
+    };
+
+    if (geometry.normals.length > 0) {
+      mesh.attributes.NORMAL = {
+        value: new Float32Array(geometry.normals),
+        size: 3
+      };
+    }
+
+    if (geometry.colors.length > 0) {
+      mesh.attributes.COLOR_0 = {
+        value: new Float32Array(geometry.colors),
+        size: 3
+      };
+    }
+
+    if (geometry.uvs.length > 0) {
+      mesh.attributes.TEXCOORD_0 = {
+        value: new Float32Array(geometry.uvs),
+        size: 2
+      };
+    }
+
+    mesh.materials = [];
+
+    for (const sourceMaterial of object.materials) {
+      const _material = {
+        name: sourceMaterial.name,
+        flatShading: !sourceMaterial.smooth
+      };
+      mesh.materials.push(_material);
+      materials.push(_material);
+    }
+
+    mesh.name = object.name;
+    meshes.push(mesh);
+  }
+
+  return {
+    meshes,
+    materials
+  };
+};
+
+exports.default = _default;
+//# sourceMappingURL=parse-obj.js.map