opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/loaders/PLYLoader.js

@@ -0,0 +1,489 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three);
+    global.PLYLoader = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.PLYLoader = void 0;
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  /**
+   * 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'
+   * } );
+   *
+   */
+  var PLYLoader = /*#__PURE__*/function (_Loader) {
+    _inherits(PLYLoader, _Loader);
+
+    var _super = _createSuper(PLYLoader);
+
+    function PLYLoader(manager) {
+      var _this;
+
+      _classCallCheck(this, PLYLoader);
+
+      _this = _super.call(this, manager);
+      _this.propertyNameMapping = {};
+      return _this;
+    }
+
+    _createClass(PLYLoader, [{
+      key: "load",
+      value: function load(url, onLoad, onProgress, onError) {
+        var scope = this;
+        var loader = new _three.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);
+      }
+    }, {
+      key: "setPropertyNameMapping",
+      value: function setPropertyNameMapping(mapping) {
+        this.propertyNameMapping = mapping;
+      }
+    }, {
+      key: "parse",
+      value: function parse(data) {
+        function parseHeader(data) {
+          var patternHeader = /ply([\s\S]*)end_header\r?\n/;
+          var headerText = '';
+          var headerLength = 0;
+          var result = patternHeader.exec(data);
+
+          if (result !== null) {
+            headerText = result[1];
+            headerLength = new Blob([result[0]]).size;
+          }
+
+          var header = {
+            comments: [],
+            elements: [],
+            headerLength: headerLength,
+            objInfo: ''
+          };
+          var lines = headerText.split('\n');
+          var currentElement;
+
+          function make_ply_element_property(propertValues, propertyNameMapping) {
+            var 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 (var i = 0; i < lines.length; i++) {
+            var line = lines[i];
+            line = line.trim();
+            if (line === '') continue;
+            var lineValues = line.split(/\s+/);
+            var 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 !== undefined) {
+                  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 !== 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':
+              return parseInt(n);
+
+            case 'float':
+            case 'double':
+            case 'float32':
+            case 'float64':
+              return parseFloat(n);
+          }
+        }
+
+        function parseASCIIElement(properties, line) {
+          var values = line.split(/\s+/);
+          var element = {};
+
+          for (var i = 0; i < properties.length; i++) {
+            if (properties[i].type === 'list') {
+              var list = [];
+              var n = parseASCIINumber(values.shift(), properties[i].countType);
+
+              for (var 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)
+          var buffer = {
+            indices: [],
+            vertices: [],
+            normals: [],
+            uvs: [],
+            faceVertexUvs: [],
+            colors: []
+          };
+          var result;
+          var patternBody = /end_header\s([\s\S]*)$/;
+          var body = '';
+
+          if ((result = patternBody.exec(data)) !== null) {
+            body = result[1];
+          }
+
+          var lines = body.split('\n');
+          var currentElement = 0;
+          var currentElementCount = 0;
+
+          for (var i = 0; i < lines.length; i++) {
+            var line = lines[i];
+            line = line.trim();
+
+            if (line === '') {
+              continue;
+            }
+
+            if (currentElementCount >= header.elements[currentElement].count) {
+              currentElement++;
+              currentElementCount = 0;
+            }
+
+            var element = parseASCIIElement(header.elements[currentElement].properties, line);
+            handleElement(buffer, header.elements[currentElement].name, element);
+            currentElementCount++;
+          }
+
+          return postProcess(buffer);
+        }
+
+        function postProcess(buffer) {
+          var geometry = new _three.BufferGeometry(); // mandatory buffer data
+
+          if (buffer.indices.length > 0) {
+            geometry.setIndex(buffer.indices);
+          }
+
+          geometry.setAttribute('position', new _three.Float32BufferAttribute(buffer.vertices, 3)); // optional buffer data
+
+          if (buffer.normals.length > 0) {
+            geometry.setAttribute('normal', new _three.Float32BufferAttribute(buffer.normals, 3));
+          }
+
+          if (buffer.uvs.length > 0) {
+            geometry.setAttribute('uv', new _three.Float32BufferAttribute(buffer.uvs, 2));
+          }
+
+          if (buffer.colors.length > 0) {
+            geometry.setAttribute('color', new _three.Float32BufferAttribute(buffer.colors, 3));
+          }
+
+          if (buffer.faceVertexUvs.length > 0) {
+            geometry = geometry.toNonIndexed();
+            geometry.setAttribute('uv', new _three.Float32BufferAttribute(buffer.faceVertexUvs, 2));
+          }
+
+          geometry.computeBoundingSphere();
+          return geometry;
+        }
+
+        function handleElement(buffer, elementName, element) {
+          function findAttrName(names) {
+            for (var i = 0, l = names.length; i < l; i++) {
+              var name = names[i];
+              if (name in element) return name;
+            }
+
+            return null;
+          }
+
+          var attrX = findAttrName(['x', 'px', 'posx']) || 'x';
+          var attrY = findAttrName(['y', 'py', 'posy']) || 'y';
+          var attrZ = findAttrName(['z', 'pz', 'posz']) || 'z';
+          var attrNX = findAttrName(['nx', 'normalx']);
+          var attrNY = findAttrName(['ny', 'normaly']);
+          var attrNZ = findAttrName(['nz', 'normalz']);
+          var attrS = findAttrName(['s', 'u', 'texture_u', 'tx']);
+          var attrT = findAttrName(['t', 'v', 'texture_v', 'ty']);
+          var attrR = findAttrName(['red', 'diffuse_red', 'r', 'diffuse_r']);
+          var attrG = findAttrName(['green', 'diffuse_green', 'g', 'diffuse_g']);
+          var attrB = findAttrName(['blue', 'diffuse_blue', 'b', 'diffuse_b']);
+
+          if (elementName === 'vertex') {
+            buffer.vertices.push(element[attrX], element[attrY], element[attrZ]);
+
+            if (attrNX !== null && attrNY !== null && attrNZ !== null) {
+              buffer.normals.push(element[attrNX], element[attrNY], element[attrNZ]);
+            }
+
+            if (attrS !== null && attrT !== null) {
+              buffer.uvs.push(element[attrS], element[attrT]);
+            }
+
+            if (attrR !== null && attrG !== null && attrB !== null) {
+              buffer.colors.push(element[attrR] / 255.0, element[attrG] / 255.0, element[attrB] / 255.0);
+            }
+          } else if (elementName === 'face') {
+            var vertex_indices = element.vertex_indices || element.vertex_index; // issue #9338
+
+            var 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) {
+            // corespondences for non-specific length types here match rply:
+            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) {
+          var element = {};
+          var result,
+              read = 0;
+
+          for (var i = 0; i < properties.length; i++) {
+            if (properties[i].type === 'list') {
+              var list = [];
+              result = binaryRead(dataview, at + read, properties[i].countType, little_endian);
+              var n = result[0];
+              read += result[1];
+
+              for (var 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(data, header) {
+          var buffer = {
+            indices: [],
+            vertices: [],
+            normals: [],
+            uvs: [],
+            faceVertexUvs: [],
+            colors: []
+          };
+          var little_endian = header.format === 'binary_little_endian';
+          var body = new DataView(data, header.headerLength);
+          var result,
+              loc = 0;
+
+          for (var currentElement = 0; currentElement < header.elements.length; currentElement++) {
+            for (var currentElementCount = 0; currentElementCount < header.elements[currentElement].count; currentElementCount++) {
+              result = binaryReadElement(body, loc, header.elements[currentElement].properties, little_endian);
+              loc += result[1];
+              var element = result[0];
+              handleElement(buffer, header.elements[currentElement].name, element);
+            }
+          }
+
+          return postProcess(buffer);
+        } //
+
+
+        var geometry;
+        var scope = this;
+
+        if (data instanceof ArrayBuffer) {
+          var text = _three.LoaderUtils.decodeText(new Uint8Array(data));
+
+          var header = parseHeader(text);
+          geometry = header.format === 'ascii' ? parseASCII(text, header) : parseBinary(data, header);
+        } else {
+          geometry = parseASCII(data, parseHeader(data));
+        }
+
+        return geometry;
+      }
+    }]);
+
+    return PLYLoader;
+  }(_three.Loader);
+
+  _exports.PLYLoader = PLYLoader;
+});