three-stdlib 2.15.2 → 2.16.1

package/loaders/PLYLoader.js

@@ -1,151 +1,201 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const THREE = require("three");
-class PLYLoader extends THREE.Loader {
+import { Loader, FileLoader, LoaderUtils, BufferGeometry, Float32BufferAttribute } from 'three';
+
+/**
+ * Description: A THREE loader for PLY ASCII files (known as the Polygon
+ * File Format or the Stanford Triangle Format).
+ *
+ * Limitations: ASCII decoding assumes file is UTF-8.
+ *
+ * Usage:
+ *	const loader = new PLYLoader();
+ *	loader.load('./models/ply/ascii/dolphins.ply', function (geometry) {
+ *
+ *		scene.add( new THREE.Mesh( geometry ) );
+ *
+ *	} );
+ *
+ * If the PLY file uses non standard property names, they can be mapped while
+ * loading. For example, the following maps the properties
+ * “diffuse_(red|green|blue)” in the file to standard color names.
+ *
+ * loader.setPropertyNameMapping( {
+ *	diffuse_red: 'red',
+ *	diffuse_green: 'green',
+ *	diffuse_blue: 'blue'
+ * } );
+ *
+ */
+
+class PLYLoader extends Loader {
   constructor(manager) {
     super(manager);
     this.propertyNameMapping = {};
   }
+
   load(url, onLoad, onProgress, onError) {
     const scope = this;
-    const loader = new THREE.FileLoader(this.manager);
+    const loader = new FileLoader(this.manager);
     loader.setPath(this.path);
-    loader.setResponseType("arraybuffer");
+    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);
+    loader.load(url, function (text) {
+      try {
+        onLoad(scope.parse(text));
+      } catch (e) {
+        if (onError) {
+          onError(e);
+        } else {
+          console.error(e);
         }
-      },
-      onProgress,
-      onError
-    );
+
+        scope.manager.itemError(url);
+      }
+    }, onProgress, onError);
   }
+
   setPropertyNameMapping(mapping) {
     this.propertyNameMapping = mapping;
   }
+
   parse(data) {
-    function parseHeader(data2) {
+    function parseHeader(data) {
       const patternHeader = /ply([\s\S]*)end_header\r?\n/;
-      let headerText = "";
+      let headerText = '';
       let headerLength = 0;
-      const result = patternHeader.exec(data2);
+      const result = patternHeader.exec(data);
+
       if (result !== null) {
         headerText = result[1];
         headerLength = new Blob([result[0]]).size;
       }
+
       const header = {
         comments: [],
         elements: [],
-        headerLength,
-        objInfo: ""
+        headerLength: headerLength,
+        objInfo: ''
       };
-      const lines = headerText.split("\n");
+      const lines = headerText.split('\n');
       let currentElement;
+
       function make_ply_element_property(propertValues, propertyNameMapping) {
-        const property = { type: propertValues[0] };
-        if (property.type === "list") {
+        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;
+        if (line === '') continue;
         const lineValues = line.split(/\s+/);
         const lineType = lineValues.shift();
-        line = lineValues.join(" ");
+        line = lineValues.join(' ');
+
         switch (lineType) {
-          case "format":
+          case 'format':
             header.format = lineValues[0];
             header.version = lineValues[1];
             break;
-          case "comment":
+
+          case 'comment':
             header.comments.push(line);
             break;
-          case "element":
-            if (currentElement !== void 0) {
+
+          case 'element':
+            if (currentElement !== undefined) {
               header.elements.push(currentElement);
             }
+
             currentElement = {};
             currentElement.name = lineValues[0];
             currentElement.count = parseInt(lineValues[1]);
             currentElement.properties = [];
             break;
-          case "property":
+
+          case 'property':
             currentElement.properties.push(make_ply_element_property(lineValues, scope.propertyNameMapping));
             break;
-          case "obj_info":
+
+          case 'obj_info':
             header.objInfo = line;
             break;
+
           default:
-            console.log("unhandled", lineType, lineValues);
+            console.log('unhandled', lineType, lineValues);
         }
       }
-      if (currentElement !== void 0) {
+
+      if (currentElement !== undefined) {
         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":
+        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":
+
+        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") {
+        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) {
+
+    function parseASCII(data, header) {
+      // PLY ascii format specification, as per http://en.wikipedia.org/wiki/PLY_(file_format)
       const buffer = {
         indices: [],
         vertices: [],
@@ -156,68 +206,90 @@ class PLYLoader extends THREE.Loader {
       };
       let result;
       const patternBody = /end_header\s([\s\S]*)$/;
-      let body = "";
-      if ((result = patternBody.exec(data2)) !== null) {
+      let body = '';
+
+      if ((result = patternBody.exec(data)) !== null) {
         body = result[1];
       }
-      const lines = body.split("\n");
+
+      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 === "") {
+
+        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 THREE.BufferGeometry();
+      let geometry = new BufferGeometry(); // mandatory buffer data
+
       if (buffer.indices.length > 0) {
-        geometry2.setIndex(buffer.indices);
+        geometry.setIndex(buffer.indices);
       }
-      geometry2.setAttribute("position", new THREE.Float32BufferAttribute(buffer.vertices, 3));
+
+      geometry.setAttribute('position', new Float32BufferAttribute(buffer.vertices, 3)); // optional buffer data
+
       if (buffer.normals.length > 0) {
-        geometry2.setAttribute("normal", new THREE.Float32BufferAttribute(buffer.normals, 3));
+        geometry.setAttribute('normal', new Float32BufferAttribute(buffer.normals, 3));
       }
+
       if (buffer.uvs.length > 0) {
-        geometry2.setAttribute("uv", new THREE.Float32BufferAttribute(buffer.uvs, 2));
+        geometry.setAttribute('uv', new Float32BufferAttribute(buffer.uvs, 2));
       }
+
       if (buffer.colors.length > 0) {
-        geometry2.setAttribute("color", new THREE.Float32BufferAttribute(buffer.colors, 3));
+        geometry.setAttribute('color', new Float32BufferAttribute(buffer.colors, 3));
       }
+
       if (buffer.faceVertexUvs.length > 0) {
-        geometry2 = geometry2.toNonIndexed();
-        geometry2.setAttribute("uv", new THREE.Float32BufferAttribute(buffer.faceVertexUvs, 2));
+        geometry = geometry.toNonIndexed();
+        geometry.setAttribute('uv', new Float32BufferAttribute(buffer.faceVertexUvs, 2));
       }
-      geometry2.computeBoundingSphere();
-      return geometry2;
+
+      geometry.computeBoundingSphere();
+      return geometry;
     }
+
     function handleElement(buffer, elementName, element) {
-      if (elementName === "vertex") {
+      if (elementName === 'vertex') {
         buffer.vertices.push(element.x, element.y, element.z);
-        if ("nx" in element && "ny" in element && "nz" in element) {
+
+        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) {
+
+        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);
+
+        if ('red' in element && 'green' in element && 'blue' in element) {
+          buffer.colors.push(element.red / 255.0, element.green / 255.0, element.blue / 255.0);
         }
-      } else if (elementName === "face") {
-        const vertex_indices = element.vertex_indices || element.vertex_index;
+      } else if (elementName === 'face') {
+        const vertex_indices = element.vertex_indices || element.vertex_index; // issue #9338
+
         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]);
@@ -229,48 +301,62 @@ class PLYLoader extends THREE.Loader {
         }
       }
     }
+
     function binaryRead(dataview, at, type, little_endian) {
       switch (type) {
-        case "int8":
-        case "char":
+        // corespondences for non-specific length types here match rply:
+        case 'int8':
+        case 'char':
           return [dataview.getInt8(at), 1];
-        case "uint8":
-        case "uchar":
+
+        case 'uint8':
+        case 'uchar':
           return [dataview.getUint8(at), 1];
-        case "int16":
-        case "short":
+
+        case 'int16':
+        case 'short':
           return [dataview.getInt16(at, little_endian), 2];
-        case "uint16":
-        case "ushort":
+
+        case 'uint16':
+        case 'ushort':
           return [dataview.getUint16(at, little_endian), 2];
-        case "int32":
-        case "int":
+
+        case 'int32':
+        case 'int':
           return [dataview.getInt32(at, little_endian), 4];
-        case "uint32":
-        case "uint":
+
+        case 'uint32':
+        case 'uint':
           return [dataview.getUint32(at, little_endian), 4];
-        case "float32":
-        case "float":
+
+        case 'float32':
+        case 'float':
           return [dataview.getFloat32(at, little_endian), 4];
-        case "float64":
-        case "double":
+
+        case 'float64':
+        case 'double':
           return [dataview.getFloat64(at, little_endian), 8];
       }
     }
+
     function binaryReadElement(dataview, at, properties, little_endian) {
       const element = {};
-      let result, read = 0;
+      let result,
+          read = 0;
+
       for (let i = 0; i < properties.length; i++) {
-        if (properties[i].type === "list") {
+        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);
@@ -278,9 +364,11 @@ class PLYLoader extends THREE.Loader {
           read += result[1];
         }
       }
+
       return [element, read];
     }
-    function parseBinary(data2, header) {
+
+    function parseBinary(data, header) {
       const buffer = {
         indices: [],
         vertices: [],
@@ -289,9 +377,11 @@ class PLYLoader extends THREE.Loader {
         faceVertexUvs: [],
         colors: []
       };
-      const little_endian = header.format === "binary_little_endian";
-      const body = new DataView(data2, header.headerLength);
-      let result, loc = 0;
+      const little_endian = header.format === 'binary_little_endian';
+      const body = new DataView(data, 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);
@@ -300,18 +390,25 @@ class PLYLoader extends THREE.Loader {
           handleElement(buffer, header.elements[currentElement].name, element);
         }
       }
+
       return postProcess(buffer);
-    }
+    } //
+
+
     let geometry;
     const scope = this;
+
     if (data instanceof ArrayBuffer) {
-      const text = THREE.LoaderUtils.decodeText(new Uint8Array(data));
+      const text = LoaderUtils.decodeText(new Uint8Array(data));
       const header = parseHeader(text);
-      geometry = header.format === "ascii" ? parseASCII(text, header) : parseBinary(data, header);
+      geometry = header.format === 'ascii' ? parseASCII(text, header) : parseBinary(data, header);
     } else {
       geometry = parseASCII(data, parseHeader(data));
     }
+
     return geometry;
   }
+
 }
-exports.PLYLoader = PLYLoader;
+
+export { PLYLoader };

package/loaders/PRWMLoader.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("three");let t=null;function r(){if(null===t){const e=new ArrayBuffer(2),r=new Uint8Array(e),n=new Uint16Array(e);r[0]=170,r[1]=187,t=43707===n[0]}return t}const n=[null,Float32Array,null,Int8Array,Int16Array,null,Int32Array,Uint8Array,Uint16Array,null,Uint32Array],o={Uint16Array:"getUint16",Uint32Array:"getUint32",Int16Array:"getInt16",Int32Array:"getInt32",Float32Array:"getFloat32",Float64Array:"getFloat64"};function a(e,t,n,a,i){const s=t.BYTES_PER_ELEMENT;let l;if(i===r()||1===s)l=new t(e,n,a);else{const r=new DataView(e,n,a*s),u=o[t.name],c=!i;l=new t(a);for(let e=0;e<a;e++)l[e]=r[u](e*s,c)}return l}class i extends e.Loader{constructor(e){super(e)}load(t,n,o,a){const i=this,s=new e.FileLoader(i.manager);s.setPath(i.path),s.setResponseType("arraybuffer"),s.setRequestHeader(i.requestHeader),s.setWithCredentials(i.withCredentials),t=t.replace(/\*/g,r()?"be":"le"),s.load(t,(function(e){try{n(i.parse(e))}catch(e){a?a(e):console.error(e),i.manager.itemError(t)}}),o,a)}parse(t){const r=function(e){const t=new Uint8Array(e),r=t[0];let o=t[1];const i=!!(o>>7&1),s=o>>6&1,l=1==(o>>5&1),u=31&o;let c=0,d=0;if(l?(c=(t[2]<<16)+(t[3]<<8)+t[4],d=(t[5]<<16)+(t[6]<<8)+t[7]):(c=t[2]+(t[3]<<8)+(t[4]<<16),d=t[5]+(t[6]<<8)+(t[7]<<16)),0===r)throw new Error("PRWM decoder: Invalid format version: 0");if(1!==r)throw new Error("PRWM decoder: Unsupported format version: "+r);if(!i){if(0!==s)throw new Error("PRWM decoder: Indices type must be set to 0 for non-indexed geometries");if(0!==d)throw new Error("PRWM decoder: Number of indices must be set to 0 for non-indexed geometries")}let f=8;const y={};for(let r=0;r<u;r++){let r="";for(;f<t.length;){const e=t[f];if(f++,0===e)break;r+=String.fromCharCode(e)}o=t[f];const i=o>>7&1,s=1+(o>>4&3),u=n[15&o];f++,f=4*Math.ceil(f/4);const d=a(e,u,f,s*c,l);f+=u.BYTES_PER_ELEMENT*s*c,y[r]={type:i,cardinality:s,values:d}}f=4*Math.ceil(f/4);let A=null;return i&&(A=a(e,1===s?Uint32Array:Uint16Array,f,d,l)),{version:r,attributes:y,indices:A}}(t),o=Object.keys(r.attributes),i=new e.BufferGeometry;for(let t=0;t<o.length;t++){const n=r.attributes[o[t]];i.setAttribute(o[t],new e.BufferAttribute(n.values,n.cardinality,n.normalized))}return null!==r.indices&&i.setIndex(new e.BufferAttribute(r.indices,1)),i}static isBigEndianPlatform(){return r()}}exports.PRWMLoader=i;