@loaders.gl/obj 3.1.3 → 3.1.7

package/dist/dist.min.js

@@ -562,10 +562,160 @@
     }
   });
 
-  // src/lib/parse-obj.ts
-  var OBJECT_RE, MATERIAL_RE, MATERIAL_USE_RE, MeshMaterial, MeshObject, ParserState, parse_obj_default;
-  var init_parse_obj = __esm({
-    "src/lib/parse-obj.ts"() {
+  // src/lib/parse-obj-meshes.ts
+  function parseOBJMeshes(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: "${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 };
+  }
+  var OBJECT_RE, MATERIAL_RE, MATERIAL_USE_RE, MeshMaterial, MeshObject, ParserState;
+  var init_parse_obj_meshes = __esm({
+    "src/lib/parse-obj-meshes.ts"() {
       OBJECT_RE = /^[og]\s*(.+)?/;
       MATERIAL_RE = /^mtllib /;
       MATERIAL_USE_RE = /^usemtl /;
@@ -780,156 +930,6 @@
           }
         }
       };
-      parse_obj_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: "${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 };
-      };
     }
   });
 
@@ -967,9 +967,9 @@
     }
   });
 
-  // src/lib/load-obj.ts
-  function loadOBJ(text, options) {
-    const { meshes } = parse_obj_default(text);
+  // src/lib/parse-obj.ts
+  function parseOBJ(text, options) {
+    const { meshes } = parseOBJMeshes(text);
     const vertexCount = meshes.reduce((s, mesh) => s + mesh.header.vertexCount, 0);
     const attributes = mergeAttributes(meshes, vertexCount);
     const header = {
@@ -1026,14 +1026,88 @@
     }
     return attributes;
   }
-  var init_load_obj = __esm({
-    "src/lib/load-obj.ts"() {
+  var init_parse_obj = __esm({
+    "src/lib/parse-obj.ts"() {
       init_src();
-      init_parse_obj();
+      init_parse_obj_meshes();
       init_get_obj_schema();
     }
   });
 
+  // src/lib/parse-mtl.ts
+  function parseMTL(text, options) {
+    const materials = [];
+    let currentMaterial = { name: "placeholder" };
+    const lines = text.split("\n");
+    for (let line of lines) {
+      line = line.trim();
+      if (line.length === 0 || line.charAt(0) === "#") {
+        continue;
+      }
+      const pos = line.indexOf(" ");
+      let key = pos >= 0 ? line.substring(0, pos) : line;
+      key = key.toLowerCase();
+      let value = pos >= 0 ? line.substring(pos + 1) : "";
+      value = value.trim();
+      switch (key) {
+        case "newmtl":
+          currentMaterial = { name: value };
+          materials.push(currentMaterial);
+          break;
+        case "ka":
+          currentMaterial.ambientColor = parseColor(value);
+          break;
+        case "kd":
+          currentMaterial.diffuseColor = parseColor(value);
+          break;
+        case "map_kd":
+          currentMaterial.diffuseTextureUrl = value;
+          break;
+        case "ks":
+          currentMaterial.specularColor = parseColor(value);
+          break;
+        case "map_ks":
+          currentMaterial.specularTextureUrl = value;
+          break;
+        case "ke":
+          currentMaterial.emissiveColor = parseColor(value);
+          break;
+        case "map_ke":
+          currentMaterial.emissiveTextureUrl = value;
+          break;
+        case "ns":
+          currentMaterial.shininess = parseFloat(value);
+          break;
+        case "map_ns":
+          break;
+        case "ni":
+          currentMaterial.refraction = parseFloat(value);
+          break;
+        case "illum":
+          currentMaterial.illumination = parseFloat(value);
+          break;
+        default:
+          break;
+      }
+    }
+    return materials;
+  }
+  function parseColor(value, options) {
+    const rgb = value.split(DELIMITER_PATTERN, 3);
+    const color = [
+      parseFloat(rgb[0]),
+      parseFloat(rgb[1]),
+      parseFloat(rgb[2])
+    ];
+    return color;
+  }
+  var DELIMITER_PATTERN;
+  var init_parse_mtl = __esm({
+    "src/lib/parse-mtl.ts"() {
+      DELIMITER_PATTERN = /\s+/;
+    }
+  });
+
   // src/obj-loader.ts
   function testOBJFile(text) {
     return text[0] === "v";
@@ -1058,24 +1132,55 @@
     }
   });
 
+  // src/mtl-loader.ts
+  var VERSION2, MTLLoader;
+  var init_mtl_loader = __esm({
+    "src/mtl-loader.ts"() {
+      VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      MTLLoader = {
+        name: "MTL",
+        id: "mtl",
+        module: "mtl",
+        version: VERSION2,
+        worker: true,
+        extensions: ["mtl"],
+        mimeTypes: ["text/plain"],
+        testText: (text) => text.includes("newmtl"),
+        options: {
+          mtl: {}
+        }
+      };
+    }
+  });
+
   // src/index.ts
   var src_exports = {};
   __export(src_exports, {
+    MTLLoader: () => MTLLoader2,
     OBJLoader: () => OBJLoader2,
     OBJWorkerLoader: () => OBJLoader,
+    _typecheckMTLLoader: () => _typecheckMTLLoader,
     _typecheckOBJLoader: () => _typecheckOBJLoader
   });
-  var OBJLoader2, _typecheckOBJLoader;
+  var OBJLoader2, MTLLoader2, _typecheckOBJLoader, _typecheckMTLLoader;
   var init_src2 = __esm({
     "src/index.ts"() {
-      init_load_obj();
+      init_parse_obj();
+      init_parse_mtl();
       init_obj_loader();
+      init_mtl_loader();
       OBJLoader2 = {
         ...OBJLoader,
-        parse: async (arrayBuffer, options) => loadOBJ(new TextDecoder().decode(arrayBuffer), options),
-        parseTextSync: loadOBJ
+        parse: async (arrayBuffer, options) => parseOBJ(new TextDecoder().decode(arrayBuffer), options),
+        parseTextSync: (text, options) => parseOBJ(text, options)
+      };
+      MTLLoader2 = {
+        ...MTLLoader,
+        parse: async (arrayBuffer, options) => parseMTL(new TextDecoder().decode(arrayBuffer), options?.mtl),
+        parseTextSync: (text, options) => parseMTL(text, options?.mtl)
       };
       _typecheckOBJLoader = OBJLoader2;
+      _typecheckMTLLoader = MTLLoader2;
     }
   });
 

package/dist/es5/index.js

@@ -11,7 +11,7 @@ Object.defineProperty(exports, "OBJWorkerLoader", {
     return _objLoader.OBJLoader;
   }
 });
-exports._typecheckOBJLoader = exports.OBJLoader = void 0;
+exports._typecheckMTLLoader = exports._typecheckOBJLoader = exports.MTLLoader = exports.OBJLoader = void 0;
 
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 
@@ -19,10 +19,14 @@ var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/
 
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
-var _loadObj = _interopRequireDefault(require("./lib/load-obj"));
+var _parseObj = require("./lib/parse-obj");
+
+var _parseMtl = require("./lib/parse-mtl");
 
 var _objLoader = require("./obj-loader");
 
+var _mtlLoader = require("./mtl-loader");
+
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
@@ -34,7 +38,7 @@ var OBJLoader = _objectSpread(_objectSpread({}, _objLoader.OBJLoader), {}, {
         while (1) {
           switch (_context.prev = _context.next) {
             case 0:
-              return _context.abrupt("return", (0, _loadObj.default)(new TextDecoder().decode(arrayBuffer), options));
+              return _context.abrupt("return", (0, _parseObj.parseOBJ)(new TextDecoder().decode(arrayBuffer), options));
 
             case 1:
             case "end":
@@ -50,10 +54,44 @@ var OBJLoader = _objectSpread(_objectSpread({}, _objLoader.OBJLoader), {}, {
 
     return parse;
   }(),
-  parseTextSync: _loadObj.default
+  parseTextSync: function parseTextSync(text, options) {
+    return (0, _parseObj.parseOBJ)(text, options);
+  }
 });
 
 exports.OBJLoader = OBJLoader;
+
+var MTLLoader = _objectSpread(_objectSpread({}, _mtlLoader.MTLLoader), {}, {
+  parse: function () {
+    var _parse2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee2(arrayBuffer, options) {
+      return _regenerator.default.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              return _context2.abrupt("return", (0, _parseMtl.parseMTL)(new TextDecoder().decode(arrayBuffer), options === null || options === void 0 ? void 0 : options.mtl));
+
+            case 1:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2);
+    }));
+
+    function parse(_x3, _x4) {
+      return _parse2.apply(this, arguments);
+    }
+
+    return parse;
+  }(),
+  parseTextSync: function parseTextSync(text, options) {
+    return (0, _parseMtl.parseMTL)(text, options === null || options === void 0 ? void 0 : options.mtl);
+  }
+});
+
+exports.MTLLoader = MTLLoader;
 var _typecheckOBJLoader = OBJLoader;
 exports._typecheckOBJLoader = _typecheckOBJLoader;
+var _typecheckMTLLoader = MTLLoader;
+exports._typecheckMTLLoader = _typecheckMTLLoader;
 //# sourceMappingURL=index.js.map

package/dist/es5/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts"],"names":["OBJLoader","OBJWorkerLoader","parse","arrayBuffer","options","TextDecoder","decode","parseTextSync","loadOBJ","_typecheckOBJLoader"],"mappings":";;;;;;;;;;;;;;;;;;;;;AACA;;AACA;;;;;;AASO,IAAMA,SAAS,mCACjBC,oBADiB;AAEpBC,EAAAA,KAAK;AAAA,2EAAE,iBAAOC,WAAP,EAAoBC,OAApB;AAAA;AAAA;AAAA;AAAA;AAAA,+CAAgC,sBAAQ,IAAIC,WAAJ,GAAkBC,MAAlB,CAAyBH,WAAzB,CAAR,EAA+CC,OAA/C,CAAhC;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,KAAF;;AAAA;AAAA;AAAA;;AAAA;AAAA,KAFe;AAGpBG,EAAAA,aAAa,EAAEC;AAHK,EAAf;;;AAMA,IAAMC,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"}
+{"version":3,"sources":["../../src/index.ts"],"names":["OBJLoader","OBJWorkerLoader","parse","arrayBuffer","options","TextDecoder","decode","parseTextSync","text","MTLLoader","MTLWorkerLoader","mtl","_typecheckOBJLoader","_typecheckMTLLoader"],"mappings":";;;;;;;;;;;;;;;;;;;;;AACA;;AACA;;AAEA;;AAEA;;;;;;AASO,IAAMA,SAAS,mCACjBC,oBADiB;AAEpBC,EAAAA,KAAK;AAAA,2EAAE,iBAAOC,WAAP,EAAiCC,OAAjC;AAAA;AAAA;AAAA;AAAA;AAAA,+CACL,wBAAS,IAAIC,WAAJ,GAAkBC,MAAlB,CAAyBH,WAAzB,CAAT,EAAgDC,OAAhD,CADK;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,KAAF;;AAAA;AAAA;AAAA;;AAAA;AAAA,KAFe;AAIpBG,EAAAA,aAAa,EAAE,uBAACC,IAAD,EAAeJ,OAAf;AAAA,WAA8C,wBAASI,IAAT,EAAeJ,OAAf,CAA9C;AAAA;AAJK,EAAf;;;;AAYA,IAAMK,SAAS,mCACjBC,oBADiB;AAEpBR,EAAAA,KAAK;AAAA,4EAAE,kBAAOC,WAAP,EAAiCC,OAAjC;AAAA;AAAA;AAAA;AAAA;AAAA,gDACL,wBAAS,IAAIC,WAAJ,GAAkBC,MAAlB,CAAyBH,WAAzB,CAAT,EAAgDC,OAAhD,aAAgDA,OAAhD,uBAAgDA,OAAO,CAAEO,GAAzD,CADK;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,KAAF;;AAAA;AAAA;AAAA;;AAAA;AAAA,KAFe;AAIpBJ,EAAAA,aAAa,EAAE,uBAACC,IAAD,EAAeJ,OAAf;AAAA,WAA8C,wBAASI,IAAT,EAAeJ,OAAf,aAAeA,OAAf,uBAAeA,OAAO,CAAEO,GAAxB,CAA9C;AAAA;AAJK,EAAf;;;AAOA,IAAMC,mBAAqC,GAAGZ,SAA9C;;AACA,IAAMa,mBAAqC,GAAGJ,SAA9C","sourcesContent":["import type {LoaderWithParser} from '@loaders.gl/loader-utils';\nimport {parseOBJ} from './lib/parse-obj';\nimport {parseMTL} from './lib/parse-mtl';\nimport type {OBJLoaderOptions} from './obj-loader';\nimport {OBJLoader as OBJWorkerLoader} from './obj-loader';\nimport type {MTLLoaderOptions} from './mtl-loader';\nimport {MTLLoader as MTLWorkerLoader} from './mtl-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: ArrayBuffer, options?: OBJLoaderOptions) =>\n    parseOBJ(new TextDecoder().decode(arrayBuffer), options),\n  parseTextSync: (text: string, options?: OBJLoaderOptions) => parseOBJ(text, options)\n};\n\n// MTLLoader\n\n/**\n * Loader for the MTL material format\n */\nexport const MTLLoader = {\n  ...MTLWorkerLoader,\n  parse: async (arrayBuffer: ArrayBuffer, options?: MTLLoaderOptions) =>\n    parseMTL(new TextDecoder().decode(arrayBuffer), options?.mtl),\n  parseTextSync: (text: string, options?: MTLLoaderOptions) => parseMTL(text, options?.mtl)\n};\n\nexport const _typecheckOBJLoader: LoaderWithParser = OBJLoader;\nexport const _typecheckMTLLoader: LoaderWithParser = MTLLoader;\n"],"file":"index.js"}

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

@@ -0,0 +1,110 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseMTL = parseMTL;
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+var DELIMITER_PATTERN = /\s+/;
+
+function parseMTL(text, options) {
+  var materials = [];
+  var currentMaterial = {
+    name: 'placeholder'
+  };
+  var lines = text.split('\n');
+
+  var _iterator = _createForOfIteratorHelper(lines),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var line = _step.value;
+      line = line.trim();
+
+      if (line.length === 0 || line.charAt(0) === '#') {
+        continue;
+      }
+
+      var pos = line.indexOf(' ');
+      var key = pos >= 0 ? line.substring(0, pos) : line;
+      key = key.toLowerCase();
+      var value = pos >= 0 ? line.substring(pos + 1) : '';
+      value = value.trim();
+
+      switch (key) {
+        case 'newmtl':
+          currentMaterial = {
+            name: value
+          };
+          materials.push(currentMaterial);
+          break;
+
+        case 'ka':
+          currentMaterial.ambientColor = parseColor(value);
+          break;
+
+        case 'kd':
+          currentMaterial.diffuseColor = parseColor(value);
+          break;
+
+        case 'map_kd':
+          currentMaterial.diffuseTextureUrl = value;
+          break;
+
+        case 'ks':
+          currentMaterial.specularColor = parseColor(value);
+          break;
+
+        case 'map_ks':
+          currentMaterial.specularTextureUrl = value;
+          break;
+
+        case 'ke':
+          currentMaterial.emissiveColor = parseColor(value);
+          break;
+
+        case 'map_ke':
+          currentMaterial.emissiveTextureUrl = value;
+          break;
+
+        case 'ns':
+          currentMaterial.shininess = parseFloat(value);
+          break;
+
+        case 'map_ns':
+          break;
+
+        case 'ni':
+          currentMaterial.refraction = parseFloat(value);
+          break;
+
+        case 'illum':
+          currentMaterial.illumination = parseFloat(value);
+          break;
+
+        default:
+          break;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return materials;
+}
+
+function parseColor(value, options) {
+  var rgb = value.split(DELIMITER_PATTERN, 3);
+  var color = [parseFloat(rgb[0]), parseFloat(rgb[1]), parseFloat(rgb[2])];
+  return color;
+}
+//# sourceMappingURL=parse-mtl.js.map