three-stdlib 2.22.7 → 2.22.9

package/dist/loaders/MTLLoader.d.ts

@@ -0,0 +1,100 @@
+import { Material, LoadingManager, Mapping, Loader, BufferGeometry, Side, Texture, Vector2, Wrapping } from 'three'
+
+export interface MaterialCreatorOptions {
+  /**
+   * side: Which side to apply the material
+   * THREE.FrontSide (default), THREE.BackSide, THREE.DoubleSide
+   */
+  side?: Side | undefined
+  /*
+   * wrap: What type of wrapping to apply for textures
+   * THREE.RepeatWrapping (default), THREE.ClampToEdgeWrapping, THREE.MirroredRepeatWrapping
+   */
+  wrap?: Wrapping | undefined
+  /*
+   * normalizeRGB: RGBs need to be normalized to 0-1 from 0-255
+   * Default: false, assumed to be already normalized
+   */
+  normalizeRGB?: boolean | undefined
+  /*
+   * ignoreZeroRGBs: Ignore values of RGBs (Ka,Kd,Ks) that are all 0's
+   * Default: false
+   */
+  ignoreZeroRGBs?: boolean | undefined
+  /*
+   * invertTrProperty: Use values 1 of Tr field for fully opaque. This option is useful for obj
+   * exported from 3ds MAX, vcglib or meshlab.
+   * Default: false
+   */
+  invertTrProperty?: boolean | undefined
+}
+
+export class MTLLoader extends Loader {
+  constructor(manager?: LoadingManager)
+  materialOptions: MaterialCreatorOptions
+
+  load(
+    url: string,
+    onLoad: (materialCreator: MaterialCreator) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  parse(text: string, path: string): MaterialCreator
+  setMaterialOptions(value: MaterialCreatorOptions): void
+
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<MaterialCreator>
+}
+
+export interface MaterialInfo {
+  ks?: number[] | undefined
+  kd?: number[] | undefined
+  ke?: number[] | undefined
+  map_kd?: string | undefined
+  map_ks?: string | undefined
+  map_ke?: string | undefined
+  norm?: string | undefined
+  map_bump?: string | undefined
+  bump?: string | undefined
+  map_d?: string | undefined
+  ns?: number | undefined
+  d?: number | undefined
+  tr?: number | undefined
+}
+
+export interface TexParams {
+  scale: Vector2
+  offset: Vector2
+  url: string
+}
+
+export class MaterialCreator {
+  constructor(baseUrl?: string, options?: MaterialCreatorOptions)
+
+  baseUrl: string
+  options: MaterialCreatorOptions
+  materialsInfo: { [key: string]: MaterialInfo }
+  materials: { [key: string]: Material }
+  private materialsArray: Material[]
+  nameLookup: { [key: string]: number }
+  side: Side
+  wrap: Wrapping
+  crossOrigin: string
+
+  setCrossOrigin(value: string): this
+  setManager(value: LoadingManager): void
+  setMaterials(materialsInfo: { [key: string]: MaterialInfo }): void
+  convert(materialsInfo: { [key: string]: MaterialInfo }): { [key: string]: MaterialInfo }
+  preload(): void
+  getIndex(materialName: string): number
+  getAsArray(): Material[]
+  create(materialName: string): Material
+  createMaterial_(materialName: string): Material
+  getTextureParams(value: string, matParams: any): TexParams
+  loadTexture(
+    url: string,
+    mapping?: Mapping,
+    onLoad?: (bufferGeometry: BufferGeometry) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): Texture
+}

package/dist/loaders/MTLLoader.js

@@ -0,0 +1,304 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+class MTLLoader extends THREE.Loader {
+  constructor(manager) {
+    super(manager);
+  }
+  /**
+   * Loads and parses a MTL asset from a URL.
+   *
+   * @param {String} url - URL to the MTL file.
+   * @param {Function} [onLoad] - Callback invoked with the loaded object.
+   * @param {Function} [onProgress] - Callback for download progress.
+   * @param {Function} [onError] - Callback for download errors.
+   *
+   * @see setPath setResourcePath
+   *
+   * @note In order for relative texture references to resolve correctly
+   * you must call setResourcePath() explicitly prior to load.
+   */
+  load(url, onLoad, onProgress, onError) {
+    const scope = this;
+    const path = this.path === "" ? THREE.LoaderUtils.extractUrlBase(url) : this.path;
+    const loader = new THREE.FileLoader(this.manager);
+    loader.setPath(this.path);
+    loader.setRequestHeader(this.requestHeader);
+    loader.setWithCredentials(this.withCredentials);
+    loader.load(
+      url,
+      function(text) {
+        try {
+          onLoad(scope.parse(text, path));
+        } catch (e) {
+          if (onError) {
+            onError(e);
+          } else {
+            console.error(e);
+          }
+          scope.manager.itemError(url);
+        }
+      },
+      onProgress,
+      onError
+    );
+  }
+  setMaterialOptions(value) {
+    this.materialOptions = value;
+    return this;
+  }
+  /**
+   * Parses a MTL file.
+   *
+   * @param {String} text - Content of MTL file
+   * @return {MaterialCreator}
+   *
+   * @see setPath setResourcePath
+   *
+   * @note In order for relative texture references to resolve correctly
+   * you must call setResourcePath() explicitly prior to parse.
+   */
+  parse(text, path) {
+    const lines = text.split("\n");
+    let info = {};
+    const delimiter_pattern = /\s+/;
+    const materialsInfo = {};
+    for (let i = 0; i < lines.length; i++) {
+      let line = lines[i];
+      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();
+      if (key === "newmtl") {
+        info = { name: value };
+        materialsInfo[value] = info;
+      } else {
+        if (key === "ka" || key === "kd" || key === "ks" || key === "ke") {
+          const ss = value.split(delimiter_pattern, 3);
+          info[key] = [parseFloat(ss[0]), parseFloat(ss[1]), parseFloat(ss[2])];
+        } else {
+          info[key] = value;
+        }
+      }
+    }
+    const materialCreator = new MaterialCreator(this.resourcePath || path, this.materialOptions);
+    materialCreator.setCrossOrigin(this.crossOrigin);
+    materialCreator.setManager(this.manager);
+    materialCreator.setMaterials(materialsInfo);
+    return materialCreator;
+  }
+}
+class MaterialCreator {
+  constructor(baseUrl = "", options = {}) {
+    this.baseUrl = baseUrl;
+    this.options = options;
+    this.materialsInfo = {};
+    this.materials = {};
+    this.materialsArray = [];
+    this.nameLookup = {};
+    this.crossOrigin = "anonymous";
+    this.side = this.options.side !== void 0 ? this.options.side : THREE.FrontSide;
+    this.wrap = this.options.wrap !== void 0 ? this.options.wrap : THREE.RepeatWrapping;
+  }
+  setCrossOrigin(value) {
+    this.crossOrigin = value;
+    return this;
+  }
+  setManager(value) {
+    this.manager = value;
+  }
+  setMaterials(materialsInfo) {
+    this.materialsInfo = this.convert(materialsInfo);
+    this.materials = {};
+    this.materialsArray = [];
+    this.nameLookup = {};
+  }
+  convert(materialsInfo) {
+    if (!this.options)
+      return materialsInfo;
+    const converted = {};
+    for (const mn in materialsInfo) {
+      const mat = materialsInfo[mn];
+      const covmat = {};
+      converted[mn] = covmat;
+      for (const prop in mat) {
+        let save = true;
+        let value = mat[prop];
+        const lprop = prop.toLowerCase();
+        switch (lprop) {
+          case "kd":
+          case "ka":
+          case "ks":
+            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) {
+                save = false;
+              }
+            }
+            break;
+          default:
+            break;
+        }
+        if (save) {
+          covmat[lprop] = value;
+        }
+      }
+    }
+    return converted;
+  }
+  preload() {
+    for (const mn in this.materialsInfo) {
+      this.create(mn);
+    }
+  }
+  getIndex(materialName) {
+    return this.nameLookup[materialName];
+  }
+  getAsArray() {
+    let index = 0;
+    for (const mn in this.materialsInfo) {
+      this.materialsArray[index] = this.create(mn);
+      this.nameLookup[mn] = index;
+      index++;
+    }
+    return this.materialsArray;
+  }
+  create(materialName) {
+    if (this.materials[materialName] === void 0) {
+      this.createMaterial_(materialName);
+    }
+    return this.materials[materialName];
+  }
+  createMaterial_(materialName) {
+    const scope = this;
+    const mat = this.materialsInfo[materialName];
+    const params = {
+      name: materialName,
+      side: this.side
+    };
+    function resolveURL(baseUrl, url) {
+      if (typeof url !== "string" || url === "")
+        return "";
+      if (/^https?:\/\//i.test(url))
+        return url;
+      return baseUrl + url;
+    }
+    function setMapForType(mapType, value) {
+      if (params[mapType])
+        return;
+      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;
+    }
+    for (const prop in mat) {
+      const value = mat[prop];
+      let n;
+      if (value === "")
+        continue;
+      switch (prop.toLowerCase()) {
+        case "kd":
+          params.color = new THREE.Color().fromArray(value);
+          break;
+        case "ks":
+          params.specular = new THREE.Color().fromArray(value);
+          break;
+        case "ke":
+          params.emissive = new THREE.Color().fromArray(value);
+          break;
+        case "map_kd":
+          setMapForType("map", value);
+          break;
+        case "map_ks":
+          setMapForType("specularMap", value);
+          break;
+        case "map_ke":
+          setMapForType("emissiveMap", value);
+          break;
+        case "norm":
+          setMapForType("normalMap", value);
+          break;
+        case "map_bump":
+        case "bump":
+          setMapForType("bumpMap", value);
+          break;
+        case "map_d":
+          setMapForType("alphaMap", value);
+          params.transparent = true;
+          break;
+        case "ns":
+          params.shininess = parseFloat(value);
+          break;
+        case "d":
+          n = parseFloat(value);
+          if (n < 1) {
+            params.opacity = n;
+            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;
+          }
+          break;
+        default:
+          break;
+      }
+    }
+    this.materials[materialName] = new THREE.MeshPhongMaterial(params);
+    return this.materials[materialName];
+  }
+  getTextureParams(value, matParams) {
+    const texParams = {
+      scale: new THREE.Vector2(1, 1),
+      offset: new THREE.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);
+    }
+    pos = items.indexOf("-o");
+    if (pos >= 0) {
+      texParams.offset.set(parseFloat(items[pos + 1]), parseFloat(items[pos + 2]));
+      items.splice(pos, 4);
+    }
+    texParams.url = items.join(" ").trim();
+    return texParams;
+  }
+  loadTexture(url, mapping, onLoad, onProgress, onError) {
+    const manager = this.manager !== void 0 ? this.manager : THREE.DefaultLoadingManager;
+    let loader = manager.getHandler(url);
+    if (loader === null) {
+      loader = new THREE.TextureLoader(manager);
+    }
+    if (loader.setCrossOrigin)
+      loader.setCrossOrigin(this.crossOrigin);
+    const texture = loader.load(url, onLoad, onProgress, onError);
+    if (mapping !== void 0)
+      texture.mapping = mapping;
+    return texture;
+  }
+}
+exports.MTLLoader = MTLLoader;

package/dist/loaders/MTLLoader.mjs

@@ -0,0 +1,304 @@
+import { Loader, LoaderUtils, FileLoader, FrontSide, RepeatWrapping, Color, MeshPhongMaterial, Vector2, DefaultLoadingManager, TextureLoader } from "three";
+class MTLLoader extends Loader {
+  constructor(manager) {
+    super(manager);
+  }
+  /**
+   * Loads and parses a MTL asset from a URL.
+   *
+   * @param {String} url - URL to the MTL file.
+   * @param {Function} [onLoad] - Callback invoked with the loaded object.
+   * @param {Function} [onProgress] - Callback for download progress.
+   * @param {Function} [onError] - Callback for download errors.
+   *
+   * @see setPath setResourcePath
+   *
+   * @note In order for relative texture references to resolve correctly
+   * you must call setResourcePath() explicitly prior to load.
+   */
+  load(url, onLoad, onProgress, onError) {
+    const scope = this;
+    const path = this.path === "" ? LoaderUtils.extractUrlBase(url) : this.path;
+    const loader = new FileLoader(this.manager);
+    loader.setPath(this.path);
+    loader.setRequestHeader(this.requestHeader);
+    loader.setWithCredentials(this.withCredentials);
+    loader.load(
+      url,
+      function(text) {
+        try {
+          onLoad(scope.parse(text, path));
+        } catch (e) {
+          if (onError) {
+            onError(e);
+          } else {
+            console.error(e);
+          }
+          scope.manager.itemError(url);
+        }
+      },
+      onProgress,
+      onError
+    );
+  }
+  setMaterialOptions(value) {
+    this.materialOptions = value;
+    return this;
+  }
+  /**
+   * Parses a MTL file.
+   *
+   * @param {String} text - Content of MTL file
+   * @return {MaterialCreator}
+   *
+   * @see setPath setResourcePath
+   *
+   * @note In order for relative texture references to resolve correctly
+   * you must call setResourcePath() explicitly prior to parse.
+   */
+  parse(text, path) {
+    const lines = text.split("\n");
+    let info = {};
+    const delimiter_pattern = /\s+/;
+    const materialsInfo = {};
+    for (let i = 0; i < lines.length; i++) {
+      let line = lines[i];
+      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();
+      if (key === "newmtl") {
+        info = { name: value };
+        materialsInfo[value] = info;
+      } else {
+        if (key === "ka" || key === "kd" || key === "ks" || key === "ke") {
+          const ss = value.split(delimiter_pattern, 3);
+          info[key] = [parseFloat(ss[0]), parseFloat(ss[1]), parseFloat(ss[2])];
+        } else {
+          info[key] = value;
+        }
+      }
+    }
+    const materialCreator = new MaterialCreator(this.resourcePath || path, this.materialOptions);
+    materialCreator.setCrossOrigin(this.crossOrigin);
+    materialCreator.setManager(this.manager);
+    materialCreator.setMaterials(materialsInfo);
+    return materialCreator;
+  }
+}
+class MaterialCreator {
+  constructor(baseUrl = "", options = {}) {
+    this.baseUrl = baseUrl;
+    this.options = options;
+    this.materialsInfo = {};
+    this.materials = {};
+    this.materialsArray = [];
+    this.nameLookup = {};
+    this.crossOrigin = "anonymous";
+    this.side = this.options.side !== void 0 ? this.options.side : FrontSide;
+    this.wrap = this.options.wrap !== void 0 ? this.options.wrap : RepeatWrapping;
+  }
+  setCrossOrigin(value) {
+    this.crossOrigin = value;
+    return this;
+  }
+  setManager(value) {
+    this.manager = value;
+  }
+  setMaterials(materialsInfo) {
+    this.materialsInfo = this.convert(materialsInfo);
+    this.materials = {};
+    this.materialsArray = [];
+    this.nameLookup = {};
+  }
+  convert(materialsInfo) {
+    if (!this.options)
+      return materialsInfo;
+    const converted = {};
+    for (const mn in materialsInfo) {
+      const mat = materialsInfo[mn];
+      const covmat = {};
+      converted[mn] = covmat;
+      for (const prop in mat) {
+        let save = true;
+        let value = mat[prop];
+        const lprop = prop.toLowerCase();
+        switch (lprop) {
+          case "kd":
+          case "ka":
+          case "ks":
+            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) {
+                save = false;
+              }
+            }
+            break;
+          default:
+            break;
+        }
+        if (save) {
+          covmat[lprop] = value;
+        }
+      }
+    }
+    return converted;
+  }
+  preload() {
+    for (const mn in this.materialsInfo) {
+      this.create(mn);
+    }
+  }
+  getIndex(materialName) {
+    return this.nameLookup[materialName];
+  }
+  getAsArray() {
+    let index = 0;
+    for (const mn in this.materialsInfo) {
+      this.materialsArray[index] = this.create(mn);
+      this.nameLookup[mn] = index;
+      index++;
+    }
+    return this.materialsArray;
+  }
+  create(materialName) {
+    if (this.materials[materialName] === void 0) {
+      this.createMaterial_(materialName);
+    }
+    return this.materials[materialName];
+  }
+  createMaterial_(materialName) {
+    const scope = this;
+    const mat = this.materialsInfo[materialName];
+    const params = {
+      name: materialName,
+      side: this.side
+    };
+    function resolveURL(baseUrl, url) {
+      if (typeof url !== "string" || url === "")
+        return "";
+      if (/^https?:\/\//i.test(url))
+        return url;
+      return baseUrl + url;
+    }
+    function setMapForType(mapType, value) {
+      if (params[mapType])
+        return;
+      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;
+    }
+    for (const prop in mat) {
+      const value = mat[prop];
+      let n;
+      if (value === "")
+        continue;
+      switch (prop.toLowerCase()) {
+        case "kd":
+          params.color = new Color().fromArray(value);
+          break;
+        case "ks":
+          params.specular = new Color().fromArray(value);
+          break;
+        case "ke":
+          params.emissive = new Color().fromArray(value);
+          break;
+        case "map_kd":
+          setMapForType("map", value);
+          break;
+        case "map_ks":
+          setMapForType("specularMap", value);
+          break;
+        case "map_ke":
+          setMapForType("emissiveMap", value);
+          break;
+        case "norm":
+          setMapForType("normalMap", value);
+          break;
+        case "map_bump":
+        case "bump":
+          setMapForType("bumpMap", value);
+          break;
+        case "map_d":
+          setMapForType("alphaMap", value);
+          params.transparent = true;
+          break;
+        case "ns":
+          params.shininess = parseFloat(value);
+          break;
+        case "d":
+          n = parseFloat(value);
+          if (n < 1) {
+            params.opacity = n;
+            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;
+          }
+          break;
+        default:
+          break;
+      }
+    }
+    this.materials[materialName] = new MeshPhongMaterial(params);
+    return this.materials[materialName];
+  }
+  getTextureParams(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);
+    }
+    pos = items.indexOf("-o");
+    if (pos >= 0) {
+      texParams.offset.set(parseFloat(items[pos + 1]), parseFloat(items[pos + 2]));
+      items.splice(pos, 4);
+    }
+    texParams.url = items.join(" ").trim();
+    return texParams;
+  }
+  loadTexture(url, mapping, onLoad, onProgress, onError) {
+    const manager = this.manager !== void 0 ? this.manager : DefaultLoadingManager;
+    let loader = manager.getHandler(url);
+    if (loader === null) {
+      loader = new TextureLoader(manager);
+    }
+    if (loader.setCrossOrigin)
+      loader.setCrossOrigin(this.crossOrigin);
+    const texture = loader.load(url, onLoad, onProgress, onError);
+    if (mapping !== void 0)
+      texture.mapping = mapping;
+    return texture;
+  }
+}
+export {
+  MTLLoader
+};