three-stdlib 2.22.7 → 2.22.9

package/dist/loaders/LUT3dlLoader.d.ts

@@ -0,0 +1,20 @@
+import { Loader, LoadingManager, DataTexture, Data3DTexture } from 'three'
+
+export interface LUT3dlResult {
+  size: number
+  texture: DataTexture
+  texture3D: Data3DTexture
+}
+
+export class LUT3dlLoader extends Loader {
+  constructor(manager?: LoadingManager)
+
+  load(
+    url: string,
+    onLoad: (result: LUT3dlResult) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: Error) => void,
+  ): any
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<LUT3dlResult>
+  parse(data: string): LUT3dlResult
+}

package/dist/loaders/LUT3dlLoader.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const Data3DTexture = require("../_polyfill/Data3DTexture.js");
+class LUT3dlLoader extends THREE.Loader {
+  load(url, onLoad, onProgress, onError) {
+    const loader = new THREE.FileLoader(this.manager);
+    loader.setPath(this.path);
+    loader.setResponseType("text");
+    loader.load(
+      url,
+      (text) => {
+        try {
+          onLoad(this.parse(text));
+        } catch (e) {
+          if (onError) {
+            onError(e);
+          } else {
+            console.error(e);
+          }
+          this.manager.itemError(url);
+        }
+      },
+      onProgress,
+      onError
+    );
+  }
+  parse(str) {
+    str = str.replace(/^#.*?(\n|\r)/gm, "").replace(/^\s*?(\n|\r)/gm, "").trim();
+    const lines = str.split(/[\n\r]+/g);
+    const gridLines = lines[0].trim().split(/\s+/g).map((e) => parseFloat(e));
+    const gridStep = gridLines[1] - gridLines[0];
+    const size = gridLines.length;
+    for (let i = 1, l = gridLines.length; i < l; i++) {
+      if (gridStep !== gridLines[i] - gridLines[i - 1]) {
+        throw new Error("LUT3dlLoader: Inconsistent grid size not supported.");
+      }
+    }
+    const dataArray = new Array(size * size * size * 4);
+    let index = 0;
+    let maxOutputValue = 0;
+    for (let i = 1, l = lines.length; i < l; i++) {
+      const line = lines[i].trim();
+      const split = line.split(/\s/g);
+      const r = parseFloat(split[0]);
+      const g = parseFloat(split[1]);
+      const b = parseFloat(split[2]);
+      maxOutputValue = Math.max(maxOutputValue, r, g, b);
+      const bLayer = index % size;
+      const gLayer = Math.floor(index / size) % size;
+      const rLayer = Math.floor(index / (size * size)) % size;
+      const pixelIndex = bLayer * size * size + gLayer * size + rLayer;
+      dataArray[4 * pixelIndex + 0] = r;
+      dataArray[4 * pixelIndex + 1] = g;
+      dataArray[4 * pixelIndex + 2] = b;
+      dataArray[4 * pixelIndex + 3] = 1;
+      index += 1;
+    }
+    const bits = Math.ceil(Math.log2(maxOutputValue));
+    const maxBitValue = Math.pow(2, bits);
+    for (let i = 0, l = dataArray.length; i < l; i += 4) {
+      const r = dataArray[i + 0];
+      const g = dataArray[i + 1];
+      const b = dataArray[i + 2];
+      dataArray[i + 0] = 255 * r / maxBitValue;
+      dataArray[i + 1] = 255 * g / maxBitValue;
+      dataArray[i + 2] = 255 * b / maxBitValue;
+    }
+    const data = new Uint8Array(dataArray);
+    const texture = new THREE.DataTexture();
+    texture.image.data = data;
+    texture.image.width = size;
+    texture.image.height = size * size;
+    texture.format = THREE.RGBAFormat;
+    texture.type = THREE.UnsignedByteType;
+    texture.magFilter = THREE.LinearFilter;
+    texture.minFilter = THREE.LinearFilter;
+    texture.wrapS = THREE.ClampToEdgeWrapping;
+    texture.wrapT = THREE.ClampToEdgeWrapping;
+    texture.generateMipmaps = false;
+    texture.needsUpdate = true;
+    const texture3D = new Data3DTexture.Data3DTexture();
+    texture3D.image.data = data;
+    texture3D.image.width = size;
+    texture3D.image.height = size;
+    texture3D.image.depth = size;
+    texture3D.format = THREE.RGBAFormat;
+    texture3D.type = THREE.UnsignedByteType;
+    texture3D.magFilter = THREE.LinearFilter;
+    texture3D.minFilter = THREE.LinearFilter;
+    texture3D.wrapS = THREE.ClampToEdgeWrapping;
+    texture3D.wrapT = THREE.ClampToEdgeWrapping;
+    texture3D.wrapR = THREE.ClampToEdgeWrapping;
+    texture3D.generateMipmaps = false;
+    texture3D.needsUpdate = true;
+    return {
+      size,
+      texture,
+      texture3D
+    };
+  }
+}
+exports.LUT3dlLoader = LUT3dlLoader;

package/dist/loaders/LUT3dlLoader.mjs

@@ -0,0 +1,103 @@
+import { Loader, FileLoader, DataTexture, RGBAFormat, UnsignedByteType, LinearFilter, ClampToEdgeWrapping } from "three";
+import { Data3DTexture } from "../_polyfill/Data3DTexture.mjs";
+class LUT3dlLoader extends Loader {
+  load(url, onLoad, onProgress, onError) {
+    const loader = new FileLoader(this.manager);
+    loader.setPath(this.path);
+    loader.setResponseType("text");
+    loader.load(
+      url,
+      (text) => {
+        try {
+          onLoad(this.parse(text));
+        } catch (e) {
+          if (onError) {
+            onError(e);
+          } else {
+            console.error(e);
+          }
+          this.manager.itemError(url);
+        }
+      },
+      onProgress,
+      onError
+    );
+  }
+  parse(str) {
+    str = str.replace(/^#.*?(\n|\r)/gm, "").replace(/^\s*?(\n|\r)/gm, "").trim();
+    const lines = str.split(/[\n\r]+/g);
+    const gridLines = lines[0].trim().split(/\s+/g).map((e) => parseFloat(e));
+    const gridStep = gridLines[1] - gridLines[0];
+    const size = gridLines.length;
+    for (let i = 1, l = gridLines.length; i < l; i++) {
+      if (gridStep !== gridLines[i] - gridLines[i - 1]) {
+        throw new Error("LUT3dlLoader: Inconsistent grid size not supported.");
+      }
+    }
+    const dataArray = new Array(size * size * size * 4);
+    let index = 0;
+    let maxOutputValue = 0;
+    for (let i = 1, l = lines.length; i < l; i++) {
+      const line = lines[i].trim();
+      const split = line.split(/\s/g);
+      const r = parseFloat(split[0]);
+      const g = parseFloat(split[1]);
+      const b = parseFloat(split[2]);
+      maxOutputValue = Math.max(maxOutputValue, r, g, b);
+      const bLayer = index % size;
+      const gLayer = Math.floor(index / size) % size;
+      const rLayer = Math.floor(index / (size * size)) % size;
+      const pixelIndex = bLayer * size * size + gLayer * size + rLayer;
+      dataArray[4 * pixelIndex + 0] = r;
+      dataArray[4 * pixelIndex + 1] = g;
+      dataArray[4 * pixelIndex + 2] = b;
+      dataArray[4 * pixelIndex + 3] = 1;
+      index += 1;
+    }
+    const bits = Math.ceil(Math.log2(maxOutputValue));
+    const maxBitValue = Math.pow(2, bits);
+    for (let i = 0, l = dataArray.length; i < l; i += 4) {
+      const r = dataArray[i + 0];
+      const g = dataArray[i + 1];
+      const b = dataArray[i + 2];
+      dataArray[i + 0] = 255 * r / maxBitValue;
+      dataArray[i + 1] = 255 * g / maxBitValue;
+      dataArray[i + 2] = 255 * b / maxBitValue;
+    }
+    const data = new Uint8Array(dataArray);
+    const texture = new DataTexture();
+    texture.image.data = data;
+    texture.image.width = size;
+    texture.image.height = size * size;
+    texture.format = RGBAFormat;
+    texture.type = UnsignedByteType;
+    texture.magFilter = LinearFilter;
+    texture.minFilter = LinearFilter;
+    texture.wrapS = ClampToEdgeWrapping;
+    texture.wrapT = ClampToEdgeWrapping;
+    texture.generateMipmaps = false;
+    texture.needsUpdate = true;
+    const texture3D = new Data3DTexture();
+    texture3D.image.data = data;
+    texture3D.image.width = size;
+    texture3D.image.height = size;
+    texture3D.image.depth = size;
+    texture3D.format = RGBAFormat;
+    texture3D.type = UnsignedByteType;
+    texture3D.magFilter = LinearFilter;
+    texture3D.minFilter = LinearFilter;
+    texture3D.wrapS = ClampToEdgeWrapping;
+    texture3D.wrapT = ClampToEdgeWrapping;
+    texture3D.wrapR = ClampToEdgeWrapping;
+    texture3D.generateMipmaps = false;
+    texture3D.needsUpdate = true;
+    return {
+      size,
+      texture,
+      texture3D
+    };
+  }
+}
+export {
+  LUT3dlLoader
+};

package/dist/loaders/LUTCubeLoader.d.ts

@@ -0,0 +1,23 @@
+import { Loader, LoadingManager, Vector3, DataTexture, Data3DTexture } from 'three'
+
+export interface LUTCubeResult {
+  title: string
+  size: number
+  domainMin: Vector3
+  domainMax: Vector3
+  texture: DataTexture
+  texture3D: Data3DTexture
+}
+
+export class LUTCubeLoader extends Loader {
+  constructor(manager?: LoadingManager)
+
+  load(
+    url: string,
+    onLoad: (result: LUTCubeResult) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: Error) => void,
+  ): any
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<LUTCubeResult>
+  parse(data: string): LUTCubeResult
+}

package/dist/loaders/LUTCubeLoader.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const Data3DTexture = require("../_polyfill/Data3DTexture.js");
+class LUTCubeLoader extends THREE.Loader {
+  load(url, onLoad, onProgress, onError) {
+    const loader = new THREE.FileLoader(this.manager);
+    loader.setPath(this.path);
+    loader.setResponseType("text");
+    loader.load(
+      url,
+      (text) => {
+        try {
+          onLoad(this.parse(text));
+        } catch (e) {
+          if (onError) {
+            onError(e);
+          } else {
+            console.error(e);
+          }
+          this.manager.itemError(url);
+        }
+      },
+      onProgress,
+      onError
+    );
+  }
+  parse(str) {
+    str = str.replace(/^#.*?(\n|\r)/gm, "").replace(/^\s*?(\n|\r)/gm, "").trim();
+    let title = null;
+    let size = null;
+    const domainMin = new THREE.Vector3(0, 0, 0);
+    const domainMax = new THREE.Vector3(1, 1, 1);
+    const lines = str.split(/[\n\r]+/g);
+    let data = null;
+    let currIndex = 0;
+    for (let i = 0, l = lines.length; i < l; i++) {
+      const line = lines[i].trim();
+      const split = line.split(/\s/g);
+      switch (split[0]) {
+        case "TITLE":
+          title = line.substring(7, line.length - 1);
+          break;
+        case "LUT_3D_SIZE":
+          const sizeToken = split[1];
+          size = parseFloat(sizeToken);
+          data = new Uint8Array(size * size * size * 4);
+          break;
+        case "DOMAIN_MIN":
+          domainMin.x = parseFloat(split[1]);
+          domainMin.y = parseFloat(split[2]);
+          domainMin.z = parseFloat(split[3]);
+          break;
+        case "DOMAIN_MAX":
+          domainMax.x = parseFloat(split[1]);
+          domainMax.y = parseFloat(split[2]);
+          domainMax.z = parseFloat(split[3]);
+          break;
+        default:
+          const r = parseFloat(split[0]);
+          const g = parseFloat(split[1]);
+          const b = parseFloat(split[2]);
+          if (r > 1 || r < 0 || g > 1 || g < 0 || b > 1 || b < 0) {
+            throw new Error("LUTCubeLoader : Non normalized values not supported.");
+          }
+          data[currIndex + 0] = r * 255;
+          data[currIndex + 1] = g * 255;
+          data[currIndex + 2] = b * 255;
+          data[currIndex + 3] = 255;
+          currIndex += 4;
+      }
+    }
+    const texture = new THREE.DataTexture();
+    texture.image.data = data;
+    texture.image.width = size;
+    texture.image.height = size * size;
+    texture.type = THREE.UnsignedByteType;
+    texture.magFilter = THREE.LinearFilter;
+    texture.minFilter = THREE.LinearFilter;
+    texture.wrapS = THREE.ClampToEdgeWrapping;
+    texture.wrapT = THREE.ClampToEdgeWrapping;
+    texture.generateMipmaps = false;
+    texture.needsUpdate = true;
+    const texture3D = new Data3DTexture.Data3DTexture();
+    texture3D.image.data = data;
+    texture3D.image.width = size;
+    texture3D.image.height = size;
+    texture3D.image.depth = size;
+    texture3D.type = THREE.UnsignedByteType;
+    texture3D.magFilter = THREE.LinearFilter;
+    texture3D.minFilter = THREE.LinearFilter;
+    texture3D.wrapS = THREE.ClampToEdgeWrapping;
+    texture3D.wrapT = THREE.ClampToEdgeWrapping;
+    texture3D.wrapR = THREE.ClampToEdgeWrapping;
+    texture3D.generateMipmaps = false;
+    texture3D.needsUpdate = true;
+    return {
+      title,
+      size,
+      domainMin,
+      domainMax,
+      texture,
+      texture3D
+    };
+  }
+}
+exports.LUTCubeLoader = LUTCubeLoader;

package/dist/loaders/LUTCubeLoader.mjs

@@ -0,0 +1,107 @@
+import { Loader, FileLoader, Vector3, DataTexture, UnsignedByteType, LinearFilter, ClampToEdgeWrapping } from "three";
+import { Data3DTexture } from "../_polyfill/Data3DTexture.mjs";
+class LUTCubeLoader extends Loader {
+  load(url, onLoad, onProgress, onError) {
+    const loader = new FileLoader(this.manager);
+    loader.setPath(this.path);
+    loader.setResponseType("text");
+    loader.load(
+      url,
+      (text) => {
+        try {
+          onLoad(this.parse(text));
+        } catch (e) {
+          if (onError) {
+            onError(e);
+          } else {
+            console.error(e);
+          }
+          this.manager.itemError(url);
+        }
+      },
+      onProgress,
+      onError
+    );
+  }
+  parse(str) {
+    str = str.replace(/^#.*?(\n|\r)/gm, "").replace(/^\s*?(\n|\r)/gm, "").trim();
+    let title = null;
+    let size = null;
+    const domainMin = new Vector3(0, 0, 0);
+    const domainMax = new Vector3(1, 1, 1);
+    const lines = str.split(/[\n\r]+/g);
+    let data = null;
+    let currIndex = 0;
+    for (let i = 0, l = lines.length; i < l; i++) {
+      const line = lines[i].trim();
+      const split = line.split(/\s/g);
+      switch (split[0]) {
+        case "TITLE":
+          title = line.substring(7, line.length - 1);
+          break;
+        case "LUT_3D_SIZE":
+          const sizeToken = split[1];
+          size = parseFloat(sizeToken);
+          data = new Uint8Array(size * size * size * 4);
+          break;
+        case "DOMAIN_MIN":
+          domainMin.x = parseFloat(split[1]);
+          domainMin.y = parseFloat(split[2]);
+          domainMin.z = parseFloat(split[3]);
+          break;
+        case "DOMAIN_MAX":
+          domainMax.x = parseFloat(split[1]);
+          domainMax.y = parseFloat(split[2]);
+          domainMax.z = parseFloat(split[3]);
+          break;
+        default:
+          const r = parseFloat(split[0]);
+          const g = parseFloat(split[1]);
+          const b = parseFloat(split[2]);
+          if (r > 1 || r < 0 || g > 1 || g < 0 || b > 1 || b < 0) {
+            throw new Error("LUTCubeLoader : Non normalized values not supported.");
+          }
+          data[currIndex + 0] = r * 255;
+          data[currIndex + 1] = g * 255;
+          data[currIndex + 2] = b * 255;
+          data[currIndex + 3] = 255;
+          currIndex += 4;
+      }
+    }
+    const texture = new DataTexture();
+    texture.image.data = data;
+    texture.image.width = size;
+    texture.image.height = size * size;
+    texture.type = UnsignedByteType;
+    texture.magFilter = LinearFilter;
+    texture.minFilter = LinearFilter;
+    texture.wrapS = ClampToEdgeWrapping;
+    texture.wrapT = ClampToEdgeWrapping;
+    texture.generateMipmaps = false;
+    texture.needsUpdate = true;
+    const texture3D = new Data3DTexture();
+    texture3D.image.data = data;
+    texture3D.image.width = size;
+    texture3D.image.height = size;
+    texture3D.image.depth = size;
+    texture3D.type = UnsignedByteType;
+    texture3D.magFilter = LinearFilter;
+    texture3D.minFilter = LinearFilter;
+    texture3D.wrapS = ClampToEdgeWrapping;
+    texture3D.wrapT = ClampToEdgeWrapping;
+    texture3D.wrapR = ClampToEdgeWrapping;
+    texture3D.generateMipmaps = false;
+    texture3D.needsUpdate = true;
+    return {
+      title,
+      size,
+      domainMin,
+      domainMax,
+      texture,
+      texture3D
+    };
+  }
+}
+export {
+  LUTCubeLoader
+};

package/dist/loaders/LWOLoader.d.ts

@@ -0,0 +1,26 @@
+import { Loader, LoadingManager, Material, Object3D } from 'three'
+
+export interface LWO {
+  materials: Material[]
+  meshes: Object3D[]
+}
+
+export interface LWOLoaderParameters {
+  /**
+   * Base content delivery folder path, use when it differs from Lightwave default structure
+   */
+  resourcePath?: string
+}
+
+export class LWOLoader extends Loader {
+  constructor(manager?: LoadingManager, parameters?: LWOLoaderParameters)
+
+  load(
+    url: string,
+    onLoad: (lwo: LWO) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<LWO>
+  parse(data: ArrayBuffer, path: string, modelName: string): LWO
+}