three-stdlib 2.15.1 → 2.16.0

package/exporters/MMDExporter.js

@@ -1,160 +1,102 @@
-import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import { Vector3, Quaternion, Matrix4 } from 'three';
-import { CharsetEncoder } from 'mmd-parser';
-
-/**
- * Dependencies
- *  - mmd-parser https://github.com/takahirox/mmd-parser
- */
-
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const THREE = require("three");
+const mmdParser = require("mmd-parser");
 class MMDExporter {
-  constructor() {
-    _defineProperty(this, "u2sTable", void 0);
-  }
-
-  /* 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.
-   */
   parseVpd(skin, outputShiftJis, useOriginalBones) {
     if (skin.isSkinnedMesh !== true) {
-      console.warn('THREE.MMDExporter: parseVpd() requires SkinnedMesh instance.');
+      console.warn("THREE.MMDExporter: parseVpd() requires SkinnedMesh instance.");
       return null;
     }
-
     function toStringsFromNumber(num) {
-      if (Math.abs(num) < 1e-6) num = 0;
+      if (Math.abs(num) < 1e-6)
+        num = 0;
       let a = num.toString();
-
-      if (a.indexOf('.') === -1) {
-        a += '.';
+      if (a.indexOf(".") === -1) {
+        a += ".";
       }
-
-      a += '000000';
-      const index = a.indexOf('.');
+      a += "000000";
+      const index = a.indexOf(".");
       const d = a.slice(0, index);
       const p = a.slice(index + 1, index + 7);
-      return d + '.' + p;
+      return d + "." + p;
     }
-
-    function toStringsFromArray(array) {
+    function toStringsFromArray(array2) {
       const a = [];
-
-      for (let i = 0, il = array.length; i < il; i++) {
-        a.push(toStringsFromNumber(array[i]));
+      for (let i = 0, il = array2.length; i < il; i++) {
+        a.push(toStringsFromNumber(array2[i]));
       }
-
-      return a.join(',');
+      return a.join(",");
     }
-
     skin.updateMatrixWorld(true);
     const bones = skin.skeleton.bones;
     const bones2 = this.getBindBones(skin);
-    const position = new Vector3();
-    const quaternion = new Quaternion();
-    const quaternion2 = new Quaternion();
-    const matrix = new Matrix4();
+    const position = new THREE.Vector3();
+    const quaternion = new THREE.Quaternion();
+    const quaternion2 = new THREE.Quaternion();
+    const matrix = new THREE.Matrix4();
     const 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('');
-
+    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 (let i = 0, il = bones.length; i < il; i++) {
       const bone = bones[i];
       const 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) {
+      if (useOriginalBones === true && bone.userData.ik !== void 0 && bone.userData.ik.originalMatrix !== void 0) {
         matrix.fromArray(bone.userData.ik.originalMatrix);
       } else {
         matrix.copy(bone.matrix);
       }
-
       position.setFromMatrixPosition(matrix);
       quaternion.setFromRotationMatrix(matrix);
       const pArray = position.sub(bone2.position).toArray();
-      const qArray = quaternion2.copy(bone2.quaternion).conjugate().multiply(quaternion).toArray(); // right to left
-
+      const qArray = quaternion2.copy(bone2.quaternion).conjugate().multiply(quaternion).toArray();
       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("Bone" + i + "{" + bone.name);
+      array.push("  " + toStringsFromArray(pArray) + ";");
+      array.push("  " + toStringsFromArray(qArray) + ";");
+      array.push("}");
+      array.push("");
     }
-
-    array.push('');
-    const lines = array.join('\n');
+    array.push("");
+    const lines = array.join("\n");
     return outputShiftJis === true ? this.unicodeToShiftjis(lines) : lines;
-  } // Unicode to Shift_JIS table
-
-
+  }
   unicodeToShiftjis(str) {
-    if (this.u2sTable === undefined) {
-      const encoder = new CharsetEncoder(); // eslint-disable-line no-undef
-
+    if (this.u2sTable === void 0) {
+      const encoder = new mmdParser.CharsetEncoder();
       const table = encoder.s2uTable;
       this.u2sTable = {};
       const keys = Object.keys(table);
-
       for (let i = 0, il = keys.length; i < il; i++) {
         let key = keys[i];
         const value = table[key];
         this.u2sTable[value] = parseInt(key);
       }
     }
-
     const array = [];
-
     for (let i = 0, il = str.length; i < il; i++) {
       const code = str.charCodeAt(i);
       const value = this.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);
+      if (value === void 0) {
+        throw "cannot convert charcode 0x" + code.toString(16);
+      } else if (value > 255) {
+        array.push(value >> 8 & 255);
+        array.push(value & 255);
       } else {
-        array.push(value & 0xff);
+        array.push(value & 255);
       }
     }
-
     return new Uint8Array(array);
   }
-
   getBindBones(skin) {
-    // any more efficient ways?
     const poseSkin = skin.clone();
     poseSkin.pose();
     return poseSkin.skeleton.bones;
   }
-
 }
-
-export { MMDExporter };
+exports.MMDExporter = MMDExporter;

package/exporters/MMDExporter.mjs

@@ -0,0 +1,102 @@
+import { Vector3, Quaternion, Matrix4 } from "three";
+import { CharsetEncoder } from "mmd-parser";
+class MMDExporter {
+  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;
+      let a = num.toString();
+      if (a.indexOf(".") === -1) {
+        a += ".";
+      }
+      a += "000000";
+      const index = a.indexOf(".");
+      const d = a.slice(0, index);
+      const p = a.slice(index + 1, index + 7);
+      return d + "." + p;
+    }
+    function toStringsFromArray(array2) {
+      const a = [];
+      for (let i = 0, il = array2.length; i < il; i++) {
+        a.push(toStringsFromNumber(array2[i]));
+      }
+      return a.join(",");
+    }
+    skin.updateMatrixWorld(true);
+    const bones = skin.skeleton.bones;
+    const bones2 = this.getBindBones(skin);
+    const position = new Vector3();
+    const quaternion = new Quaternion();
+    const quaternion2 = new Quaternion();
+    const matrix = new Matrix4();
+    const 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 (let i = 0, il = bones.length; i < il; i++) {
+      const bone = bones[i];
+      const bone2 = bones2[i];
+      if (useOriginalBones === true && bone.userData.ik !== void 0 && bone.userData.ik.originalMatrix !== void 0) {
+        matrix.fromArray(bone.userData.ik.originalMatrix);
+      } else {
+        matrix.copy(bone.matrix);
+      }
+      position.setFromMatrixPosition(matrix);
+      quaternion.setFromRotationMatrix(matrix);
+      const pArray = position.sub(bone2.position).toArray();
+      const qArray = quaternion2.copy(bone2.quaternion).conjugate().multiply(quaternion).toArray();
+      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("");
+    const lines = array.join("\n");
+    return outputShiftJis === true ? this.unicodeToShiftjis(lines) : lines;
+  }
+  unicodeToShiftjis(str) {
+    if (this.u2sTable === void 0) {
+      const encoder = new CharsetEncoder();
+      const table = encoder.s2uTable;
+      this.u2sTable = {};
+      const keys = Object.keys(table);
+      for (let i = 0, il = keys.length; i < il; i++) {
+        let key = keys[i];
+        const value = table[key];
+        this.u2sTable[value] = parseInt(key);
+      }
+    }
+    const array = [];
+    for (let i = 0, il = str.length; i < il; i++) {
+      const code = str.charCodeAt(i);
+      const value = this.u2sTable[code];
+      if (value === void 0) {
+        throw "cannot convert charcode 0x" + code.toString(16);
+      } else if (value > 255) {
+        array.push(value >> 8 & 255);
+        array.push(value & 255);
+      } else {
+        array.push(value & 255);
+      }
+    }
+    return new Uint8Array(array);
+  }
+  getBindBones(skin) {
+    const poseSkin = skin.clone();
+    poseSkin.pose();
+    return poseSkin.skeleton.bones;
+  }
+}
+export {
+  MMDExporter
+};

package/exporters/OBJExporter.js

@@ -1,228 +1,166 @@
-import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import { Vector3, Color, Vector2, Mesh, Line, Points, Matrix3, BufferAttribute } from 'three';
-
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const THREE = require("three");
 class OBJExporter {
   constructor() {
-    _defineProperty(this, "output", void 0);
-
-    _defineProperty(this, "indexVertex", void 0);
-
-    _defineProperty(this, "indexVertexUvs", void 0);
-
-    _defineProperty(this, "indexNormals", void 0);
-
-    _defineProperty(this, "vertex", void 0);
-
-    _defineProperty(this, "color", void 0);
-
-    _defineProperty(this, "normal", void 0);
-
-    _defineProperty(this, "uv", void 0);
-
-    _defineProperty(this, "face", void 0);
-
-    this.output = '';
+    this.output = "";
     this.indexVertex = 0;
     this.indexVertexUvs = 0;
     this.indexNormals = 0;
-    this.vertex = new Vector3();
-    this.color = new Color();
-    this.normal = new Vector3();
-    this.uv = new Vector2();
+    this.vertex = new THREE.Vector3();
+    this.color = new THREE.Color();
+    this.normal = new THREE.Vector3();
+    this.uv = new THREE.Vector2();
     this.face = [];
   }
-
   parse(object) {
-    object.traverse(child => {
-      if (child instanceof Mesh && child.isMesh) {
+    object.traverse((child) => {
+      if (child instanceof THREE.Mesh && child.isMesh) {
         this.parseMesh(child);
       }
-
-      if (child instanceof Line && child.isLine) {
+      if (child instanceof THREE.Line && child.isLine) {
         this.parseLine(child);
       }
-
-      if (child instanceof Points && child.isPoints) {
+      if (child instanceof THREE.Points && child.isPoints) {
         this.parsePoints(child);
       }
     });
     return this.output;
   }
-
   parseMesh(mesh) {
     let nbVertex = 0;
     let nbNormals = 0;
     let nbVertexUvs = 0;
     const geometry = mesh.geometry;
-    const normalMatrixWorld = new Matrix3();
-
+    const normalMatrixWorld = new THREE.Matrix3();
     if (!geometry.isBufferGeometry) {
-      throw new Error('THREE.OBJExporter: Geometry is not of type THREE.BufferGeometry.');
-    } // shortcuts
-
-
-    const vertices = geometry.getAttribute('position');
-    const normals = geometry.getAttribute('normal');
-    const uvs = geometry.getAttribute('uv');
-    const indices = geometry.getIndex(); // name of the mesh object
-
-    this.output += `o ${mesh.name}\n`; // name of the mesh material
-
+      throw new Error("THREE.OBJExporter: Geometry is not of type THREE.BufferGeometry.");
+    }
+    const vertices = geometry.getAttribute("position");
+    const normals = geometry.getAttribute("normal");
+    const uvs = geometry.getAttribute("uv");
+    const indices = geometry.getIndex();
+    this.output += `o ${mesh.name}
+`;
     if (mesh.material && !Array.isArray(mesh.material) && mesh.material.name) {
-      this.output += `usemtl ${mesh.material.name}\n`;
-    } // vertices
-
-
-    if (vertices !== undefined) {
+      this.output += `usemtl ${mesh.material.name}
+`;
+    }
+    if (vertices !== void 0) {
       for (let i = 0, l = vertices.count; i < l; i++, nbVertex++) {
         this.vertex.x = vertices.getX(i);
         this.vertex.y = vertices.getY(i);
-        this.vertex.z = vertices.getZ(i); // transform the vertex to world space
-
-        this.vertex.applyMatrix4(mesh.matrixWorld); // transform the vertex to export format
-
-        this.output += `v ${this.vertex.x} ${this.vertex.y} ${this.vertex.z}\n`;
+        this.vertex.z = vertices.getZ(i);
+        this.vertex.applyMatrix4(mesh.matrixWorld);
+        this.output += `v ${this.vertex.x} ${this.vertex.y} ${this.vertex.z}
+`;
       }
-    } // uvs
-
-
-    if (uvs !== undefined) {
+    }
+    if (uvs !== void 0) {
       for (let i = 0, l = uvs.count; i < l; i++, nbVertexUvs++) {
         this.uv.x = uvs.getX(i);
-        this.uv.y = uvs.getY(i); // transform the uv to export format
-
-        this.output += `vt ${this.uv.x} ${this.uv.y}\n`;
+        this.uv.y = uvs.getY(i);
+        this.output += `vt ${this.uv.x} ${this.uv.y}
+`;
       }
-    } // normals
-
-
-    if (normals !== undefined) {
+    }
+    if (normals !== void 0) {
       normalMatrixWorld.getNormalMatrix(mesh.matrixWorld);
-
       for (let i = 0, l = normals.count; i < l; i++, nbNormals++) {
         this.normal.x = normals.getX(i);
         this.normal.y = normals.getY(i);
-        this.normal.z = normals.getZ(i); // transform the normal to world space
-
-        this.normal.applyMatrix3(normalMatrixWorld).normalize(); // transform the normal to export format
-
-        this.output += `vn ${this.normal.x} ${this.normal.y} ${this.normal.z}\n`;
+        this.normal.z = normals.getZ(i);
+        this.normal.applyMatrix3(normalMatrixWorld).normalize();
+        this.output += `vn ${this.normal.x} ${this.normal.y} ${this.normal.z}
+`;
       }
-    } // faces
-
-
+    }
     if (indices !== null) {
       for (let i = 0, l = indices.count; i < l; i += 3) {
         for (let m = 0; m < 3; m++) {
           const j = indices.getX(i + m) + 1;
-          this.face[m] = this.indexVertex + j + (normals || uvs ? `/${uvs ? this.indexVertexUvs + j : ''}${normals ? `/${this.indexNormals + j}` : ''}` : '');
-        } // transform the face to export format
-
-
-        this.output += `f ${this.face.join(' ')}\n`;
+          this.face[m] = this.indexVertex + j + (normals || uvs ? `/${uvs ? this.indexVertexUvs + j : ""}${normals ? `/${this.indexNormals + j}` : ""}` : "");
+        }
+        this.output += `f ${this.face.join(" ")}
+`;
       }
     } else {
       for (let i = 0, l = vertices.count; i < l; i += 3) {
         for (let m = 0; m < 3; m++) {
           const j = i + m + 1;
-          this.face[m] = this.indexVertex + j + (normals || uvs ? `/${uvs ? this.indexVertexUvs + j : ''}${normals ? `/${this.indexNormals + j}` : ''}` : '');
-        } // transform the face to export format
-
-
-        this.output += `f ${this.face.join(' ')}\n`;
+          this.face[m] = this.indexVertex + j + (normals || uvs ? `/${uvs ? this.indexVertexUvs + j : ""}${normals ? `/${this.indexNormals + j}` : ""}` : "");
+        }
+        this.output += `f ${this.face.join(" ")}
+`;
       }
-    } // update index
-
-
+    }
     this.indexVertex += nbVertex;
     this.indexVertexUvs += nbVertexUvs;
     this.indexNormals += nbNormals;
   }
-
   parseLine(line) {
     let nbVertex = 0;
     const geometry = line.geometry;
     const type = line.type;
-
     if (geometry.isBufferGeometry) {
-      throw new Error('THREE.OBJExporter: Geometry is not of type THREE.BufferGeometry.');
-    } // shortcuts
-
-
-    const vertices = geometry.getAttribute('position'); // name of the line object
-
-    this.output += `o ${line.name}\n`;
-
-    if (vertices !== undefined) {
+      throw new Error("THREE.OBJExporter: Geometry is not of type THREE.BufferGeometry.");
+    }
+    const vertices = geometry.getAttribute("position");
+    this.output += `o ${line.name}
+`;
+    if (vertices !== void 0) {
       for (let i = 0, l = vertices.count; i < l; i++, nbVertex++) {
         this.vertex.x = vertices.getX(i);
         this.vertex.y = vertices.getY(i);
-        this.vertex.z = vertices.getZ(i); // transform the vertex to world space
-
-        this.vertex.applyMatrix4(line.matrixWorld); // transform the vertex to export format
-
-        this.output += `v ${this.vertex.x} ${this.vertex.y} ${this.vertex.z}\n`;
+        this.vertex.z = vertices.getZ(i);
+        this.vertex.applyMatrix4(line.matrixWorld);
+        this.output += `v ${this.vertex.x} ${this.vertex.y} ${this.vertex.z}
+`;
       }
     }
-
-    if (type === 'Line') {
-      this.output += 'l ';
-
+    if (type === "Line") {
+      this.output += "l ";
       for (let j = 1, l = vertices.count; j <= l; j++) {
         this.output += `${this.indexVertex + j} `;
       }
-
-      this.output += '\n';
+      this.output += "\n";
     }
-
-    if (type === 'LineSegments') {
+    if (type === "LineSegments") {
       for (let j = 1, k = j + 1, l = vertices.count; j < l; j += 2, k = j + 1) {
-        this.output += `l ${this.indexVertex + j} ${this.indexVertex + k}\n`;
+        this.output += `l ${this.indexVertex + j} ${this.indexVertex + k}
+`;
       }
-    } // update index
-
-
+    }
     this.indexVertex += nbVertex;
   }
-
   parsePoints(points) {
     let nbVertex = 0;
     const geometry = points.geometry;
-
     if (!geometry.isBufferGeometry) {
-      throw new Error('THREE.OBJExporter: Geometry is not of type THREE.BufferGeometry.');
+      throw new Error("THREE.OBJExporter: Geometry is not of type THREE.BufferGeometry.");
     }
-
-    const vertices = geometry.getAttribute('position');
-    const colors = geometry.getAttribute('color');
-    this.output += `o ${points.name}\n`;
-
-    if (vertices !== undefined) {
+    const vertices = geometry.getAttribute("position");
+    const colors = geometry.getAttribute("color");
+    this.output += `o ${points.name}
+`;
+    if (vertices !== void 0) {
       for (let i = 0, l = vertices.count; i < l; i++, nbVertex++) {
         this.vertex.fromBufferAttribute(vertices, i);
         this.vertex.applyMatrix4(points.matrixWorld);
         this.output += `v ${this.vertex.x} ${this.vertex.y} ${this.vertex.z}`;
-
-        if (colors !== undefined && colors instanceof BufferAttribute) {
+        if (colors !== void 0 && colors instanceof THREE.BufferAttribute) {
           this.color.fromBufferAttribute(colors, i);
           this.output += ` ${this.color.r} ${this.color.g} ${this.color.b}`;
         }
-
-        this.output += '\n';
+        this.output += "\n";
       }
     }
-
-    this.output += 'p ';
-
+    this.output += "p ";
     for (let j = 1, l = vertices.count; j <= l; j++) {
       this.output += `${this.indexVertex + j} `;
     }
-
-    this.output += '\n'; // update index
-
+    this.output += "\n";
     this.indexVertex += nbVertex;
   }
-
 }
-
-export { OBJExporter };
+exports.OBJExporter = OBJExporter;