@loaders.gl/obj 3.1.3 → 4.0.0-alpha.5

package/dist/obj-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/obj-loader.ts"],"names":["VERSION","OBJLoader","name","id","module","version","worker","extensions","mimeTypes","testText","testOBJFile","options","obj","text","_typecheckOBJLoader"],"mappings":"AAIA,MAAMA,OAAO,GAAG,2BAAuB,WAAvB,qBAAmD,QAAnE;AASA,OAAO,MAAMC,SAAS,GAAG;AACvBC,EAAAA,IAAI,EAAE,KADiB;AAEvBC,EAAAA,EAAE,EAAE,KAFmB;AAGvBC,EAAAA,MAAM,EAAE,KAHe;AAIvBC,EAAAA,OAAO,EAAEL,OAJc;AAKvBM,EAAAA,MAAM,EAAE,IALe;AAMvBC,EAAAA,UAAU,EAAE,CAAC,KAAD,CANW;AAOvBC,EAAAA,SAAS,EAAE,CAAC,YAAD,CAPY;AAQvBC,EAAAA,QAAQ,EAAEC,WARa;AASvBC,EAAAA,OAAO,EAAE;AACPC,IAAAA,GAAG,EAAE;AADE;AATc,CAAlB;;AAcP,SAASF,WAAT,CAAqBG,IAArB,EAA4C;AAE1C,SAAOA,IAAI,CAAC,CAAD,CAAJ,KAAY,GAAnB;AACD;;AAED,OAAO,MAAMC,mBAA2B,GAAGb,SAApC","sourcesContent":["import type {Loader, LoaderOptions} from '@loaders.gl/loader-utils';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\nexport type OBJLoaderOptions = LoaderOptions & {\n  obj?: {};\n};\n\n/**\n * Worker loader for the OBJ geometry format\n */\nexport const OBJLoader = {\n  name: 'OBJ',\n  id: 'obj',\n  module: 'obj',\n  version: VERSION,\n  worker: true,\n  extensions: ['obj'],\n  mimeTypes: ['text/plain'],\n  testText: testOBJFile,\n  options: {\n    obj: {}\n  }\n};\n\nfunction testOBJFile(text: string): boolean {\n  // TODO - There could be comment line first\n  return text[0] === 'v';\n}\n\nexport const _typecheckOBJLoader: Loader = OBJLoader;\n"],"file":"obj-loader.js"}

package/dist/obj-worker.js

@@ -648,7 +648,7 @@
     }
   }
 
-  // src/lib/parse-obj.ts
+  // src/lib/parse-obj-meshes.ts
   var OBJECT_RE = /^[og]\s*(.+)?/;
   var MATERIAL_RE = /^mtllib /;
   var MATERIAL_USE_RE = /^usemtl /;
@@ -863,7 +863,7 @@
       }
     }
   };
-  var parse_obj_default = (text) => {
+  function parseOBJMeshes(text) {
     const state = new ParserState();
     if (text.indexOf("\r\n") !== -1) {
       text = text.replace(/\r\n/g, "\n");
@@ -1012,7 +1012,7 @@
       meshes.push(mesh);
     }
     return { meshes, materials };
-  };
+  }
 
   // src/lib/get-obj-schema.ts
   function getOBJSchema(attributes, metadata = {}) {
@@ -1043,9 +1043,9 @@
     return isSingleValue ? new Field(attributeName, type, false, metadataMap) : new Field(attributeName, new FixedSizeList(attribute.size, new Field("value", type)), false, metadataMap);
   }
 
-  // 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 = {
@@ -1103,8 +1103,77 @@
     return attributes;
   }
 
+  // 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/obj-loader.ts
-  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var VERSION = true ? "4.0.0-alpha.5" : "latest";
   var OBJLoader = {
     name: "OBJ",
     id: "obj",
@@ -1122,11 +1191,32 @@
     return text[0] === "v";
   }
 
+  // src/mtl-loader.ts
+  var VERSION2 = true ? "4.0.0-alpha.5" : "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) => loadOBJ(new TextDecoder().decode(arrayBuffer), options),
-    parseTextSync: loadOBJ
+    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?.mtl),
+    parseTextSync: (text, options) => parseMTL(text, options?.mtl)
   };
 
   // src/workers/obj-worker.ts

package/dist/workers/obj-worker.js

@@ -1,5 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const index_1 = require("../index");
-(0, loader_utils_1.createLoaderWorker)(index_1.OBJLoader);
+import { createLoaderWorker } from '@loaders.gl/loader-utils';
+import { OBJLoader } from '../index';
+createLoaderWorker(OBJLoader);
+//# sourceMappingURL=obj-worker.js.map

package/dist/workers/obj-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/workers/obj-worker.ts"],"names":["createLoaderWorker","OBJLoader"],"mappings":"AAAA,SAAQA,kBAAR,QAAiC,0BAAjC;AACA,SAAQC,SAAR,QAAwB,UAAxB;AAEAD,kBAAkB,CAACC,SAAD,CAAlB","sourcesContent":["import {createLoaderWorker} from '@loaders.gl/loader-utils';\nimport {OBJLoader} from '../index';\n\ncreateLoaderWorker(OBJLoader);\n"],"file":"obj-worker.js"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/obj",
-  "version": "3.1.3",
+  "version": "4.0.0-alpha.5",
   "description": "Framework-independent loader for the OBJ format",
   "license": "MIT",
   "publishConfig": {
@@ -19,8 +19,8 @@
     "OBJ"
   ],
   "types": "dist/index.d.ts",
-  "main": "dist/es5/index.js",
-  "module": "dist/esm/index.js",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
   "sideEffects": false,
   "files": [
     "src",
@@ -30,12 +30,12 @@
   "scripts": {
     "pre-build": "npm run build-worker && npm run build-bundle",
     "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/dist.min.js",
-    "build-worker": "esbuild src/workers/obj-worker.ts --bundle --outfile=dist/obj-worker.js"
+    "build-worker": "esbuild src/workers/obj-worker.ts --bundle --outfile=dist/obj-worker.js --define:__VERSION__=\\\"$npm_package_version\\\""
   },
   "dependencies": {
     "@babel/runtime": "^7.3.1",
-    "@loaders.gl/loader-utils": "3.1.3",
-    "@loaders.gl/schema": "3.1.3"
+    "@loaders.gl/loader-utils": "4.0.0-alpha.5",
+    "@loaders.gl/schema": "4.0.0-alpha.5"
   },
-  "gitHead": "4a690c369779346d73c9a27395d1c08d77d279a4"
+  "gitHead": "7a71a54bdf1ddf985cc3af3db90b82e7fa97d025"
 }

package/src/index.ts

@@ -1,6 +1,10 @@
 import type {LoaderWithParser} from '@loaders.gl/loader-utils';
-import loadOBJ from './lib/load-obj';
+import {parseOBJ} from './lib/parse-obj';
+import {parseMTL} from './lib/parse-mtl';
+import type {OBJLoaderOptions} from './obj-loader';
 import {OBJLoader as OBJWorkerLoader} from './obj-loader';
+import type {MTLLoaderOptions} from './mtl-loader';
+import {MTLLoader as MTLWorkerLoader} from './mtl-loader';
 
 // OBJLoader
 
@@ -11,8 +15,22 @@ export {OBJWorkerLoader};
  */
 export const OBJLoader = {
   ...OBJWorkerLoader,
-  parse: async (arrayBuffer, options) => loadOBJ(new TextDecoder().decode(arrayBuffer), options),
-  parseTextSync: loadOBJ
+  parse: async (arrayBuffer: ArrayBuffer, options?: OBJLoaderOptions) =>
+    parseOBJ(new TextDecoder().decode(arrayBuffer), options),
+  parseTextSync: (text: string, options?: OBJLoaderOptions) => parseOBJ(text, options)
+};
+
+// MTLLoader
+
+/**
+ * Loader for the MTL material format
+ */
+export const MTLLoader = {
+  ...MTLWorkerLoader,
+  parse: async (arrayBuffer: ArrayBuffer, options?: MTLLoaderOptions) =>
+    parseMTL(new TextDecoder().decode(arrayBuffer), options?.mtl),
+  parseTextSync: (text: string, options?: MTLLoaderOptions) => parseMTL(text, options?.mtl)
 };
 
 export const _typecheckOBJLoader: LoaderWithParser = OBJLoader;
+export const _typecheckMTLLoader: LoaderWithParser = MTLLoader;

package/src/lib/parse-mtl.ts

@@ -0,0 +1,246 @@
+// loaders.gl, MIT license
+// Forked from THREE.js under MIT license
+// https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/MTLLoader.js
+
+// import type {DiffuseMaterial} from '@loaders.gl/schema';
+
+export type MTLMaterial = {
+  name: string;
+  ambientColor?: [number, number, number];
+  diffuseColor?: [number, number, number];
+  specularColor?: [number, number, number];
+  emissiveColor?: [number, number, number];
+  // specular?: number;
+  shininess?: number;
+  refraction?: number;
+  illumination?: number;
+  diffuseTextureUrl?: string;
+  emissiveTextureUrl?: string;
+  specularTextureUrl?: string;
+};
+
+const DELIMITER_PATTERN = /\s+/;
+
+/**
+ * Set of options on how to construct materials
+ * @param normalizeRGB: RGBs need to be normalized to 0-1 from 0-255 (Default: false, assumed to be already normalized)
+ * @param ignoreZeroRGBs: Ignore values of RGBs (Ka,Kd,Ks) that are all 0's Default: false
+ * @param baseUrl - Url relative to which textures are loaded
+ */
+export type ParseMTLOptions = {
+  normalizeRGB?: boolean;
+  ignoreZeroRGBs?: boolean;
+  baseUrl?: string;
+};
+
+/**
+ * Parses a MTL file.
+ * Parses a Wavefront .mtl file specifying materials
+ * http://paulbourke.net/dataformats/mtl/
+ * https://www.loc.gov/preservation/digital/formats/fdd/fdd000508.shtml
+ *
+ * @param  text - Content of MTL file
+ */
+// eslint-disable-next-line complexity
+export function parseMTL(text: string, options?: ParseMTLOptions): MTLMaterial[] {
+  // const materialsInfo: Record<string, MTLMaterial> = {};
+  const materials: MTLMaterial[] = [];
+
+  let currentMaterial: MTLMaterial = {name: 'placeholder'};
+
+  const lines = text.split('\n');
+  for (let line of lines) {
+    line = line.trim();
+
+    if (line.length === 0 || line.charAt(0) === '#') {
+      // Blank line or comment ignore
+      continue; // eslint-disable-line no-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':
+        // New material
+        currentMaterial = {name: value};
+        // insert into map
+        materials.push(currentMaterial);
+        break;
+
+      case 'ka': // Ka
+        currentMaterial.ambientColor = parseColor(value);
+        break;
+
+      case 'kd':
+        // Kd: Diffuse color (color under white light) using RGB values
+        currentMaterial.diffuseColor = parseColor(value);
+        break;
+      case 'map_kd':
+        // Diffuse texture map
+        currentMaterial.diffuseTextureUrl = value;
+        //         setMapForType('map', value);
+        break;
+
+      case 'ks':
+        // Specular color (color when light is reflected from shiny surface) using RGB values
+        currentMaterial.specularColor = parseColor(value);
+        break;
+      case 'map_ks':
+        // Specular map
+        currentMaterial.specularTextureUrl = value;
+        // setMapForType('specularMap', value);
+        break;
+
+      case 'ke':
+        // Emissive using RGB values
+        currentMaterial.emissiveColor = parseColor(value);
+        break;
+      case 'map_ke':
+        // Emissive map
+        currentMaterial.emissiveTextureUrl = value;
+        // setMapForType('emissiveMap', value);
+        break;
+
+      case 'ns':
+        // Ns is material specular exponent (defines the focus of the specular highlight)
+        // A high exponent results in a tight, concentrated highlight. Ns values normally range from 0 to 1000.
+        currentMaterial.shininess = parseFloat(value);
+        break;
+      case 'map_ns':
+        // Ns is material specular exponent
+        // TODO?
+        // currentMaterial.shininessMap = parseFloat(value);
+        break;
+      case 'ni':
+        currentMaterial.refraction = parseFloat(value);
+        break;
+      case 'illum':
+        currentMaterial.illumination = parseFloat(value);
+        break;
+
+      default:
+        // log unknown message?
+        break;
+
+      /*
+      case 'norm':
+        setMapForType('normalMap', value);
+        break;
+
+      case 'map_bump':
+      case 'bump':
+        // Bump texture map
+        setMapForType('bumpMap', value);
+        break;
+
+      case 'd':
+        n = parseFloat(value);
+        if (n < 1) {
+          params.opacity = n;
+          params.transparent = true;
+        }
+        break;
+
+      case 'map_d':
+        // Alpha map
+        setMapForType('alphaMap', value);
+        params.transparent = true;
+        break;
+
+      case 'tr':
+        n = parseFloat(value);
+        if (this.options && this.options.invertTrProperty) n = 1 - n;
+        if (n > 0) {
+          params.opacity = 1 - n;
+          params.transparent = true;
+        }
+      */
+    }
+  }
+
+  return materials;
+}
+
+function parseColor(value: string, options?: ParseMTLOptions): [number, number, number] {
+  const rgb = value.split(DELIMITER_PATTERN, 3);
+  const color: [number, number, number] = [
+    parseFloat(rgb[0]),
+    parseFloat(rgb[1]),
+    parseFloat(rgb[2])
+  ];
+  // TODO auto detect big values?
+  // if (this.options && this.options.normalizeRGB) {
+  //   value = [ value[ 0 ] / 255, value[ 1 ] / 255, value[ 2 ] / 255 ];
+  // }
+
+  // if (this.options && this.options.ignoreZeroRGBs) {
+  //   if (value[ 0 ] === 0 && value[ 1 ] === 0 && value[ 2 ] === 0) {
+  //     // ignore
+  //     save = false;
+  //   }
+  // }
+  return color;
+}
+
+/* TODO parse url options
+function parseTexture(value, matParams) {
+  const texParams = {
+    scale: new Vector2(1, 1),
+    offset: new Vector2(0, 0)
+  };
+
+  const items = value.split(/\s+/);
+  let pos;
+
+  pos = items.indexOf('-bm');
+  if (pos >= 0) {
+    matParams.bumpScale = parseFloat(items[ pos + 1 ]);
+    items.splice(pos, 2);
+  }
+
+  pos = items.indexOf('-s');
+  if (pos >= 0) {
+    texParams.scale.set(parseFloat(items[ pos + 1 ]), parseFloat(items[ pos + 2 ]));
+    items.splice(pos, 4); // we expect 3 parameters here!
+
+  }
+
+  pos = items.indexOf('-o');
+
+  if (pos >= 0) {
+    texParams.offset.set(parseFloat(items[ pos + 1 ]), parseFloat(items[ pos + 2 ]));
+    items.splice(pos, 4); // we expect 3 parameters here!
+  }
+
+  texParams.url = items.join(' ').trim();
+  return texParams;
+}
+
+ *function resolveURL(baseUrl, url) {
+ * baseUrl?: string;
+    // Absolute URL
+    if (/^https?:\/\//i.test(url)) return url;
+    return baseUrl + url;
+  }
+
+  function setMapForType(mapType, value) {
+    if (params[ mapType ]) return; // Keep the first encountered texture
+
+    const texParams = scope.getTextureParams(value, params);
+    const map = scope.loadTexture(resolveURL(scope.baseUrl, texParams.url));
+
+    map.repeat.copy(texParams.scale);
+    map.offset.copy(texParams.offset);
+
+    map.wrapS = scope.wrap;
+    map.wrapT = scope.wrap;
+
+    params[ mapType ] = map;
+  }
+*/