opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/exporters/MMDExporter.js

@@ -0,0 +1,189 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three", "../libs/mmdparser.module.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"), require("../libs/mmdparser.module.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three, global.mmdparserModule);
+    global.MMDExporter = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three, _mmdparserModule) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.MMDExporter = 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; }
+
+  /**
+   * Dependencies
+   *  - mmd-parser https://github.com/takahirox/mmd-parser
+   */
+  var MMDExporter = /*#__PURE__*/function () {
+    function MMDExporter() {
+      _classCallCheck(this, MMDExporter);
+    }
+
+    _createClass(MMDExporter, [{
+      key: "parseVpd",
+      value:
+      /* TODO: implement
+      // mesh -> pmd
+      this.parsePmd = function ( object ) {
+      	};
+      */
+
+      /* TODO: implement
+      // mesh -> pmx
+      this.parsePmx = function ( object ) {
+      	};
+      */
+
+      /* TODO: implement
+      // animation + skeleton -> vmd
+      this.parseVmd = function ( object ) {
+      	};
+      */
+
+      /*
+       * skeleton -> vpd
+       * Returns Shift_JIS encoded Uint8Array. Otherwise return strings.
+       */
+      function parseVpd(skin, outputShiftJis, useOriginalBones) {
+        if (skin.isSkinnedMesh !== true) {
+          console.warn('THREE.MMDExporter: parseVpd() requires SkinnedMesh instance.');
+          return null;
+        }
+
+        function toStringsFromNumber(num) {
+          if (Math.abs(num) < 1e-6) num = 0;
+          var a = num.toString();
+
+          if (a.indexOf('.') === -1) {
+            a += '.';
+          }
+
+          a += '000000';
+          var index = a.indexOf('.');
+          var d = a.slice(0, index);
+          var p = a.slice(index + 1, index + 7);
+          return d + '.' + p;
+        }
+
+        function toStringsFromArray(array) {
+          var a = [];
+
+          for (var i = 0, il = array.length; i < il; i++) {
+            a.push(toStringsFromNumber(array[i]));
+          }
+
+          return a.join(',');
+        }
+
+        skin.updateMatrixWorld(true);
+        var bones = skin.skeleton.bones;
+        var bones2 = getBindBones(skin);
+        var position = new _three.Vector3();
+        var quaternion = new _three.Quaternion();
+        var quaternion2 = new _three.Quaternion();
+        var matrix = new _three.Matrix4();
+        var array = [];
+        array.push('Vocaloid Pose Data file');
+        array.push('');
+        array.push((skin.name !== '' ? skin.name.replace(/\s/g, '_') : 'skin') + '.osm;');
+        array.push(bones.length + ';');
+        array.push('');
+
+        for (var i = 0, il = bones.length; i < il; i++) {
+          var bone = bones[i];
+          var bone2 = bones2[i];
+          /*
+           * use the bone matrix saved before solving IK.
+           * see CCDIKSolver for the detail.
+           */
+
+          if (useOriginalBones === true && bone.userData.ik !== undefined && bone.userData.ik.originalMatrix !== undefined) {
+            matrix.fromArray(bone.userData.ik.originalMatrix);
+          } else {
+            matrix.copy(bone.matrix);
+          }
+
+          position.setFromMatrixPosition(matrix);
+          quaternion.setFromRotationMatrix(matrix);
+          var pArray = position.sub(bone2.position).toArray();
+          var qArray = quaternion2.copy(bone2.quaternion).conjugate().multiply(quaternion).toArray(); // right to left
+
+          pArray[2] = -pArray[2];
+          qArray[0] = -qArray[0];
+          qArray[1] = -qArray[1];
+          array.push('Bone' + i + '{' + bone.name);
+          array.push('  ' + toStringsFromArray(pArray) + ';');
+          array.push('  ' + toStringsFromArray(qArray) + ';');
+          array.push('}');
+          array.push('');
+        }
+
+        array.push('');
+        var lines = array.join('\n');
+        return outputShiftJis === true ? unicodeToShiftjis(lines) : lines;
+      }
+    }]);
+
+    return MMDExporter;
+  }(); // Unicode to Shift_JIS table
+
+
+  _exports.MMDExporter = MMDExporter;
+  var u2sTable;
+
+  function unicodeToShiftjis(str) {
+    if (u2sTable === undefined) {
+      var encoder = new _mmdparserModule.MMDParser.CharsetEncoder(); // eslint-disable-line no-undef
+
+      var table = encoder.s2uTable;
+      u2sTable = {};
+      var keys = Object.keys(table);
+
+      for (var i = 0, il = keys.length; i < il; i++) {
+        var key = keys[i];
+        var value = table[key];
+        key = parseInt(key);
+        u2sTable[value] = key;
+      }
+    }
+
+    var array = [];
+
+    for (var _i = 0, _il = str.length; _i < _il; _i++) {
+      var code = str.charCodeAt(_i);
+      var _value = u2sTable[code];
+
+      if (_value === undefined) {
+        throw 'cannot convert charcode 0x' + code.toString(16);
+      } else if (_value > 0xff) {
+        array.push(_value >> 8 & 0xff);
+        array.push(_value & 0xff);
+      } else {
+        array.push(_value & 0xff);
+      }
+    }
+
+    return new Uint8Array(array);
+  }
+
+  function getBindBones(skin) {
+    // any more efficient ways?
+    var poseSkin = skin.clone();
+    poseSkin.pose();
+    return poseSkin.skeleton.bones;
+  }
+});

data/lib-opal/js_wrap/three/exporters/OBJExporter.js

@@ -0,0 +1,241 @@
+(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.OBJExporter = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.OBJExporter = 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; }
+
+  var OBJExporter = /*#__PURE__*/function () {
+    function OBJExporter() {
+      _classCallCheck(this, OBJExporter);
+    }
+
+    _createClass(OBJExporter, [{
+      key: "parse",
+      value: function parse(object) {
+        var output = '';
+        var indexVertex = 0;
+        var indexVertexUvs = 0;
+        var indexNormals = 0;
+        var vertex = new _three.Vector3();
+        var color = new _three.Color();
+        var normal = new _three.Vector3();
+        var uv = new _three.Vector2();
+        var face = [];
+
+        function parseMesh(mesh) {
+          var nbVertex = 0;
+          var nbNormals = 0;
+          var nbVertexUvs = 0;
+          var geometry = mesh.geometry;
+          var normalMatrixWorld = new _three.Matrix3();
+
+          if (geometry.isBufferGeometry !== true) {
+            throw new Error('THREE.OBJExporter: Geometry is not of type THREE.BufferGeometry.');
+          } // shortcuts
+
+
+          var vertices = geometry.getAttribute('position');
+          var normals = geometry.getAttribute('normal');
+          var uvs = geometry.getAttribute('uv');
+          var indices = geometry.getIndex(); // name of the mesh object
+
+          output += 'o ' + mesh.name + '\n'; // name of the mesh material
+
+          if (mesh.material && mesh.material.name) {
+            output += 'usemtl ' + mesh.material.name + '\n';
+          } // vertices
+
+
+          if (vertices !== undefined) {
+            for (var i = 0, l = vertices.count; i < l; i++, nbVertex++) {
+              vertex.x = vertices.getX(i);
+              vertex.y = vertices.getY(i);
+              vertex.z = vertices.getZ(i); // transform the vertex to world space
+
+              vertex.applyMatrix4(mesh.matrixWorld); // transform the vertex to export format
+
+              output += 'v ' + vertex.x + ' ' + vertex.y + ' ' + vertex.z + '\n';
+            }
+          } // uvs
+
+
+          if (uvs !== undefined) {
+            for (var _i = 0, _l = uvs.count; _i < _l; _i++, nbVertexUvs++) {
+              uv.x = uvs.getX(_i);
+              uv.y = uvs.getY(_i); // transform the uv to export format
+
+              output += 'vt ' + uv.x + ' ' + uv.y + '\n';
+            }
+          } // normals
+
+
+          if (normals !== undefined) {
+            normalMatrixWorld.getNormalMatrix(mesh.matrixWorld);
+
+            for (var _i2 = 0, _l2 = normals.count; _i2 < _l2; _i2++, nbNormals++) {
+              normal.x = normals.getX(_i2);
+              normal.y = normals.getY(_i2);
+              normal.z = normals.getZ(_i2); // transform the normal to world space
+
+              normal.applyMatrix3(normalMatrixWorld).normalize(); // transform the normal to export format
+
+              output += 'vn ' + normal.x + ' ' + normal.y + ' ' + normal.z + '\n';
+            }
+          } // faces
+
+
+          if (indices !== null) {
+            for (var _i3 = 0, _l3 = indices.count; _i3 < _l3; _i3 += 3) {
+              for (var m = 0; m < 3; m++) {
+                var j = indices.getX(_i3 + m) + 1;
+                face[m] = indexVertex + j + (normals || uvs ? '/' + (uvs ? indexVertexUvs + j : '') + (normals ? '/' + (indexNormals + j) : '') : '');
+              } // transform the face to export format
+
+
+              output += 'f ' + face.join(' ') + '\n';
+            }
+          } else {
+            for (var _i4 = 0, _l4 = vertices.count; _i4 < _l4; _i4 += 3) {
+              for (var _m = 0; _m < 3; _m++) {
+                var _j = _i4 + _m + 1;
+
+                face[_m] = indexVertex + _j + (normals || uvs ? '/' + (uvs ? indexVertexUvs + _j : '') + (normals ? '/' + (indexNormals + _j) : '') : '');
+              } // transform the face to export format
+
+
+              output += 'f ' + face.join(' ') + '\n';
+            }
+          } // update index
+
+
+          indexVertex += nbVertex;
+          indexVertexUvs += nbVertexUvs;
+          indexNormals += nbNormals;
+        }
+
+        function parseLine(line) {
+          var nbVertex = 0;
+          var geometry = line.geometry;
+          var type = line.type;
+
+          if (geometry.isBufferGeometry !== true) {
+            throw new Error('THREE.OBJExporter: Geometry is not of type THREE.BufferGeometry.');
+          } // shortcuts
+
+
+          var vertices = geometry.getAttribute('position'); // name of the line object
+
+          output += 'o ' + line.name + '\n';
+
+          if (vertices !== undefined) {
+            for (var i = 0, l = vertices.count; i < l; i++, nbVertex++) {
+              vertex.x = vertices.getX(i);
+              vertex.y = vertices.getY(i);
+              vertex.z = vertices.getZ(i); // transform the vertex to world space
+
+              vertex.applyMatrix4(line.matrixWorld); // transform the vertex to export format
+
+              output += 'v ' + vertex.x + ' ' + vertex.y + ' ' + vertex.z + '\n';
+            }
+          }
+
+          if (type === 'Line') {
+            output += 'l ';
+
+            for (var j = 1, _l5 = vertices.count; j <= _l5; j++) {
+              output += indexVertex + j + ' ';
+            }
+
+            output += '\n';
+          }
+
+          if (type === 'LineSegments') {
+            for (var _j2 = 1, k = _j2 + 1, _l6 = vertices.count; _j2 < _l6; _j2 += 2, k = _j2 + 1) {
+              output += 'l ' + (indexVertex + _j2) + ' ' + (indexVertex + k) + '\n';
+            }
+          } // update index
+
+
+          indexVertex += nbVertex;
+        }
+
+        function parsePoints(points) {
+          var nbVertex = 0;
+          var geometry = points.geometry;
+
+          if (geometry.isBufferGeometry !== true) {
+            throw new Error('THREE.OBJExporter: Geometry is not of type THREE.BufferGeometry.');
+          }
+
+          var vertices = geometry.getAttribute('position');
+          var colors = geometry.getAttribute('color');
+          output += 'o ' + points.name + '\n';
+
+          if (vertices !== undefined) {
+            for (var i = 0, l = vertices.count; i < l; i++, nbVertex++) {
+              vertex.fromBufferAttribute(vertices, i);
+              vertex.applyMatrix4(points.matrixWorld);
+              output += 'v ' + vertex.x + ' ' + vertex.y + ' ' + vertex.z;
+
+              if (colors !== undefined) {
+                color.fromBufferAttribute(colors, i);
+                output += ' ' + color.r + ' ' + color.g + ' ' + color.b;
+              }
+
+              output += '\n';
+            }
+          }
+
+          output += 'p ';
+
+          for (var j = 1, _l7 = vertices.count; j <= _l7; j++) {
+            output += indexVertex + j + ' ';
+          }
+
+          output += '\n'; // update index
+
+          indexVertex += nbVertex;
+        }
+
+        object.traverse(function (child) {
+          if (child.isMesh === true) {
+            parseMesh(child);
+          }
+
+          if (child.isLine === true) {
+            parseLine(child);
+          }
+
+          if (child.isPoints === true) {
+            parsePoints(child);
+          }
+        });
+        return output;
+      }
+    }]);
+
+    return OBJExporter;
+  }();
+
+  _exports.OBJExporter = OBJExporter;
+});