three-stdlib 2.15.0 → 2.15.2

package/loaders/PLYLoader.js

@@ -1,201 +1,151 @@
-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 {
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const THREE = require("three");
+class PLYLoader extends THREE.Loader {
   constructor(manager) {
     super(manager);
     this.propertyNameMapping = {};
   }
-
   load(url, onLoad, onProgress, onError) {
     const scope = this;
-    const loader = new FileLoader(this.manager);
+    const loader = new THREE.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);
+    loader.load(
+      url,
+      function(text) {
+        try {
+          onLoad(scope.parse(text));
+        } catch (e) {
+          if (onError) {
+            onError(e);
+          } else {
+            console.error(e);
+          }
+          scope.manager.itemError(url);
         }
-
-        scope.manager.itemError(url);
-      }
-    }, onProgress, onError);
+      },
+      onProgress,
+      onError
+    );
   }
-
   setPropertyNameMapping(mapping) {
     this.propertyNameMapping = mapping;
   }
-
   parse(data) {
-    function parseHeader(data) {
+    function parseHeader(data2) {
       const patternHeader = /ply([\s\S]*)end_header\r?\n/;
-      let headerText = '';
+      let headerText = "";
       let headerLength = 0;
-      const result = patternHeader.exec(data);
-
+      const result = patternHeader.exec(data2);
       if (result !== null) {
         headerText = result[1];
         headerLength = new Blob([result[0]]).size;
       }
-
       const header = {
         comments: [],
         elements: [],
-        headerLength: headerLength,
-        objInfo: ''
+        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 !== undefined) {
+          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':
+          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 !== undefined) {
+      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':
+        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(data, header) {
-      // PLY ascii format specification, as per http://en.wikipedia.org/wiki/PLY_(file_format)
+    function parseASCII(data2, header) {
       const buffer = {
         indices: [],
         vertices: [],
@@ -206,90 +156,68 @@ class PLYLoader extends Loader {
       };
       let result;
       const patternBody = /end_header\s([\s\S]*)$/;
-      let body = '';
-
-      if ((result = patternBody.exec(data)) !== null) {
+      let body = "";
+      if ((result = patternBody.exec(data2)) !== 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 geometry = new BufferGeometry(); // mandatory buffer data
-
+      let geometry2 = new THREE.BufferGeometry();
       if (buffer.indices.length > 0) {
-        geometry.setIndex(buffer.indices);
+        geometry2.setIndex(buffer.indices);
       }
-
-      geometry.setAttribute('position', new Float32BufferAttribute(buffer.vertices, 3)); // optional buffer data
-
+      geometry2.setAttribute("position", new THREE.Float32BufferAttribute(buffer.vertices, 3));
       if (buffer.normals.length > 0) {
-        geometry.setAttribute('normal', new Float32BufferAttribute(buffer.normals, 3));
+        geometry2.setAttribute("normal", new THREE.Float32BufferAttribute(buffer.normals, 3));
       }
-
       if (buffer.uvs.length > 0) {
-        geometry.setAttribute('uv', new Float32BufferAttribute(buffer.uvs, 2));
+        geometry2.setAttribute("uv", new THREE.Float32BufferAttribute(buffer.uvs, 2));
       }
-
       if (buffer.colors.length > 0) {
-        geometry.setAttribute('color', new Float32BufferAttribute(buffer.colors, 3));
+        geometry2.setAttribute("color", new THREE.Float32BufferAttribute(buffer.colors, 3));
       }
-
       if (buffer.faceVertexUvs.length > 0) {
-        geometry = geometry.toNonIndexed();
-        geometry.setAttribute('uv', new Float32BufferAttribute(buffer.faceVertexUvs, 2));
+        geometry2 = geometry2.toNonIndexed();
+        geometry2.setAttribute("uv", new THREE.Float32BufferAttribute(buffer.faceVertexUvs, 2));
       }
-
-      geometry.computeBoundingSphere();
-      return geometry;
+      geometry2.computeBoundingSphere();
+      return geometry2;
     }
-
     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.0, element.green / 255.0, element.blue / 255.0);
+        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; // issue #9338
-
+      } 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]);
@@ -301,62 +229,48 @@ class PLYLoader extends Loader {
         }
       }
     }
-
     function binaryRead(dataview, at, type, little_endian) {
       switch (type) {
-        // corespondences for non-specific length types here match rply:
-        case 'int8':
-        case 'char':
+        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);
@@ -364,11 +278,9 @@ class PLYLoader extends Loader {
           read += result[1];
         }
       }
-
       return [element, read];
     }
-
-    function parseBinary(data, header) {
+    function parseBinary(data2, header) {
       const buffer = {
         indices: [],
         vertices: [],
@@ -377,11 +289,9 @@ class PLYLoader extends Loader {
         faceVertexUvs: [],
         colors: []
       };
-      const little_endian = header.format === 'binary_little_endian';
-      const body = new DataView(data, header.headerLength);
-      let result,
-          loc = 0;
-
+      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);
@@ -390,25 +300,18 @@ class PLYLoader extends Loader {
           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 text = THREE.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;
   }
-
 }
-
-export { PLYLoader };
+exports.PLYLoader = PLYLoader;