@loaders.gl/obj 4.0.0-beta.2 → 4.0.0-beta.3

package/dist/index.cjs

@@ -0,0 +1,610 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  MTLLoader: () => MTLLoader2,
+  OBJLoader: () => OBJLoader2,
+  OBJWorkerLoader: () => OBJLoader
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/lib/parse-obj.ts
+var import_schema2 = require("@loaders.gl/schema");
+
+// src/lib/parse-obj-meshes.ts
+var OBJECT_RE = /^[og]\s*(.+)?/;
+var MATERIAL_RE = /^mtllib /;
+var MATERIAL_USE_RE = /^usemtl /;
+var MeshMaterial = class {
+  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
+    });
+  }
+};
+var MeshObject = class {
+  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 !== void 0 ? previous.smooth : this.smooth,
+      groupStart: previous !== void 0 ? previous.groupEnd : 0
+    });
+    this.materials.push(material);
+    return material;
+  }
+  currentMaterial() {
+    if (this.materials.length > 0) {
+      return this.materials[this.materials.length - 1];
+    }
+    return void 0;
+  }
+  _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;
+  }
+};
+var ParserState = class {
+  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() : void 0;
+    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]);
+  }
+  // eslint-disable-next-line max-params
+  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 !== void 0 && 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 !== void 0 && 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));
+    }
+  }
+};
+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 >= 7) {
+            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 };
+}
+
+// src/lib/get-obj-schema.ts
+var import_schema = require("@loaders.gl/schema");
+function getOBJSchema(attributes, metadata = {}) {
+  const stringMetadata = {};
+  for (const key in metadata) {
+    if (key !== "value") {
+      stringMetadata[key] = JSON.stringify(metadata[key]);
+    }
+  }
+  const fields = [];
+  for (const attributeName in attributes) {
+    const attribute = attributes[attributeName];
+    const field = getFieldFromAttribute(attributeName, attribute);
+    fields.push(field);
+  }
+  return { fields, metadata: stringMetadata };
+}
+function getFieldFromAttribute(name, attribute) {
+  const metadata = {};
+  for (const key in attribute) {
+    if (key !== "value") {
+      metadata[key] = JSON.stringify(attribute[key]);
+    }
+  }
+  let { type } = (0, import_schema.getDataTypeFromArray)(attribute.value);
+  const isSingleValue = attribute.size === 1 || attribute.size === void 0;
+  if (!isSingleValue) {
+    type = { type: "fixed-size-list", listSize: attribute.size, children: [{ name: "values", type }] };
+  }
+  return { name, type, nullable: false, metadata };
+}
+
+// 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 = {
+    vertexCount,
+    // @ts-ignore Need to export Attributes type
+    boundingBox: (0, import_schema2.getMeshBoundingBox)(attributes)
+  };
+  const schema = getOBJSchema(attributes, {
+    mode: 4,
+    boundingBox: header.boundingBox
+  });
+  return {
+    // Data return by this loader implementation
+    loaderData: {
+      header: {}
+    },
+    // Normalised data
+    schema,
+    header,
+    mode: 4,
+    // TRIANGLES
+    topology: "point-list",
+    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;
+}
+
+// src/obj-loader.ts
+var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+var OBJLoader = {
+  name: "OBJ",
+  id: "obj",
+  module: "obj",
+  version: VERSION,
+  worker: true,
+  extensions: ["obj"],
+  mimeTypes: ["text/plain"],
+  testText: testOBJFile,
+  options: {
+    obj: {}
+  }
+};
+function testOBJFile(text) {
+  return text[0] === "v";
+}
+
+// src/lib/parse-mtl.ts
+var DELIMITER_PATTERN = /\s+/;
+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;
+}
+
+// src/mtl-loader.ts
+var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+var 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 OBJLoader2 = {
+  ...OBJLoader,
+  parse: async (arrayBuffer, options) => parseOBJ(new TextDecoder().decode(arrayBuffer), options),
+  parseTextSync: (text, options) => parseOBJ(text, options)
+};
+var MTLLoader2 = {
+  ...MTLLoader,
+  parse: async (arrayBuffer, options) => parseMTL(new TextDecoder().decode(arrayBuffer), options == null ? void 0 : options.mtl),
+  parseTextSync: (text, options) => parseMTL(text, options == null ? void 0 : options.mtl)
+};

package/dist/{esm/index.js → index.js}

@@ -1,7 +1,7 @@
-import { parseOBJ } from './lib/parse-obj';
-import { OBJLoader as OBJWorkerLoader } from './obj-loader';
-import { parseMTL } from './lib/parse-mtl';
-import { MTLLoader as MTLWorkerLoader } from './mtl-loader';
+import { parseOBJ } from "./lib/parse-obj.js";
+import { OBJLoader as OBJWorkerLoader } from "./obj-loader.js";
+import { parseMTL } from "./lib/parse-mtl.js";
+import { MTLLoader as MTLWorkerLoader } from "./mtl-loader.js";
 export { OBJWorkerLoader };
 export const OBJLoader = {
   ...OBJWorkerLoader,

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["parseOBJ","OBJLoader","OBJWorkerLoader","parseMTL","MTLLoader","MTLWorkerLoader","parse","arrayBuffer","options","TextDecoder","decode","parseTextSync","text","mtl"],"sources":["../src/index.ts"],"sourcesContent":["import type {LoaderWithParser} from '@loaders.gl/loader-utils';\nimport type {Mesh} from '@loaders.gl/schema';\nimport {parseOBJ} from './lib/parse-obj';\nimport type {OBJLoaderOptions} from './obj-loader';\nimport {OBJLoader as OBJWorkerLoader} from './obj-loader';\n\nimport type {MTLMaterial} from './lib/parse-mtl';\nimport {parseMTL} from './lib/parse-mtl';\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: LoaderWithParser<Mesh, never, OBJLoaderOptions> = {\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: LoaderWithParser<MTLMaterial[], never, MTLLoaderOptions> = {\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"],"mappings":"SAEQA,QAAQ;AAAA,SAERC,SAAS,IAAIC,eAAe;AAAA,SAG5BC,QAAQ;AAAA,SAERC,SAAS,IAAIC,eAAe;AAIpC,SAAQH,eAAe;AAKvB,OAAO,MAAMD,SAA0D,GAAG;EACxE,GAAGC,eAAe;EAClBI,KAAK,EAAE,MAAAA,CAAOC,WAAwB,EAAEC,OAA0B,KAChER,QAAQ,CAAC,IAAIS,WAAW,CAAC,CAAC,CAACC,MAAM,CAACH,WAAW,CAAC,EAAEC,OAAO,CAAC;EAC1DG,aAAa,EAAEA,CAACC,IAAY,EAAEJ,OAA0B,KAAKR,QAAQ,CAACY,IAAI,EAAEJ,OAAO;AACrF,CAAC;AAOD,OAAO,MAAMJ,SAAmE,GAAG;EACjF,GAAGC,eAAe;EAClBC,KAAK,EAAE,MAAAA,CAAOC,WAAwB,EAAEC,OAA0B,KAChEL,QAAQ,CAAC,IAAIM,WAAW,CAAC,CAAC,CAACC,MAAM,CAACH,WAAW,CAAC,EAAEC,OAAO,aAAPA,OAAO,uBAAPA,OAAO,CAAEK,GAAG,CAAC;EAC/DF,aAAa,EAAEA,CAACC,IAAY,EAAEJ,OAA0B,KAAKL,QAAQ,CAACS,IAAI,EAAEJ,OAAO,aAAPA,OAAO,uBAAPA,OAAO,CAAEK,GAAG;AAC1F,CAAC"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-obj-schema.js","names":["getDataTypeFromArray","getOBJSchema","attributes","metadata","arguments","length","undefined","stringMetadata","key","JSON","stringify","fields","attributeName","attribute","field","getFieldFromAttribute","push","name","type","value","isSingleValue","size","listSize","children","nullable"],"sources":["../../src/lib/get-obj-schema.ts"],"sourcesContent":["// loaders.gl, MIT license\n\nimport type {Schema, SchemaMetadata, Field, MeshAttribute} from '@loaders.gl/schema';\nimport {getDataTypeFromArray} from '@loaders.gl/schema';\n\n/** Get Mesh Schema */\nexport function getOBJSchema(\n  attributes: Record<string, MeshAttribute>,\n  metadata: Record<string, unknown> = {}\n): Schema {\n  const stringMetadata: SchemaMetadata = {};\n  for (const key in metadata) {\n    if (key !== 'value') {\n      stringMetadata[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 = getFieldFromAttribute(attributeName, attribute);\n    fields.push(field);\n  }\n\n  return {fields, metadata: stringMetadata};\n}\n\n/** Get a Field describing the column from an OBJ attribute */\nfunction getFieldFromAttribute(name: string, attribute: MeshAttribute): Field {\n  const metadata: Record<string, string> = {};\n  for (const key in attribute) {\n    if (key !== 'value') {\n      metadata[key] = JSON.stringify(attribute[key]);\n    }\n  }\n\n  let {type} = getDataTypeFromArray(attribute.value);\n  const isSingleValue = attribute.size === 1 || attribute.size === undefined;\n  if (!isSingleValue) {\n    type = {type: 'fixed-size-list', listSize: attribute.size, children: [{name: 'values', type}]};\n  }\n  return {name, type, nullable: false, metadata};\n}\n"],"mappings":"AAGA,SAAQA,oBAAoB,QAAO,oBAAoB;AAGvD,OAAO,SAASC,YAAYA,CAC1BC,UAAyC,EAEjC;EAAA,IADRC,QAAiC,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC,CAAC;EAEtC,MAAMG,cAA8B,GAAG,CAAC,CAAC;EACzC,KAAK,MAAMC,GAAG,IAAIL,QAAQ,EAAE;IAC1B,IAAIK,GAAG,KAAK,OAAO,EAAE;MACnBD,cAAc,CAACC,GAAG,CAAC,GAAGC,IAAI,CAACC,SAAS,CAACP,QAAQ,CAACK,GAAG,CAAC,CAAC;IACrD;EACF;EAEA,MAAMG,MAAe,GAAG,EAAE;EAC1B,KAAK,MAAMC,aAAa,IAAIV,UAAU,EAAE;IACtC,MAAMW,SAAS,GAAGX,UAAU,CAACU,aAAa,CAAC;IAC3C,MAAME,KAAK,GAAGC,qBAAqB,CAACH,aAAa,EAAEC,SAAS,CAAC;IAC7DF,MAAM,CAACK,IAAI,CAACF,KAAK,CAAC;EACpB;EAEA,OAAO;IAACH,MAAM;IAAER,QAAQ,EAAEI;EAAc,CAAC;AAC3C;AAGA,SAASQ,qBAAqBA,CAACE,IAAY,EAAEJ,SAAwB,EAAS;EAC5E,MAAMV,QAAgC,GAAG,CAAC,CAAC;EAC3C,KAAK,MAAMK,GAAG,IAAIK,SAAS,EAAE;IAC3B,IAAIL,GAAG,KAAK,OAAO,EAAE;MACnBL,QAAQ,CAACK,GAAG,CAAC,GAAGC,IAAI,CAACC,SAAS,CAACG,SAAS,CAACL,GAAG,CAAC,CAAC;IAChD;EACF;EAEA,IAAI;IAACU;EAAI,CAAC,GAAGlB,oBAAoB,CAACa,SAAS,CAACM,KAAK,CAAC;EAClD,MAAMC,aAAa,GAAGP,SAAS,CAACQ,IAAI,KAAK,CAAC,IAAIR,SAAS,CAACQ,IAAI,KAAKf,SAAS;EAC1E,IAAI,CAACc,aAAa,EAAE;IAClBF,IAAI,GAAG;MAACA,IAAI,EAAE,iBAAiB;MAAEI,QAAQ,EAAET,SAAS,CAACQ,IAAI;MAAEE,QAAQ,EAAE,CAAC;QAACN,IAAI,EAAE,QAAQ;QAAEC;MAAI,CAAC;IAAC,CAAC;EAChG;EACA,OAAO;IAACD,IAAI;IAAEC,IAAI;IAAEM,QAAQ,EAAE,KAAK;IAAErB;EAAQ,CAAC;AAChD"}

package/dist/{es5/lib → lib}/obj-types.js.map

@@ -1 +1 @@
-{"version":3,"file":"obj-types.js","names":[],"sources":["../../../src/lib/obj-types.ts"],"sourcesContent":[""],"mappings":""}
+{"version":3,"file":"obj-types.js","names":[],"sources":["../../src/lib/obj-types.ts"],"sourcesContent":[""],"mappings":""}

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

@@ -0,0 +1 @@
+{"version":3,"file":"parse-mtl.js","names":["DELIMITER_PATTERN","parseMTL","text","options","materials","currentMaterial","name","lines","split","line","trim","length","charAt","pos","indexOf","key","substring","toLowerCase","value","push","ambientColor","parseColor","diffuseColor","diffuseTextureUrl","specularColor","specularTextureUrl","emissiveColor","emissiveTextureUrl","shininess","parseFloat","refraction","illumination","rgb","color"],"sources":["../../src/lib/parse-mtl.ts"],"sourcesContent":["// loaders.gl, MIT license\n// Forked from THREE.js under MIT license\n// https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/MTLLoader.js\n\n// import type {DiffuseMaterial} from '@loaders.gl/schema';\n\nexport type MTLMaterial = {\n  name: string;\n  ambientColor?: [number, number, number];\n  diffuseColor?: [number, number, number];\n  specularColor?: [number, number, number];\n  emissiveColor?: [number, number, number];\n  // specular?: number;\n  shininess?: number;\n  refraction?: number;\n  illumination?: number;\n  diffuseTextureUrl?: string;\n  emissiveTextureUrl?: string;\n  specularTextureUrl?: string;\n};\n\nconst DELIMITER_PATTERN = /\\s+/;\n\n/**\n * Set of options on how to construct materials\n * @param normalizeRGB: RGBs need to be normalized to 0-1 from 0-255 (Default: false, assumed to be already normalized)\n * @param ignoreZeroRGBs: Ignore values of RGBs (Ka,Kd,Ks) that are all 0's Default: false\n * @param baseUrl - Url relative to which textures are loaded\n */\nexport type ParseMTLOptions = {\n  normalizeRGB?: boolean;\n  ignoreZeroRGBs?: boolean;\n  baseUrl?: string;\n};\n\n/**\n * Parses a MTL file.\n * Parses a Wavefront .mtl file specifying materials\n * http://paulbourke.net/dataformats/mtl/\n * https://www.loc.gov/preservation/digital/formats/fdd/fdd000508.shtml\n *\n * @param  text - Content of MTL file\n */\n// eslint-disable-next-line complexity\nexport function parseMTL(text: string, options?: ParseMTLOptions): MTLMaterial[] {\n  // const materialsInfo: Record<string, MTLMaterial> = {};\n  const materials: MTLMaterial[] = [];\n\n  let currentMaterial: MTLMaterial = {name: 'placeholder'};\n\n  const lines = text.split('\\n');\n  for (let line of lines) {\n    line = line.trim();\n\n    if (line.length === 0 || line.charAt(0) === '#') {\n      // Blank line or comment ignore\n      continue; // eslint-disable-line no-continue\n    }\n\n    const pos = line.indexOf(' ');\n\n    let key = pos >= 0 ? line.substring(0, pos) : line;\n    key = key.toLowerCase();\n\n    let value = pos >= 0 ? line.substring(pos + 1) : '';\n    value = value.trim();\n\n    switch (key) {\n      case 'newmtl':\n        // New material\n        currentMaterial = {name: value};\n        // insert into map\n        materials.push(currentMaterial);\n        break;\n\n      case 'ka': // Ka\n        currentMaterial.ambientColor = parseColor(value);\n        break;\n\n      case 'kd':\n        // Kd: Diffuse color (color under white light) using RGB values\n        currentMaterial.diffuseColor = parseColor(value);\n        break;\n      case 'map_kd':\n        // Diffuse texture map\n        currentMaterial.diffuseTextureUrl = value;\n        //         setMapForType('map', value);\n        break;\n\n      case 'ks':\n        // Specular color (color when light is reflected from shiny surface) using RGB values\n        currentMaterial.specularColor = parseColor(value);\n        break;\n      case 'map_ks':\n        // Specular map\n        currentMaterial.specularTextureUrl = value;\n        // setMapForType('specularMap', value);\n        break;\n\n      case 'ke':\n        // Emissive using RGB values\n        currentMaterial.emissiveColor = parseColor(value);\n        break;\n      case 'map_ke':\n        // Emissive map\n        currentMaterial.emissiveTextureUrl = value;\n        // setMapForType('emissiveMap', value);\n        break;\n\n      case 'ns':\n        // Ns is material specular exponent (defines the focus of the specular highlight)\n        // A high exponent results in a tight, concentrated highlight. Ns values normally range from 0 to 1000.\n        currentMaterial.shininess = parseFloat(value);\n        break;\n      case 'map_ns':\n        // Ns is material specular exponent\n        // TODO?\n        // currentMaterial.shininessMap = parseFloat(value);\n        break;\n      case 'ni':\n        currentMaterial.refraction = parseFloat(value);\n        break;\n      case 'illum':\n        currentMaterial.illumination = parseFloat(value);\n        break;\n\n      default:\n        // log unknown message?\n        break;\n\n      /*\n      case 'norm':\n        setMapForType('normalMap', value);\n        break;\n\n      case 'map_bump':\n      case 'bump':\n        // Bump texture map\n        setMapForType('bumpMap', value);\n        break;\n\n      case 'd':\n        n = parseFloat(value);\n        if (n < 1) {\n          params.opacity = n;\n          params.transparent = true;\n        }\n        break;\n\n      case 'map_d':\n        // Alpha map\n        setMapForType('alphaMap', value);\n        params.transparent = true;\n        break;\n\n      case 'tr':\n        n = parseFloat(value);\n        if (this.options && this.options.invertTrProperty) n = 1 - n;\n        if (n > 0) {\n          params.opacity = 1 - n;\n          params.transparent = true;\n        }\n      */\n    }\n  }\n\n  return materials;\n}\n\nfunction parseColor(value: string, options?: ParseMTLOptions): [number, number, number] {\n  const rgb = value.split(DELIMITER_PATTERN, 3);\n  const color: [number, number, number] = [\n    parseFloat(rgb[0]),\n    parseFloat(rgb[1]),\n    parseFloat(rgb[2])\n  ];\n  // TODO auto detect big values?\n  // if (this.options && this.options.normalizeRGB) {\n  //   value = [ value[ 0 ] / 255, value[ 1 ] / 255, value[ 2 ] / 255 ];\n  // }\n\n  // if (this.options && this.options.ignoreZeroRGBs) {\n  //   if (value[ 0 ] === 0 && value[ 1 ] === 0 && value[ 2 ] === 0) {\n  //     // ignore\n  //     save = false;\n  //   }\n  // }\n  return color;\n}\n\n/* TODO parse url options\nfunction parseTexture(value, matParams) {\n  const texParams = {\n    scale: new Vector2(1, 1),\n    offset: new Vector2(0, 0)\n  };\n\n  const items = value.split(/\\s+/);\n  let pos;\n\n  pos = items.indexOf('-bm');\n  if (pos >= 0) {\n    matParams.bumpScale = parseFloat(items[ pos + 1 ]);\n    items.splice(pos, 2);\n  }\n\n  pos = items.indexOf('-s');\n  if (pos >= 0) {\n    texParams.scale.set(parseFloat(items[ pos + 1 ]), parseFloat(items[ pos + 2 ]));\n    items.splice(pos, 4); // we expect 3 parameters here!\n\n  }\n\n  pos = items.indexOf('-o');\n\n  if (pos >= 0) {\n    texParams.offset.set(parseFloat(items[ pos + 1 ]), parseFloat(items[ pos + 2 ]));\n    items.splice(pos, 4); // we expect 3 parameters here!\n  }\n\n  texParams.url = items.join(' ').trim();\n  return texParams;\n}\n\n *function resolveURL(baseUrl, url) {\n * baseUrl?: string;\n    // Absolute URL\n    if (/^https?:\\/\\//i.test(url)) return url;\n    return baseUrl + url;\n  }\n\n  function setMapForType(mapType, value) {\n    if (params[ mapType ]) return; // Keep the first encountered texture\n\n    const texParams = scope.getTextureParams(value, params);\n    const map = scope.loadTexture(resolveURL(scope.baseUrl, texParams.url));\n\n    map.repeat.copy(texParams.scale);\n    map.offset.copy(texParams.offset);\n\n    map.wrapS = scope.wrap;\n    map.wrapT = scope.wrap;\n\n    params[ mapType ] = map;\n  }\n*/\n"],"mappings":"AAqBA,MAAMA,iBAAiB,GAAG,KAAK;AAuB/B,OAAO,SAASC,QAAQA,CAACC,IAAY,EAAEC,OAAyB,EAAiB;EAE/E,MAAMC,SAAwB,GAAG,EAAE;EAEnC,IAAIC,eAA4B,GAAG;IAACC,IAAI,EAAE;EAAa,CAAC;EAExD,MAAMC,KAAK,GAAGL,IAAI,CAACM,KAAK,CAAC,IAAI,CAAC;EAC9B,KAAK,IAAIC,IAAI,IAAIF,KAAK,EAAE;IACtBE,IAAI,GAAGA,IAAI,CAACC,IAAI,CAAC,CAAC;IAElB,IAAID,IAAI,CAACE,MAAM,KAAK,CAAC,IAAIF,IAAI,CAACG,MAAM,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE;MAE/C;IACF;IAEA,MAAMC,GAAG,GAAGJ,IAAI,CAACK,OAAO,CAAC,GAAG,CAAC;IAE7B,IAAIC,GAAG,GAAGF,GAAG,IAAI,CAAC,GAAGJ,IAAI,CAACO,SAAS,CAAC,CAAC,EAAEH,GAAG,CAAC,GAAGJ,IAAI;IAClDM,GAAG,GAAGA,GAAG,CAACE,WAAW,CAAC,CAAC;IAEvB,IAAIC,KAAK,GAAGL,GAAG,IAAI,CAAC,GAAGJ,IAAI,CAACO,SAAS,CAACH,GAAG,GAAG,CAAC,CAAC,GAAG,EAAE;IACnDK,KAAK,GAAGA,KAAK,CAACR,IAAI,CAAC,CAAC;IAEpB,QAAQK,GAAG;MACT,KAAK,QAAQ;QAEXV,eAAe,GAAG;UAACC,IAAI,EAAEY;QAAK,CAAC;QAE/Bd,SAAS,CAACe,IAAI,CAACd,eAAe,CAAC;QAC/B;MAEF,KAAK,IAAI;QACPA,eAAe,CAACe,YAAY,GAAGC,UAAU,CAACH,KAAK,CAAC;QAChD;MAEF,KAAK,IAAI;QAEPb,eAAe,CAACiB,YAAY,GAAGD,UAAU,CAACH,KAAK,CAAC;QAChD;MACF,KAAK,QAAQ;QAEXb,eAAe,CAACkB,iBAAiB,GAAGL,KAAK;QAEzC;MAEF,KAAK,IAAI;QAEPb,eAAe,CAACmB,aAAa,GAAGH,UAAU,CAACH,KAAK,CAAC;QACjD;MACF,KAAK,QAAQ;QAEXb,eAAe,CAACoB,kBAAkB,GAAGP,KAAK;QAE1C;MAEF,KAAK,IAAI;QAEPb,eAAe,CAACqB,aAAa,GAAGL,UAAU,CAACH,KAAK,CAAC;QACjD;MACF,KAAK,QAAQ;QAEXb,eAAe,CAACsB,kBAAkB,GAAGT,KAAK;QAE1C;MAEF,KAAK,IAAI;QAGPb,eAAe,CAACuB,SAAS,GAAGC,UAAU,CAACX,KAAK,CAAC;QAC7C;MACF,KAAK,QAAQ;QAIX;MACF,KAAK,IAAI;QACPb,eAAe,CAACyB,UAAU,GAAGD,UAAU,CAACX,KAAK,CAAC;QAC9C;MACF,KAAK,OAAO;QACVb,eAAe,CAAC0B,YAAY,GAAGF,UAAU,CAACX,KAAK,CAAC;QAChD;MAEF;QAEE;IAmCJ;EACF;EAEA,OAAOd,SAAS;AAClB;AAEA,SAASiB,UAAUA,CAACH,KAAa,EAAEf,OAAyB,EAA4B;EACtF,MAAM6B,GAAG,GAAGd,KAAK,CAACV,KAAK,CAACR,iBAAiB,EAAE,CAAC,CAAC;EAC7C,MAAMiC,KAA+B,GAAG,CACtCJ,UAAU,CAACG,GAAG,CAAC,CAAC,CAAC,CAAC,EAClBH,UAAU,CAACG,GAAG,CAAC,CAAC,CAAC,CAAC,EAClBH,UAAU,CAACG,GAAG,CAAC,CAAC,CAAC,CAAC,CACnB;EAYD,OAAOC,KAAK;AACd"}

package/dist/{esm/lib → lib}/parse-obj-meshes.js

@@ -315,7 +315,7 @@ export function parseOBJMeshes(text) {
       if (material) material.smooth = state.object.smooth;
     } else {
       if (line === '\0') continue;
-      throw new Error("Unexpected line: \"".concat(line, "\""));
+      throw new Error(`Unexpected line: "${line}"`);
     }
   }
   state.finalize();