three-stdlib 2.15.0 → 2.15.2

package/loaders/PLYLoader.mjs

@@ -0,0 +1,317 @@
+import { Loader, FileLoader, BufferGeometry, Float32BufferAttribute, LoaderUtils } from "three";
+class PLYLoader extends Loader {
+  constructor(manager) {
+    super(manager);
+    this.propertyNameMapping = {};
+  }
+  load(url, onLoad, onProgress, onError) {
+    const scope = this;
+    const loader = new FileLoader(this.manager);
+    loader.setPath(this.path);
+    loader.setResponseType("arraybuffer");
+    loader.setRequestHeader(this.requestHeader);
+    loader.setWithCredentials(this.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
+    );
+  }
+  setPropertyNameMapping(mapping) {
+    this.propertyNameMapping = mapping;
+  }
+  parse(data) {
+    function parseHeader(data2) {
+      const patternHeader = /ply([\s\S]*)end_header\r?\n/;
+      let headerText = "";
+      let headerLength = 0;
+      const result = patternHeader.exec(data2);
+      if (result !== null) {
+        headerText = result[1];
+        headerLength = new Blob([result[0]]).size;
+      }
+      const header = {
+        comments: [],
+        elements: [],
+        headerLength,
+        objInfo: ""
+      };
+      const lines = headerText.split("\n");
+      let currentElement;
+      function make_ply_element_property(propertValues, propertyNameMapping) {
+        const property = { type: propertValues[0] };
+        if (property.type === "list") {
+          property.name = propertValues[3];
+          property.countType = propertValues[1];
+          property.itemType = propertValues[2];
+        } else {
+          property.name = propertValues[1];
+        }
+        if (property.name in propertyNameMapping) {
+          property.name = propertyNameMapping[property.name];
+        }
+        return property;
+      }
+      for (let i = 0; i < lines.length; i++) {
+        let line = lines[i];
+        line = line.trim();
+        if (line === "")
+          continue;
+        const lineValues = line.split(/\s+/);
+        const lineType = lineValues.shift();
+        line = lineValues.join(" ");
+        switch (lineType) {
+          case "format":
+            header.format = lineValues[0];
+            header.version = lineValues[1];
+            break;
+          case "comment":
+            header.comments.push(line);
+            break;
+          case "element":
+            if (currentElement !== void 0) {
+              header.elements.push(currentElement);
+            }
+            currentElement = {};
+            currentElement.name = lineValues[0];
+            currentElement.count = parseInt(lineValues[1]);
+            currentElement.properties = [];
+            break;
+          case "property":
+            currentElement.properties.push(make_ply_element_property(lineValues, scope.propertyNameMapping));
+            break;
+          case "obj_info":
+            header.objInfo = line;
+            break;
+          default:
+            console.log("unhandled", lineType, lineValues);
+        }
+      }
+      if (currentElement !== void 0) {
+        header.elements.push(currentElement);
+      }
+      return header;
+    }
+    function parseASCIINumber(n, type) {
+      switch (type) {
+        case "char":
+        case "uchar":
+        case "short":
+        case "ushort":
+        case "int":
+        case "uint":
+        case "int8":
+        case "uint8":
+        case "int16":
+        case "uint16":
+        case "int32":
+        case "uint32":
+          return parseInt(n);
+        case "float":
+        case "double":
+        case "float32":
+        case "float64":
+          return parseFloat(n);
+      }
+    }
+    function parseASCIIElement(properties, line) {
+      const values = line.split(/\s+/);
+      const element = {};
+      for (let i = 0; i < properties.length; i++) {
+        if (properties[i].type === "list") {
+          const list = [];
+          const n = parseASCIINumber(values.shift(), properties[i].countType);
+          for (let j = 0; j < n; j++) {
+            list.push(parseASCIINumber(values.shift(), properties[i].itemType));
+          }
+          element[properties[i].name] = list;
+        } else {
+          element[properties[i].name] = parseASCIINumber(values.shift(), properties[i].type);
+        }
+      }
+      return element;
+    }
+    function parseASCII(data2, header) {
+      const buffer = {
+        indices: [],
+        vertices: [],
+        normals: [],
+        uvs: [],
+        faceVertexUvs: [],
+        colors: []
+      };
+      let result;
+      const patternBody = /end_header\s([\s\S]*)$/;
+      let body = "";
+      if ((result = patternBody.exec(data2)) !== null) {
+        body = result[1];
+      }
+      const lines = body.split("\n");
+      let currentElement = 0;
+      let currentElementCount = 0;
+      for (let i = 0; i < lines.length; i++) {
+        let line = lines[i];
+        line = line.trim();
+        if (line === "") {
+          continue;
+        }
+        if (currentElementCount >= header.elements[currentElement].count) {
+          currentElement++;
+          currentElementCount = 0;
+        }
+        const element = parseASCIIElement(header.elements[currentElement].properties, line);
+        handleElement(buffer, header.elements[currentElement].name, element);
+        currentElementCount++;
+      }
+      return postProcess(buffer);
+    }
+    function postProcess(buffer) {
+      let geometry2 = new BufferGeometry();
+      if (buffer.indices.length > 0) {
+        geometry2.setIndex(buffer.indices);
+      }
+      geometry2.setAttribute("position", new Float32BufferAttribute(buffer.vertices, 3));
+      if (buffer.normals.length > 0) {
+        geometry2.setAttribute("normal", new Float32BufferAttribute(buffer.normals, 3));
+      }
+      if (buffer.uvs.length > 0) {
+        geometry2.setAttribute("uv", new Float32BufferAttribute(buffer.uvs, 2));
+      }
+      if (buffer.colors.length > 0) {
+        geometry2.setAttribute("color", new Float32BufferAttribute(buffer.colors, 3));
+      }
+      if (buffer.faceVertexUvs.length > 0) {
+        geometry2 = geometry2.toNonIndexed();
+        geometry2.setAttribute("uv", new Float32BufferAttribute(buffer.faceVertexUvs, 2));
+      }
+      geometry2.computeBoundingSphere();
+      return geometry2;
+    }
+    function handleElement(buffer, elementName, element) {
+      if (elementName === "vertex") {
+        buffer.vertices.push(element.x, element.y, element.z);
+        if ("nx" in element && "ny" in element && "nz" in element) {
+          buffer.normals.push(element.nx, element.ny, element.nz);
+        }
+        if ("s" in element && "t" in element) {
+          buffer.uvs.push(element.s, element.t);
+        }
+        if ("red" in element && "green" in element && "blue" in element) {
+          buffer.colors.push(element.red / 255, element.green / 255, element.blue / 255);
+        }
+      } else if (elementName === "face") {
+        const vertex_indices = element.vertex_indices || element.vertex_index;
+        const texcoord = element.texcoord;
+        if (vertex_indices.length === 3) {
+          buffer.indices.push(vertex_indices[0], vertex_indices[1], vertex_indices[2]);
+          if (texcoord && texcoord.length === 6) {
+            buffer.faceVertexUvs.push(texcoord[0], texcoord[1]);
+            buffer.faceVertexUvs.push(texcoord[2], texcoord[3]);
+            buffer.faceVertexUvs.push(texcoord[4], texcoord[5]);
+          }
+        } else if (vertex_indices.length === 4) {
+          buffer.indices.push(vertex_indices[0], vertex_indices[1], vertex_indices[3]);
+          buffer.indices.push(vertex_indices[1], vertex_indices[2], vertex_indices[3]);
+        }
+      }
+    }
+    function binaryRead(dataview, at, type, little_endian) {
+      switch (type) {
+        case "int8":
+        case "char":
+          return [dataview.getInt8(at), 1];
+        case "uint8":
+        case "uchar":
+          return [dataview.getUint8(at), 1];
+        case "int16":
+        case "short":
+          return [dataview.getInt16(at, little_endian), 2];
+        case "uint16":
+        case "ushort":
+          return [dataview.getUint16(at, little_endian), 2];
+        case "int32":
+        case "int":
+          return [dataview.getInt32(at, little_endian), 4];
+        case "uint32":
+        case "uint":
+          return [dataview.getUint32(at, little_endian), 4];
+        case "float32":
+        case "float":
+          return [dataview.getFloat32(at, little_endian), 4];
+        case "float64":
+        case "double":
+          return [dataview.getFloat64(at, little_endian), 8];
+      }
+    }
+    function binaryReadElement(dataview, at, properties, little_endian) {
+      const element = {};
+      let result, read = 0;
+      for (let i = 0; i < properties.length; i++) {
+        if (properties[i].type === "list") {
+          const list = [];
+          result = binaryRead(dataview, at + read, properties[i].countType, little_endian);
+          const n = result[0];
+          read += result[1];
+          for (let j = 0; j < n; j++) {
+            result = binaryRead(dataview, at + read, properties[i].itemType, little_endian);
+            list.push(result[0]);
+            read += result[1];
+          }
+          element[properties[i].name] = list;
+        } else {
+          result = binaryRead(dataview, at + read, properties[i].type, little_endian);
+          element[properties[i].name] = result[0];
+          read += result[1];
+        }
+      }
+      return [element, read];
+    }
+    function parseBinary(data2, header) {
+      const buffer = {
+        indices: [],
+        vertices: [],
+        normals: [],
+        uvs: [],
+        faceVertexUvs: [],
+        colors: []
+      };
+      const little_endian = header.format === "binary_little_endian";
+      const body = new DataView(data2, header.headerLength);
+      let result, loc = 0;
+      for (let currentElement = 0; currentElement < header.elements.length; currentElement++) {
+        for (let currentElementCount = 0; currentElementCount < header.elements[currentElement].count; currentElementCount++) {
+          result = binaryReadElement(body, loc, header.elements[currentElement].properties, little_endian);
+          loc += result[1];
+          const element = result[0];
+          handleElement(buffer, header.elements[currentElement].name, element);
+        }
+      }
+      return postProcess(buffer);
+    }
+    let geometry;
+    const scope = this;
+    if (data instanceof ArrayBuffer) {
+      const text = LoaderUtils.decodeText(new Uint8Array(data));
+      const header = parseHeader(text);
+      geometry = header.format === "ascii" ? parseASCII(text, header) : parseBinary(data, header);
+    } else {
+      geometry = parseASCII(data, parseHeader(data));
+    }
+    return geometry;
+  }
+}
+export {
+  PLYLoader
+};

package/loaders/PRWMLoader.js

@@ -1,73 +1,56 @@
-import { Loader, FileLoader, BufferGeometry, BufferAttribute } from 'three';
-
-/**
- * See https://github.com/kchapelier/PRWM for more informations about this file format
- */
-
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const THREE = require("three");
 let bigEndianPlatform = null;
-/**
- * Check if the endianness of the platform is big-endian (most significant bit first)
- * @returns {boolean} True if big-endian, false if little-endian
- */
-
 function isBigEndianPlatform() {
   if (bigEndianPlatform === null) {
-    const buffer = new ArrayBuffer(2),
-          uint8Array = new Uint8Array(buffer),
-          uint16Array = new Uint16Array(buffer);
-    uint8Array[0] = 0xaa; // set first byte
-
-    uint8Array[1] = 0xbb; // set second byte
-
-    bigEndianPlatform = uint16Array[0] === 0xaabb;
+    const buffer = new ArrayBuffer(2), uint8Array = new Uint8Array(buffer), uint16Array = new Uint16Array(buffer);
+    uint8Array[0] = 170;
+    uint8Array[1] = 187;
+    bigEndianPlatform = uint16Array[0] === 43707;
   }
-
   return bigEndianPlatform;
-} // match the values defined in the spec to the TypedArray types
-
-
-const InvertedEncodingTypes = [null, Float32Array, null, Int8Array, Int16Array, null, Int32Array, Uint8Array, Uint16Array, null, Uint32Array]; // define the method to use on a DataView, corresponding the TypedArray type
-
+}
+const InvertedEncodingTypes = [
+  null,
+  Float32Array,
+  null,
+  Int8Array,
+  Int16Array,
+  null,
+  Int32Array,
+  Uint8Array,
+  Uint16Array,
+  null,
+  Uint32Array
+];
 const getMethods = {
-  Uint16Array: 'getUint16',
-  Uint32Array: 'getUint32',
-  Int16Array: 'getInt16',
-  Int32Array: 'getInt32',
-  Float32Array: 'getFloat32',
-  Float64Array: 'getFloat64'
+  Uint16Array: "getUint16",
+  Uint32Array: "getUint32",
+  Int16Array: "getInt16",
+  Int32Array: "getInt32",
+  Float32Array: "getFloat32",
+  Float64Array: "getFloat64"
 };
-
 function copyFromBuffer(sourceArrayBuffer, viewType, position, length, fromBigEndian) {
   const bytesPerElement = viewType.BYTES_PER_ELEMENT;
   let result;
-
   if (fromBigEndian === isBigEndianPlatform() || bytesPerElement === 1) {
     result = new viewType(sourceArrayBuffer, position, length);
   } else {
-    const readView = new DataView(sourceArrayBuffer, position, length * bytesPerElement),
-          getMethod = getMethods[viewType.name],
-          littleEndian = !fromBigEndian;
+    const readView = new DataView(sourceArrayBuffer, position, length * bytesPerElement), getMethod = getMethods[viewType.name], littleEndian = !fromBigEndian;
     result = new viewType(length);
-
     for (let i = 0; i < length; i++) {
       result[i] = readView[getMethod](i * bytesPerElement, littleEndian);
     }
   }
-
   return result;
 }
-
 function decodePrwm(buffer) {
-  const array = new Uint8Array(buffer),
-        version = array[0];
+  const array = new Uint8Array(buffer), version = array[0];
   let flags = array[1];
-  const indexedGeometry = !!(flags >> 7 & 0x01),
-        indicesType = flags >> 6 & 0x01,
-        bigEndian = (flags >> 5 & 0x01) === 1,
-        attributesNumber = flags & 0x1f;
-  let valuesNumber = 0,
-      indicesNumber = 0;
-
+  const indexedGeometry = !!(flags >> 7 & 1), indicesType = flags >> 6 & 1, bigEndian = (flags >> 5 & 1) === 1, attributesNumber = flags & 31;
+  let valuesNumber = 0, indicesNumber = 0;
   if (bigEndian) {
     valuesNumber = (array[2] << 16) + (array[3] << 8) + array[4];
     indicesNumber = (array[5] << 16) + (array[6] << 8) + array[7];
@@ -75,123 +58,103 @@ function decodePrwm(buffer) {
     valuesNumber = array[2] + (array[3] << 8) + (array[4] << 16);
     indicesNumber = array[5] + (array[6] << 8) + (array[7] << 16);
   }
-  /** PRELIMINARY CHECKS **/
-
-
   if (version === 0) {
-    throw new Error('PRWM decoder: Invalid format version: 0');
+    throw new Error("PRWM decoder: Invalid format version: 0");
   } else if (version !== 1) {
-    throw new Error('PRWM decoder: Unsupported format version: ' + version);
+    throw new Error("PRWM decoder: Unsupported format version: " + version);
   }
-
   if (!indexedGeometry) {
     if (indicesType !== 0) {
-      throw new Error('PRWM decoder: Indices type must be set to 0 for non-indexed geometries');
+      throw new Error("PRWM decoder: Indices type must be set to 0 for non-indexed geometries");
     } else if (indicesNumber !== 0) {
-      throw new Error('PRWM decoder: Number of indices must be set to 0 for non-indexed geometries');
+      throw new Error("PRWM decoder: Number of indices must be set to 0 for non-indexed geometries");
     }
   }
-  /** PARSING **/
-
-
   let pos = 8;
   const attributes = {};
-
   for (let i = 0; i < attributesNumber; i++) {
-    let attributeName = '';
-
+    let attributeName = "";
     while (pos < array.length) {
       const char = array[pos];
       pos++;
-
       if (char === 0) {
         break;
       } else {
         attributeName += String.fromCharCode(char);
       }
     }
-
     flags = array[pos];
-    const attributeType = flags >> 7 & 0x01;
-    const cardinality = (flags >> 4 & 0x03) + 1;
-    const encodingType = flags & 0x0f;
+    const attributeType = flags >> 7 & 1;
+    const cardinality = (flags >> 4 & 3) + 1;
+    const encodingType = flags & 15;
     const arrayType = InvertedEncodingTypes[encodingType];
-    pos++; // padding to next multiple of 4
-
+    pos++;
     pos = Math.ceil(pos / 4) * 4;
     const values = copyFromBuffer(buffer, arrayType, pos, cardinality * valuesNumber, bigEndian);
     pos += arrayType.BYTES_PER_ELEMENT * cardinality * valuesNumber;
     attributes[attributeName] = {
       type: attributeType,
-      cardinality: cardinality,
-      values: values
+      cardinality,
+      values
     };
   }
-
   pos = Math.ceil(pos / 4) * 4;
   let indices = null;
-
   if (indexedGeometry) {
     indices = copyFromBuffer(buffer, indicesType === 1 ? Uint32Array : Uint16Array, pos, indicesNumber, bigEndian);
   }
-
   return {
-    version: version,
-    attributes: attributes,
-    indices: indices
+    version,
+    attributes,
+    indices
   };
-} // Define the public interface
-
-
-class PRWMLoader extends Loader {
+}
+class PRWMLoader extends THREE.Loader {
   constructor(manager) {
     super(manager);
   }
-
   load(url, onLoad, onProgress, onError) {
     const scope = this;
-    const loader = new FileLoader(scope.manager);
+    const loader = new THREE.FileLoader(scope.manager);
     loader.setPath(scope.path);
-    loader.setResponseType('arraybuffer');
+    loader.setResponseType("arraybuffer");
     loader.setRequestHeader(scope.requestHeader);
     loader.setWithCredentials(scope.withCredentials);
-    url = url.replace(/\*/g, isBigEndianPlatform() ? 'be' : 'le');
-    loader.load(url, function (arrayBuffer) {
-      try {
-        onLoad(scope.parse(arrayBuffer));
-      } catch (e) {
-        if (onError) {
-          onError(e);
-        } else {
-          console.error(e);
+    url = url.replace(/\*/g, isBigEndianPlatform() ? "be" : "le");
+    loader.load(
+      url,
+      function(arrayBuffer) {
+        try {
+          onLoad(scope.parse(arrayBuffer));
+        } catch (e) {
+          if (onError) {
+            onError(e);
+          } else {
+            console.error(e);
+          }
+          scope.manager.itemError(url);
         }
-
-        scope.manager.itemError(url);
-      }
-    }, onProgress, onError);
+      },
+      onProgress,
+      onError
+    );
   }
-
   parse(arrayBuffer) {
-    const data = decodePrwm(arrayBuffer),
-          attributesKey = Object.keys(data.attributes),
-          bufferGeometry = new BufferGeometry();
-
+    const data = decodePrwm(arrayBuffer), attributesKey = Object.keys(data.attributes), bufferGeometry = new THREE.BufferGeometry();
     for (let i = 0; i < attributesKey.length; i++) {
       const attribute = data.attributes[attributesKey[i]];
-      bufferGeometry.setAttribute(attributesKey[i], new BufferAttribute(attribute.values, attribute.cardinality, attribute.normalized));
+      bufferGeometry.setAttribute(
+        attributesKey[i],
+        new THREE.BufferAttribute(attribute.values, attribute.cardinality, attribute.normalized)
+      );
     }
-
     if (data.indices !== null) {
-      bufferGeometry.setIndex(new BufferAttribute(data.indices, 1));
+      bufferGeometry.setIndex(new THREE.BufferAttribute(data.indices, 1));
     }
-
     return bufferGeometry;
   }
-
   static isBigEndianPlatform() {
     return isBigEndianPlatform();
   }
-
 }
-
-export { PRWMLoader };
+exports.PRWMLoader = PRWMLoader;