three-stdlib 2.22.7 → 2.22.8

package/dist/loaders/HDRCubeTextureLoader.d.ts

@@ -0,0 +1,18 @@
+import { CubeTexture, Loader, LoadingManager, TextureDataType } from 'three'
+
+import { RGBELoader } from './RGBELoader'
+
+export class HDRCubeTextureLoader extends Loader {
+  constructor(manager?: LoadingManager)
+  hdrLoader: RGBELoader
+  type: TextureDataType
+
+  load(
+    urls: string[],
+    onLoad: (texture: CubeTexture) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): CubeTexture
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<CubeTexture>
+  setDataType(type: TextureDataType): this
+}

package/dist/loaders/HDRCubeTextureLoader.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const RGBELoader = require("./RGBELoader.js");
+class HDRCubeTextureLoader extends THREE.Loader {
+  constructor(manager) {
+    super(manager);
+    this.hdrLoader = new RGBELoader.RGBELoader();
+    this.type = THREE.HalfFloatType;
+  }
+  load(urls, onLoad, onProgress, onError) {
+    if (!Array.isArray(urls)) {
+      console.warn("THREE.HDRCubeTextureLoader signature has changed. Use .setDataType() instead.");
+      this.setDataType(urls);
+      urls = onLoad;
+      onLoad = onProgress;
+      onProgress = onError;
+      onError = arguments[4];
+    }
+    const texture = new THREE.CubeTexture();
+    texture.type = this.type;
+    switch (texture.type) {
+      case THREE.FloatType:
+      case THREE.HalfFloatType:
+        if ("colorSpace" in texture)
+          texture.colorSpace = "srgb-linear";
+        else
+          texture.encoding = 3e3;
+        texture.minFilter = THREE.LinearFilter;
+        texture.magFilter = THREE.LinearFilter;
+        texture.generateMipmaps = false;
+        break;
+    }
+    const scope = this;
+    let loaded = 0;
+    function loadHDRData(i, onLoad2, onProgress2, onError2) {
+      new THREE.FileLoader(scope.manager).setPath(scope.path).setResponseType("arraybuffer").setWithCredentials(scope.withCredentials).load(
+        urls[i],
+        function(buffer) {
+          loaded++;
+          const texData = scope.hdrLoader.parse(buffer);
+          if (!texData)
+            return;
+          if (texData.data !== void 0) {
+            const dataTexture = new THREE.DataTexture(texData.data, texData.width, texData.height);
+            dataTexture.type = texture.type;
+            dataTexture.encoding = texture.encoding;
+            dataTexture.format = texture.format;
+            dataTexture.minFilter = texture.minFilter;
+            dataTexture.magFilter = texture.magFilter;
+            dataTexture.generateMipmaps = texture.generateMipmaps;
+            texture.images[i] = dataTexture;
+          }
+          if (loaded === 6) {
+            texture.needsUpdate = true;
+            if (onLoad2)
+              onLoad2(texture);
+          }
+        },
+        onProgress2,
+        onError2
+      );
+    }
+    for (let i = 0; i < urls.length; i++) {
+      loadHDRData(i, onLoad, onProgress, onError);
+    }
+    return texture;
+  }
+  setDataType(value) {
+    this.type = value;
+    this.hdrLoader.setDataType(value);
+    return this;
+  }
+}
+exports.HDRCubeTextureLoader = HDRCubeTextureLoader;

package/dist/loaders/HDRCubeTextureLoader.mjs

@@ -0,0 +1,75 @@
+import { Loader, HalfFloatType, CubeTexture, LinearFilter, FloatType, FileLoader, DataTexture } from "three";
+import { RGBELoader } from "./RGBELoader.mjs";
+class HDRCubeTextureLoader extends Loader {
+  constructor(manager) {
+    super(manager);
+    this.hdrLoader = new RGBELoader();
+    this.type = HalfFloatType;
+  }
+  load(urls, onLoad, onProgress, onError) {
+    if (!Array.isArray(urls)) {
+      console.warn("THREE.HDRCubeTextureLoader signature has changed. Use .setDataType() instead.");
+      this.setDataType(urls);
+      urls = onLoad;
+      onLoad = onProgress;
+      onProgress = onError;
+      onError = arguments[4];
+    }
+    const texture = new CubeTexture();
+    texture.type = this.type;
+    switch (texture.type) {
+      case FloatType:
+      case HalfFloatType:
+        if ("colorSpace" in texture)
+          texture.colorSpace = "srgb-linear";
+        else
+          texture.encoding = 3e3;
+        texture.minFilter = LinearFilter;
+        texture.magFilter = LinearFilter;
+        texture.generateMipmaps = false;
+        break;
+    }
+    const scope = this;
+    let loaded = 0;
+    function loadHDRData(i, onLoad2, onProgress2, onError2) {
+      new FileLoader(scope.manager).setPath(scope.path).setResponseType("arraybuffer").setWithCredentials(scope.withCredentials).load(
+        urls[i],
+        function(buffer) {
+          loaded++;
+          const texData = scope.hdrLoader.parse(buffer);
+          if (!texData)
+            return;
+          if (texData.data !== void 0) {
+            const dataTexture = new DataTexture(texData.data, texData.width, texData.height);
+            dataTexture.type = texture.type;
+            dataTexture.encoding = texture.encoding;
+            dataTexture.format = texture.format;
+            dataTexture.minFilter = texture.minFilter;
+            dataTexture.magFilter = texture.magFilter;
+            dataTexture.generateMipmaps = texture.generateMipmaps;
+            texture.images[i] = dataTexture;
+          }
+          if (loaded === 6) {
+            texture.needsUpdate = true;
+            if (onLoad2)
+              onLoad2(texture);
+          }
+        },
+        onProgress2,
+        onError2
+      );
+    }
+    for (let i = 0; i < urls.length; i++) {
+      loadHDRData(i, onLoad, onProgress, onError);
+    }
+    return texture;
+  }
+  setDataType(value) {
+    this.type = value;
+    this.hdrLoader.setDataType(value);
+    return this;
+  }
+}
+export {
+  HDRCubeTextureLoader
+};

package/dist/loaders/KMZLoader.d.ts

@@ -0,0 +1,16 @@
+import { Loader, LoadingManager } from 'three'
+
+import { Collada } from './ColladaLoader'
+
+export class KMZLoader extends Loader {
+  constructor(manager?: LoadingManager)
+
+  load(
+    url: string,
+    onLoad: (kmz: Collada) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Collada>
+  parse(data: ArrayBuffer): Collada
+}

package/dist/loaders/KMZLoader.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const ColladaLoader = require("./ColladaLoader.js");
+const fflate$1 = require("fflate");
+class KMZLoader extends THREE.Loader {
+  constructor(manager) {
+    super(manager);
+  }
+  load(url, onLoad, onProgress, onError) {
+    const scope = this;
+    const loader = new THREE.FileLoader(scope.manager);
+    loader.setPath(scope.path);
+    loader.setResponseType("arraybuffer");
+    loader.setRequestHeader(scope.requestHeader);
+    loader.setWithCredentials(scope.withCredentials);
+    loader.load(
+      url,
+      function(text) {
+        try {
+          onLoad(scope.parse(text));
+        } catch (e) {
+          if (onError) {
+            onError(e);
+          } else {
+            console.error(e);
+          }
+          scope.manager.itemError(url);
+        }
+      },
+      onProgress,
+      onError
+    );
+  }
+  parse(data) {
+    function findFile(url) {
+      for (const path in zip) {
+        if (path.substr(-url.length) === url) {
+          return zip[path];
+        }
+      }
+    }
+    const manager = new THREE.LoadingManager();
+    manager.setURLModifier(function(url) {
+      const image = findFile(url);
+      if (image) {
+        console.log("Loading", url);
+        const blob = new Blob([image.buffer], { type: "application/octet-stream" });
+        return URL.createObjectURL(blob);
+      }
+      return url;
+    });
+    const zip = fflate$1.unzipSync(new Uint8Array(data));
+    if (zip["doc.kml"]) {
+      const xml = new DOMParser().parseFromString(fflate.strFromU8(zip["doc.kml"]), "application/xml");
+      const model = xml.querySelector("Placemark Model Link href");
+      if (model) {
+        const loader = new ColladaLoader.ColladaLoader(manager);
+        return loader.parse(fflate.strFromU8(zip[model.textContent]));
+      }
+    } else {
+      console.warn("KMZLoader: Missing doc.kml file.");
+      for (const path in zip) {
+        const extension = path.split(".").pop().toLowerCase();
+        if (extension === "dae") {
+          const loader = new ColladaLoader.ColladaLoader(manager);
+          return loader.parse(fflate.strFromU8(zip[path]));
+        }
+      }
+    }
+    console.error("KMZLoader: Couldn't find .dae file.");
+    return { scene: new THREE.Group() };
+  }
+}
+exports.KMZLoader = KMZLoader;

package/dist/loaders/KMZLoader.mjs

@@ -0,0 +1,75 @@
+import { Loader, FileLoader, LoadingManager, Group } from "three";
+import { ColladaLoader } from "./ColladaLoader.mjs";
+import { unzipSync } from "fflate";
+class KMZLoader extends Loader {
+  constructor(manager) {
+    super(manager);
+  }
+  load(url, onLoad, onProgress, onError) {
+    const scope = this;
+    const loader = new FileLoader(scope.manager);
+    loader.setPath(scope.path);
+    loader.setResponseType("arraybuffer");
+    loader.setRequestHeader(scope.requestHeader);
+    loader.setWithCredentials(scope.withCredentials);
+    loader.load(
+      url,
+      function(text) {
+        try {
+          onLoad(scope.parse(text));
+        } catch (e) {
+          if (onError) {
+            onError(e);
+          } else {
+            console.error(e);
+          }
+          scope.manager.itemError(url);
+        }
+      },
+      onProgress,
+      onError
+    );
+  }
+  parse(data) {
+    function findFile(url) {
+      for (const path in zip) {
+        if (path.substr(-url.length) === url) {
+          return zip[path];
+        }
+      }
+    }
+    const manager = new LoadingManager();
+    manager.setURLModifier(function(url) {
+      const image = findFile(url);
+      if (image) {
+        console.log("Loading", url);
+        const blob = new Blob([image.buffer], { type: "application/octet-stream" });
+        return URL.createObjectURL(blob);
+      }
+      return url;
+    });
+    const zip = unzipSync(new Uint8Array(data));
+    if (zip["doc.kml"]) {
+      const xml = new DOMParser().parseFromString(fflate.strFromU8(zip["doc.kml"]), "application/xml");
+      const model = xml.querySelector("Placemark Model Link href");
+      if (model) {
+        const loader = new ColladaLoader(manager);
+        return loader.parse(fflate.strFromU8(zip[model.textContent]));
+      }
+    } else {
+      console.warn("KMZLoader: Missing doc.kml file.");
+      for (const path in zip) {
+        const extension = path.split(".").pop().toLowerCase();
+        if (extension === "dae") {
+          const loader = new ColladaLoader(manager);
+          return loader.parse(fflate.strFromU8(zip[path]));
+        }
+      }
+    }
+    console.error("KMZLoader: Couldn't find .dae file.");
+    return { scene: new Group() };
+  }
+}
+export {
+  KMZLoader
+};

package/dist/loaders/KTX2Loader.d.ts

@@ -0,0 +1,16 @@
+import { LoadingManager, CompressedTextureLoader, CompressedTexture, WebGLRenderer } from 'three'
+
+export class KTX2Loader extends CompressedTextureLoader {
+  constructor(manager?: LoadingManager)
+
+  setTranscoderPath(path: string): KTX2Loader
+  setWorkerLimit(limit: number): KTX2Loader
+  detectSupport(renderer: WebGLRenderer): KTX2Loader
+  dispose(): KTX2Loader
+
+  parse(
+    buffer: ArrayBuffer,
+    onLoad: (texture: CompressedTexture) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): KTX2Loader
+}