three-stdlib 2.15.2 → 2.16.1

package/loaders/DDSLoader.mjs

@@ -1,148 +0,0 @@
-import { CompressedTextureLoader, RGBAFormat, RGB_ETC1_Format, RGBA_S3TC_DXT5_Format, RGBA_S3TC_DXT3_Format, RGB_S3TC_DXT1_Format } from "three";
-class DDSLoader extends CompressedTextureLoader {
-  constructor(manager) {
-    super(manager);
-  }
-  parse(buffer, loadMipmaps) {
-    const dds = { mipmaps: [], width: 0, height: 0, format: null, mipmapCount: 1 };
-    const DDS_MAGIC = 542327876;
-    const DDSD_MIPMAPCOUNT = 131072;
-    const DDSCAPS2_CUBEMAP = 512;
-    const DDSCAPS2_CUBEMAP_POSITIVEX = 1024;
-    const DDSCAPS2_CUBEMAP_NEGATIVEX = 2048;
-    const DDSCAPS2_CUBEMAP_POSITIVEY = 4096;
-    const DDSCAPS2_CUBEMAP_NEGATIVEY = 8192;
-    const DDSCAPS2_CUBEMAP_POSITIVEZ = 16384;
-    const DDSCAPS2_CUBEMAP_NEGATIVEZ = 32768;
-    const DDPF_FOURCC = 4;
-    function fourCCToInt32(value) {
-      return value.charCodeAt(0) + (value.charCodeAt(1) << 8) + (value.charCodeAt(2) << 16) + (value.charCodeAt(3) << 24);
-    }
-    function int32ToFourCC(value) {
-      return String.fromCharCode(value & 255, value >> 8 & 255, value >> 16 & 255, value >> 24 & 255);
-    }
-    function loadARGBMip(buffer2, dataOffset2, width, height) {
-      const dataLength = width * height * 4;
-      const srcBuffer = new Uint8Array(buffer2, dataOffset2, dataLength);
-      const byteArray = new Uint8Array(dataLength);
-      let dst = 0;
-      let src = 0;
-      for (let y = 0; y < height; y++) {
-        for (let x = 0; x < width; x++) {
-          const b = srcBuffer[src];
-          src++;
-          const g = srcBuffer[src];
-          src++;
-          const r = srcBuffer[src];
-          src++;
-          const a = srcBuffer[src];
-          src++;
-          byteArray[dst] = r;
-          dst++;
-          byteArray[dst] = g;
-          dst++;
-          byteArray[dst] = b;
-          dst++;
-          byteArray[dst] = a;
-          dst++;
-        }
-      }
-      return byteArray;
-    }
-    const FOURCC_DXT1 = fourCCToInt32("DXT1");
-    const FOURCC_DXT3 = fourCCToInt32("DXT3");
-    const FOURCC_DXT5 = fourCCToInt32("DXT5");
-    const FOURCC_ETC1 = fourCCToInt32("ETC1");
-    const headerLengthInt = 31;
-    const off_magic = 0;
-    const off_size = 1;
-    const off_flags = 2;
-    const off_height = 3;
-    const off_width = 4;
-    const off_mipmapCount = 7;
-    const off_pfFlags = 20;
-    const off_pfFourCC = 21;
-    const off_RGBBitCount = 22;
-    const off_RBitMask = 23;
-    const off_GBitMask = 24;
-    const off_BBitMask = 25;
-    const off_ABitMask = 26;
-    const off_caps2 = 28;
-    const header = new Int32Array(buffer, 0, headerLengthInt);
-    if (header[off_magic] !== DDS_MAGIC) {
-      console.error("THREE.DDSLoader.parse: Invalid magic number in DDS header.");
-      return dds;
-    }
-    if (!header[off_pfFlags] & DDPF_FOURCC) {
-      console.error("THREE.DDSLoader.parse: Unsupported format, must contain a FourCC code.");
-      return dds;
-    }
-    let blockBytes;
-    const fourCC = header[off_pfFourCC];
-    let isRGBAUncompressed = false;
-    switch (fourCC) {
-      case FOURCC_DXT1:
-        blockBytes = 8;
-        dds.format = RGB_S3TC_DXT1_Format;
-        break;
-      case FOURCC_DXT3:
-        blockBytes = 16;
-        dds.format = RGBA_S3TC_DXT3_Format;
-        break;
-      case FOURCC_DXT5:
-        blockBytes = 16;
-        dds.format = RGBA_S3TC_DXT5_Format;
-        break;
-      case FOURCC_ETC1:
-        blockBytes = 8;
-        dds.format = RGB_ETC1_Format;
-        break;
-      default:
-        if (header[off_RGBBitCount] === 32 && header[off_RBitMask] & 16711680 && header[off_GBitMask] & 65280 && header[off_BBitMask] & 255 && header[off_ABitMask] & 4278190080) {
-          isRGBAUncompressed = true;
-          blockBytes = 64;
-          dds.format = RGBAFormat;
-        } else {
-          console.error("THREE.DDSLoader.parse: Unsupported FourCC code ", int32ToFourCC(fourCC));
-          return dds;
-        }
-    }
-    dds.mipmapCount = 1;
-    if (header[off_flags] & DDSD_MIPMAPCOUNT && loadMipmaps !== false) {
-      dds.mipmapCount = Math.max(1, header[off_mipmapCount]);
-    }
-    const caps2 = header[off_caps2];
-    dds.isCubemap = caps2 & DDSCAPS2_CUBEMAP ? true : false;
-    if (dds.isCubemap && (!(caps2 & DDSCAPS2_CUBEMAP_POSITIVEX) || !(caps2 & DDSCAPS2_CUBEMAP_NEGATIVEX) || !(caps2 & DDSCAPS2_CUBEMAP_POSITIVEY) || !(caps2 & DDSCAPS2_CUBEMAP_NEGATIVEY) || !(caps2 & DDSCAPS2_CUBEMAP_POSITIVEZ) || !(caps2 & DDSCAPS2_CUBEMAP_NEGATIVEZ))) {
-      console.error("THREE.DDSLoader.parse: Incomplete cubemap faces");
-      return dds;
-    }
-    dds.width = header[off_width];
-    dds.height = header[off_height];
-    let dataOffset = header[off_size] + 4;
-    const faces = dds.isCubemap ? 6 : 1;
-    for (let face = 0; face < faces; face++) {
-      let width = dds.width;
-      let height = dds.height;
-      for (let i = 0; i < dds.mipmapCount; i++) {
-        let byteArray, dataLength;
-        if (isRGBAUncompressed) {
-          byteArray = loadARGBMip(buffer, dataOffset, width, height);
-          dataLength = byteArray.length;
-        } else {
-          dataLength = Math.max(4, width) / 4 * Math.max(4, height) / 4 * blockBytes;
-          byteArray = new Uint8Array(buffer, dataOffset, dataLength);
-        }
-        const mipmap = { data: byteArray, width, height };
-        dds.mipmaps.push(mipmap);
-        dataOffset += dataLength;
-        width = Math.max(width >> 1, 1);
-        height = Math.max(height >> 1, 1);
-      }
-    }
-    return dds;
-  }
-}
-export {
-  DDSLoader
-};

package/loaders/DRACOLoader.mjs

@@ -1,340 +0,0 @@
-import { Loader, FileLoader, BufferGeometry, BufferAttribute } from "three";
-const _taskCache = /* @__PURE__ */ new WeakMap();
-class DRACOLoader extends Loader {
-  constructor(manager) {
-    super(manager);
-    this.decoderPath = "";
-    this.decoderConfig = {};
-    this.decoderBinary = null;
-    this.decoderPending = null;
-    this.workerLimit = 4;
-    this.workerPool = [];
-    this.workerNextTaskID = 1;
-    this.workerSourceURL = "";
-    this.defaultAttributeIDs = {
-      position: "POSITION",
-      normal: "NORMAL",
-      color: "COLOR",
-      uv: "TEX_COORD"
-    };
-    this.defaultAttributeTypes = {
-      position: "Float32Array",
-      normal: "Float32Array",
-      color: "Float32Array",
-      uv: "Float32Array"
-    };
-  }
-  setDecoderPath(path) {
-    this.decoderPath = path;
-    return this;
-  }
-  setDecoderConfig(config) {
-    this.decoderConfig = config;
-    return this;
-  }
-  setWorkerLimit(workerLimit) {
-    this.workerLimit = workerLimit;
-    return this;
-  }
-  load(url, onLoad, onProgress, onError) {
-    const loader = new FileLoader(this.manager);
-    loader.setPath(this.path);
-    loader.setResponseType("arraybuffer");
-    loader.setRequestHeader(this.requestHeader);
-    loader.setWithCredentials(this.withCredentials);
-    loader.load(
-      url,
-      (buffer) => {
-        const taskConfig = {
-          attributeIDs: this.defaultAttributeIDs,
-          attributeTypes: this.defaultAttributeTypes,
-          useUniqueIDs: false
-        };
-        this.decodeGeometry(buffer, taskConfig).then(onLoad).catch(onError);
-      },
-      onProgress,
-      onError
-    );
-  }
-  decodeDracoFile(buffer, callback, attributeIDs, attributeTypes) {
-    const taskConfig = {
-      attributeIDs: attributeIDs || this.defaultAttributeIDs,
-      attributeTypes: attributeTypes || this.defaultAttributeTypes,
-      useUniqueIDs: !!attributeIDs
-    };
-    this.decodeGeometry(buffer, taskConfig).then(callback);
-  }
-  decodeGeometry(buffer, taskConfig) {
-    for (const attribute in taskConfig.attributeTypes) {
-      const type = taskConfig.attributeTypes[attribute];
-      if (type.BYTES_PER_ELEMENT !== void 0) {
-        taskConfig.attributeTypes[attribute] = type.name;
-      }
-    }
-    const taskKey = JSON.stringify(taskConfig);
-    if (_taskCache.has(buffer)) {
-      const cachedTask = _taskCache.get(buffer);
-      if (cachedTask.key === taskKey) {
-        return cachedTask.promise;
-      } else if (buffer.byteLength === 0) {
-        throw new Error(
-          "THREE.DRACOLoader: Unable to re-decode a buffer with different settings. Buffer has already been transferred."
-        );
-      }
-    }
-    let worker;
-    const taskID = this.workerNextTaskID++;
-    const taskCost = buffer.byteLength;
-    const geometryPending = this._getWorker(taskID, taskCost).then((_worker) => {
-      worker = _worker;
-      return new Promise((resolve, reject) => {
-        worker._callbacks[taskID] = { resolve, reject };
-        worker.postMessage({ type: "decode", id: taskID, taskConfig, buffer }, [buffer]);
-      });
-    }).then((message) => this._createGeometry(message.geometry));
-    geometryPending.catch(() => true).then(() => {
-      if (worker && taskID) {
-        this._releaseTask(worker, taskID);
-      }
-    });
-    _taskCache.set(buffer, {
-      key: taskKey,
-      promise: geometryPending
-    });
-    return geometryPending;
-  }
-  _createGeometry(geometryData) {
-    const geometry = new BufferGeometry();
-    if (geometryData.index) {
-      geometry.setIndex(new BufferAttribute(geometryData.index.array, 1));
-    }
-    for (let i = 0; i < geometryData.attributes.length; i++) {
-      const attribute = geometryData.attributes[i];
-      const name = attribute.name;
-      const array = attribute.array;
-      const itemSize = attribute.itemSize;
-      geometry.setAttribute(name, new BufferAttribute(array, itemSize));
-    }
-    return geometry;
-  }
-  _loadLibrary(url, responseType) {
-    const loader = new FileLoader(this.manager);
-    loader.setPath(this.decoderPath);
-    loader.setResponseType(responseType);
-    loader.setWithCredentials(this.withCredentials);
-    return new Promise((resolve, reject) => {
-      loader.load(url, resolve, void 0, reject);
-    });
-  }
-  preload() {
-    this._initDecoder();
-    return this;
-  }
-  _initDecoder() {
-    if (this.decoderPending)
-      return this.decoderPending;
-    const useJS = typeof WebAssembly !== "object" || this.decoderConfig.type === "js";
-    const librariesPending = [];
-    if (useJS) {
-      librariesPending.push(this._loadLibrary("draco_decoder.js", "text"));
-    } else {
-      librariesPending.push(this._loadLibrary("draco_wasm_wrapper.js", "text"));
-      librariesPending.push(this._loadLibrary("draco_decoder.wasm", "arraybuffer"));
-    }
-    this.decoderPending = Promise.all(librariesPending).then((libraries) => {
-      const jsContent = libraries[0];
-      if (!useJS) {
-        this.decoderConfig.wasmBinary = libraries[1];
-      }
-      const fn = DRACOWorker.toString();
-      const body = [
-        "/* draco decoder */",
-        jsContent,
-        "",
-        "/* worker */",
-        fn.substring(fn.indexOf("{") + 1, fn.lastIndexOf("}"))
-      ].join("\n");
-      this.workerSourceURL = URL.createObjectURL(new Blob([body]));
-    });
-    return this.decoderPending;
-  }
-  _getWorker(taskID, taskCost) {
-    return this._initDecoder().then(() => {
-      if (this.workerPool.length < this.workerLimit) {
-        const worker2 = new Worker(this.workerSourceURL);
-        worker2._callbacks = {};
-        worker2._taskCosts = {};
-        worker2._taskLoad = 0;
-        worker2.postMessage({ type: "init", decoderConfig: this.decoderConfig });
-        worker2.onmessage = function(e) {
-          const message = e.data;
-          switch (message.type) {
-            case "decode":
-              worker2._callbacks[message.id].resolve(message);
-              break;
-            case "error":
-              worker2._callbacks[message.id].reject(message);
-              break;
-            default:
-              console.error('THREE.DRACOLoader: Unexpected message, "' + message.type + '"');
-          }
-        };
-        this.workerPool.push(worker2);
-      } else {
-        this.workerPool.sort(function(a, b) {
-          return a._taskLoad > b._taskLoad ? -1 : 1;
-        });
-      }
-      const worker = this.workerPool[this.workerPool.length - 1];
-      worker._taskCosts[taskID] = taskCost;
-      worker._taskLoad += taskCost;
-      return worker;
-    });
-  }
-  _releaseTask(worker, taskID) {
-    worker._taskLoad -= worker._taskCosts[taskID];
-    delete worker._callbacks[taskID];
-    delete worker._taskCosts[taskID];
-  }
-  debug() {
-    console.log(
-      "Task load: ",
-      this.workerPool.map((worker) => worker._taskLoad)
-    );
-  }
-  dispose() {
-    for (let i = 0; i < this.workerPool.length; ++i) {
-      this.workerPool[i].terminate();
-    }
-    this.workerPool.length = 0;
-    return this;
-  }
-}
-function DRACOWorker() {
-  let decoderConfig;
-  let decoderPending;
-  onmessage = function(e) {
-    const message = e.data;
-    switch (message.type) {
-      case "init":
-        decoderConfig = message.decoderConfig;
-        decoderPending = new Promise(function(resolve) {
-          decoderConfig.onModuleLoaded = function(draco) {
-            resolve({ draco });
-          };
-          DracoDecoderModule(decoderConfig);
-        });
-        break;
-      case "decode":
-        const buffer = message.buffer;
-        const taskConfig = message.taskConfig;
-        decoderPending.then((module) => {
-          const draco = module.draco;
-          const decoder = new draco.Decoder();
-          const decoderBuffer = new draco.DecoderBuffer();
-          decoderBuffer.Init(new Int8Array(buffer), buffer.byteLength);
-          try {
-            const geometry = decodeGeometry(draco, decoder, decoderBuffer, taskConfig);
-            const buffers = geometry.attributes.map((attr) => attr.array.buffer);
-            if (geometry.index)
-              buffers.push(geometry.index.array.buffer);
-            self.postMessage({ type: "decode", id: message.id, geometry }, buffers);
-          } catch (error) {
-            console.error(error);
-            self.postMessage({ type: "error", id: message.id, error: error.message });
-          } finally {
-            draco.destroy(decoderBuffer);
-            draco.destroy(decoder);
-          }
-        });
-        break;
-    }
-  };
-  function decodeGeometry(draco, decoder, decoderBuffer, taskConfig) {
-    const attributeIDs = taskConfig.attributeIDs;
-    const attributeTypes = taskConfig.attributeTypes;
-    let dracoGeometry;
-    let decodingStatus;
-    const geometryType = decoder.GetEncodedGeometryType(decoderBuffer);
-    if (geometryType === draco.TRIANGULAR_MESH) {
-      dracoGeometry = new draco.Mesh();
-      decodingStatus = decoder.DecodeBufferToMesh(decoderBuffer, dracoGeometry);
-    } else if (geometryType === draco.POINT_CLOUD) {
-      dracoGeometry = new draco.PointCloud();
-      decodingStatus = decoder.DecodeBufferToPointCloud(decoderBuffer, dracoGeometry);
-    } else {
-      throw new Error("THREE.DRACOLoader: Unexpected geometry type.");
-    }
-    if (!decodingStatus.ok() || dracoGeometry.ptr === 0) {
-      throw new Error("THREE.DRACOLoader: Decoding failed: " + decodingStatus.error_msg());
-    }
-    const geometry = { index: null, attributes: [] };
-    for (const attributeName in attributeIDs) {
-      const attributeType = self[attributeTypes[attributeName]];
-      let attribute;
-      let attributeID;
-      if (taskConfig.useUniqueIDs) {
-        attributeID = attributeIDs[attributeName];
-        attribute = decoder.GetAttributeByUniqueId(dracoGeometry, attributeID);
-      } else {
-        attributeID = decoder.GetAttributeId(dracoGeometry, draco[attributeIDs[attributeName]]);
-        if (attributeID === -1)
-          continue;
-        attribute = decoder.GetAttribute(dracoGeometry, attributeID);
-      }
-      geometry.attributes.push(decodeAttribute(draco, decoder, dracoGeometry, attributeName, attributeType, attribute));
-    }
-    if (geometryType === draco.TRIANGULAR_MESH) {
-      geometry.index = decodeIndex(draco, decoder, dracoGeometry);
-    }
-    draco.destroy(dracoGeometry);
-    return geometry;
-  }
-  function decodeIndex(draco, decoder, dracoGeometry) {
-    const numFaces = dracoGeometry.num_faces();
-    const numIndices = numFaces * 3;
-    const byteLength = numIndices * 4;
-    const ptr = draco._malloc(byteLength);
-    decoder.GetTrianglesUInt32Array(dracoGeometry, byteLength, ptr);
-    const index = new Uint32Array(draco.HEAPF32.buffer, ptr, numIndices).slice();
-    draco._free(ptr);
-    return { array: index, itemSize: 1 };
-  }
-  function decodeAttribute(draco, decoder, dracoGeometry, attributeName, attributeType, attribute) {
-    const numComponents = attribute.num_components();
-    const numPoints = dracoGeometry.num_points();
-    const numValues = numPoints * numComponents;
-    const byteLength = numValues * attributeType.BYTES_PER_ELEMENT;
-    const dataType = getDracoDataType(draco, attributeType);
-    const ptr = draco._malloc(byteLength);
-    decoder.GetAttributeDataArrayForAllPoints(dracoGeometry, attribute, dataType, byteLength, ptr);
-    const array = new attributeType(draco.HEAPF32.buffer, ptr, numValues).slice();
-    draco._free(ptr);
-    return {
-      name: attributeName,
-      array,
-      itemSize: numComponents
-    };
-  }
-  function getDracoDataType(draco, attributeType) {
-    switch (attributeType) {
-      case Float32Array:
-        return draco.DT_FLOAT32;
-      case Int8Array:
-        return draco.DT_INT8;
-      case Int16Array:
-        return draco.DT_INT16;
-      case Int32Array:
-        return draco.DT_INT32;
-      case Uint8Array:
-        return draco.DT_UINT8;
-      case Uint16Array:
-        return draco.DT_UINT16;
-      case Uint32Array:
-        return draco.DT_UINT32;
-    }
-  }
-}
-export {
-  DRACOLoader
-};