three-stdlib 2.35.4 → 2.35.5

package/deprecated/Geometry.cjs

@@ -1,209 +1,227 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const THREE = require("three");
-const _m1 = /* @__PURE__ */ new THREE.Matrix4();
-const _obj = /* @__PURE__ */ new THREE.Object3D();
-const _offset = /* @__PURE__ */ new THREE.Vector3();
-const Geometry = /* @__PURE__ */ (() => {
-  class Geometry2 extends THREE.EventDispatcher {
-    static createBufferGeometryFromObject(object) {
-      let buffergeometry = new THREE.BufferGeometry();
-      const geometry = object.geometry;
-      if (object.isPoints || object.isLine) {
-        const positions = new THREE.Float32BufferAttribute(geometry.vertices.length * 3, 3);
-        const colors = new THREE.Float32BufferAttribute(geometry.colors.length * 3, 3);
-        buffergeometry.setAttribute("position", positions.copyVector3sArray(geometry.vertices));
-        buffergeometry.setAttribute("color", colors.copyColorsArray(geometry.colors));
-        if (geometry.lineDistances && geometry.lineDistances.length === geometry.vertices.length) {
-          const lineDistances = new THREE.Float32BufferAttribute(geometry.lineDistances.length, 1);
-          buffergeometry.setAttribute("lineDistance", lineDistances.copyArray(geometry.lineDistances));
-        }
-        if (geometry.boundingSphere !== null) {
-          buffergeometry.boundingSphere = geometry.boundingSphere.clone();
-        }
-        if (geometry.boundingBox !== null) {
-          buffergeometry.boundingBox = geometry.boundingBox.clone();
-        }
-      } else if (object.isMesh) {
-        buffergeometry = geometry.toBufferGeometry();
-      }
-      return buffergeometry;
-    }
-    constructor() {
-      super();
-      this.isGeometry = true;
-      this.uuid = THREE.MathUtils.generateUUID();
-      this.name = "";
-      this.type = "Geometry";
-      this.vertices = [];
-      this.colors = [];
-      this.faces = [];
-      this.faceVertexUvs = [[]];
-      this.morphTargets = [];
-      this.morphNormals = [];
-      this.skinWeights = [];
-      this.skinIndices = [];
-      this.lineDistances = [];
-      this.boundingBox = null;
-      this.boundingSphere = null;
-      this.elementsNeedUpdate = false;
-      this.verticesNeedUpdate = false;
-      this.uvsNeedUpdate = false;
-      this.normalsNeedUpdate = false;
-      this.colorsNeedUpdate = false;
-      this.lineDistancesNeedUpdate = false;
-      this.groupsNeedUpdate = false;
-    }
-    applyMatrix4(matrix) {
-      const normalMatrix = new THREE.Matrix3().getNormalMatrix(matrix);
-      for (let i = 0, il = this.vertices.length; i < il; i++) {
-        const vertex = this.vertices[i];
-        vertex.applyMatrix4(matrix);
-      }
-      for (let i = 0, il = this.faces.length; i < il; i++) {
-        const face = this.faces[i];
-        face.normal.applyMatrix3(normalMatrix).normalize();
-        for (let j = 0, jl = face.vertexNormals.length; j < jl; j++) {
-          face.vertexNormals[j].applyMatrix3(normalMatrix).normalize();
-        }
+const _m1 = new THREE.Matrix4();
+const _obj = new THREE.Object3D();
+const _offset = new THREE.Vector3();
+class Geometry extends THREE.EventDispatcher {
+  static createBufferGeometryFromObject(object) {
+    let buffergeometry = new THREE.BufferGeometry();
+    const geometry = object.geometry;
+    if (object.isPoints || object.isLine) {
+      const positions = new THREE.Float32BufferAttribute(geometry.vertices.length * 3, 3);
+      const colors = new THREE.Float32BufferAttribute(geometry.colors.length * 3, 3);
+      buffergeometry.setAttribute("position", positions.copyVector3sArray(geometry.vertices));
+      buffergeometry.setAttribute("color", colors.copyColorsArray(geometry.colors));
+      if (geometry.lineDistances && geometry.lineDistances.length === geometry.vertices.length) {
+        const lineDistances = new THREE.Float32BufferAttribute(geometry.lineDistances.length, 1);
+        buffergeometry.setAttribute("lineDistance", lineDistances.copyArray(geometry.lineDistances));
       }
-      if (this.boundingBox !== null) {
-        this.computeBoundingBox();
+      if (geometry.boundingSphere !== null) {
+        buffergeometry.boundingSphere = geometry.boundingSphere.clone();
       }
-      if (this.boundingSphere !== null) {
-        this.computeBoundingSphere();
+      if (geometry.boundingBox !== null) {
+        buffergeometry.boundingBox = geometry.boundingBox.clone();
       }
-      this.verticesNeedUpdate = true;
-      this.normalsNeedUpdate = true;
-      return this;
+    } else if (object.isMesh) {
+      buffergeometry = geometry.toBufferGeometry();
     }
-    rotateX(angle) {
-      _m1.makeRotationX(angle);
-      this.applyMatrix4(_m1);
-      return this;
-    }
-    rotateY(angle) {
-      _m1.makeRotationY(angle);
-      this.applyMatrix4(_m1);
-      return this;
+    return buffergeometry;
+  }
+  constructor() {
+    super();
+    this.isGeometry = true;
+    this.uuid = THREE.MathUtils.generateUUID();
+    this.name = "";
+    this.type = "Geometry";
+    this.vertices = [];
+    this.colors = [];
+    this.faces = [];
+    this.faceVertexUvs = [[]];
+    this.morphTargets = [];
+    this.morphNormals = [];
+    this.skinWeights = [];
+    this.skinIndices = [];
+    this.lineDistances = [];
+    this.boundingBox = null;
+    this.boundingSphere = null;
+    this.elementsNeedUpdate = false;
+    this.verticesNeedUpdate = false;
+    this.uvsNeedUpdate = false;
+    this.normalsNeedUpdate = false;
+    this.colorsNeedUpdate = false;
+    this.lineDistancesNeedUpdate = false;
+    this.groupsNeedUpdate = false;
+  }
+  applyMatrix4(matrix) {
+    const normalMatrix = new THREE.Matrix3().getNormalMatrix(matrix);
+    for (let i = 0, il = this.vertices.length; i < il; i++) {
+      const vertex = this.vertices[i];
+      vertex.applyMatrix4(matrix);
     }
-    rotateZ(angle) {
-      _m1.makeRotationZ(angle);
-      this.applyMatrix4(_m1);
-      return this;
+    for (let i = 0, il = this.faces.length; i < il; i++) {
+      const face = this.faces[i];
+      face.normal.applyMatrix3(normalMatrix).normalize();
+      for (let j = 0, jl = face.vertexNormals.length; j < jl; j++) {
+        face.vertexNormals[j].applyMatrix3(normalMatrix).normalize();
+      }
     }
-    translate(x, y, z) {
-      _m1.makeTranslation(x, y, z);
-      this.applyMatrix4(_m1);
-      return this;
+    if (this.boundingBox !== null) {
+      this.computeBoundingBox();
     }
-    scale(x, y, z) {
-      _m1.makeScale(x, y, z);
-      this.applyMatrix4(_m1);
-      return this;
+    if (this.boundingSphere !== null) {
+      this.computeBoundingSphere();
     }
-    lookAt(vector) {
-      _obj.lookAt(vector);
-      _obj.updateMatrix();
-      this.applyMatrix4(_obj.matrix);
+    this.verticesNeedUpdate = true;
+    this.normalsNeedUpdate = true;
+    return this;
+  }
+  rotateX(angle) {
+    _m1.makeRotationX(angle);
+    this.applyMatrix4(_m1);
+    return this;
+  }
+  rotateY(angle) {
+    _m1.makeRotationY(angle);
+    this.applyMatrix4(_m1);
+    return this;
+  }
+  rotateZ(angle) {
+    _m1.makeRotationZ(angle);
+    this.applyMatrix4(_m1);
+    return this;
+  }
+  translate(x, y, z) {
+    _m1.makeTranslation(x, y, z);
+    this.applyMatrix4(_m1);
+    return this;
+  }
+  scale(x, y, z) {
+    _m1.makeScale(x, y, z);
+    this.applyMatrix4(_m1);
+    return this;
+  }
+  lookAt(vector) {
+    _obj.lookAt(vector);
+    _obj.updateMatrix();
+    this.applyMatrix4(_obj.matrix);
+    return this;
+  }
+  fromBufferGeometry(geometry) {
+    const scope = this;
+    const index = geometry.index !== null ? geometry.index : void 0;
+    const attributes = geometry.attributes;
+    if (attributes.position === void 0) {
+      console.error("THREE.Geometry.fromBufferGeometry(): Position attribute required for conversion.");
       return this;
     }
-    fromBufferGeometry(geometry) {
-      const scope = this;
-      const index = geometry.index !== null ? geometry.index : void 0;
-      const attributes = geometry.attributes;
-      if (attributes.position === void 0) {
-        console.error("THREE.Geometry.fromBufferGeometry(): Position attribute required for conversion.");
-        return this;
-      }
-      const position = attributes.position;
-      const normal = attributes.normal;
-      const color = attributes.color;
-      const uv = attributes.uv;
-      const uv2 = attributes.uv2;
-      if (uv2 !== void 0)
-        this.faceVertexUvs[1] = [];
-      for (let i = 0; i < position.count; i++) {
-        scope.vertices.push(new THREE.Vector3().fromBufferAttribute(position, i));
-        if (color !== void 0) {
-          scope.colors.push(new THREE.Color().fromBufferAttribute(color, i));
-        }
-      }
-      function addFace(a, b, c, materialIndex) {
-        const vertexColors = color === void 0 ? [] : [scope.colors[a].clone(), scope.colors[b].clone(), scope.colors[c].clone()];
-        const vertexNormals = normal === void 0 ? [] : [
-          new THREE.Vector3().fromBufferAttribute(normal, a),
-          new THREE.Vector3().fromBufferAttribute(normal, b),
-          new THREE.Vector3().fromBufferAttribute(normal, c)
-        ];
-        const face = new Face3(a, b, c, vertexNormals, vertexColors, materialIndex);
-        scope.faces.push(face);
-        if (uv !== void 0) {
-          scope.faceVertexUvs[0].push([
-            new THREE.Vector2().fromBufferAttribute(uv, a),
-            new THREE.Vector2().fromBufferAttribute(uv, b),
-            new THREE.Vector2().fromBufferAttribute(uv, c)
-          ]);
-        }
-        if (uv2 !== void 0) {
-          scope.faceVertexUvs[1].push([
-            new THREE.Vector2().fromBufferAttribute(uv2, a),
-            new THREE.Vector2().fromBufferAttribute(uv2, b),
-            new THREE.Vector2().fromBufferAttribute(uv2, c)
-          ]);
+    const position = attributes.position;
+    const normal = attributes.normal;
+    const color = attributes.color;
+    const uv = attributes.uv;
+    const uv2 = attributes.uv2;
+    if (uv2 !== void 0)
+      this.faceVertexUvs[1] = [];
+    for (let i = 0; i < position.count; i++) {
+      scope.vertices.push(new THREE.Vector3().fromBufferAttribute(position, i));
+      if (color !== void 0) {
+        scope.colors.push(new THREE.Color().fromBufferAttribute(color, i));
+      }
+    }
+    function addFace(a, b, c, materialIndex) {
+      const vertexColors = color === void 0 ? [] : [scope.colors[a].clone(), scope.colors[b].clone(), scope.colors[c].clone()];
+      const vertexNormals = normal === void 0 ? [] : [
+        new THREE.Vector3().fromBufferAttribute(normal, a),
+        new THREE.Vector3().fromBufferAttribute(normal, b),
+        new THREE.Vector3().fromBufferAttribute(normal, c)
+      ];
+      const face = new Face3(a, b, c, vertexNormals, vertexColors, materialIndex);
+      scope.faces.push(face);
+      if (uv !== void 0) {
+        scope.faceVertexUvs[0].push([
+          new THREE.Vector2().fromBufferAttribute(uv, a),
+          new THREE.Vector2().fromBufferAttribute(uv, b),
+          new THREE.Vector2().fromBufferAttribute(uv, c)
+        ]);
+      }
+      if (uv2 !== void 0) {
+        scope.faceVertexUvs[1].push([
+          new THREE.Vector2().fromBufferAttribute(uv2, a),
+          new THREE.Vector2().fromBufferAttribute(uv2, b),
+          new THREE.Vector2().fromBufferAttribute(uv2, c)
+        ]);
+      }
+    }
+    const groups = geometry.groups;
+    if (groups.length > 0) {
+      for (let i = 0; i < groups.length; i++) {
+        const group = groups[i];
+        const start = group.start;
+        const count = group.count;
+        for (let j = start, jl = start + count; j < jl; j += 3) {
+          if (index !== void 0) {
+            addFace(index.getX(j), index.getX(j + 1), index.getX(j + 2), group.materialIndex);
+          } else {
+            addFace(j, j + 1, j + 2, group.materialIndex);
+          }
         }
       }
-      const groups = geometry.groups;
-      if (groups.length > 0) {
-        for (let i = 0; i < groups.length; i++) {
-          const group = groups[i];
-          const start = group.start;
-          const count = group.count;
-          for (let j = start, jl = start + count; j < jl; j += 3) {
-            if (index !== void 0) {
-              addFace(index.getX(j), index.getX(j + 1), index.getX(j + 2), group.materialIndex);
-            } else {
-              addFace(j, j + 1, j + 2, group.materialIndex);
-            }
-          }
+    } else {
+      if (index !== void 0) {
+        for (let i = 0; i < index.count; i += 3) {
+          addFace(index.getX(i), index.getX(i + 1), index.getX(i + 2));
         }
       } else {
-        if (index !== void 0) {
-          for (let i = 0; i < index.count; i += 3) {
-            addFace(index.getX(i), index.getX(i + 1), index.getX(i + 2));
-          }
-        } else {
-          for (let i = 0; i < position.count; i += 3) {
-            addFace(i, i + 1, i + 2);
-          }
+        for (let i = 0; i < position.count; i += 3) {
+          addFace(i, i + 1, i + 2);
         }
       }
-      this.computeFaceNormals();
-      if (geometry.boundingBox !== null) {
-        this.boundingBox = geometry.boundingBox.clone();
-      }
-      if (geometry.boundingSphere !== null) {
-        this.boundingSphere = geometry.boundingSphere.clone();
-      }
-      return this;
     }
-    center() {
-      this.computeBoundingBox();
-      this.boundingBox.getCenter(_offset).negate();
-      this.translate(_offset.x, _offset.y, _offset.z);
-      return this;
+    this.computeFaceNormals();
+    if (geometry.boundingBox !== null) {
+      this.boundingBox = geometry.boundingBox.clone();
     }
-    normalize() {
-      this.computeBoundingSphere();
-      const center = this.boundingSphere.center;
-      const radius = this.boundingSphere.radius;
-      const s = radius === 0 ? 1 : 1 / radius;
-      const matrix = new THREE.Matrix4();
-      matrix.set(s, 0, 0, -s * center.x, 0, s, 0, -s * center.y, 0, 0, s, -s * center.z, 0, 0, 0, 1);
-      this.applyMatrix4(matrix);
-      return this;
+    if (geometry.boundingSphere !== null) {
+      this.boundingSphere = geometry.boundingSphere.clone();
     }
-    computeFaceNormals() {
+    return this;
+  }
+  center() {
+    this.computeBoundingBox();
+    this.boundingBox.getCenter(_offset).negate();
+    this.translate(_offset.x, _offset.y, _offset.z);
+    return this;
+  }
+  normalize() {
+    this.computeBoundingSphere();
+    const center = this.boundingSphere.center;
+    const radius = this.boundingSphere.radius;
+    const s = radius === 0 ? 1 : 1 / radius;
+    const matrix = new THREE.Matrix4();
+    matrix.set(s, 0, 0, -s * center.x, 0, s, 0, -s * center.y, 0, 0, s, -s * center.z, 0, 0, 0, 1);
+    this.applyMatrix4(matrix);
+    return this;
+  }
+  computeFaceNormals() {
+    const cb = new THREE.Vector3(), ab = new THREE.Vector3();
+    for (let f = 0, fl = this.faces.length; f < fl; f++) {
+      const face = this.faces[f];
+      const vA = this.vertices[face.a];
+      const vB = this.vertices[face.b];
+      const vC = this.vertices[face.c];
+      cb.subVectors(vC, vB);
+      ab.subVectors(vA, vB);
+      cb.cross(ab);
+      cb.normalize();
+      face.normal.copy(cb);
+    }
+  }
+  computeVertexNormals(areaWeighted = true) {
+    const vertices = new Array(this.vertices.length);
+    for (let v = 0, vl = this.vertices.length; v < vl; v++) {
+      vertices[v] = new THREE.Vector3();
+    }
+    if (areaWeighted) {
       const cb = new THREE.Vector3(), ab = new THREE.Vector3();
       for (let f = 0, fl = this.faces.length; f < fl; f++) {
         const face = this.faces[f];
@@ -213,589 +231,564 @@ const Geometry = /* @__PURE__ */ (() => {
         cb.subVectors(vC, vB);
         ab.subVectors(vA, vB);
         cb.cross(ab);
-        cb.normalize();
-        face.normal.copy(cb);
-      }
-    }
-    computeVertexNormals(areaWeighted = true) {
-      const vertices = new Array(this.vertices.length);
-      for (let v = 0, vl = this.vertices.length; v < vl; v++) {
-        vertices[v] = new THREE.Vector3();
-      }
-      if (areaWeighted) {
-        const cb = new THREE.Vector3(), ab = new THREE.Vector3();
-        for (let f = 0, fl = this.faces.length; f < fl; f++) {
-          const face = this.faces[f];
-          const vA = this.vertices[face.a];
-          const vB = this.vertices[face.b];
-          const vC = this.vertices[face.c];
-          cb.subVectors(vC, vB);
-          ab.subVectors(vA, vB);
-          cb.cross(ab);
-          vertices[face.a].add(cb);
-          vertices[face.b].add(cb);
-          vertices[face.c].add(cb);
-        }
-      } else {
-        this.computeFaceNormals();
-        for (let f = 0, fl = this.faces.length; f < fl; f++) {
-          const face = this.faces[f];
-          vertices[face.a].add(face.normal);
-          vertices[face.b].add(face.normal);
-          vertices[face.c].add(face.normal);
-        }
-      }
-      for (let v = 0, vl = this.vertices.length; v < vl; v++) {
-        vertices[v].normalize();
+        vertices[face.a].add(cb);
+        vertices[face.b].add(cb);
+        vertices[face.c].add(cb);
       }
+    } else {
+      this.computeFaceNormals();
       for (let f = 0, fl = this.faces.length; f < fl; f++) {
         const face = this.faces[f];
-        const vertexNormals = face.vertexNormals;
-        if (vertexNormals.length === 3) {
-          vertexNormals[0].copy(vertices[face.a]);
-          vertexNormals[1].copy(vertices[face.b]);
-          vertexNormals[2].copy(vertices[face.c]);
-        } else {
-          vertexNormals[0] = vertices[face.a].clone();
-          vertexNormals[1] = vertices[face.b].clone();
-          vertexNormals[2] = vertices[face.c].clone();
-        }
-      }
-      if (this.faces.length > 0) {
-        this.normalsNeedUpdate = true;
+        vertices[face.a].add(face.normal);
+        vertices[face.b].add(face.normal);
+        vertices[face.c].add(face.normal);
       }
     }
-    computeFlatVertexNormals() {
-      this.computeFaceNormals();
-      for (let f = 0, fl = this.faces.length; f < fl; f++) {
-        const face = this.faces[f];
-        const vertexNormals = face.vertexNormals;
-        if (vertexNormals.length === 3) {
-          vertexNormals[0].copy(face.normal);
-          vertexNormals[1].copy(face.normal);
-          vertexNormals[2].copy(face.normal);
-        } else {
-          vertexNormals[0] = face.normal.clone();
-          vertexNormals[1] = face.normal.clone();
-          vertexNormals[2] = face.normal.clone();
-        }
+    for (let v = 0, vl = this.vertices.length; v < vl; v++) {
+      vertices[v].normalize();
+    }
+    for (let f = 0, fl = this.faces.length; f < fl; f++) {
+      const face = this.faces[f];
+      const vertexNormals = face.vertexNormals;
+      if (vertexNormals.length === 3) {
+        vertexNormals[0].copy(vertices[face.a]);
+        vertexNormals[1].copy(vertices[face.b]);
+        vertexNormals[2].copy(vertices[face.c]);
+      } else {
+        vertexNormals[0] = vertices[face.a].clone();
+        vertexNormals[1] = vertices[face.b].clone();
+        vertexNormals[2] = vertices[face.c].clone();
       }
-      if (this.faces.length > 0) {
-        this.normalsNeedUpdate = true;
+    }
+    if (this.faces.length > 0) {
+      this.normalsNeedUpdate = true;
+    }
+  }
+  computeFlatVertexNormals() {
+    this.computeFaceNormals();
+    for (let f = 0, fl = this.faces.length; f < fl; f++) {
+      const face = this.faces[f];
+      const vertexNormals = face.vertexNormals;
+      if (vertexNormals.length === 3) {
+        vertexNormals[0].copy(face.normal);
+        vertexNormals[1].copy(face.normal);
+        vertexNormals[2].copy(face.normal);
+      } else {
+        vertexNormals[0] = face.normal.clone();
+        vertexNormals[1] = face.normal.clone();
+        vertexNormals[2] = face.normal.clone();
       }
     }
-    computeMorphNormals() {
-      for (let f = 0, fl = this.faces.length; f < fl; f++) {
-        const face = this.faces[f];
-        if (!face.__originalFaceNormal) {
-          face.__originalFaceNormal = face.normal.clone();
+    if (this.faces.length > 0) {
+      this.normalsNeedUpdate = true;
+    }
+  }
+  computeMorphNormals() {
+    for (let f = 0, fl = this.faces.length; f < fl; f++) {
+      const face = this.faces[f];
+      if (!face.__originalFaceNormal) {
+        face.__originalFaceNormal = face.normal.clone();
+      } else {
+        face.__originalFaceNormal.copy(face.normal);
+      }
+      if (!face.__originalVertexNormals)
+        face.__originalVertexNormals = [];
+      for (let i = 0, il = face.vertexNormals.length; i < il; i++) {
+        if (!face.__originalVertexNormals[i]) {
+          face.__originalVertexNormals[i] = face.vertexNormals[i].clone();
         } else {
-          face.__originalFaceNormal.copy(face.normal);
-        }
-        if (!face.__originalVertexNormals)
-          face.__originalVertexNormals = [];
-        for (let i = 0, il = face.vertexNormals.length; i < il; i++) {
-          if (!face.__originalVertexNormals[i]) {
-            face.__originalVertexNormals[i] = face.vertexNormals[i].clone();
-          } else {
-            face.__originalVertexNormals[i].copy(face.vertexNormals[i]);
-          }
+          face.__originalVertexNormals[i].copy(face.vertexNormals[i]);
         }
       }
-      const tmpGeo = new Geometry2();
-      tmpGeo.faces = this.faces;
-      for (let i = 0, il = this.morphTargets.length; i < il; i++) {
-        if (!this.morphNormals[i]) {
-          this.morphNormals[i] = {};
-          this.morphNormals[i].faceNormals = [];
-          this.morphNormals[i].vertexNormals = [];
-          const dstNormalsFace = this.morphNormals[i].faceNormals;
-          const dstNormalsVertex = this.morphNormals[i].vertexNormals;
-          for (let f = 0, fl = this.faces.length; f < fl; f++) {
-            const faceNormal = new THREE.Vector3();
-            const vertexNormals = {
-              a: new THREE.Vector3(),
-              b: new THREE.Vector3(),
-              c: new THREE.Vector3()
-            };
-            dstNormalsFace.push(faceNormal);
-            dstNormalsVertex.push(vertexNormals);
-          }
-        }
-        const morphNormals = this.morphNormals[i];
-        tmpGeo.vertices = this.morphTargets[i].vertices;
-        tmpGeo.computeFaceNormals();
-        tmpGeo.computeVertexNormals();
+    }
+    const tmpGeo = new Geometry();
+    tmpGeo.faces = this.faces;
+    for (let i = 0, il = this.morphTargets.length; i < il; i++) {
+      if (!this.morphNormals[i]) {
+        this.morphNormals[i] = {};
+        this.morphNormals[i].faceNormals = [];
+        this.morphNormals[i].vertexNormals = [];
+        const dstNormalsFace = this.morphNormals[i].faceNormals;
+        const dstNormalsVertex = this.morphNormals[i].vertexNormals;
         for (let f = 0, fl = this.faces.length; f < fl; f++) {
-          const face = this.faces[f];
-          const faceNormal = morphNormals.faceNormals[f];
-          const vertexNormals = morphNormals.vertexNormals[f];
-          faceNormal.copy(face.normal);
-          vertexNormals.a.copy(face.vertexNormals[0]);
-          vertexNormals.b.copy(face.vertexNormals[1]);
-          vertexNormals.c.copy(face.vertexNormals[2]);
-        }
-      }
+          const faceNormal = new THREE.Vector3();
+          const vertexNormals = {
+            a: new THREE.Vector3(),
+            b: new THREE.Vector3(),
+            c: new THREE.Vector3()
+          };
+          dstNormalsFace.push(faceNormal);
+          dstNormalsVertex.push(vertexNormals);
+        }
+      }
+      const morphNormals = this.morphNormals[i];
+      tmpGeo.vertices = this.morphTargets[i].vertices;
+      tmpGeo.computeFaceNormals();
+      tmpGeo.computeVertexNormals();
       for (let f = 0, fl = this.faces.length; f < fl; f++) {
         const face = this.faces[f];
-        face.normal = face.__originalFaceNormal;
-        face.vertexNormals = face.__originalVertexNormals;
+        const faceNormal = morphNormals.faceNormals[f];
+        const vertexNormals = morphNormals.vertexNormals[f];
+        faceNormal.copy(face.normal);
+        vertexNormals.a.copy(face.vertexNormals[0]);
+        vertexNormals.b.copy(face.vertexNormals[1]);
+        vertexNormals.c.copy(face.vertexNormals[2]);
       }
     }
-    computeBoundingBox() {
-      if (this.boundingBox === null) {
-        this.boundingBox = new THREE.Box3();
-      }
-      this.boundingBox.setFromPoints(this.vertices);
+    for (let f = 0, fl = this.faces.length; f < fl; f++) {
+      const face = this.faces[f];
+      face.normal = face.__originalFaceNormal;
+      face.vertexNormals = face.__originalVertexNormals;
     }
-    computeBoundingSphere() {
-      if (this.boundingSphere === null) {
-        this.boundingSphere = new THREE.Sphere();
-      }
-      this.boundingSphere.setFromPoints(this.vertices);
+  }
+  computeBoundingBox() {
+    if (this.boundingBox === null) {
+      this.boundingBox = new THREE.Box3();
     }
-    merge(geometry, matrix, materialIndexOffset = 0) {
-      if (!(geometry && geometry.isGeometry)) {
-        console.error("THREE.Geometry.merge(): geometry not an instance of THREE.Geometry.", geometry);
-        return;
-      }
-      let normalMatrix;
-      const vertexOffset = this.vertices.length, vertices1 = this.vertices, vertices2 = geometry.vertices, faces1 = this.faces, faces2 = geometry.faces, colors1 = this.colors, colors2 = geometry.colors;
-      if (matrix !== void 0) {
-        normalMatrix = new THREE.Matrix3().getNormalMatrix(matrix);
-      }
-      for (let i = 0, il = vertices2.length; i < il; i++) {
-        const vertex = vertices2[i];
-        const vertexCopy = vertex.clone();
-        if (matrix !== void 0)
-          vertexCopy.applyMatrix4(matrix);
-        vertices1.push(vertexCopy);
-      }
-      for (let i = 0, il = colors2.length; i < il; i++) {
-        colors1.push(colors2[i].clone());
-      }
-      for (let i = 0, il = faces2.length; i < il; i++) {
-        const face = faces2[i];
-        let normal, color;
-        const faceVertexNormals = face.vertexNormals, faceVertexColors = face.vertexColors;
-        const faceCopy = new Face3(face.a + vertexOffset, face.b + vertexOffset, face.c + vertexOffset);
-        faceCopy.normal.copy(face.normal);
+    this.boundingBox.setFromPoints(this.vertices);
+  }
+  computeBoundingSphere() {
+    if (this.boundingSphere === null) {
+      this.boundingSphere = new THREE.Sphere();
+    }
+    this.boundingSphere.setFromPoints(this.vertices);
+  }
+  merge(geometry, matrix, materialIndexOffset = 0) {
+    if (!(geometry && geometry.isGeometry)) {
+      console.error("THREE.Geometry.merge(): geometry not an instance of THREE.Geometry.", geometry);
+      return;
+    }
+    let normalMatrix;
+    const vertexOffset = this.vertices.length, vertices1 = this.vertices, vertices2 = geometry.vertices, faces1 = this.faces, faces2 = geometry.faces, colors1 = this.colors, colors2 = geometry.colors;
+    if (matrix !== void 0) {
+      normalMatrix = new THREE.Matrix3().getNormalMatrix(matrix);
+    }
+    for (let i = 0, il = vertices2.length; i < il; i++) {
+      const vertex = vertices2[i];
+      const vertexCopy = vertex.clone();
+      if (matrix !== void 0)
+        vertexCopy.applyMatrix4(matrix);
+      vertices1.push(vertexCopy);
+    }
+    for (let i = 0, il = colors2.length; i < il; i++) {
+      colors1.push(colors2[i].clone());
+    }
+    for (let i = 0, il = faces2.length; i < il; i++) {
+      const face = faces2[i];
+      let normal, color;
+      const faceVertexNormals = face.vertexNormals, faceVertexColors = face.vertexColors;
+      const faceCopy = new Face3(face.a + vertexOffset, face.b + vertexOffset, face.c + vertexOffset);
+      faceCopy.normal.copy(face.normal);
+      if (normalMatrix !== void 0) {
+        faceCopy.normal.applyMatrix3(normalMatrix).normalize();
+      }
+      for (let j = 0, jl = faceVertexNormals.length; j < jl; j++) {
+        normal = faceVertexNormals[j].clone();
         if (normalMatrix !== void 0) {
-          faceCopy.normal.applyMatrix3(normalMatrix).normalize();
-        }
-        for (let j = 0, jl = faceVertexNormals.length; j < jl; j++) {
-          normal = faceVertexNormals[j].clone();
-          if (normalMatrix !== void 0) {
-            normal.applyMatrix3(normalMatrix).normalize();
-          }
-          faceCopy.vertexNormals.push(normal);
-        }
-        faceCopy.color.copy(face.color);
-        for (let j = 0, jl = faceVertexColors.length; j < jl; j++) {
-          color = faceVertexColors[j];
-          faceCopy.vertexColors.push(color.clone());
-        }
-        faceCopy.materialIndex = face.materialIndex + materialIndexOffset;
-        faces1.push(faceCopy);
-      }
-      for (let i = 0, il = geometry.faceVertexUvs.length; i < il; i++) {
-        const faceVertexUvs2 = geometry.faceVertexUvs[i];
-        if (this.faceVertexUvs[i] === void 0)
-          this.faceVertexUvs[i] = [];
-        for (let j = 0, jl = faceVertexUvs2.length; j < jl; j++) {
-          const uvs2 = faceVertexUvs2[j], uvsCopy = [];
-          for (let k = 0, kl = uvs2.length; k < kl; k++) {
-            uvsCopy.push(uvs2[k].clone());
-          }
-          this.faceVertexUvs[i].push(uvsCopy);
+          normal.applyMatrix3(normalMatrix).normalize();
         }
+        faceCopy.vertexNormals.push(normal);
+      }
+      faceCopy.color.copy(face.color);
+      for (let j = 0, jl = faceVertexColors.length; j < jl; j++) {
+        color = faceVertexColors[j];
+        faceCopy.vertexColors.push(color.clone());
       }
+      faceCopy.materialIndex = face.materialIndex + materialIndexOffset;
+      faces1.push(faceCopy);
     }
-    mergeMesh(mesh) {
-      if (!(mesh && mesh.isMesh)) {
-        console.error("THREE.Geometry.mergeMesh(): mesh not an instance of THREE.Mesh.", mesh);
-        return;
-      }
-      if (mesh.matrixAutoUpdate)
-        mesh.updateMatrix();
-      this.merge(mesh.geometry, mesh.matrix);
-    }
-    /*
-     * Checks for duplicate vertices with hashmap.
-     * Duplicated vertices are removed
-     * and faces' vertices are updated.
-     */
-    mergeVertices(precisionPoints = 4) {
-      const verticesMap = {};
-      const unique = [], changes = [];
-      const precision = Math.pow(10, precisionPoints);
-      for (let i = 0, il = this.vertices.length; i < il; i++) {
-        const v = this.vertices[i];
-        const key = `${Math.round(v.x * precision)}_${Math.round(v.y * precision)}_${Math.round(v.z * precision)}`;
-        if (verticesMap[key] === void 0) {
-          verticesMap[key] = i;
-          unique.push(this.vertices[i]);
-          changes[i] = unique.length - 1;
-        } else {
-          changes[i] = changes[verticesMap[key]];
+    for (let i = 0, il = geometry.faceVertexUvs.length; i < il; i++) {
+      const faceVertexUvs2 = geometry.faceVertexUvs[i];
+      if (this.faceVertexUvs[i] === void 0)
+        this.faceVertexUvs[i] = [];
+      for (let j = 0, jl = faceVertexUvs2.length; j < jl; j++) {
+        const uvs2 = faceVertexUvs2[j], uvsCopy = [];
+        for (let k = 0, kl = uvs2.length; k < kl; k++) {
+          uvsCopy.push(uvs2[k].clone());
         }
+        this.faceVertexUvs[i].push(uvsCopy);
       }
-      const faceIndicesToRemove = [];
-      for (let i = 0, il = this.faces.length; i < il; i++) {
-        const face = this.faces[i];
-        face.a = changes[face.a];
-        face.b = changes[face.b];
-        face.c = changes[face.c];
-        const indices = [face.a, face.b, face.c];
-        for (let n = 0; n < 3; n++) {
-          if (indices[n] === indices[(n + 1) % 3]) {
-            faceIndicesToRemove.push(i);
-            break;
-          }
-        }
+    }
+  }
+  mergeMesh(mesh) {
+    if (!(mesh && mesh.isMesh)) {
+      console.error("THREE.Geometry.mergeMesh(): mesh not an instance of THREE.Mesh.", mesh);
+      return;
+    }
+    if (mesh.matrixAutoUpdate)
+      mesh.updateMatrix();
+    this.merge(mesh.geometry, mesh.matrix);
+  }
+  /*
+   * Checks for duplicate vertices with hashmap.
+   * Duplicated vertices are removed
+   * and faces' vertices are updated.
+   */
+  mergeVertices(precisionPoints = 4) {
+    const verticesMap = {};
+    const unique = [], changes = [];
+    const precision = Math.pow(10, precisionPoints);
+    for (let i = 0, il = this.vertices.length; i < il; i++) {
+      const v = this.vertices[i];
+      const key = `${Math.round(v.x * precision)}_${Math.round(v.y * precision)}_${Math.round(v.z * precision)}`;
+      if (verticesMap[key] === void 0) {
+        verticesMap[key] = i;
+        unique.push(this.vertices[i]);
+        changes[i] = unique.length - 1;
+      } else {
+        changes[i] = changes[verticesMap[key]];
       }
-      for (let i = faceIndicesToRemove.length - 1; i >= 0; i--) {
-        const idx = faceIndicesToRemove[i];
-        this.faces.splice(idx, 1);
-        for (let j = 0, jl = this.faceVertexUvs.length; j < jl; j++) {
-          this.faceVertexUvs[j].splice(idx, 1);
+    }
+    const faceIndicesToRemove = [];
+    for (let i = 0, il = this.faces.length; i < il; i++) {
+      const face = this.faces[i];
+      face.a = changes[face.a];
+      face.b = changes[face.b];
+      face.c = changes[face.c];
+      const indices = [face.a, face.b, face.c];
+      for (let n = 0; n < 3; n++) {
+        if (indices[n] === indices[(n + 1) % 3]) {
+          faceIndicesToRemove.push(i);
+          break;
         }
       }
-      const diff = this.vertices.length - unique.length;
-      this.vertices = unique;
-      return diff;
     }
-    setFromPoints(points) {
-      this.vertices = [];
-      for (let i = 0, l = points.length; i < l; i++) {
-        const point = points[i];
-        this.vertices.push(new THREE.Vector3(point.x, point.y, point.z || 0));
+    for (let i = faceIndicesToRemove.length - 1; i >= 0; i--) {
+      const idx = faceIndicesToRemove[i];
+      this.faces.splice(idx, 1);
+      for (let j = 0, jl = this.faceVertexUvs.length; j < jl; j++) {
+        this.faceVertexUvs[j].splice(idx, 1);
       }
-      return this;
     }
-    sortFacesByMaterialIndex() {
-      const faces = this.faces;
-      const length = faces.length;
-      for (let i = 0; i < length; i++) {
-        faces[i]._id = i;
-      }
-      function materialIndexSort(a, b) {
-        return a.materialIndex - b.materialIndex;
-      }
-      faces.sort(materialIndexSort);
-      const uvs1 = this.faceVertexUvs[0];
-      const uvs2 = this.faceVertexUvs[1];
-      let newUvs1, newUvs2;
-      if (uvs1 && uvs1.length === length)
-        newUvs1 = [];
-      if (uvs2 && uvs2.length === length)
-        newUvs2 = [];
-      for (let i = 0; i < length; i++) {
-        const id = faces[i]._id;
-        if (newUvs1)
-          newUvs1.push(uvs1[id]);
-        if (newUvs2)
-          newUvs2.push(uvs2[id]);
-      }
+    const diff = this.vertices.length - unique.length;
+    this.vertices = unique;
+    return diff;
+  }
+  setFromPoints(points) {
+    this.vertices = [];
+    for (let i = 0, l = points.length; i < l; i++) {
+      const point = points[i];
+      this.vertices.push(new THREE.Vector3(point.x, point.y, point.z || 0));
+    }
+    return this;
+  }
+  sortFacesByMaterialIndex() {
+    const faces = this.faces;
+    const length = faces.length;
+    for (let i = 0; i < length; i++) {
+      faces[i]._id = i;
+    }
+    function materialIndexSort(a, b) {
+      return a.materialIndex - b.materialIndex;
+    }
+    faces.sort(materialIndexSort);
+    const uvs1 = this.faceVertexUvs[0];
+    const uvs2 = this.faceVertexUvs[1];
+    let newUvs1, newUvs2;
+    if (uvs1 && uvs1.length === length)
+      newUvs1 = [];
+    if (uvs2 && uvs2.length === length)
+      newUvs2 = [];
+    for (let i = 0; i < length; i++) {
+      const id = faces[i]._id;
       if (newUvs1)
-        this.faceVertexUvs[0] = newUvs1;
+        newUvs1.push(uvs1[id]);
       if (newUvs2)
-        this.faceVertexUvs[1] = newUvs2;
-    }
-    toJSON() {
-      const data = {
-        metadata: {
-          version: 4.5,
-          type: "Geometry",
-          generator: "Geometry.toJSON"
-        }
-      };
-      data.uuid = this.uuid;
-      data.type = this.type;
-      if (this.name !== "")
-        data.name = this.name;
-      if (this.parameters !== void 0) {
-        const parameters = this.parameters;
-        for (let key in parameters) {
-          if (parameters[key] !== void 0)
-            data[key] = parameters[key];
-        }
-        return data;
-      }
-      const vertices = [];
-      for (let i = 0; i < this.vertices.length; i++) {
-        const vertex = this.vertices[i];
-        vertices.push(vertex.x, vertex.y, vertex.z);
-      }
-      const faces = [];
-      const normals = [];
-      const normalsHash = {};
-      const colors = [];
-      const colorsHash = {};
-      const uvs = [];
-      const uvsHash = {};
-      for (let i = 0; i < this.faces.length; i++) {
-        const face = this.faces[i];
-        const hasMaterial = true;
-        const hasFaceUv = false;
-        const hasFaceVertexUv = this.faceVertexUvs[0][i] !== void 0;
-        const hasFaceNormal = face.normal.length() > 0;
-        const hasFaceVertexNormal = face.vertexNormals.length > 0;
-        const hasFaceColor = face.color.r !== 1 || face.color.g !== 1 || face.color.b !== 1;
-        const hasFaceVertexColor = face.vertexColors.length > 0;
-        let faceType = 0;
-        faceType = setBit(faceType, 0, 0);
-        faceType = setBit(faceType, 1, hasMaterial);
-        faceType = setBit(faceType, 2, hasFaceUv);
-        faceType = setBit(faceType, 3, hasFaceVertexUv);
-        faceType = setBit(faceType, 4, hasFaceNormal);
-        faceType = setBit(faceType, 5, hasFaceVertexNormal);
-        faceType = setBit(faceType, 6, hasFaceColor);
-        faceType = setBit(faceType, 7, hasFaceVertexColor);
-        faces.push(faceType);
-        faces.push(face.a, face.b, face.c);
-        faces.push(face.materialIndex);
-        if (hasFaceVertexUv) {
-          const faceVertexUvs = this.faceVertexUvs[0][i];
-          faces.push(getUvIndex(faceVertexUvs[0]), getUvIndex(faceVertexUvs[1]), getUvIndex(faceVertexUvs[2]));
-        }
-        if (hasFaceNormal) {
-          faces.push(getNormalIndex(face.normal));
-        }
-        if (hasFaceVertexNormal) {
-          const vertexNormals = face.vertexNormals;
-          faces.push(
-            getNormalIndex(vertexNormals[0]),
-            getNormalIndex(vertexNormals[1]),
-            getNormalIndex(vertexNormals[2])
-          );
-        }
-        if (hasFaceColor) {
-          faces.push(getColorIndex(face.color));
-        }
-        if (hasFaceVertexColor) {
-          const vertexColors = face.vertexColors;
-          faces.push(getColorIndex(vertexColors[0]), getColorIndex(vertexColors[1]), getColorIndex(vertexColors[2]));
-        }
-      }
-      function setBit(value, position, enabled) {
-        return enabled ? value | 1 << position : value & ~(1 << position);
-      }
-      function getNormalIndex(normal) {
-        const hash = normal.x.toString() + normal.y.toString() + normal.z.toString();
-        if (normalsHash[hash] !== void 0) {
-          return normalsHash[hash];
-        }
-        normalsHash[hash] = normals.length / 3;
-        normals.push(normal.x, normal.y, normal.z);
-        return normalsHash[hash];
-      }
-      function getColorIndex(color) {
-        const hash = color.r.toString() + color.g.toString() + color.b.toString();
-        if (colorsHash[hash] !== void 0) {
-          return colorsHash[hash];
-        }
-        colorsHash[hash] = colors.length;
-        colors.push(color.getHex());
-        return colorsHash[hash];
-      }
-      function getUvIndex(uv) {
-        const hash = uv.x.toString() + uv.y.toString();
-        if (uvsHash[hash] !== void 0) {
-          return uvsHash[hash];
-        }
-        uvsHash[hash] = uvs.length / 2;
-        uvs.push(uv.x, uv.y);
-        return uvsHash[hash];
-      }
-      data.data = {};
-      data.data.vertices = vertices;
-      data.data.normals = normals;
-      if (colors.length > 0)
-        data.data.colors = colors;
-      if (uvs.length > 0)
-        data.data.uvs = [uvs];
-      data.data.faces = faces;
-      return data;
+        newUvs2.push(uvs2[id]);
     }
-    clone() {
-      return new Geometry2().copy(this);
-    }
-    copy(source) {
-      this.vertices = [];
-      this.colors = [];
-      this.faces = [];
-      this.faceVertexUvs = [[]];
-      this.morphTargets = [];
-      this.morphNormals = [];
-      this.skinWeights = [];
-      this.skinIndices = [];
-      this.lineDistances = [];
-      this.boundingBox = null;
-      this.boundingSphere = null;
-      this.name = source.name;
-      const vertices = source.vertices;
-      for (let i = 0, il = vertices.length; i < il; i++) {
-        this.vertices.push(vertices[i].clone());
-      }
-      const colors = source.colors;
-      for (let i = 0, il = colors.length; i < il; i++) {
-        this.colors.push(colors[i].clone());
-      }
-      const faces = source.faces;
-      for (let i = 0, il = faces.length; i < il; i++) {
-        this.faces.push(faces[i].clone());
-      }
-      for (let i = 0, il = source.faceVertexUvs.length; i < il; i++) {
-        const faceVertexUvs = source.faceVertexUvs[i];
-        if (this.faceVertexUvs[i] === void 0) {
-          this.faceVertexUvs[i] = [];
-        }
-        for (let j = 0, jl = faceVertexUvs.length; j < jl; j++) {
-          const uvs = faceVertexUvs[j], uvsCopy = [];
-          for (let k = 0, kl = uvs.length; k < kl; k++) {
-            const uv = uvs[k];
-            uvsCopy.push(uv.clone());
-          }
-          this.faceVertexUvs[i].push(uvsCopy);
-        }
+    if (newUvs1)
+      this.faceVertexUvs[0] = newUvs1;
+    if (newUvs2)
+      this.faceVertexUvs[1] = newUvs2;
+  }
+  toJSON() {
+    const data = {
+      metadata: {
+        version: 4.5,
+        type: "Geometry",
+        generator: "Geometry.toJSON"
+      }
+    };
+    data.uuid = this.uuid;
+    data.type = this.type;
+    if (this.name !== "")
+      data.name = this.name;
+    if (this.parameters !== void 0) {
+      const parameters = this.parameters;
+      for (let key in parameters) {
+        if (parameters[key] !== void 0)
+          data[key] = parameters[key];
       }
-      const morphTargets = source.morphTargets;
-      for (let i = 0, il = morphTargets.length; i < il; i++) {
-        const morphTarget = {};
-        morphTarget.name = morphTargets[i].name;
-        if (morphTargets[i].vertices !== void 0) {
-          morphTarget.vertices = [];
-          for (let j = 0, jl = morphTargets[i].vertices.length; j < jl; j++) {
-            morphTarget.vertices.push(morphTargets[i].vertices[j].clone());
-          }
-        }
-        if (morphTargets[i].normals !== void 0) {
-          morphTarget.normals = [];
-          for (let j = 0, jl = morphTargets[i].normals.length; j < jl; j++) {
-            morphTarget.normals.push(morphTargets[i].normals[j].clone());
-          }
-        }
-        this.morphTargets.push(morphTarget);
-      }
-      const morphNormals = source.morphNormals;
-      for (let i = 0, il = morphNormals.length; i < il; i++) {
-        const morphNormal = {};
-        if (morphNormals[i].vertexNormals !== void 0) {
-          morphNormal.vertexNormals = [];
-          for (let j = 0, jl = morphNormals[i].vertexNormals.length; j < jl; j++) {
-            const srcVertexNormal = morphNormals[i].vertexNormals[j];
-            const destVertexNormal = {};
-            destVertexNormal.a = srcVertexNormal.a.clone();
-            destVertexNormal.b = srcVertexNormal.b.clone();
-            destVertexNormal.c = srcVertexNormal.c.clone();
-            morphNormal.vertexNormals.push(destVertexNormal);
-          }
-        }
-        if (morphNormals[i].faceNormals !== void 0) {
-          morphNormal.faceNormals = [];
-          for (let j = 0, jl = morphNormals[i].faceNormals.length; j < jl; j++) {
-            morphNormal.faceNormals.push(morphNormals[i].faceNormals[j].clone());
-          }
-        }
-        this.morphNormals.push(morphNormal);
-      }
-      const skinWeights = source.skinWeights;
-      for (let i = 0, il = skinWeights.length; i < il; i++) {
-        this.skinWeights.push(skinWeights[i].clone());
-      }
-      const skinIndices = source.skinIndices;
-      for (let i = 0, il = skinIndices.length; i < il; i++) {
-        this.skinIndices.push(skinIndices[i].clone());
-      }
-      const lineDistances = source.lineDistances;
-      for (let i = 0, il = lineDistances.length; i < il; i++) {
-        this.lineDistances.push(lineDistances[i]);
-      }
-      const boundingBox = source.boundingBox;
-      if (boundingBox !== null) {
-        this.boundingBox = boundingBox.clone();
-      }
-      const boundingSphere = source.boundingSphere;
-      if (boundingSphere !== null) {
-        this.boundingSphere = boundingSphere.clone();
-      }
-      this.elementsNeedUpdate = source.elementsNeedUpdate;
-      this.verticesNeedUpdate = source.verticesNeedUpdate;
-      this.uvsNeedUpdate = source.uvsNeedUpdate;
-      this.normalsNeedUpdate = source.normalsNeedUpdate;
-      this.colorsNeedUpdate = source.colorsNeedUpdate;
-      this.lineDistancesNeedUpdate = source.lineDistancesNeedUpdate;
-      this.groupsNeedUpdate = source.groupsNeedUpdate;
-      return this;
+      return data;
     }
-    toBufferGeometry() {
-      const geometry = new DirectGeometry().fromGeometry(this);
-      const buffergeometry = new THREE.BufferGeometry();
-      const positions = new Float32Array(geometry.vertices.length * 3);
-      buffergeometry.setAttribute("position", new THREE.BufferAttribute(positions, 3).copyVector3sArray(geometry.vertices));
-      if (geometry.normals.length > 0) {
-        const normals = new Float32Array(geometry.normals.length * 3);
-        buffergeometry.setAttribute("normal", new THREE.BufferAttribute(normals, 3).copyVector3sArray(geometry.normals));
-      }
-      if (geometry.colors.length > 0) {
-        const colors = new Float32Array(geometry.colors.length * 3);
-        buffergeometry.setAttribute("color", new THREE.BufferAttribute(colors, 3).copyColorsArray(geometry.colors));
-      }
-      if (geometry.uvs.length > 0) {
-        const uvs = new Float32Array(geometry.uvs.length * 2);
-        buffergeometry.setAttribute("uv", new THREE.BufferAttribute(uvs, 2).copyVector2sArray(geometry.uvs));
-      }
-      if (geometry.uvs2.length > 0) {
-        const uvs2 = new Float32Array(geometry.uvs2.length * 2);
-        buffergeometry.setAttribute("uv2", new THREE.BufferAttribute(uvs2, 2).copyVector2sArray(geometry.uvs2));
-      }
-      buffergeometry.groups = geometry.groups;
-      for (let name in geometry.morphTargets) {
-        const array = [];
-        const morphTargets = geometry.morphTargets[name];
-        for (let i = 0, l = morphTargets.length; i < l; i++) {
-          const morphTarget = morphTargets[i];
-          const attribute = new THREE.Float32BufferAttribute(morphTarget.data.length * 3, 3);
-          attribute.name = morphTarget.name;
-          array.push(attribute.copyVector3sArray(morphTarget.data));
-        }
-        buffergeometry.morphAttributes[name] = array;
+    const vertices = [];
+    for (let i = 0; i < this.vertices.length; i++) {
+      const vertex = this.vertices[i];
+      vertices.push(vertex.x, vertex.y, vertex.z);
+    }
+    const faces = [];
+    const normals = [];
+    const normalsHash = {};
+    const colors = [];
+    const colorsHash = {};
+    const uvs = [];
+    const uvsHash = {};
+    for (let i = 0; i < this.faces.length; i++) {
+      const face = this.faces[i];
+      const hasMaterial = true;
+      const hasFaceUv = false;
+      const hasFaceVertexUv = this.faceVertexUvs[0][i] !== void 0;
+      const hasFaceNormal = face.normal.length() > 0;
+      const hasFaceVertexNormal = face.vertexNormals.length > 0;
+      const hasFaceColor = face.color.r !== 1 || face.color.g !== 1 || face.color.b !== 1;
+      const hasFaceVertexColor = face.vertexColors.length > 0;
+      let faceType = 0;
+      faceType = setBit(faceType, 0, 0);
+      faceType = setBit(faceType, 1, hasMaterial);
+      faceType = setBit(faceType, 2, hasFaceUv);
+      faceType = setBit(faceType, 3, hasFaceVertexUv);
+      faceType = setBit(faceType, 4, hasFaceNormal);
+      faceType = setBit(faceType, 5, hasFaceVertexNormal);
+      faceType = setBit(faceType, 6, hasFaceColor);
+      faceType = setBit(faceType, 7, hasFaceVertexColor);
+      faces.push(faceType);
+      faces.push(face.a, face.b, face.c);
+      faces.push(face.materialIndex);
+      if (hasFaceVertexUv) {
+        const faceVertexUvs = this.faceVertexUvs[0][i];
+        faces.push(getUvIndex(faceVertexUvs[0]), getUvIndex(faceVertexUvs[1]), getUvIndex(faceVertexUvs[2]));
+      }
+      if (hasFaceNormal) {
+        faces.push(getNormalIndex(face.normal));
+      }
+      if (hasFaceVertexNormal) {
+        const vertexNormals = face.vertexNormals;
+        faces.push(getNormalIndex(vertexNormals[0]), getNormalIndex(vertexNormals[1]), getNormalIndex(vertexNormals[2]));
       }
-      if (geometry.skinIndices.length > 0) {
-        const skinIndices = new THREE.Float32BufferAttribute(geometry.skinIndices.length * 4, 4);
-        buffergeometry.setAttribute("skinIndex", skinIndices.copyVector4sArray(geometry.skinIndices));
+      if (hasFaceColor) {
+        faces.push(getColorIndex(face.color));
       }
-      if (geometry.skinWeights.length > 0) {
-        const skinWeights = new THREE.Float32BufferAttribute(geometry.skinWeights.length * 4, 4);
-        buffergeometry.setAttribute("skinWeight", skinWeights.copyVector4sArray(geometry.skinWeights));
+      if (hasFaceVertexColor) {
+        const vertexColors = face.vertexColors;
+        faces.push(getColorIndex(vertexColors[0]), getColorIndex(vertexColors[1]), getColorIndex(vertexColors[2]));
       }
-      if (geometry.boundingSphere !== null) {
-        buffergeometry.boundingSphere = geometry.boundingSphere.clone();
-      }
-      if (geometry.boundingBox !== null) {
-        buffergeometry.boundingBox = geometry.boundingBox.clone();
+    }
+    function setBit(value, position, enabled) {
+      return enabled ? value | 1 << position : value & ~(1 << position);
+    }
+    function getNormalIndex(normal) {
+      const hash = normal.x.toString() + normal.y.toString() + normal.z.toString();
+      if (normalsHash[hash] !== void 0) {
+        return normalsHash[hash];
       }
-      return buffergeometry;
+      normalsHash[hash] = normals.length / 3;
+      normals.push(normal.x, normal.y, normal.z);
+      return normalsHash[hash];
     }
-    computeTangents() {
-      console.error("THREE.Geometry: .computeTangents() has been removed.");
+    function getColorIndex(color) {
+      const hash = color.r.toString() + color.g.toString() + color.b.toString();
+      if (colorsHash[hash] !== void 0) {
+        return colorsHash[hash];
+      }
+      colorsHash[hash] = colors.length;
+      colors.push(color.getHex());
+      return colorsHash[hash];
     }
-    computeLineDistances() {
-      console.error(
-        "THREE.Geometry: .computeLineDistances() has been removed. Use THREE.Line.computeLineDistances() instead."
-      );
+    function getUvIndex(uv) {
+      const hash = uv.x.toString() + uv.y.toString();
+      if (uvsHash[hash] !== void 0) {
+        return uvsHash[hash];
+      }
+      uvsHash[hash] = uvs.length / 2;
+      uvs.push(uv.x, uv.y);
+      return uvsHash[hash];
+    }
+    data.data = {};
+    data.data.vertices = vertices;
+    data.data.normals = normals;
+    if (colors.length > 0)
+      data.data.colors = colors;
+    if (uvs.length > 0)
+      data.data.uvs = [uvs];
+    data.data.faces = faces;
+    return data;
+  }
+  clone() {
+    return new Geometry().copy(this);
+  }
+  copy(source) {
+    this.vertices = [];
+    this.colors = [];
+    this.faces = [];
+    this.faceVertexUvs = [[]];
+    this.morphTargets = [];
+    this.morphNormals = [];
+    this.skinWeights = [];
+    this.skinIndices = [];
+    this.lineDistances = [];
+    this.boundingBox = null;
+    this.boundingSphere = null;
+    this.name = source.name;
+    const vertices = source.vertices;
+    for (let i = 0, il = vertices.length; i < il; i++) {
+      this.vertices.push(vertices[i].clone());
+    }
+    const colors = source.colors;
+    for (let i = 0, il = colors.length; i < il; i++) {
+      this.colors.push(colors[i].clone());
+    }
+    const faces = source.faces;
+    for (let i = 0, il = faces.length; i < il; i++) {
+      this.faces.push(faces[i].clone());
+    }
+    for (let i = 0, il = source.faceVertexUvs.length; i < il; i++) {
+      const faceVertexUvs = source.faceVertexUvs[i];
+      if (this.faceVertexUvs[i] === void 0) {
+        this.faceVertexUvs[i] = [];
+      }
+      for (let j = 0, jl = faceVertexUvs.length; j < jl; j++) {
+        const uvs = faceVertexUvs[j], uvsCopy = [];
+        for (let k = 0, kl = uvs.length; k < kl; k++) {
+          const uv = uvs[k];
+          uvsCopy.push(uv.clone());
+        }
+        this.faceVertexUvs[i].push(uvsCopy);
+      }
+    }
+    const morphTargets = source.morphTargets;
+    for (let i = 0, il = morphTargets.length; i < il; i++) {
+      const morphTarget = {};
+      morphTarget.name = morphTargets[i].name;
+      if (morphTargets[i].vertices !== void 0) {
+        morphTarget.vertices = [];
+        for (let j = 0, jl = morphTargets[i].vertices.length; j < jl; j++) {
+          morphTarget.vertices.push(morphTargets[i].vertices[j].clone());
+        }
+      }
+      if (morphTargets[i].normals !== void 0) {
+        morphTarget.normals = [];
+        for (let j = 0, jl = morphTargets[i].normals.length; j < jl; j++) {
+          morphTarget.normals.push(morphTargets[i].normals[j].clone());
+        }
+      }
+      this.morphTargets.push(morphTarget);
+    }
+    const morphNormals = source.morphNormals;
+    for (let i = 0, il = morphNormals.length; i < il; i++) {
+      const morphNormal = {};
+      if (morphNormals[i].vertexNormals !== void 0) {
+        morphNormal.vertexNormals = [];
+        for (let j = 0, jl = morphNormals[i].vertexNormals.length; j < jl; j++) {
+          const srcVertexNormal = morphNormals[i].vertexNormals[j];
+          const destVertexNormal = {};
+          destVertexNormal.a = srcVertexNormal.a.clone();
+          destVertexNormal.b = srcVertexNormal.b.clone();
+          destVertexNormal.c = srcVertexNormal.c.clone();
+          morphNormal.vertexNormals.push(destVertexNormal);
+        }
+      }
+      if (morphNormals[i].faceNormals !== void 0) {
+        morphNormal.faceNormals = [];
+        for (let j = 0, jl = morphNormals[i].faceNormals.length; j < jl; j++) {
+          morphNormal.faceNormals.push(morphNormals[i].faceNormals[j].clone());
+        }
+      }
+      this.morphNormals.push(morphNormal);
+    }
+    const skinWeights = source.skinWeights;
+    for (let i = 0, il = skinWeights.length; i < il; i++) {
+      this.skinWeights.push(skinWeights[i].clone());
+    }
+    const skinIndices = source.skinIndices;
+    for (let i = 0, il = skinIndices.length; i < il; i++) {
+      this.skinIndices.push(skinIndices[i].clone());
+    }
+    const lineDistances = source.lineDistances;
+    for (let i = 0, il = lineDistances.length; i < il; i++) {
+      this.lineDistances.push(lineDistances[i]);
+    }
+    const boundingBox = source.boundingBox;
+    if (boundingBox !== null) {
+      this.boundingBox = boundingBox.clone();
+    }
+    const boundingSphere = source.boundingSphere;
+    if (boundingSphere !== null) {
+      this.boundingSphere = boundingSphere.clone();
+    }
+    this.elementsNeedUpdate = source.elementsNeedUpdate;
+    this.verticesNeedUpdate = source.verticesNeedUpdate;
+    this.uvsNeedUpdate = source.uvsNeedUpdate;
+    this.normalsNeedUpdate = source.normalsNeedUpdate;
+    this.colorsNeedUpdate = source.colorsNeedUpdate;
+    this.lineDistancesNeedUpdate = source.lineDistancesNeedUpdate;
+    this.groupsNeedUpdate = source.groupsNeedUpdate;
+    return this;
+  }
+  toBufferGeometry() {
+    const geometry = new DirectGeometry().fromGeometry(this);
+    const buffergeometry = new THREE.BufferGeometry();
+    const positions = new Float32Array(geometry.vertices.length * 3);
+    buffergeometry.setAttribute("position", new THREE.BufferAttribute(positions, 3).copyVector3sArray(geometry.vertices));
+    if (geometry.normals.length > 0) {
+      const normals = new Float32Array(geometry.normals.length * 3);
+      buffergeometry.setAttribute("normal", new THREE.BufferAttribute(normals, 3).copyVector3sArray(geometry.normals));
+    }
+    if (geometry.colors.length > 0) {
+      const colors = new Float32Array(geometry.colors.length * 3);
+      buffergeometry.setAttribute("color", new THREE.BufferAttribute(colors, 3).copyColorsArray(geometry.colors));
+    }
+    if (geometry.uvs.length > 0) {
+      const uvs = new Float32Array(geometry.uvs.length * 2);
+      buffergeometry.setAttribute("uv", new THREE.BufferAttribute(uvs, 2).copyVector2sArray(geometry.uvs));
+    }
+    if (geometry.uvs2.length > 0) {
+      const uvs2 = new Float32Array(geometry.uvs2.length * 2);
+      buffergeometry.setAttribute("uv2", new THREE.BufferAttribute(uvs2, 2).copyVector2sArray(geometry.uvs2));
+    }
+    buffergeometry.groups = geometry.groups;
+    for (let name in geometry.morphTargets) {
+      const array = [];
+      const morphTargets = geometry.morphTargets[name];
+      for (let i = 0, l = morphTargets.length; i < l; i++) {
+        const morphTarget = morphTargets[i];
+        const attribute = new THREE.Float32BufferAttribute(morphTarget.data.length * 3, 3);
+        attribute.name = morphTarget.name;
+        array.push(attribute.copyVector3sArray(morphTarget.data));
+      }
+      buffergeometry.morphAttributes[name] = array;
+    }
+    if (geometry.skinIndices.length > 0) {
+      const skinIndices = new THREE.Float32BufferAttribute(geometry.skinIndices.length * 4, 4);
+      buffergeometry.setAttribute("skinIndex", skinIndices.copyVector4sArray(geometry.skinIndices));
+    }
+    if (geometry.skinWeights.length > 0) {
+      const skinWeights = new THREE.Float32BufferAttribute(geometry.skinWeights.length * 4, 4);
+      buffergeometry.setAttribute("skinWeight", skinWeights.copyVector4sArray(geometry.skinWeights));
     }
-    applyMatrix(matrix) {
-      console.warn("THREE.Geometry: .applyMatrix() has been renamed to .applyMatrix4().");
-      return this.applyMatrix4(matrix);
+    if (geometry.boundingSphere !== null) {
+      buffergeometry.boundingSphere = geometry.boundingSphere.clone();
     }
-    dispose() {
-      this.dispatchEvent({ type: "dispose" });
+    if (geometry.boundingBox !== null) {
+      buffergeometry.boundingBox = geometry.boundingBox.clone();
     }
+    return buffergeometry;
+  }
+  computeTangents() {
+    console.error("THREE.Geometry: .computeTangents() has been removed.");
+  }
+  computeLineDistances() {
+    console.error(
+      "THREE.Geometry: .computeLineDistances() has been removed. Use THREE.Line.computeLineDistances() instead."
+    );
   }
-  return Geometry2;
-})();
+  applyMatrix(matrix) {
+    console.warn("THREE.Geometry: .applyMatrix() has been renamed to .applyMatrix4().");
+    return this.applyMatrix4(matrix);
+  }
+  dispose() {
+    this.dispatchEvent({ type: "dispose" });
+  }
+}
 class DirectGeometry {
   constructor() {
     this.vertices = [];