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

package/dist/index.d.ts

@@ -1,72 +1,18 @@
 import type { LoaderWithParser } from '@loaders.gl/loader-utils';
+import type { Mesh } from '@loaders.gl/schema';
 import type { OBJLoaderOptions } from './obj-loader';
 import { OBJLoader as OBJWorkerLoader } from './obj-loader';
+import type { MTLMaterial } from './lib/parse-mtl';
 import type { MTLLoaderOptions } from './mtl-loader';
 export { OBJWorkerLoader };
 /**
  * Loader for the OBJ geometry format
  */
-export declare const OBJLoader: {
-    parse: (arrayBuffer: ArrayBuffer, options?: OBJLoaderOptions | undefined) => Promise<{
-        /**
-         * Loader for the MTL material format
-         */
-        loaderData: {
-            header: {};
-        };
-        schema: import("@loaders.gl/schema").Schema;
-        header: {
-            vertexCount: number;
-            boundingBox: [[number, number, number], [number, number, number]];
-        };
-        mode: number;
-        attributes: import("@loaders.gl/schema").MeshAttributes;
-    }>;
-    parseTextSync: (text: string, options?: OBJLoaderOptions | undefined) => {
-        /**
-         * Loader for the MTL material format
-         */
-        loaderData: {
-            header: {};
-        };
-        schema: import("@loaders.gl/schema").Schema;
-        header: {
-            vertexCount: number;
-            boundingBox: [[number, number, number], [number, number, number]];
-        };
-        mode: number;
-        attributes: import("@loaders.gl/schema").MeshAttributes;
-    };
-    name: string;
-    id: string;
-    module: string;
-    version: any;
-    worker: boolean;
-    extensions: string[];
-    mimeTypes: string[];
-    testText: (text: string) => boolean;
-    options: {
-        obj: {};
-    };
-};
+export declare const OBJLoader: LoaderWithParser<Mesh, never, OBJLoaderOptions>;
 /**
  * Loader for the MTL material format
  */
-export declare const MTLLoader: {
-    parse: (arrayBuffer: ArrayBuffer, options?: MTLLoaderOptions | undefined) => Promise<import("./lib/parse-mtl").MTLMaterial[]>;
-    parseTextSync: (text: string, options?: MTLLoaderOptions | undefined) => import("./lib/parse-mtl").MTLMaterial[];
-    name: string;
-    id: string;
-    module: string;
-    version: any;
-    worker: boolean;
-    extensions: string[];
-    mimeTypes: string[];
-    testText: (text: string) => boolean;
-    options: {
-        mtl: {};
-    };
-};
+export declare const MTLLoader: LoaderWithParser<MTLMaterial[], never, MTLLoaderOptions>;
 export declare const _typecheckOBJLoader: LoaderWithParser;
 export declare const _typecheckMTLLoader: LoaderWithParser;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAG/D,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,cAAc,CAAC;AACnD,OAAO,EAAC,SAAS,IAAI,eAAe,EAAC,MAAM,cAAc,CAAC;AAC1D,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,cAAc,CAAC;AAKnD,OAAO,EAAC,eAAe,EAAC,CAAC;AAEzB;;GAEG;AACH,eAAO,MAAM,SAAS;yBAEO,WAAW;QAOxC;;WAEG;;;;;;;;;;;;0BAPqB,MAAM;QAK9B;;WAEG;;;;;;;;;;;;;;;;;;;;;;;CANF,CAAC;AAIF;;GAEG;AACH,eAAO,MAAM,SAAS;yBAEO,WAAW;0BAEhB,MAAM;;;;;;;;;;;;CAC7B,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,gBAA4B,CAAC;AAC/D,eAAO,MAAM,mBAAmB,EAAE,gBAA4B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,oBAAoB,CAAC;AAE7C,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,cAAc,CAAC;AACnD,OAAO,EAAC,SAAS,IAAI,eAAe,EAAC,MAAM,cAAc,CAAC;AAE1D,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,iBAAiB,CAAC;AAEjD,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,cAAc,CAAC;AAKnD,OAAO,EAAC,eAAe,EAAC,CAAC;AAEzB;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,gBAAgB,CAAC,IAAI,EAAE,KAAK,EAAE,gBAAgB,CAKrE,CAAC;AAIF;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,gBAAgB,CAAC,WAAW,EAAE,EAAE,KAAK,EAAE,gBAAgB,CAK9E,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,gBAA4B,CAAC;AAC/D,eAAO,MAAM,mBAAmB,EAAE,gBAA4B,CAAC"}

package/dist/index.js

@@ -1,16 +1,27 @@
-import { parseOBJ } from './lib/parse-obj';
-import { parseMTL } from './lib/parse-mtl';
-import { OBJLoader as OBJWorkerLoader } from './obj-loader';
-import { MTLLoader as MTLWorkerLoader } from './mtl-loader';
-export { OBJWorkerLoader };
-export const OBJLoader = { ...OBJWorkerLoader,
-  parse: async (arrayBuffer, options) => parseOBJ(new TextDecoder().decode(arrayBuffer), options),
-  parseTextSync: (text, options) => parseOBJ(text, options)
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._typecheckMTLLoader = exports._typecheckOBJLoader = exports.MTLLoader = exports.OBJLoader = exports.OBJWorkerLoader = void 0;
+const parse_obj_1 = require("./lib/parse-obj");
+const obj_loader_1 = require("./obj-loader");
+Object.defineProperty(exports, "OBJWorkerLoader", { enumerable: true, get: function () { return obj_loader_1.OBJLoader; } });
+const parse_mtl_1 = require("./lib/parse-mtl");
+const mtl_loader_1 = require("./mtl-loader");
+/**
+ * Loader for the OBJ geometry format
+ */
+exports.OBJLoader = {
+    ...obj_loader_1.OBJLoader,
+    parse: async (arrayBuffer, options) => (0, parse_obj_1.parseOBJ)(new TextDecoder().decode(arrayBuffer), options),
+    parseTextSync: (text, options) => (0, parse_obj_1.parseOBJ)(text, options)
 };
-export const MTLLoader = { ...MTLWorkerLoader,
-  parse: async (arrayBuffer, options) => parseMTL(new TextDecoder().decode(arrayBuffer), options === null || options === void 0 ? void 0 : options.mtl),
-  parseTextSync: (text, options) => parseMTL(text, options === null || options === void 0 ? void 0 : options.mtl)
+// MTLLoader
+/**
+ * Loader for the MTL material format
+ */
+exports.MTLLoader = {
+    ...mtl_loader_1.MTLLoader,
+    parse: async (arrayBuffer, options) => (0, parse_mtl_1.parseMTL)(new TextDecoder().decode(arrayBuffer), options?.mtl),
+    parseTextSync: (text, options) => (0, parse_mtl_1.parseMTL)(text, options?.mtl)
 };
-export const _typecheckOBJLoader = OBJLoader;
-export const _typecheckMTLLoader = MTLLoader;
-//# sourceMappingURL=index.js.map
+exports._typecheckOBJLoader = exports.OBJLoader;
+exports._typecheckMTLLoader = exports.MTLLoader;

package/dist/lib/get-obj-schema.d.ts

@@ -1,3 +1,4 @@
-import { Schema } from '@loaders.gl/schema';
-export declare function getOBJSchema(attributes: any, metadata?: {}): Schema;
+import type { Schema, MeshAttribute } from '@loaders.gl/schema';
+/** Get Mesh Schema */
+export declare function getOBJSchema(attributes: Record<string, MeshAttribute>, metadata?: Record<string, unknown>): Schema;
 //# sourceMappingURL=get-obj-schema.d.ts.map

package/dist/lib/get-obj-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-obj-schema.d.ts","sourceRoot":"","sources":["../../src/lib/get-obj-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAmD,MAAM,oBAAoB,CAAC;AAE5F,wBAAgB,YAAY,CAAC,UAAU,KAAA,EAAE,QAAQ,KAAK,UAgBrD"}
+{"version":3,"file":"get-obj-schema.d.ts","sourceRoot":"","sources":["../../src/lib/get-obj-schema.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,MAAM,EAAyB,aAAa,EAAC,MAAM,oBAAoB,CAAC;AAGrF,sBAAsB;AACtB,wBAAgB,YAAY,CAC1B,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,EACzC,QAAQ,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GACrC,MAAM,CAgBR"}

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

@@ -1,37 +1,37 @@
-import { Schema, Field, FixedSizeList, getArrowTypeFromTypedArray } from '@loaders.gl/schema';
-export 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]));
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOBJSchema = void 0;
+const schema_1 = require("@loaders.gl/schema");
+/** Get Mesh 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 = getArrowFieldFromAttribute(attributeName, attribute);
-    fields.push(field);
-  }
-
-  return new Schema(fields, metadataMap);
+    const fields = [];
+    for (const attributeName in attributes) {
+        const attribute = attributes[attributeName];
+        const field = getFieldFromAttribute(attributeName, attribute);
+        fields.push(field);
+    }
+    return { fields, metadata: stringMetadata };
 }
-
-function getArrowFieldFromAttribute(attributeName, attribute) {
-  const metadataMap = new Map();
-
-  for (const key in attribute) {
-    if (key !== 'value') {
-      metadataMap.set(key, JSON.stringify(attribute[key]));
+exports.getOBJSchema = getOBJSchema;
+/** Get a Field describing the column from an OBJ attribute */
+function getFieldFromAttribute(name, attribute) {
+    const metadata = {};
+    for (const key in attribute) {
+        if (key !== 'value') {
+            metadata[key] = JSON.stringify(attribute[key]);
+        }
+    }
+    let { type } = (0, schema_1.getDataTypeFromArray)(attribute.value);
+    const isSingleValue = attribute.size === 1 || attribute.size === undefined;
+    if (!isSingleValue) {
+        type = { type: 'fixed-size-list', listSize: attribute.size, children: [{ name: 'values', type }] };
     }
-  }
-
-  const type = getArrowTypeFromTypedArray(attribute.value);
-  const isSingleValue = !('size' in attribute) || attribute.size === 1;
-  return isSingleValue ? new Field(attributeName, type, false, metadataMap) : new Field(attributeName, new FixedSizeList(attribute.size, new Field('value', type)), false, metadataMap);
+    return { name, type, nullable: false, metadata };
 }
-//# sourceMappingURL=get-obj-schema.js.map

package/dist/lib/obj-types.js

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

package/dist/lib/parse-mtl.d.ts

@@ -1,4 +1,4 @@
-export declare type MTLMaterial = {
+export type MTLMaterial = {
     name: string;
     ambientColor?: [number, number, number];
     diffuseColor?: [number, number, number];
@@ -17,7 +17,7 @@ export declare type MTLMaterial = {
  * @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 declare type ParseMTLOptions = {
+export type ParseMTLOptions = {
     normalizeRGB?: boolean;
     ignoreZeroRGBs?: boolean;
     baseUrl?: string;

package/dist/lib/parse-mtl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-mtl.d.ts","sourceRoot":"","sources":["../../src/lib/parse-mtl.ts"],"names":[],"mappings":"AAMA,oBAAY,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAEzC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B,CAAC;AAIF;;;;;GAKG;AACH,oBAAY,eAAe,GAAG;IAC5B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;;;;;;GAOG;AAEH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,WAAW,EAAE,CA2H/E"}
+{"version":3,"file":"parse-mtl.d.ts","sourceRoot":"","sources":["../../src/lib/parse-mtl.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAEzC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B,CAAC;AAIF;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;;;;;;GAOG;AAEH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,WAAW,EAAE,CA2H/E"}

package/dist/lib/parse-mtl.js

@@ -1,86 +1,201 @@
+"use strict";
+// loaders.gl, MIT license
+// Forked from THREE.js under MIT license
+// https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/MTLLoader.js
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMTL = void 0;
 const DELIMITER_PATTERN = /\s+/;
-export 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;
+/**
+ * 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
+function parseMTL(text, options) {
+    // const materialsInfo: Record<string, MTLMaterial> = {};
+    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) === '#') {
+            // 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;
+}
+exports.parseMTL = parseMTL;
+function parseColor(value, options) {
+    const rgb = value.split(DELIMITER_PATTERN, 3);
+    const color = [
+        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 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;
+  const items = value.split(/\s+/);
+  let pos;
 
-      case 'ka':
-        currentMaterial.ambientColor = parseColor(value);
-        break;
+  pos = items.indexOf('-bm');
+  if (pos >= 0) {
+    matParams.bumpScale = parseFloat(items[ pos + 1 ]);
+    items.splice(pos, 2);
+  }
 
-      case 'kd':
-        currentMaterial.diffuseColor = parseColor(value);
-        break;
+  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!
 
-      case 'map_kd':
-        currentMaterial.diffuseTextureUrl = value;
-        break;
+  }
 
-      case 'ks':
-        currentMaterial.specularColor = parseColor(value);
-        break;
+  pos = items.indexOf('-o');
 
-      case 'map_ks':
-        currentMaterial.specularTextureUrl = value;
-        break;
+  if (pos >= 0) {
+    texParams.offset.set(parseFloat(items[ pos + 1 ]), parseFloat(items[ pos + 2 ]));
+    items.splice(pos, 4); // we expect 3 parameters here!
+  }
 
-      case 'ke':
-        currentMaterial.emissiveColor = parseColor(value);
-        break;
+  texParams.url = items.join(' ').trim();
+  return texParams;
+}
 
-      case 'map_ke':
-        currentMaterial.emissiveTextureUrl = value;
-        break;
+ *function resolveURL(baseUrl, url) {
+ * baseUrl?: string;
+    // Absolute URL
+    if (/^https?:\/\//i.test(url)) return url;
+    return baseUrl + url;
+  }
 
-      case 'ns':
-        currentMaterial.shininess = parseFloat(value);
-        break;
+  function setMapForType(mapType, value) {
+    if (params[ mapType ]) return; // Keep the first encountered texture
 
-      case 'map_ns':
-        break;
+    const texParams = scope.getTextureParams(value, params);
+    const map = scope.loadTexture(resolveURL(scope.baseUrl, texParams.url));
 
-      case 'ni':
-        currentMaterial.refraction = parseFloat(value);
-        break;
+    map.repeat.copy(texParams.scale);
+    map.offset.copy(texParams.offset);
 
-      case 'illum':
-        currentMaterial.illumination = parseFloat(value);
-        break;
+    map.wrapS = scope.wrap;
+    map.wrapT = scope.wrap;
 
-      default:
-        break;
-    }
+    params[ mapType ] = map;
   }
-
-  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;
-}
-//# sourceMappingURL=parse-mtl.js.map
+*/