three-stdlib 2.22.7 → 2.22.8

package/dist/exporters/MMDExporter.d.ts

@@ -0,0 +1,12 @@
+import { SkinnedMesh } from 'three';
+/**
+ * Dependencies
+ *  - mmd-parser https://github.com/takahirox/mmd-parser
+ */
+declare class MMDExporter {
+    parseVpd(skin: SkinnedMesh, outputShiftJis: boolean, useOriginalBones: boolean): Uint8Array | string | null;
+    private u2sTable;
+    private unicodeToShiftjis;
+    private getBindBones;
+}
+export { MMDExporter };

package/dist/exporters/MMDExporter.js

@@ -0,0 +1,131 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const mmdParser = require("mmd-parser");
+class MMDExporter {
+  constructor() {
+    // Unicode to Shift_JIS table
+    __publicField(this, "u2sTable");
+  }
+  /* 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.");
+      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 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("");
+    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 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 === 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;
+  }
+}
+exports.MMDExporter = MMDExporter;

package/dist/exporters/MMDExporter.mjs

@@ -0,0 +1,131 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { Vector3, Quaternion, Matrix4 } from "three";
+import { CharsetEncoder } from "mmd-parser";
+class MMDExporter {
+  constructor() {
+    // Unicode to Shift_JIS table
+    __publicField(this, "u2sTable");
+  }
+  /* 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.");
+      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/dist/exporters/OBJExporter.d.ts

@@ -0,0 +1,18 @@
+import { Object3D } from 'three';
+declare class OBJExporter {
+    private output;
+    private indexVertex;
+    private indexVertexUvs;
+    private indexNormals;
+    private vertex;
+    private color;
+    private normal;
+    private uv;
+    private face;
+    constructor();
+    parse(object: Object3D): string;
+    private parseMesh;
+    private parseLine;
+    private parsePoints;
+}
+export { OBJExporter };

package/dist/exporters/OBJExporter.js

@@ -0,0 +1,181 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+class OBJExporter {
+  constructor() {
+    __publicField(this, "output");
+    __publicField(this, "indexVertex");
+    __publicField(this, "indexVertexUvs");
+    __publicField(this, "indexNormals");
+    __publicField(this, "vertex");
+    __publicField(this, "color");
+    __publicField(this, "normal");
+    __publicField(this, "uv");
+    __publicField(this, "face");
+    this.output = "";
+    this.indexVertex = 0;
+    this.indexVertexUvs = 0;
+    this.indexNormals = 0;
+    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 THREE.Mesh && child.isMesh) {
+        this.parseMesh(child);
+      }
+      if (child instanceof THREE.Line && child.isLine) {
+        this.parseLine(child);
+      }
+      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 THREE.Matrix3();
+    if (!geometry.isBufferGeometry) {
+      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}
+`;
+    }
+    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);
+        this.vertex.applyMatrix4(mesh.matrixWorld);
+        this.output += `v ${this.vertex.x} ${this.vertex.y} ${this.vertex.z}
+`;
+      }
+    }
+    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);
+        this.output += `vt ${this.uv.x} ${this.uv.y}
+`;
+      }
+    }
+    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);
+        this.normal.applyMatrix3(normalMatrixWorld).normalize();
+        this.output += `vn ${this.normal.x} ${this.normal.y} ${this.normal.z}
+`;
+      }
+    }
+    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}` : ""}` : "");
+        }
+        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}` : ""}` : "");
+        }
+        this.output += `f ${this.face.join(" ")}
+`;
+      }
+    }
+    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.");
+    }
+    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);
+        this.vertex.applyMatrix4(line.matrixWorld);
+        this.output += `v ${this.vertex.x} ${this.vertex.y} ${this.vertex.z}
+`;
+      }
+    }
+    if (type === "Line") {
+      this.output += "l ";
+      for (let j = 1, l = vertices.count; j <= l; j++) {
+        this.output += `${this.indexVertex + j} `;
+      }
+      this.output += "\n";
+    }
+    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}
+`;
+      }
+    }
+    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.");
+    }
+    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 !== 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 += "p ";
+    for (let j = 1, l = vertices.count; j <= l; j++) {
+      this.output += `${this.indexVertex + j} `;
+    }
+    this.output += "\n";
+    this.indexVertex += nbVertex;
+  }
+}
+exports.OBJExporter = OBJExporter;

package/dist/exporters/OBJExporter.mjs

@@ -0,0 +1,181 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { Vector3, Color, Vector2, Mesh, Line, Points, Matrix3, BufferAttribute } from "three";
+class OBJExporter {
+  constructor() {
+    __publicField(this, "output");
+    __publicField(this, "indexVertex");
+    __publicField(this, "indexVertexUvs");
+    __publicField(this, "indexNormals");
+    __publicField(this, "vertex");
+    __publicField(this, "color");
+    __publicField(this, "normal");
+    __publicField(this, "uv");
+    __publicField(this, "face");
+    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.face = [];
+  }
+  parse(object) {
+    object.traverse((child) => {
+      if (child instanceof Mesh && child.isMesh) {
+        this.parseMesh(child);
+      }
+      if (child instanceof Line && child.isLine) {
+        this.parseLine(child);
+      }
+      if (child instanceof 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();
+    if (!geometry.isBufferGeometry) {
+      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}
+`;
+    }
+    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);
+        this.vertex.applyMatrix4(mesh.matrixWorld);
+        this.output += `v ${this.vertex.x} ${this.vertex.y} ${this.vertex.z}
+`;
+      }
+    }
+    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);
+        this.output += `vt ${this.uv.x} ${this.uv.y}
+`;
+      }
+    }
+    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);
+        this.normal.applyMatrix3(normalMatrixWorld).normalize();
+        this.output += `vn ${this.normal.x} ${this.normal.y} ${this.normal.z}
+`;
+      }
+    }
+    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}` : ""}` : "");
+        }
+        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}` : ""}` : "");
+        }
+        this.output += `f ${this.face.join(" ")}
+`;
+      }
+    }
+    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.");
+    }
+    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);
+        this.vertex.applyMatrix4(line.matrixWorld);
+        this.output += `v ${this.vertex.x} ${this.vertex.y} ${this.vertex.z}
+`;
+      }
+    }
+    if (type === "Line") {
+      this.output += "l ";
+      for (let j = 1, l = vertices.count; j <= l; j++) {
+        this.output += `${this.indexVertex + j} `;
+      }
+      this.output += "\n";
+    }
+    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}
+`;
+      }
+    }
+    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.");
+    }
+    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 !== void 0 && colors instanceof BufferAttribute) {
+          this.color.fromBufferAttribute(colors, i);
+          this.output += ` ${this.color.r} ${this.color.g} ${this.color.b}`;
+        }
+        this.output += "\n";
+      }
+    }
+    this.output += "p ";
+    for (let j = 1, l = vertices.count; j <= l; j++) {
+      this.output += `${this.indexVertex + j} `;
+    }
+    this.output += "\n";
+    this.indexVertex += nbVertex;
+  }
+}
+export {
+  OBJExporter
+};

package/dist/exporters/PLYExporter.d.ts

@@ -0,0 +1,23 @@
+import { Object3D } from 'three';
+/**
+ * https://github.com/gkjohnson/ply-exporter-js
+ *
+ * Usage:
+ *  const exporter = new PLYExporter();
+ *
+ *  // second argument is a list of options
+ *  exporter.parse(mesh, data => console.log(data), { binary: true, excludeAttributes: [ 'color' ], littleEndian: true });
+ *
+ * Format Definition:
+ * http://paulbourke.net/dataformats/ply/
+ */
+export interface PLYExporterOptions {
+    binary?: boolean;
+    excludeAttributes?: string[];
+    littleEndian?: boolean;
+}
+declare class PLYExporter {
+    parse(object: Object3D, onDone: ((res: string) => void) | undefined, options: PLYExporterOptions): string | ArrayBuffer | null;
+    private traverseMeshes;
+}
+export { PLYExporter };