minerender 2.1.0-alpha.49 → 2.1.0-alpha.50

package/dist/node/index.mjs

@@ -3487,7 +3487,7 @@ var init_SceneObject = __esm({
 });
 
 // src/model/ModelCulling.ts
-import { Vector3 as Vector36 } from "three";
+import { Vector3 as Vector39 } from "three";
 var ModelCulling;
 var init_ModelCulling = __esm({
   "src/model/ModelCulling.ts"() {
@@ -3496,7 +3496,7 @@ var init_ModelCulling = __esm({
       static toLocalMask(worldMask, rotation) {
         let localMask = 0;
         for (const [localFace, offset] of CUBE_FACE_OFFSETS.entries()) {
-          const normal = new Vector36(...offset).applyEuler(rotation);
+          const normal = new Vector39(...offset).applyEuler(rotation);
           const worldFace = CUBE_FACE_OFFSETS.findIndex(([x, y, z]) => Math.abs(normal.x - x) < 1e-6 && Math.abs(normal.y - y) < 1e-6 && Math.abs(normal.z - z) < 1e-6);
           if (worldFace < 0) return 0;
           if (worldMask & 1 << worldFace) localMask |= 1 << localFace;
@@ -3530,15 +3530,15 @@ var init_ModelCulling = __esm({
 
 // src/three/BufferGeometryUtils.js
 import {
-  BufferAttribute as BufferAttribute3,
-  BufferGeometry,
-  Float32BufferAttribute as Float32BufferAttribute3,
+  BufferAttribute as BufferAttribute4,
+  BufferGeometry as BufferGeometry2,
+  Float32BufferAttribute as Float32BufferAttribute4,
   InterleavedBuffer,
   InterleavedBufferAttribute,
   TriangleFanDrawMode,
   TriangleStripDrawMode,
   TrianglesDrawMode,
-  Vector3 as Vector37
+  Vector3 as Vector310
 } from "three";
 function computeTangents(geometry) {
   geometry.computeTangents();
@@ -3551,7 +3551,7 @@ function mergeBufferGeometries(geometries, useGroups = false) {
   const attributes = {};
   const morphAttributes = {};
   const morphTargetsRelative = geometries[0].morphTargetsRelative;
-  const mergedGeometry = new BufferGeometry();
+  const mergedGeometry = new BufferGeometry2();
   let offset = 0;
   for (let i = 0; i < geometries.length; ++i) {
     const geometry = geometries[i];
@@ -3675,7 +3675,7 @@ function mergeBufferAttributes(attributes) {
     array.set(attributes[i].array, offset);
     offset += attributes[i].array.length;
   }
-  return new BufferAttribute3(array, itemSize, normalized);
+  return new BufferAttribute4(array, itemSize, normalized);
 }
 function interleaveAttributes(attributes) {
   let TypedArray;
@@ -3784,13 +3784,13 @@ function mergeVertices(geometry, tolerance = 1e-4) {
     const name = attributeNames[i];
     const oldAttribute = geometry.getAttribute(name);
     const buffer = new oldAttribute.array.constructor(attrArrays[name]);
-    const attribute = new BufferAttribute3(buffer, oldAttribute.itemSize, oldAttribute.normalized);
+    const attribute = new BufferAttribute4(buffer, oldAttribute.itemSize, oldAttribute.normalized);
     result.setAttribute(name, attribute);
     if (name in morphAttrsArrays) {
       for (let j = 0; j < morphAttrsArrays[name].length; j++) {
         const oldMorphAttribute = geometry.morphAttributes[name][j];
         const buffer2 = new oldMorphAttribute.array.constructor(morphAttrsArrays[name][j]);
-        const morphAttribute = new BufferAttribute3(buffer2, oldMorphAttribute.itemSize, oldMorphAttribute.normalized);
+        const morphAttribute = new BufferAttribute4(buffer2, oldMorphAttribute.itemSize, oldMorphAttribute.normalized);
         result.morphAttributes[name][j] = morphAttribute;
       }
     }
@@ -3857,15 +3857,15 @@ function computeMorphedAttributes(object) {
     console.error("THREE.BufferGeometryUtils: Geometry is not of type BufferGeometry.");
     return null;
   }
-  const _vA = new Vector37();
-  const _vB = new Vector37();
-  const _vC = new Vector37();
-  const _tempA = new Vector37();
-  const _tempB = new Vector37();
-  const _tempC = new Vector37();
-  const _morphA = new Vector37();
-  const _morphB = new Vector37();
-  const _morphC = new Vector37();
+  const _vA = new Vector310();
+  const _vB = new Vector310();
+  const _vC = new Vector310();
+  const _tempA = new Vector310();
+  const _tempB = new Vector310();
+  const _tempC = new Vector310();
+  const _morphA = new Vector310();
+  const _morphB = new Vector310();
+  const _morphC = new Vector310();
   function _calculateMorphedAttributeData(object2, material2, attribute, morphAttribute, morphTargetsRelative2, a2, b2, c2, modifiedAttributeArray) {
     _vA.fromBufferAttribute(attribute, a2);
     _vB.fromBufferAttribute(attribute, b2);
@@ -4060,8 +4060,8 @@ function computeMorphedAttributes(object) {
       }
     }
   }
-  const morphedPositionAttribute = new Float32BufferAttribute3(modifiedPosition, 3);
-  const morphedNormalAttribute = new Float32BufferAttribute3(modifiedNormal, 3);
+  const morphedPositionAttribute = new Float32BufferAttribute4(modifiedPosition, 3);
+  const morphedNormalAttribute = new Float32BufferAttribute4(modifiedNormal, 3);
   return {
     positionAttribute,
     normalAttribute,
@@ -4075,7 +4075,7 @@ var init_BufferGeometryUtils = __esm({
 });
 
 // src/model/scene/ModelObject.ts
-import { BoxGeometry as BoxGeometry5, BufferAttribute as BufferAttribute4, Color as Color3, Euler as Euler6, Matrix4 as Matrix44 } from "three";
+import { BoxGeometry as BoxGeometry5, BufferAttribute as BufferAttribute5, Color as Color7, Euler as Euler6, Matrix4 as Matrix46 } from "three";
 function isModelObject(obj) {
   return obj.isModelObject;
 }
@@ -4151,19 +4151,19 @@ var init_ModelObject = __esm({
                   if (tintIndex === void 0 || tintIndex < 0) continue;
                   const tint = this.options.tints[tintIndex];
                   if (tint === void 0) continue;
-                  const color = new Color3(tint);
+                  const color = new Color7(tint);
                   for (let vertex = 0; vertex < 4; vertex++) {
                     color.toArray(colors, (faceIndex * 4 + vertex) * 3);
                   }
                 }
-                elGeo.setAttribute("color", new BufferAttribute4(colors, 3));
+                elGeo.setAttribute("color", new BufferAttribute5(colors, 3));
               }
-              elGeo.applyMatrix4(new Matrix44().makeTranslation((el.to[0] - el.from[0]) / 2, (el.to[1] - el.from[1]) / 2, (el.to[2] - el.from[2]) / 2));
-              elGeo.applyMatrix4(new Matrix44().makeTranslation(el.from[0], el.from[1], el.from[2]));
+              elGeo.applyMatrix4(new Matrix46().makeTranslation((el.to[0] - el.from[0]) / 2, (el.to[1] - el.from[1]) / 2, (el.to[2] - el.from[2]) / 2));
+              elGeo.applyMatrix4(new Matrix46().makeTranslation(el.from[0], el.from[1], el.from[2]));
               if (el.rotation) {
                 applyElementRotation(el.rotation, elGeo);
               }
-              elGeo.applyMatrix4(new Matrix44().makeTranslation(-8, -8, -8));
+              elGeo.applyMatrix4(new Matrix46().makeTranslation(-8, -8, -8));
               if (displayTransform) DisplayTransforms.apply(elGeo, displayTransform);
               if (this.options.mergeMeshes) {
                 allGeos.push(elGeo);
@@ -4276,7 +4276,7 @@ var init_fluidBlocks = __esm({
 });
 
 // src/model/fluid/FluidGeometry.ts
-import { BufferGeometry as BufferGeometry2, Float32BufferAttribute as Float32BufferAttribute4 } from "three";
+import { BufferGeometry as BufferGeometry3, Float32BufferAttribute as Float32BufferAttribute5 } from "three";
 function getBlockFluidState(key, state) {
   const rule = key && fluidRules[key.toNamespacedString()];
   if (rule) return {
@@ -4294,7 +4294,7 @@ function ownHeight(sample) {
   return (level === 0 || level >= 8 ? 8 : 8 - level) / 9;
 }
 function createFluidGeometry(kind, sample) {
-  const geometry = new BufferGeometry2();
+  const geometry = new BufferGeometry3();
   const positions = [], normals = [], uvs = [], indices = [];
   const self = sample(0, 0, 0);
   const height = (x, z) => {
@@ -4393,9 +4393,9 @@ function createFluidGeometry(kind, sample) {
       1
     );
   }
-  geometry.setAttribute("position", new Float32BufferAttribute4(positions, 3));
-  geometry.setAttribute("normal", new Float32BufferAttribute4(normals, 3));
-  geometry.setAttribute("uv", new Float32BufferAttribute4(uvs, 2));
+  geometry.setAttribute("position", new Float32BufferAttribute5(positions, 3));
+  geometry.setAttribute("normal", new Float32BufferAttribute5(normals, 3));
+  geometry.setAttribute("uv", new Float32BufferAttribute5(uvs, 2));
   geometry.setIndex(indices);
   return geometry;
 }
@@ -4415,7 +4415,7 @@ __export(FluidModelObject_exports, {
   FluidModelObject: () => FluidModelObject,
   sampleFluid: () => sampleFluid
 });
-import { BufferAttribute as BufferAttribute5, Color as Color4, DoubleSide as DoubleSide2 } from "three";
+import { BufferAttribute as BufferAttribute6, Color as Color8, DoubleSide as DoubleSide3 } from "three";
 function sampleFluid(kind, sample) {
   const cells = [];
   const key = [];
@@ -4466,10 +4466,10 @@ var init_FluidModelObject = __esm({
           }
         }
         geometry.clearGroups();
-        const color = new Color4(this.options.tints?.[0] ?? (this.kind === "water" ? 4159204 : 16777215));
+        const color = new Color8(this.options.tints?.[0] ?? (this.kind === "water" ? 4159204 : 16777215));
         const colors = new Float32Array(geometry.getAttribute("position").count * 3);
         for (let i = 0; i < colors.length; i += 3) color.toArray(colors, i);
-        geometry.setAttribute("color", new BufferAttribute5(colors, 3));
+        geometry.setAttribute("color", new BufferAttribute6(colors, 3));
         geometry.computeBoundingBox();
         geometry.computeBoundingSphere();
         if (this.options.instanceMeshes) {
@@ -4483,7 +4483,7 @@ var init_FluidModelObject = __esm({
         super.applyTextures();
         this.iterateAllMeshes((mesh) => {
           const material = mesh.material;
-          material.side = DoubleSide2;
+          material.side = DoubleSide3;
           material.forceSinglePass = true;
           material.depthWrite = !material.transparent;
         });
@@ -4835,6 +4835,37 @@ init_PersistentCache();
 init_CanvasCompat();
 init_CanvasImage();
 
+// src/canvas/trimCanvas.ts
+init_CanvasCompat();
+function trimCanvas(source) {
+  if (source.width === 0 || source.height === 0) return createCanvas2(1, 1);
+  const canvas = createCanvas2(source.width, source.height);
+  const context = canvas.getContext("2d");
+  if (!context) throw new Error("Image export requires a 2D canvas context");
+  context.drawImage(source, 0, 0);
+  const pixels = context.getImageData(0, 0, canvas.width, canvas.height).data;
+  let left = canvas.width, top = canvas.height, right = -1, bottom = -1;
+  for (let y = 0; y < canvas.height; y++) {
+    for (let x = 0; x < canvas.width; x++) {
+      if (pixels[(y * canvas.width + x) * 4 + 3] === 0) continue;
+      left = Math.min(left, x);
+      top = Math.min(top, y);
+      right = Math.max(right, x);
+      bottom = Math.max(bottom, y);
+    }
+  }
+  if (right < left) {
+    canvas.width = canvas.height = 1;
+    return canvas;
+  }
+  const width = right - left + 1, height = bottom - top + 1;
+  const cropped = context.getImageData(left, top, width, height);
+  canvas.width = width;
+  canvas.height = height;
+  context.putImageData(cropped, 0, 0);
+  return canvas;
+}
+
 // src/entity/scene/EntityObject.ts
 init_SceneObject();
 init_Caching();
@@ -4957,6 +4988,2555 @@ function isEntityObject(obj) {
 // src/error/index.ts
 init_MineRenderError();
 
+// src/export/SceneExporter.ts
+import { ClampToEdgeWrapping as ClampToEdgeWrapping2, Color as Color6, Float32BufferAttribute as Float32BufferAttribute3, Matrix4 as Matrix45, Mesh as Mesh5, MeshBasicMaterial as MeshBasicMaterial2, NearestFilter as NearestFilter3, RGBAFormat as RGBAFormat3, Scene as Scene4, Source as Source2, Texture as Texture4, UnsignedByteType } from "three";
+
+// ../../node_modules/three/examples/jsm/exporters/OBJExporter.js
+import {
+  Color as Color3,
+  Matrix3,
+  Vector2 as Vector22,
+  Vector3 as Vector36
+} from "three";
+var OBJExporter = class {
+  parse(object) {
+    let output = "";
+    let indexVertex = 0;
+    let indexVertexUvs = 0;
+    let indexNormals = 0;
+    const vertex = new Vector36();
+    const color = new Color3();
+    const normal = new Vector36();
+    const uv = new Vector22();
+    const face = [];
+    function parseMesh(mesh) {
+      let nbVertex = 0;
+      let nbNormals = 0;
+      let nbVertexUvs = 0;
+      const geometry = mesh.geometry;
+      const normalMatrixWorld = new Matrix3();
+      const vertices = geometry.getAttribute("position");
+      const normals = geometry.getAttribute("normal");
+      const uvs = geometry.getAttribute("uv");
+      const indices = geometry.getIndex();
+      output += "o " + mesh.name + "\n";
+      if (mesh.material && mesh.material.name) {
+        output += "usemtl " + mesh.material.name + "\n";
+      }
+      if (vertices !== void 0) {
+        for (let i = 0, l = vertices.count; i < l; i++, nbVertex++) {
+          vertex.fromBufferAttribute(vertices, i);
+          vertex.applyMatrix4(mesh.matrixWorld);
+          output += "v " + vertex.x + " " + vertex.y + " " + vertex.z + "\n";
+        }
+      }
+      if (uvs !== void 0) {
+        for (let i = 0, l = uvs.count; i < l; i++, nbVertexUvs++) {
+          uv.fromBufferAttribute(uvs, i);
+          output += "vt " + uv.x + " " + uv.y + "\n";
+        }
+      }
+      if (normals !== void 0) {
+        normalMatrixWorld.getNormalMatrix(mesh.matrixWorld);
+        for (let i = 0, l = normals.count; i < l; i++, nbNormals++) {
+          normal.fromBufferAttribute(normals, i);
+          normal.applyMatrix3(normalMatrixWorld).normalize();
+          output += "vn " + normal.x + " " + normal.y + " " + normal.z + "\n";
+        }
+      }
+      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;
+            face[m] = indexVertex + j + (normals || uvs ? "/" + (uvs ? indexVertexUvs + j : "") + (normals ? "/" + (indexNormals + j) : "") : "");
+          }
+          output += "f " + face.join(" ") + "\n";
+        }
+      } else {
+        for (let i = 0, l = vertices.count; i < l; i += 3) {
+          for (let m = 0; m < 3; m++) {
+            const j = i + m + 1;
+            face[m] = indexVertex + j + (normals || uvs ? "/" + (uvs ? indexVertexUvs + j : "") + (normals ? "/" + (indexNormals + j) : "") : "");
+          }
+          output += "f " + face.join(" ") + "\n";
+        }
+      }
+      indexVertex += nbVertex;
+      indexVertexUvs += nbVertexUvs;
+      indexNormals += nbNormals;
+    }
+    function parseLine(line) {
+      let nbVertex = 0;
+      const geometry = line.geometry;
+      const type = line.type;
+      const vertices = geometry.getAttribute("position");
+      output += "o " + line.name + "\n";
+      if (vertices !== void 0) {
+        for (let i = 0, l = vertices.count; i < l; i++, nbVertex++) {
+          vertex.fromBufferAttribute(vertices, i);
+          vertex.applyMatrix4(line.matrixWorld);
+          output += "v " + vertex.x + " " + vertex.y + " " + vertex.z + "\n";
+        }
+      }
+      if (type === "Line") {
+        output += "l ";
+        for (let j = 1, l = vertices.count; j <= l; j++) {
+          output += indexVertex + j + " ";
+        }
+        output += "\n";
+      }
+      if (type === "LineSegments") {
+        for (let j = 1, k = j + 1, l = vertices.count; j < l; j += 2, k = j + 1) {
+          output += "l " + (indexVertex + j) + " " + (indexVertex + k) + "\n";
+        }
+      }
+      indexVertex += nbVertex;
+    }
+    function parsePoints(points) {
+      let nbVertex = 0;
+      const geometry = points.geometry;
+      const vertices = geometry.getAttribute("position");
+      const colors = geometry.getAttribute("color");
+      output += "o " + points.name + "\n";
+      if (vertices !== void 0) {
+        for (let i = 0, l = vertices.count; i < l; i++, nbVertex++) {
+          vertex.fromBufferAttribute(vertices, i);
+          vertex.applyMatrix4(points.matrixWorld);
+          output += "v " + vertex.x + " " + vertex.y + " " + vertex.z;
+          if (colors !== void 0) {
+            color.fromBufferAttribute(colors, i).convertLinearToSRGB();
+            output += " " + color.r + " " + color.g + " " + color.b;
+          }
+          output += "\n";
+        }
+        output += "p ";
+        for (let j = 1, l = vertices.count; j <= l; j++) {
+          output += indexVertex + j + " ";
+        }
+        output += "\n";
+      }
+      indexVertex += nbVertex;
+    }
+    object.traverse(function(child) {
+      if (child.isMesh === true) {
+        parseMesh(child);
+      }
+      if (child.isLine === true) {
+        parseLine(child);
+      }
+      if (child.isPoints === true) {
+        parsePoints(child);
+      }
+    });
+    return output;
+  }
+};
+
+// ../../node_modules/three/examples/jsm/exporters/PLYExporter.js
+import {
+  Matrix3 as Matrix32,
+  Vector3 as Vector37,
+  Color as Color4
+} from "three";
+var PLYExporter = class {
+  parse(object, onDone, options = {}) {
+    function traverseMeshes(cb) {
+      object.traverse(function(child) {
+        if (child.isMesh === true || child.isPoints) {
+          const mesh = child;
+          const geometry = mesh.geometry;
+          if (geometry.hasAttribute("position") === true) {
+            cb(mesh, geometry);
+          }
+        }
+      });
+    }
+    const defaultOptions = {
+      binary: false,
+      excludeAttributes: [],
+      // normal, uv, color, index
+      littleEndian: false
+    };
+    options = Object.assign(defaultOptions, options);
+    const excludeAttributes = options.excludeAttributes;
+    let includeIndices = true;
+    let includeNormals = false;
+    let includeColors = false;
+    let includeUVs = false;
+    let vertexCount = 0;
+    let faceCount = 0;
+    object.traverse(function(child) {
+      if (child.isMesh === true) {
+        const mesh = child;
+        const geometry = mesh.geometry;
+        const vertices = geometry.getAttribute("position");
+        const normals = geometry.getAttribute("normal");
+        const uvs = geometry.getAttribute("uv");
+        const colors = geometry.getAttribute("color");
+        const indices = geometry.getIndex();
+        if (vertices === void 0) {
+          return;
+        }
+        vertexCount += vertices.count;
+        faceCount += indices ? indices.count / 3 : vertices.count / 3;
+        if (normals !== void 0) includeNormals = true;
+        if (uvs !== void 0) includeUVs = true;
+        if (colors !== void 0) includeColors = true;
+      } else if (child.isPoints) {
+        const mesh = child;
+        const geometry = mesh.geometry;
+        const vertices = geometry.getAttribute("position");
+        const normals = geometry.getAttribute("normal");
+        const colors = geometry.getAttribute("color");
+        vertexCount += vertices.count;
+        if (normals !== void 0) includeNormals = true;
+        if (colors !== void 0) includeColors = true;
+        includeIndices = false;
+      }
+    });
+    const tempColor = new Color4();
+    includeIndices = includeIndices && excludeAttributes.indexOf("index") === -1;
+    includeNormals = includeNormals && excludeAttributes.indexOf("normal") === -1;
+    includeColors = includeColors && excludeAttributes.indexOf("color") === -1;
+    includeUVs = includeUVs && excludeAttributes.indexOf("uv") === -1;
+    if (includeIndices && faceCount !== Math.floor(faceCount)) {
+      console.error(
+        "PLYExporter: Failed to generate a valid PLY file with triangle indices because the number of indices is not divisible by 3."
+      );
+      return null;
+    }
+    const indexByteCount = 4;
+    let header = `ply
+format ${options.binary ? options.littleEndian ? "binary_little_endian" : "binary_big_endian" : "ascii"} 1.0
+element vertex ${vertexCount}
+property float x
+property float y
+property float z
+`;
+    if (includeNormals === true) {
+      header += "property float nx\nproperty float ny\nproperty float nz\n";
+    }
+    if (includeUVs === true) {
+      header += "property float s\nproperty float t\n";
+    }
+    if (includeColors === true) {
+      header += "property uchar red\nproperty uchar green\nproperty uchar blue\n";
+    }
+    if (includeIndices === true) {
+      header += `element face ${faceCount}
+property list uchar int vertex_index
+`;
+    }
+    header += "end_header\n";
+    const vertex = new Vector37();
+    const normalMatrixWorld = new Matrix32();
+    let result = null;
+    if (options.binary === true) {
+      const headerBin = new TextEncoder().encode(header);
+      const vertexListLength = vertexCount * (4 * 3 + (includeNormals ? 4 * 3 : 0) + (includeColors ? 3 : 0) + (includeUVs ? 4 * 2 : 0));
+      const faceListLength = includeIndices ? faceCount * (indexByteCount * 3 + 1) : 0;
+      const output = new DataView(new ArrayBuffer(headerBin.length + vertexListLength + faceListLength));
+      new Uint8Array(output.buffer).set(headerBin, 0);
+      let vOffset = headerBin.length;
+      let fOffset = headerBin.length + vertexListLength;
+      let writtenVertices = 0;
+      traverseMeshes(function(mesh, geometry) {
+        const vertices = geometry.getAttribute("position");
+        const normals = geometry.getAttribute("normal");
+        const uvs = geometry.getAttribute("uv");
+        const colors = geometry.getAttribute("color");
+        const indices = geometry.getIndex();
+        normalMatrixWorld.getNormalMatrix(mesh.matrixWorld);
+        for (let i = 0, l = vertices.count; i < l; i++) {
+          vertex.fromBufferAttribute(vertices, i);
+          vertex.applyMatrix4(mesh.matrixWorld);
+          output.setFloat32(vOffset, vertex.x, options.littleEndian);
+          vOffset += 4;
+          output.setFloat32(vOffset, vertex.y, options.littleEndian);
+          vOffset += 4;
+          output.setFloat32(vOffset, vertex.z, options.littleEndian);
+          vOffset += 4;
+          if (includeNormals === true) {
+            if (normals != null) {
+              vertex.fromBufferAttribute(normals, i);
+              vertex.applyMatrix3(normalMatrixWorld).normalize();
+              output.setFloat32(vOffset, vertex.x, options.littleEndian);
+              vOffset += 4;
+              output.setFloat32(vOffset, vertex.y, options.littleEndian);
+              vOffset += 4;
+              output.setFloat32(vOffset, vertex.z, options.littleEndian);
+              vOffset += 4;
+            } else {
+              output.setFloat32(vOffset, 0, options.littleEndian);
+              vOffset += 4;
+              output.setFloat32(vOffset, 0, options.littleEndian);
+              vOffset += 4;
+              output.setFloat32(vOffset, 0, options.littleEndian);
+              vOffset += 4;
+            }
+          }
+          if (includeUVs === true) {
+            if (uvs != null) {
+              output.setFloat32(vOffset, uvs.getX(i), options.littleEndian);
+              vOffset += 4;
+              output.setFloat32(vOffset, uvs.getY(i), options.littleEndian);
+              vOffset += 4;
+            } else {
+              output.setFloat32(vOffset, 0, options.littleEndian);
+              vOffset += 4;
+              output.setFloat32(vOffset, 0, options.littleEndian);
+              vOffset += 4;
+            }
+          }
+          if (includeColors === true) {
+            if (colors != null) {
+              tempColor.fromBufferAttribute(colors, i).convertLinearToSRGB();
+              output.setUint8(vOffset, Math.floor(tempColor.r * 255));
+              vOffset += 1;
+              output.setUint8(vOffset, Math.floor(tempColor.g * 255));
+              vOffset += 1;
+              output.setUint8(vOffset, Math.floor(tempColor.b * 255));
+              vOffset += 1;
+            } else {
+              output.setUint8(vOffset, 255);
+              vOffset += 1;
+              output.setUint8(vOffset, 255);
+              vOffset += 1;
+              output.setUint8(vOffset, 255);
+              vOffset += 1;
+            }
+          }
+        }
+        if (includeIndices === true) {
+          if (indices !== null) {
+            for (let i = 0, l = indices.count; i < l; i += 3) {
+              output.setUint8(fOffset, 3);
+              fOffset += 1;
+              output.setUint32(fOffset, indices.getX(i + 0) + writtenVertices, options.littleEndian);
+              fOffset += indexByteCount;
+              output.setUint32(fOffset, indices.getX(i + 1) + writtenVertices, options.littleEndian);
+              fOffset += indexByteCount;
+              output.setUint32(fOffset, indices.getX(i + 2) + writtenVertices, options.littleEndian);
+              fOffset += indexByteCount;
+            }
+          } else {
+            for (let i = 0, l = vertices.count; i < l; i += 3) {
+              output.setUint8(fOffset, 3);
+              fOffset += 1;
+              output.setUint32(fOffset, writtenVertices + i, options.littleEndian);
+              fOffset += indexByteCount;
+              output.setUint32(fOffset, writtenVertices + i + 1, options.littleEndian);
+              fOffset += indexByteCount;
+              output.setUint32(fOffset, writtenVertices + i + 2, options.littleEndian);
+              fOffset += indexByteCount;
+            }
+          }
+        }
+        writtenVertices += vertices.count;
+      });
+      result = output.buffer;
+    } else {
+      let writtenVertices = 0;
+      let vertexList = "";
+      let faceList = "";
+      traverseMeshes(function(mesh, geometry) {
+        const vertices = geometry.getAttribute("position");
+        const normals = geometry.getAttribute("normal");
+        const uvs = geometry.getAttribute("uv");
+        const colors = geometry.getAttribute("color");
+        const indices = geometry.getIndex();
+        normalMatrixWorld.getNormalMatrix(mesh.matrixWorld);
+        for (let i = 0, l = vertices.count; i < l; i++) {
+          vertex.fromBufferAttribute(vertices, i);
+          vertex.applyMatrix4(mesh.matrixWorld);
+          let line = vertex.x + " " + vertex.y + " " + vertex.z;
+          if (includeNormals === true) {
+            if (normals != null) {
+              vertex.fromBufferAttribute(normals, i);
+              vertex.applyMatrix3(normalMatrixWorld).normalize();
+              line += " " + vertex.x + " " + vertex.y + " " + vertex.z;
+            } else {
+              line += " 0 0 0";
+            }
+          }
+          if (includeUVs === true) {
+            if (uvs != null) {
+              line += " " + uvs.getX(i) + " " + uvs.getY(i);
+            } else {
+              line += " 0 0";
+            }
+          }
+          if (includeColors === true) {
+            if (colors != null) {
+              tempColor.fromBufferAttribute(colors, i).convertLinearToSRGB();
+              line += " " + Math.floor(tempColor.r * 255) + " " + Math.floor(tempColor.g * 255) + " " + Math.floor(tempColor.b * 255);
+            } else {
+              line += " 255 255 255";
+            }
+          }
+          vertexList += line + "\n";
+        }
+        if (includeIndices === true) {
+          if (indices !== null) {
+            for (let i = 0, l = indices.count; i < l; i += 3) {
+              faceList += `3 ${indices.getX(i + 0) + writtenVertices}`;
+              faceList += ` ${indices.getX(i + 1) + writtenVertices}`;
+              faceList += ` ${indices.getX(i + 2) + writtenVertices}
+`;
+            }
+          } else {
+            for (let i = 0, l = vertices.count; i < l; i += 3) {
+              faceList += `3 ${writtenVertices + i} ${writtenVertices + i + 1} ${writtenVertices + i + 2}
+`;
+            }
+          }
+          faceCount += indices ? indices.count / 3 : vertices.count / 3;
+        }
+        writtenVertices += vertices.count;
+      });
+      result = `${header}${vertexList}${includeIndices ? `${faceList}
+` : "\n"}`;
+    }
+    if (typeof onDone === "function") requestAnimationFrame(() => onDone(result));
+    return result;
+  }
+};
+
+// ../../node_modules/three/examples/jsm/exporters/GLTFExporter.js
+import {
+  BufferAttribute as BufferAttribute3,
+  ClampToEdgeWrapping,
+  Color as Color5,
+  DoubleSide as DoubleSide2,
+  InterpolateDiscrete,
+  InterpolateLinear,
+  NoColorSpace,
+  LinearFilter,
+  LinearMipmapLinearFilter,
+  LinearMipmapNearestFilter,
+  MathUtils as MathUtils2,
+  Matrix4 as Matrix44,
+  MirroredRepeatWrapping,
+  NearestFilter as NearestFilter2,
+  NearestMipmapLinearFilter,
+  NearestMipmapNearestFilter,
+  PropertyBinding,
+  RGBAFormat as RGBAFormat2,
+  RepeatWrapping,
+  Scene as Scene3,
+  Source,
+  SRGBColorSpace as SRGBColorSpace4,
+  CompressedTexture,
+  Vector3 as Vector38,
+  Quaternion as Quaternion4
+} from "three";
+
+// ../../node_modules/three/examples/jsm/utils/TextureUtils.js
+import {
+  PlaneGeometry,
+  ShaderMaterial as ShaderMaterial2,
+  Uniform,
+  Mesh as Mesh4,
+  PerspectiveCamera,
+  Scene as Scene2,
+  WebGLRenderer,
+  Texture as Texture3,
+  SRGBColorSpace as SRGBColorSpace3
+} from "three";
+var _renderer;
+var fullscreenQuadGeometry;
+var fullscreenQuadMaterial;
+var fullscreenQuad;
+function decompress(texture, maxTextureSize = Infinity, renderer = null) {
+  if (!fullscreenQuadGeometry) fullscreenQuadGeometry = new PlaneGeometry(2, 2, 1, 1);
+  if (!fullscreenQuadMaterial) fullscreenQuadMaterial = new ShaderMaterial2({
+    uniforms: { blitTexture: new Uniform(texture) },
+    vertexShader: `
+            varying vec2 vUv;
+            void main(){
+                vUv = uv;
+                gl_Position = vec4(position.xy * 1.0,0.,.999999);
+            }`,
+    fragmentShader: `
+            uniform sampler2D blitTexture; 
+            varying vec2 vUv;
+
+            void main(){ 
+                gl_FragColor = vec4(vUv.xy, 0, 1);
+                
+                #ifdef IS_SRGB
+                gl_FragColor = LinearTosRGB( texture2D( blitTexture, vUv) );
+                #else
+                gl_FragColor = texture2D( blitTexture, vUv);
+                #endif
+            }`
+  });
+  fullscreenQuadMaterial.uniforms.blitTexture.value = texture;
+  fullscreenQuadMaterial.defines.IS_SRGB = texture.colorSpace == SRGBColorSpace3;
+  fullscreenQuadMaterial.needsUpdate = true;
+  if (!fullscreenQuad) {
+    fullscreenQuad = new Mesh4(fullscreenQuadGeometry, fullscreenQuadMaterial);
+    fullscreenQuad.frustrumCulled = false;
+  }
+  const _camera = new PerspectiveCamera();
+  const _scene = new Scene2();
+  _scene.add(fullscreenQuad);
+  if (!renderer) {
+    renderer = _renderer = new WebGLRenderer({ antialias: false });
+  }
+  renderer.setSize(Math.min(texture.image.width, maxTextureSize), Math.min(texture.image.height, maxTextureSize));
+  renderer.clear();
+  renderer.render(_scene, _camera);
+  const readableTexture = new Texture3(renderer.domElement);
+  readableTexture.minFilter = texture.minFilter;
+  readableTexture.magFilter = texture.magFilter;
+  readableTexture.wrapS = texture.wrapS;
+  readableTexture.wrapT = texture.wrapT;
+  readableTexture.name = texture.name;
+  if (_renderer) {
+    _renderer.dispose();
+    _renderer = null;
+  }
+  return readableTexture;
+}
+
+// ../../node_modules/three/examples/jsm/exporters/GLTFExporter.js
+var KHR_mesh_quantization_ExtraAttrTypes = {
+  POSITION: [
+    "byte",
+    "byte normalized",
+    "unsigned byte",
+    "unsigned byte normalized",
+    "short",
+    "short normalized",
+    "unsigned short",
+    "unsigned short normalized"
+  ],
+  NORMAL: [
+    "byte normalized",
+    "short normalized"
+  ],
+  TANGENT: [
+    "byte normalized",
+    "short normalized"
+  ],
+  TEXCOORD: [
+    "byte",
+    "byte normalized",
+    "unsigned byte",
+    "short",
+    "short normalized",
+    "unsigned short"
+  ]
+};
+var GLTFExporter = class {
+  constructor() {
+    this.pluginCallbacks = [];
+    this.register(function(writer) {
+      return new GLTFLightExtension(writer);
+    });
+    this.register(function(writer) {
+      return new GLTFMaterialsUnlitExtension(writer);
+    });
+    this.register(function(writer) {
+      return new GLTFMaterialsTransmissionExtension(writer);
+    });
+    this.register(function(writer) {
+      return new GLTFMaterialsVolumeExtension(writer);
+    });
+    this.register(function(writer) {
+      return new GLTFMaterialsIorExtension(writer);
+    });
+    this.register(function(writer) {
+      return new GLTFMaterialsSpecularExtension(writer);
+    });
+    this.register(function(writer) {
+      return new GLTFMaterialsClearcoatExtension(writer);
+    });
+    this.register(function(writer) {
+      return new GLTFMaterialsIridescenceExtension(writer);
+    });
+    this.register(function(writer) {
+      return new GLTFMaterialsSheenExtension(writer);
+    });
+    this.register(function(writer) {
+      return new GLTFMaterialsAnisotropyExtension(writer);
+    });
+    this.register(function(writer) {
+      return new GLTFMaterialsEmissiveStrengthExtension(writer);
+    });
+    this.register(function(writer) {
+      return new GLTFMeshGpuInstancing(writer);
+    });
+  }
+  register(callback) {
+    if (this.pluginCallbacks.indexOf(callback) === -1) {
+      this.pluginCallbacks.push(callback);
+    }
+    return this;
+  }
+  unregister(callback) {
+    if (this.pluginCallbacks.indexOf(callback) !== -1) {
+      this.pluginCallbacks.splice(this.pluginCallbacks.indexOf(callback), 1);
+    }
+    return this;
+  }
+  /**
+   * Parse scenes and generate GLTF output
+   * @param  {Scene or [THREE.Scenes]} input   Scene or Array of THREE.Scenes
+   * @param  {Function} onDone  Callback on completed
+   * @param  {Function} onError  Callback on errors
+   * @param  {Object} options options
+   */
+  parse(input, onDone, onError, options) {
+    const writer = new GLTFWriter();
+    const plugins = [];
+    for (let i = 0, il = this.pluginCallbacks.length; i < il; i++) {
+      plugins.push(this.pluginCallbacks[i](writer));
+    }
+    writer.setPlugins(plugins);
+    writer.write(input, onDone, options).catch(onError);
+  }
+  parseAsync(input, options) {
+    const scope = this;
+    return new Promise(function(resolve, reject) {
+      scope.parse(input, resolve, reject, options);
+    });
+  }
+};
+var WEBGL_CONSTANTS = {
+  POINTS: 0,
+  LINES: 1,
+  LINE_LOOP: 2,
+  LINE_STRIP: 3,
+  TRIANGLES: 4,
+  TRIANGLE_STRIP: 5,
+  TRIANGLE_FAN: 6,
+  BYTE: 5120,
+  UNSIGNED_BYTE: 5121,
+  SHORT: 5122,
+  UNSIGNED_SHORT: 5123,
+  INT: 5124,
+  UNSIGNED_INT: 5125,
+  FLOAT: 5126,
+  ARRAY_BUFFER: 34962,
+  ELEMENT_ARRAY_BUFFER: 34963,
+  NEAREST: 9728,
+  LINEAR: 9729,
+  NEAREST_MIPMAP_NEAREST: 9984,
+  LINEAR_MIPMAP_NEAREST: 9985,
+  NEAREST_MIPMAP_LINEAR: 9986,
+  LINEAR_MIPMAP_LINEAR: 9987,
+  CLAMP_TO_EDGE: 33071,
+  MIRRORED_REPEAT: 33648,
+  REPEAT: 10497
+};
+var KHR_MESH_QUANTIZATION = "KHR_mesh_quantization";
+var THREE_TO_WEBGL = {};
+THREE_TO_WEBGL[NearestFilter2] = WEBGL_CONSTANTS.NEAREST;
+THREE_TO_WEBGL[NearestMipmapNearestFilter] = WEBGL_CONSTANTS.NEAREST_MIPMAP_NEAREST;
+THREE_TO_WEBGL[NearestMipmapLinearFilter] = WEBGL_CONSTANTS.NEAREST_MIPMAP_LINEAR;
+THREE_TO_WEBGL[LinearFilter] = WEBGL_CONSTANTS.LINEAR;
+THREE_TO_WEBGL[LinearMipmapNearestFilter] = WEBGL_CONSTANTS.LINEAR_MIPMAP_NEAREST;
+THREE_TO_WEBGL[LinearMipmapLinearFilter] = WEBGL_CONSTANTS.LINEAR_MIPMAP_LINEAR;
+THREE_TO_WEBGL[ClampToEdgeWrapping] = WEBGL_CONSTANTS.CLAMP_TO_EDGE;
+THREE_TO_WEBGL[RepeatWrapping] = WEBGL_CONSTANTS.REPEAT;
+THREE_TO_WEBGL[MirroredRepeatWrapping] = WEBGL_CONSTANTS.MIRRORED_REPEAT;
+var PATH_PROPERTIES = {
+  scale: "scale",
+  position: "translation",
+  quaternion: "rotation",
+  morphTargetInfluences: "weights"
+};
+var DEFAULT_SPECULAR_COLOR = new Color5();
+var GLB_HEADER_BYTES = 12;
+var GLB_HEADER_MAGIC = 1179937895;
+var GLB_VERSION = 2;
+var GLB_CHUNK_PREFIX_BYTES = 8;
+var GLB_CHUNK_TYPE_JSON = 1313821514;
+var GLB_CHUNK_TYPE_BIN = 5130562;
+function equalArray(array1, array2) {
+  return array1.length === array2.length && array1.every(function(element, index) {
+    return element === array2[index];
+  });
+}
+function stringToArrayBuffer(text) {
+  return new TextEncoder().encode(text).buffer;
+}
+function isIdentityMatrix(matrix) {
+  return equalArray(matrix.elements, [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
+}
+function getMinMax(attribute, start, count) {
+  const output = {
+    min: new Array(attribute.itemSize).fill(Number.POSITIVE_INFINITY),
+    max: new Array(attribute.itemSize).fill(Number.NEGATIVE_INFINITY)
+  };
+  for (let i = start; i < start + count; i++) {
+    for (let a = 0; a < attribute.itemSize; a++) {
+      let value;
+      if (attribute.itemSize > 4) {
+        value = attribute.array[i * attribute.itemSize + a];
+      } else {
+        if (a === 0) value = attribute.getX(i);
+        else if (a === 1) value = attribute.getY(i);
+        else if (a === 2) value = attribute.getZ(i);
+        else if (a === 3) value = attribute.getW(i);
+        if (attribute.normalized === true) {
+          value = MathUtils2.normalize(value, attribute.array);
+        }
+      }
+      output.min[a] = Math.min(output.min[a], value);
+      output.max[a] = Math.max(output.max[a], value);
+    }
+  }
+  return output;
+}
+function getPaddedBufferSize(bufferSize) {
+  return Math.ceil(bufferSize / 4) * 4;
+}
+function getPaddedArrayBuffer(arrayBuffer, paddingByte = 0) {
+  const paddedLength = getPaddedBufferSize(arrayBuffer.byteLength);
+  if (paddedLength !== arrayBuffer.byteLength) {
+    const array = new Uint8Array(paddedLength);
+    array.set(new Uint8Array(arrayBuffer));
+    if (paddingByte !== 0) {
+      for (let i = arrayBuffer.byteLength; i < paddedLength; i++) {
+        array[i] = paddingByte;
+      }
+    }
+    return array.buffer;
+  }
+  return arrayBuffer;
+}
+function getCanvas() {
+  if (typeof document === "undefined" && typeof OffscreenCanvas !== "undefined") {
+    return new OffscreenCanvas(1, 1);
+  }
+  return document.createElement("canvas");
+}
+function getToBlobPromise(canvas, mimeType) {
+  if (canvas.toBlob !== void 0) {
+    return new Promise((resolve) => canvas.toBlob(resolve, mimeType));
+  }
+  let quality;
+  if (mimeType === "image/jpeg") {
+    quality = 0.92;
+  } else if (mimeType === "image/webp") {
+    quality = 0.8;
+  }
+  return canvas.convertToBlob({
+    type: mimeType,
+    quality
+  });
+}
+var GLTFWriter = class {
+  constructor() {
+    this.plugins = [];
+    this.options = {};
+    this.pending = [];
+    this.buffers = [];
+    this.byteOffset = 0;
+    this.buffers = [];
+    this.nodeMap = /* @__PURE__ */ new Map();
+    this.skins = [];
+    this.extensionsUsed = {};
+    this.extensionsRequired = {};
+    this.uids = /* @__PURE__ */ new Map();
+    this.uid = 0;
+    this.json = {
+      asset: {
+        version: "2.0",
+        generator: "THREE.GLTFExporter"
+      }
+    };
+    this.cache = {
+      meshes: /* @__PURE__ */ new Map(),
+      attributes: /* @__PURE__ */ new Map(),
+      attributesNormalized: /* @__PURE__ */ new Map(),
+      materials: /* @__PURE__ */ new Map(),
+      textures: /* @__PURE__ */ new Map(),
+      images: /* @__PURE__ */ new Map()
+    };
+  }
+  setPlugins(plugins) {
+    this.plugins = plugins;
+  }
+  /**
+   * Parse scenes and generate GLTF output
+   * @param  {Scene or [THREE.Scenes]} input   Scene or Array of THREE.Scenes
+   * @param  {Function} onDone  Callback on completed
+   * @param  {Object} options options
+   */
+  async write(input, onDone, options = {}) {
+    this.options = Object.assign({
+      // default options
+      binary: false,
+      trs: false,
+      onlyVisible: true,
+      maxTextureSize: Infinity,
+      animations: [],
+      includeCustomExtensions: false
+    }, options);
+    if (this.options.animations.length > 0) {
+      this.options.trs = true;
+    }
+    this.processInput(input);
+    await Promise.all(this.pending);
+    const writer = this;
+    const buffers = writer.buffers;
+    const json = writer.json;
+    options = writer.options;
+    const extensionsUsed = writer.extensionsUsed;
+    const extensionsRequired = writer.extensionsRequired;
+    const blob = new Blob(buffers, { type: "application/octet-stream" });
+    const extensionsUsedList = Object.keys(extensionsUsed);
+    const extensionsRequiredList = Object.keys(extensionsRequired);
+    if (extensionsUsedList.length > 0) json.extensionsUsed = extensionsUsedList;
+    if (extensionsRequiredList.length > 0) json.extensionsRequired = extensionsRequiredList;
+    if (json.buffers && json.buffers.length > 0) json.buffers[0].byteLength = blob.size;
+    if (options.binary === true) {
+      const reader = new FileReader();
+      reader.readAsArrayBuffer(blob);
+      reader.onloadend = function() {
+        const binaryChunk = getPaddedArrayBuffer(reader.result);
+        const binaryChunkPrefix = new DataView(new ArrayBuffer(GLB_CHUNK_PREFIX_BYTES));
+        binaryChunkPrefix.setUint32(0, binaryChunk.byteLength, true);
+        binaryChunkPrefix.setUint32(4, GLB_CHUNK_TYPE_BIN, true);
+        const jsonChunk = getPaddedArrayBuffer(stringToArrayBuffer(JSON.stringify(json)), 32);
+        const jsonChunkPrefix = new DataView(new ArrayBuffer(GLB_CHUNK_PREFIX_BYTES));
+        jsonChunkPrefix.setUint32(0, jsonChunk.byteLength, true);
+        jsonChunkPrefix.setUint32(4, GLB_CHUNK_TYPE_JSON, true);
+        const header = new ArrayBuffer(GLB_HEADER_BYTES);
+        const headerView = new DataView(header);
+        headerView.setUint32(0, GLB_HEADER_MAGIC, true);
+        headerView.setUint32(4, GLB_VERSION, true);
+        const totalByteLength = GLB_HEADER_BYTES + jsonChunkPrefix.byteLength + jsonChunk.byteLength + binaryChunkPrefix.byteLength + binaryChunk.byteLength;
+        headerView.setUint32(8, totalByteLength, true);
+        const glbBlob = new Blob([
+          header,
+          jsonChunkPrefix,
+          jsonChunk,
+          binaryChunkPrefix,
+          binaryChunk
+        ], { type: "application/octet-stream" });
+        const glbReader = new FileReader();
+        glbReader.readAsArrayBuffer(glbBlob);
+        glbReader.onloadend = function() {
+          onDone(glbReader.result);
+        };
+      };
+    } else {
+      if (json.buffers && json.buffers.length > 0) {
+        const reader = new FileReader();
+        reader.readAsDataURL(blob);
+        reader.onloadend = function() {
+          const base64data = reader.result;
+          json.buffers[0].uri = base64data;
+          onDone(json);
+        };
+      } else {
+        onDone(json);
+      }
+    }
+  }
+  /**
+   * Serializes a userData.
+   *
+   * @param {THREE.Object3D|THREE.Material} object
+   * @param {Object} objectDef
+   */
+  serializeUserData(object, objectDef) {
+    if (Object.keys(object.userData).length === 0) return;
+    const options = this.options;
+    const extensionsUsed = this.extensionsUsed;
+    try {
+      const json = JSON.parse(JSON.stringify(object.userData));
+      if (options.includeCustomExtensions && json.gltfExtensions) {
+        if (objectDef.extensions === void 0) objectDef.extensions = {};
+        for (const extensionName in json.gltfExtensions) {
+          objectDef.extensions[extensionName] = json.gltfExtensions[extensionName];
+          extensionsUsed[extensionName] = true;
+        }
+        delete json.gltfExtensions;
+      }
+      if (Object.keys(json).length > 0) objectDef.extras = json;
+    } catch (error) {
+      console.warn("THREE.GLTFExporter: userData of '" + object.name + "' won't be serialized because of JSON.stringify error - " + error.message);
+    }
+  }
+  /**
+   * Returns ids for buffer attributes.
+   * @param  {Object} object
+   * @return {Integer}
+   */
+  getUID(attribute, isRelativeCopy = false) {
+    if (this.uids.has(attribute) === false) {
+      const uids2 = /* @__PURE__ */ new Map();
+      uids2.set(true, this.uid++);
+      uids2.set(false, this.uid++);
+      this.uids.set(attribute, uids2);
+    }
+    const uids = this.uids.get(attribute);
+    return uids.get(isRelativeCopy);
+  }
+  /**
+   * Checks if normal attribute values are normalized.
+   *
+   * @param {BufferAttribute} normal
+   * @returns {Boolean}
+   */
+  isNormalizedNormalAttribute(normal) {
+    const cache = this.cache;
+    if (cache.attributesNormalized.has(normal)) return false;
+    const v = new Vector38();
+    for (let i = 0, il = normal.count; i < il; i++) {
+      if (Math.abs(v.fromBufferAttribute(normal, i).length() - 1) > 5e-4) return false;
+    }
+    return true;
+  }
+  /**
+   * Creates normalized normal buffer attribute.
+   *
+   * @param {BufferAttribute} normal
+   * @returns {BufferAttribute}
+   *
+   */
+  createNormalizedNormalAttribute(normal) {
+    const cache = this.cache;
+    if (cache.attributesNormalized.has(normal)) return cache.attributesNormalized.get(normal);
+    const attribute = normal.clone();
+    const v = new Vector38();
+    for (let i = 0, il = attribute.count; i < il; i++) {
+      v.fromBufferAttribute(attribute, i);
+      if (v.x === 0 && v.y === 0 && v.z === 0) {
+        v.setX(1);
+      } else {
+        v.normalize();
+      }
+      attribute.setXYZ(i, v.x, v.y, v.z);
+    }
+    cache.attributesNormalized.set(normal, attribute);
+    return attribute;
+  }
+  /**
+   * Applies a texture transform, if present, to the map definition. Requires
+   * the KHR_texture_transform extension.
+   *
+   * @param {Object} mapDef
+   * @param {THREE.Texture} texture
+   */
+  applyTextureTransform(mapDef, texture) {
+    let didTransform = false;
+    const transformDef = {};
+    if (texture.offset.x !== 0 || texture.offset.y !== 0) {
+      transformDef.offset = texture.offset.toArray();
+      didTransform = true;
+    }
+    if (texture.rotation !== 0) {
+      transformDef.rotation = texture.rotation;
+      didTransform = true;
+    }
+    if (texture.repeat.x !== 1 || texture.repeat.y !== 1) {
+      transformDef.scale = texture.repeat.toArray();
+      didTransform = true;
+    }
+    if (didTransform) {
+      mapDef.extensions = mapDef.extensions || {};
+      mapDef.extensions["KHR_texture_transform"] = transformDef;
+      this.extensionsUsed["KHR_texture_transform"] = true;
+    }
+  }
+  buildMetalRoughTexture(metalnessMap, roughnessMap) {
+    if (metalnessMap === roughnessMap) return metalnessMap;
+    function getEncodingConversion(map) {
+      if (map.colorSpace === SRGBColorSpace4) {
+        return function SRGBToLinear(c) {
+          return c < 0.04045 ? c * 0.0773993808 : Math.pow(c * 0.9478672986 + 0.0521327014, 2.4);
+        };
+      }
+      return function LinearToLinear(c) {
+        return c;
+      };
+    }
+    console.warn("THREE.GLTFExporter: Merged metalnessMap and roughnessMap textures.");
+    if (metalnessMap instanceof CompressedTexture) {
+      metalnessMap = decompress(metalnessMap);
+    }
+    if (roughnessMap instanceof CompressedTexture) {
+      roughnessMap = decompress(roughnessMap);
+    }
+    const metalness = metalnessMap ? metalnessMap.image : null;
+    const roughness = roughnessMap ? roughnessMap.image : null;
+    const width = Math.max(metalness ? metalness.width : 0, roughness ? roughness.width : 0);
+    const height = Math.max(metalness ? metalness.height : 0, roughness ? roughness.height : 0);
+    const canvas = getCanvas();
+    canvas.width = width;
+    canvas.height = height;
+    const context = canvas.getContext("2d");
+    context.fillStyle = "#00ffff";
+    context.fillRect(0, 0, width, height);
+    const composite = context.getImageData(0, 0, width, height);
+    if (metalness) {
+      context.drawImage(metalness, 0, 0, width, height);
+      const convert = getEncodingConversion(metalnessMap);
+      const data = context.getImageData(0, 0, width, height).data;
+      for (let i = 2; i < data.length; i += 4) {
+        composite.data[i] = convert(data[i] / 256) * 256;
+      }
+    }
+    if (roughness) {
+      context.drawImage(roughness, 0, 0, width, height);
+      const convert = getEncodingConversion(roughnessMap);
+      const data = context.getImageData(0, 0, width, height).data;
+      for (let i = 1; i < data.length; i += 4) {
+        composite.data[i] = convert(data[i] / 256) * 256;
+      }
+    }
+    context.putImageData(composite, 0, 0);
+    const reference = metalnessMap || roughnessMap;
+    const texture = reference.clone();
+    texture.source = new Source(canvas);
+    texture.colorSpace = NoColorSpace;
+    texture.channel = (metalnessMap || roughnessMap).channel;
+    if (metalnessMap && roughnessMap && metalnessMap.channel !== roughnessMap.channel) {
+      console.warn("THREE.GLTFExporter: UV channels for metalnessMap and roughnessMap textures must match.");
+    }
+    return texture;
+  }
+  /**
+   * Process a buffer to append to the default one.
+   * @param  {ArrayBuffer} buffer
+   * @return {Integer}
+   */
+  processBuffer(buffer) {
+    const json = this.json;
+    const buffers = this.buffers;
+    if (!json.buffers) json.buffers = [{ byteLength: 0 }];
+    buffers.push(buffer);
+    return 0;
+  }
+  /**
+   * Process and generate a BufferView
+   * @param  {BufferAttribute} attribute
+   * @param  {number} componentType
+   * @param  {number} start
+   * @param  {number} count
+   * @param  {number} target (Optional) Target usage of the BufferView
+   * @return {Object}
+   */
+  processBufferView(attribute, componentType, start, count, target) {
+    const json = this.json;
+    if (!json.bufferViews) json.bufferViews = [];
+    let componentSize;
+    switch (componentType) {
+      case WEBGL_CONSTANTS.BYTE:
+      case WEBGL_CONSTANTS.UNSIGNED_BYTE:
+        componentSize = 1;
+        break;
+      case WEBGL_CONSTANTS.SHORT:
+      case WEBGL_CONSTANTS.UNSIGNED_SHORT:
+        componentSize = 2;
+        break;
+      default:
+        componentSize = 4;
+    }
+    const byteLength = getPaddedBufferSize(count * attribute.itemSize * componentSize);
+    const dataView = new DataView(new ArrayBuffer(byteLength));
+    let offset = 0;
+    for (let i = start; i < start + count; i++) {
+      for (let a = 0; a < attribute.itemSize; a++) {
+        let value;
+        if (attribute.itemSize > 4) {
+          value = attribute.array[i * attribute.itemSize + a];
+        } else {
+          if (a === 0) value = attribute.getX(i);
+          else if (a === 1) value = attribute.getY(i);
+          else if (a === 2) value = attribute.getZ(i);
+          else if (a === 3) value = attribute.getW(i);
+          if (attribute.normalized === true) {
+            value = MathUtils2.normalize(value, attribute.array);
+          }
+        }
+        if (componentType === WEBGL_CONSTANTS.FLOAT) {
+          dataView.setFloat32(offset, value, true);
+        } else if (componentType === WEBGL_CONSTANTS.INT) {
+          dataView.setInt32(offset, value, true);
+        } else if (componentType === WEBGL_CONSTANTS.UNSIGNED_INT) {
+          dataView.setUint32(offset, value, true);
+        } else if (componentType === WEBGL_CONSTANTS.SHORT) {
+          dataView.setInt16(offset, value, true);
+        } else if (componentType === WEBGL_CONSTANTS.UNSIGNED_SHORT) {
+          dataView.setUint16(offset, value, true);
+        } else if (componentType === WEBGL_CONSTANTS.BYTE) {
+          dataView.setInt8(offset, value);
+        } else if (componentType === WEBGL_CONSTANTS.UNSIGNED_BYTE) {
+          dataView.setUint8(offset, value);
+        }
+        offset += componentSize;
+      }
+    }
+    const bufferViewDef = {
+      buffer: this.processBuffer(dataView.buffer),
+      byteOffset: this.byteOffset,
+      byteLength
+    };
+    if (target !== void 0) bufferViewDef.target = target;
+    if (target === WEBGL_CONSTANTS.ARRAY_BUFFER) {
+      bufferViewDef.byteStride = attribute.itemSize * componentSize;
+    }
+    this.byteOffset += byteLength;
+    json.bufferViews.push(bufferViewDef);
+    const output = {
+      id: json.bufferViews.length - 1,
+      byteLength: 0
+    };
+    return output;
+  }
+  /**
+   * Process and generate a BufferView from an image Blob.
+   * @param {Blob} blob
+   * @return {Promise<Integer>}
+   */
+  processBufferViewImage(blob) {
+    const writer = this;
+    const json = writer.json;
+    if (!json.bufferViews) json.bufferViews = [];
+    return new Promise(function(resolve) {
+      const reader = new FileReader();
+      reader.readAsArrayBuffer(blob);
+      reader.onloadend = function() {
+        const buffer = getPaddedArrayBuffer(reader.result);
+        const bufferViewDef = {
+          buffer: writer.processBuffer(buffer),
+          byteOffset: writer.byteOffset,
+          byteLength: buffer.byteLength
+        };
+        writer.byteOffset += buffer.byteLength;
+        resolve(json.bufferViews.push(bufferViewDef) - 1);
+      };
+    });
+  }
+  /**
+   * Process attribute to generate an accessor
+   * @param  {BufferAttribute} attribute Attribute to process
+   * @param  {THREE.BufferGeometry} geometry (Optional) Geometry used for truncated draw range
+   * @param  {Integer} start (Optional)
+   * @param  {Integer} count (Optional)
+   * @return {Integer|null} Index of the processed accessor on the "accessors" array
+   */
+  processAccessor(attribute, geometry, start, count) {
+    const json = this.json;
+    const types = {
+      1: "SCALAR",
+      2: "VEC2",
+      3: "VEC3",
+      4: "VEC4",
+      9: "MAT3",
+      16: "MAT4"
+    };
+    let componentType;
+    if (attribute.array.constructor === Float32Array) {
+      componentType = WEBGL_CONSTANTS.FLOAT;
+    } else if (attribute.array.constructor === Int32Array) {
+      componentType = WEBGL_CONSTANTS.INT;
+    } else if (attribute.array.constructor === Uint32Array) {
+      componentType = WEBGL_CONSTANTS.UNSIGNED_INT;
+    } else if (attribute.array.constructor === Int16Array) {
+      componentType = WEBGL_CONSTANTS.SHORT;
+    } else if (attribute.array.constructor === Uint16Array) {
+      componentType = WEBGL_CONSTANTS.UNSIGNED_SHORT;
+    } else if (attribute.array.constructor === Int8Array) {
+      componentType = WEBGL_CONSTANTS.BYTE;
+    } else if (attribute.array.constructor === Uint8Array) {
+      componentType = WEBGL_CONSTANTS.UNSIGNED_BYTE;
+    } else {
+      throw new Error("THREE.GLTFExporter: Unsupported bufferAttribute component type: " + attribute.array.constructor.name);
+    }
+    if (start === void 0) start = 0;
+    if (count === void 0 || count === Infinity) count = attribute.count;
+    if (count === 0) return null;
+    const minMax = getMinMax(attribute, start, count);
+    let bufferViewTarget;
+    if (geometry !== void 0) {
+      bufferViewTarget = attribute === geometry.index ? WEBGL_CONSTANTS.ELEMENT_ARRAY_BUFFER : WEBGL_CONSTANTS.ARRAY_BUFFER;
+    }
+    const bufferView = this.processBufferView(attribute, componentType, start, count, bufferViewTarget);
+    const accessorDef = {
+      bufferView: bufferView.id,
+      byteOffset: bufferView.byteOffset,
+      componentType,
+      count,
+      max: minMax.max,
+      min: minMax.min,
+      type: types[attribute.itemSize]
+    };
+    if (attribute.normalized === true) accessorDef.normalized = true;
+    if (!json.accessors) json.accessors = [];
+    return json.accessors.push(accessorDef) - 1;
+  }
+  /**
+   * Process image
+   * @param  {Image} image to process
+   * @param  {Integer} format of the image (RGBAFormat)
+   * @param  {Boolean} flipY before writing out the image
+   * @param  {String} mimeType export format
+   * @return {Integer}     Index of the processed texture in the "images" array
+   */
+  processImage(image, format, flipY, mimeType = "image/png") {
+    if (image !== null) {
+      const writer = this;
+      const cache = writer.cache;
+      const json = writer.json;
+      const options = writer.options;
+      const pending = writer.pending;
+      if (!cache.images.has(image)) cache.images.set(image, {});
+      const cachedImages = cache.images.get(image);
+      const key = mimeType + ":flipY/" + flipY.toString();
+      if (cachedImages[key] !== void 0) return cachedImages[key];
+      if (!json.images) json.images = [];
+      const imageDef = { mimeType };
+      const canvas = getCanvas();
+      canvas.width = Math.min(image.width, options.maxTextureSize);
+      canvas.height = Math.min(image.height, options.maxTextureSize);
+      const ctx = canvas.getContext("2d");
+      if (flipY === true) {
+        ctx.translate(0, canvas.height);
+        ctx.scale(1, -1);
+      }
+      if (image.data !== void 0) {
+        if (format !== RGBAFormat2) {
+          console.error("GLTFExporter: Only RGBAFormat is supported.", format);
+        }
+        if (image.width > options.maxTextureSize || image.height > options.maxTextureSize) {
+          console.warn("GLTFExporter: Image size is bigger than maxTextureSize", image);
+        }
+        const data = new Uint8ClampedArray(image.height * image.width * 4);
+        for (let i = 0; i < data.length; i += 4) {
+          data[i + 0] = image.data[i + 0];
+          data[i + 1] = image.data[i + 1];
+          data[i + 2] = image.data[i + 2];
+          data[i + 3] = image.data[i + 3];
+        }
+        ctx.putImageData(new ImageData(data, image.width, image.height), 0, 0);
+      } else {
+        ctx.drawImage(image, 0, 0, canvas.width, canvas.height);
+      }
+      if (options.binary === true) {
+        pending.push(
+          getToBlobPromise(canvas, mimeType).then((blob) => writer.processBufferViewImage(blob)).then((bufferViewIndex) => {
+            imageDef.bufferView = bufferViewIndex;
+          })
+        );
+      } else {
+        if (canvas.toDataURL !== void 0) {
+          imageDef.uri = canvas.toDataURL(mimeType);
+        } else {
+          pending.push(
+            getToBlobPromise(canvas, mimeType).then((blob) => new FileReader().readAsDataURL(blob)).then((dataURL) => {
+              imageDef.uri = dataURL;
+            })
+          );
+        }
+      }
+      const index = json.images.push(imageDef) - 1;
+      cachedImages[key] = index;
+      return index;
+    } else {
+      throw new Error("THREE.GLTFExporter: No valid image data found. Unable to process texture.");
+    }
+  }
+  /**
+   * Process sampler
+   * @param  {Texture} map Texture to process
+   * @return {Integer}     Index of the processed texture in the "samplers" array
+   */
+  processSampler(map) {
+    const json = this.json;
+    if (!json.samplers) json.samplers = [];
+    const samplerDef = {
+      magFilter: THREE_TO_WEBGL[map.magFilter],
+      minFilter: THREE_TO_WEBGL[map.minFilter],
+      wrapS: THREE_TO_WEBGL[map.wrapS],
+      wrapT: THREE_TO_WEBGL[map.wrapT]
+    };
+    return json.samplers.push(samplerDef) - 1;
+  }
+  /**
+   * Process texture
+   * @param  {Texture} map Map to process
+   * @return {Integer} Index of the processed texture in the "textures" array
+   */
+  processTexture(map) {
+    const writer = this;
+    const options = writer.options;
+    const cache = this.cache;
+    const json = this.json;
+    if (cache.textures.has(map)) return cache.textures.get(map);
+    if (!json.textures) json.textures = [];
+    if (map instanceof CompressedTexture) {
+      map = decompress(map, options.maxTextureSize);
+    }
+    let mimeType = map.userData.mimeType;
+    if (mimeType === "image/webp") mimeType = "image/png";
+    const textureDef = {
+      sampler: this.processSampler(map),
+      source: this.processImage(map.image, map.format, map.flipY, mimeType)
+    };
+    if (map.name) textureDef.name = map.name;
+    this._invokeAll(function(ext) {
+      ext.writeTexture && ext.writeTexture(map, textureDef);
+    });
+    const index = json.textures.push(textureDef) - 1;
+    cache.textures.set(map, index);
+    return index;
+  }
+  /**
+   * Process material
+   * @param  {THREE.Material} material Material to process
+   * @return {Integer|null} Index of the processed material in the "materials" array
+   */
+  processMaterial(material) {
+    const cache = this.cache;
+    const json = this.json;
+    if (cache.materials.has(material)) return cache.materials.get(material);
+    if (material.isShaderMaterial) {
+      console.warn("GLTFExporter: THREE.ShaderMaterial not supported.");
+      return null;
+    }
+    if (!json.materials) json.materials = [];
+    const materialDef = { pbrMetallicRoughness: {} };
+    if (material.isMeshStandardMaterial !== true && material.isMeshBasicMaterial !== true) {
+      console.warn("GLTFExporter: Use MeshStandardMaterial or MeshBasicMaterial for best results.");
+    }
+    const color = material.color.toArray().concat([material.opacity]);
+    if (!equalArray(color, [1, 1, 1, 1])) {
+      materialDef.pbrMetallicRoughness.baseColorFactor = color;
+    }
+    if (material.isMeshStandardMaterial) {
+      materialDef.pbrMetallicRoughness.metallicFactor = material.metalness;
+      materialDef.pbrMetallicRoughness.roughnessFactor = material.roughness;
+    } else {
+      materialDef.pbrMetallicRoughness.metallicFactor = 0.5;
+      materialDef.pbrMetallicRoughness.roughnessFactor = 0.5;
+    }
+    if (material.metalnessMap || material.roughnessMap) {
+      const metalRoughTexture = this.buildMetalRoughTexture(material.metalnessMap, material.roughnessMap);
+      const metalRoughMapDef = {
+        index: this.processTexture(metalRoughTexture),
+        channel: metalRoughTexture.channel
+      };
+      this.applyTextureTransform(metalRoughMapDef, metalRoughTexture);
+      materialDef.pbrMetallicRoughness.metallicRoughnessTexture = metalRoughMapDef;
+    }
+    if (material.map) {
+      const baseColorMapDef = {
+        index: this.processTexture(material.map),
+        texCoord: material.map.channel
+      };
+      this.applyTextureTransform(baseColorMapDef, material.map);
+      materialDef.pbrMetallicRoughness.baseColorTexture = baseColorMapDef;
+    }
+    if (material.emissive) {
+      const emissive = material.emissive;
+      const maxEmissiveComponent = Math.max(emissive.r, emissive.g, emissive.b);
+      if (maxEmissiveComponent > 0) {
+        materialDef.emissiveFactor = material.emissive.toArray();
+      }
+      if (material.emissiveMap) {
+        const emissiveMapDef = {
+          index: this.processTexture(material.emissiveMap),
+          texCoord: material.emissiveMap.channel
+        };
+        this.applyTextureTransform(emissiveMapDef, material.emissiveMap);
+        materialDef.emissiveTexture = emissiveMapDef;
+      }
+    }
+    if (material.normalMap) {
+      const normalMapDef = {
+        index: this.processTexture(material.normalMap),
+        texCoord: material.normalMap.channel
+      };
+      if (material.normalScale && material.normalScale.x !== 1) {
+        normalMapDef.scale = material.normalScale.x;
+      }
+      this.applyTextureTransform(normalMapDef, material.normalMap);
+      materialDef.normalTexture = normalMapDef;
+    }
+    if (material.aoMap) {
+      const occlusionMapDef = {
+        index: this.processTexture(material.aoMap),
+        texCoord: material.aoMap.channel
+      };
+      if (material.aoMapIntensity !== 1) {
+        occlusionMapDef.strength = material.aoMapIntensity;
+      }
+      this.applyTextureTransform(occlusionMapDef, material.aoMap);
+      materialDef.occlusionTexture = occlusionMapDef;
+    }
+    if (material.transparent) {
+      materialDef.alphaMode = "BLEND";
+    } else {
+      if (material.alphaTest > 0) {
+        materialDef.alphaMode = "MASK";
+        materialDef.alphaCutoff = material.alphaTest;
+      }
+    }
+    if (material.side === DoubleSide2) materialDef.doubleSided = true;
+    if (material.name !== "") materialDef.name = material.name;
+    this.serializeUserData(material, materialDef);
+    this._invokeAll(function(ext) {
+      ext.writeMaterial && ext.writeMaterial(material, materialDef);
+    });
+    const index = json.materials.push(materialDef) - 1;
+    cache.materials.set(material, index);
+    return index;
+  }
+  /**
+   * Process mesh
+   * @param  {THREE.Mesh} mesh Mesh to process
+   * @return {Integer|null} Index of the processed mesh in the "meshes" array
+   */
+  processMesh(mesh) {
+    const cache = this.cache;
+    const json = this.json;
+    const meshCacheKeyParts = [mesh.geometry.uuid];
+    if (Array.isArray(mesh.material)) {
+      for (let i = 0, l = mesh.material.length; i < l; i++) {
+        meshCacheKeyParts.push(mesh.material[i].uuid);
+      }
+    } else {
+      meshCacheKeyParts.push(mesh.material.uuid);
+    }
+    const meshCacheKey = meshCacheKeyParts.join(":");
+    if (cache.meshes.has(meshCacheKey)) return cache.meshes.get(meshCacheKey);
+    const geometry = mesh.geometry;
+    let mode;
+    if (mesh.isLineSegments) {
+      mode = WEBGL_CONSTANTS.LINES;
+    } else if (mesh.isLineLoop) {
+      mode = WEBGL_CONSTANTS.LINE_LOOP;
+    } else if (mesh.isLine) {
+      mode = WEBGL_CONSTANTS.LINE_STRIP;
+    } else if (mesh.isPoints) {
+      mode = WEBGL_CONSTANTS.POINTS;
+    } else {
+      mode = mesh.material.wireframe ? WEBGL_CONSTANTS.LINES : WEBGL_CONSTANTS.TRIANGLES;
+    }
+    const meshDef = {};
+    const attributes = {};
+    const primitives = [];
+    const targets = [];
+    const nameConversion = {
+      uv: "TEXCOORD_0",
+      uv1: "TEXCOORD_1",
+      uv2: "TEXCOORD_2",
+      uv3: "TEXCOORD_3",
+      color: "COLOR_0",
+      skinWeight: "WEIGHTS_0",
+      skinIndex: "JOINTS_0"
+    };
+    const originalNormal = geometry.getAttribute("normal");
+    if (originalNormal !== void 0 && !this.isNormalizedNormalAttribute(originalNormal)) {
+      console.warn("THREE.GLTFExporter: Creating normalized normal attribute from the non-normalized one.");
+      geometry.setAttribute("normal", this.createNormalizedNormalAttribute(originalNormal));
+    }
+    let modifiedAttribute = null;
+    for (let attributeName in geometry.attributes) {
+      if (attributeName.slice(0, 5) === "morph") continue;
+      const attribute = geometry.attributes[attributeName];
+      attributeName = nameConversion[attributeName] || attributeName.toUpperCase();
+      const validVertexAttributes = /^(POSITION|NORMAL|TANGENT|TEXCOORD_\d+|COLOR_\d+|JOINTS_\d+|WEIGHTS_\d+)$/;
+      if (!validVertexAttributes.test(attributeName)) attributeName = "_" + attributeName;
+      if (cache.attributes.has(this.getUID(attribute))) {
+        attributes[attributeName] = cache.attributes.get(this.getUID(attribute));
+        continue;
+      }
+      modifiedAttribute = null;
+      const array = attribute.array;
+      if (attributeName === "JOINTS_0" && !(array instanceof Uint16Array) && !(array instanceof Uint8Array)) {
+        console.warn('GLTFExporter: Attribute "skinIndex" converted to type UNSIGNED_SHORT.');
+        modifiedAttribute = new BufferAttribute3(new Uint16Array(array), attribute.itemSize, attribute.normalized);
+      }
+      const accessor = this.processAccessor(modifiedAttribute || attribute, geometry);
+      if (accessor !== null) {
+        if (!attributeName.startsWith("_")) {
+          this.detectMeshQuantization(attributeName, attribute);
+        }
+        attributes[attributeName] = accessor;
+        cache.attributes.set(this.getUID(attribute), accessor);
+      }
+    }
+    if (originalNormal !== void 0) geometry.setAttribute("normal", originalNormal);
+    if (Object.keys(attributes).length === 0) return null;
+    if (mesh.morphTargetInfluences !== void 0 && mesh.morphTargetInfluences.length > 0) {
+      const weights = [];
+      const targetNames = [];
+      const reverseDictionary = {};
+      if (mesh.morphTargetDictionary !== void 0) {
+        for (const key in mesh.morphTargetDictionary) {
+          reverseDictionary[mesh.morphTargetDictionary[key]] = key;
+        }
+      }
+      for (let i = 0; i < mesh.morphTargetInfluences.length; ++i) {
+        const target = {};
+        let warned = false;
+        for (const attributeName in geometry.morphAttributes) {
+          if (attributeName !== "position" && attributeName !== "normal") {
+            if (!warned) {
+              console.warn("GLTFExporter: Only POSITION and NORMAL morph are supported.");
+              warned = true;
+            }
+            continue;
+          }
+          const attribute = geometry.morphAttributes[attributeName][i];
+          const gltfAttributeName = attributeName.toUpperCase();
+          const baseAttribute = geometry.attributes[attributeName];
+          if (cache.attributes.has(this.getUID(attribute, true))) {
+            target[gltfAttributeName] = cache.attributes.get(this.getUID(attribute, true));
+            continue;
+          }
+          const relativeAttribute = attribute.clone();
+          if (!geometry.morphTargetsRelative) {
+            for (let j = 0, jl = attribute.count; j < jl; j++) {
+              for (let a = 0; a < attribute.itemSize; a++) {
+                if (a === 0) relativeAttribute.setX(j, attribute.getX(j) - baseAttribute.getX(j));
+                if (a === 1) relativeAttribute.setY(j, attribute.getY(j) - baseAttribute.getY(j));
+                if (a === 2) relativeAttribute.setZ(j, attribute.getZ(j) - baseAttribute.getZ(j));
+                if (a === 3) relativeAttribute.setW(j, attribute.getW(j) - baseAttribute.getW(j));
+              }
+            }
+          }
+          target[gltfAttributeName] = this.processAccessor(relativeAttribute, geometry);
+          cache.attributes.set(this.getUID(baseAttribute, true), target[gltfAttributeName]);
+        }
+        targets.push(target);
+        weights.push(mesh.morphTargetInfluences[i]);
+        if (mesh.morphTargetDictionary !== void 0) targetNames.push(reverseDictionary[i]);
+      }
+      meshDef.weights = weights;
+      if (targetNames.length > 0) {
+        meshDef.extras = {};
+        meshDef.extras.targetNames = targetNames;
+      }
+    }
+    const isMultiMaterial = Array.isArray(mesh.material);
+    if (isMultiMaterial && geometry.groups.length === 0) return null;
+    const materials = isMultiMaterial ? mesh.material : [mesh.material];
+    const groups = isMultiMaterial ? geometry.groups : [{ materialIndex: 0, start: void 0, count: void 0 }];
+    for (let i = 0, il = groups.length; i < il; i++) {
+      const primitive = {
+        mode,
+        attributes
+      };
+      this.serializeUserData(geometry, primitive);
+      if (targets.length > 0) primitive.targets = targets;
+      if (geometry.index !== null) {
+        let cacheKey = this.getUID(geometry.index);
+        if (groups[i].start !== void 0 || groups[i].count !== void 0) {
+          cacheKey += ":" + groups[i].start + ":" + groups[i].count;
+        }
+        if (cache.attributes.has(cacheKey)) {
+          primitive.indices = cache.attributes.get(cacheKey);
+        } else {
+          primitive.indices = this.processAccessor(geometry.index, geometry, groups[i].start, groups[i].count);
+          cache.attributes.set(cacheKey, primitive.indices);
+        }
+        if (primitive.indices === null) delete primitive.indices;
+      }
+      const material = this.processMaterial(materials[groups[i].materialIndex]);
+      if (material !== null) primitive.material = material;
+      primitives.push(primitive);
+    }
+    meshDef.primitives = primitives;
+    if (!json.meshes) json.meshes = [];
+    this._invokeAll(function(ext) {
+      ext.writeMesh && ext.writeMesh(mesh, meshDef);
+    });
+    const index = json.meshes.push(meshDef) - 1;
+    cache.meshes.set(meshCacheKey, index);
+    return index;
+  }
+  /**
+   * If a vertex attribute with a
+   * [non-standard data type](https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#meshes-overview)
+   * is used, it is checked whether it is a valid data type according to the
+   * [KHR_mesh_quantization](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_mesh_quantization/README.md)
+   * extension.
+   * In this case the extension is automatically added to the list of used extensions.
+   *
+   * @param {string} attributeName
+   * @param {THREE.BufferAttribute} attribute
+   */
+  detectMeshQuantization(attributeName, attribute) {
+    if (this.extensionsUsed[KHR_MESH_QUANTIZATION]) return;
+    let attrType = void 0;
+    switch (attribute.array.constructor) {
+      case Int8Array:
+        attrType = "byte";
+        break;
+      case Uint8Array:
+        attrType = "unsigned byte";
+        break;
+      case Int16Array:
+        attrType = "short";
+        break;
+      case Uint16Array:
+        attrType = "unsigned short";
+        break;
+      default:
+        return;
+    }
+    if (attribute.normalized) attrType += " normalized";
+    const attrNamePrefix = attributeName.split("_", 1)[0];
+    if (KHR_mesh_quantization_ExtraAttrTypes[attrNamePrefix] && KHR_mesh_quantization_ExtraAttrTypes[attrNamePrefix].includes(attrType)) {
+      this.extensionsUsed[KHR_MESH_QUANTIZATION] = true;
+      this.extensionsRequired[KHR_MESH_QUANTIZATION] = true;
+    }
+  }
+  /**
+   * Process camera
+   * @param  {THREE.Camera} camera Camera to process
+   * @return {Integer}      Index of the processed mesh in the "camera" array
+   */
+  processCamera(camera) {
+    const json = this.json;
+    if (!json.cameras) json.cameras = [];
+    const isOrtho = camera.isOrthographicCamera;
+    const cameraDef = {
+      type: isOrtho ? "orthographic" : "perspective"
+    };
+    if (isOrtho) {
+      cameraDef.orthographic = {
+        xmag: camera.right * 2,
+        ymag: camera.top * 2,
+        zfar: camera.far <= 0 ? 1e-3 : camera.far,
+        znear: camera.near < 0 ? 0 : camera.near
+      };
+    } else {
+      cameraDef.perspective = {
+        aspectRatio: camera.aspect,
+        yfov: MathUtils2.degToRad(camera.fov),
+        zfar: camera.far <= 0 ? 1e-3 : camera.far,
+        znear: camera.near < 0 ? 0 : camera.near
+      };
+    }
+    if (camera.name !== "") cameraDef.name = camera.type;
+    return json.cameras.push(cameraDef) - 1;
+  }
+  /**
+   * Creates glTF animation entry from AnimationClip object.
+   *
+   * Status:
+   * - Only properties listed in PATH_PROPERTIES may be animated.
+   *
+   * @param {THREE.AnimationClip} clip
+   * @param {THREE.Object3D} root
+   * @return {number|null}
+   */
+  processAnimation(clip, root) {
+    const json = this.json;
+    const nodeMap = this.nodeMap;
+    if (!json.animations) json.animations = [];
+    clip = GLTFExporter.Utils.mergeMorphTargetTracks(clip.clone(), root);
+    const tracks = clip.tracks;
+    const channels = [];
+    const samplers = [];
+    for (let i = 0; i < tracks.length; ++i) {
+      const track = tracks[i];
+      const trackBinding = PropertyBinding.parseTrackName(track.name);
+      let trackNode = PropertyBinding.findNode(root, trackBinding.nodeName);
+      const trackProperty = PATH_PROPERTIES[trackBinding.propertyName];
+      if (trackBinding.objectName === "bones") {
+        if (trackNode.isSkinnedMesh === true) {
+          trackNode = trackNode.skeleton.getBoneByName(trackBinding.objectIndex);
+        } else {
+          trackNode = void 0;
+        }
+      }
+      if (!trackNode || !trackProperty) {
+        console.warn('THREE.GLTFExporter: Could not export animation track "%s".', track.name);
+        return null;
+      }
+      const inputItemSize = 1;
+      let outputItemSize = track.values.length / track.times.length;
+      if (trackProperty === PATH_PROPERTIES.morphTargetInfluences) {
+        outputItemSize /= trackNode.morphTargetInfluences.length;
+      }
+      let interpolation;
+      if (track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline === true) {
+        interpolation = "CUBICSPLINE";
+        outputItemSize /= 3;
+      } else if (track.getInterpolation() === InterpolateDiscrete) {
+        interpolation = "STEP";
+      } else {
+        interpolation = "LINEAR";
+      }
+      samplers.push({
+        input: this.processAccessor(new BufferAttribute3(track.times, inputItemSize)),
+        output: this.processAccessor(new BufferAttribute3(track.values, outputItemSize)),
+        interpolation
+      });
+      channels.push({
+        sampler: samplers.length - 1,
+        target: {
+          node: nodeMap.get(trackNode),
+          path: trackProperty
+        }
+      });
+    }
+    json.animations.push({
+      name: clip.name || "clip_" + json.animations.length,
+      samplers,
+      channels
+    });
+    return json.animations.length - 1;
+  }
+  /**
+   * @param {THREE.Object3D} object
+   * @return {number|null}
+   */
+  processSkin(object) {
+    const json = this.json;
+    const nodeMap = this.nodeMap;
+    const node = json.nodes[nodeMap.get(object)];
+    const skeleton = object.skeleton;
+    if (skeleton === void 0) return null;
+    const rootJoint = object.skeleton.bones[0];
+    if (rootJoint === void 0) return null;
+    const joints = [];
+    const inverseBindMatrices = new Float32Array(skeleton.bones.length * 16);
+    const temporaryBoneInverse = new Matrix44();
+    for (let i = 0; i < skeleton.bones.length; ++i) {
+      joints.push(nodeMap.get(skeleton.bones[i]));
+      temporaryBoneInverse.copy(skeleton.boneInverses[i]);
+      temporaryBoneInverse.multiply(object.bindMatrix).toArray(inverseBindMatrices, i * 16);
+    }
+    if (json.skins === void 0) json.skins = [];
+    json.skins.push({
+      inverseBindMatrices: this.processAccessor(new BufferAttribute3(inverseBindMatrices, 16)),
+      joints,
+      skeleton: nodeMap.get(rootJoint)
+    });
+    const skinIndex = node.skin = json.skins.length - 1;
+    return skinIndex;
+  }
+  /**
+   * Process Object3D node
+   * @param  {THREE.Object3D} node Object3D to processNode
+   * @return {Integer} Index of the node in the nodes list
+   */
+  processNode(object) {
+    const json = this.json;
+    const options = this.options;
+    const nodeMap = this.nodeMap;
+    if (!json.nodes) json.nodes = [];
+    const nodeDef = {};
+    if (options.trs) {
+      const rotation = object.quaternion.toArray();
+      const position = object.position.toArray();
+      const scale = object.scale.toArray();
+      if (!equalArray(rotation, [0, 0, 0, 1])) {
+        nodeDef.rotation = rotation;
+      }
+      if (!equalArray(position, [0, 0, 0])) {
+        nodeDef.translation = position;
+      }
+      if (!equalArray(scale, [1, 1, 1])) {
+        nodeDef.scale = scale;
+      }
+    } else {
+      if (object.matrixAutoUpdate) {
+        object.updateMatrix();
+      }
+      if (isIdentityMatrix(object.matrix) === false) {
+        nodeDef.matrix = object.matrix.elements;
+      }
+    }
+    if (object.name !== "") nodeDef.name = String(object.name);
+    this.serializeUserData(object, nodeDef);
+    if (object.isMesh || object.isLine || object.isPoints) {
+      const meshIndex = this.processMesh(object);
+      if (meshIndex !== null) nodeDef.mesh = meshIndex;
+    } else if (object.isCamera) {
+      nodeDef.camera = this.processCamera(object);
+    }
+    if (object.isSkinnedMesh) this.skins.push(object);
+    if (object.children.length > 0) {
+      const children = [];
+      for (let i = 0, l = object.children.length; i < l; i++) {
+        const child = object.children[i];
+        if (child.visible || options.onlyVisible === false) {
+          const nodeIndex2 = this.processNode(child);
+          if (nodeIndex2 !== null) children.push(nodeIndex2);
+        }
+      }
+      if (children.length > 0) nodeDef.children = children;
+    }
+    this._invokeAll(function(ext) {
+      ext.writeNode && ext.writeNode(object, nodeDef);
+    });
+    const nodeIndex = json.nodes.push(nodeDef) - 1;
+    nodeMap.set(object, nodeIndex);
+    return nodeIndex;
+  }
+  /**
+   * Process Scene
+   * @param  {Scene} node Scene to process
+   */
+  processScene(scene) {
+    const json = this.json;
+    const options = this.options;
+    if (!json.scenes) {
+      json.scenes = [];
+      json.scene = 0;
+    }
+    const sceneDef = {};
+    if (scene.name !== "") sceneDef.name = scene.name;
+    json.scenes.push(sceneDef);
+    const nodes = [];
+    for (let i = 0, l = scene.children.length; i < l; i++) {
+      const child = scene.children[i];
+      if (child.visible || options.onlyVisible === false) {
+        const nodeIndex = this.processNode(child);
+        if (nodeIndex !== null) nodes.push(nodeIndex);
+      }
+    }
+    if (nodes.length > 0) sceneDef.nodes = nodes;
+    this.serializeUserData(scene, sceneDef);
+  }
+  /**
+   * Creates a Scene to hold a list of objects and parse it
+   * @param  {Array} objects List of objects to process
+   */
+  processObjects(objects) {
+    const scene = new Scene3();
+    scene.name = "AuxScene";
+    for (let i = 0; i < objects.length; i++) {
+      scene.children.push(objects[i]);
+    }
+    this.processScene(scene);
+  }
+  /**
+   * @param {THREE.Object3D|Array<THREE.Object3D>} input
+   */
+  processInput(input) {
+    const options = this.options;
+    input = input instanceof Array ? input : [input];
+    this._invokeAll(function(ext) {
+      ext.beforeParse && ext.beforeParse(input);
+    });
+    const objectsWithoutScene = [];
+    for (let i = 0; i < input.length; i++) {
+      if (input[i] instanceof Scene3) {
+        this.processScene(input[i]);
+      } else {
+        objectsWithoutScene.push(input[i]);
+      }
+    }
+    if (objectsWithoutScene.length > 0) this.processObjects(objectsWithoutScene);
+    for (let i = 0; i < this.skins.length; ++i) {
+      this.processSkin(this.skins[i]);
+    }
+    for (let i = 0; i < options.animations.length; ++i) {
+      this.processAnimation(options.animations[i], input[0]);
+    }
+    this._invokeAll(function(ext) {
+      ext.afterParse && ext.afterParse(input);
+    });
+  }
+  _invokeAll(func) {
+    for (let i = 0, il = this.plugins.length; i < il; i++) {
+      func(this.plugins[i]);
+    }
+  }
+};
+var GLTFLightExtension = class {
+  constructor(writer) {
+    this.writer = writer;
+    this.name = "KHR_lights_punctual";
+  }
+  writeNode(light, nodeDef) {
+    if (!light.isLight) return;
+    if (!light.isDirectionalLight && !light.isPointLight && !light.isSpotLight) {
+      console.warn("THREE.GLTFExporter: Only directional, point, and spot lights are supported.", light);
+      return;
+    }
+    const writer = this.writer;
+    const json = writer.json;
+    const extensionsUsed = writer.extensionsUsed;
+    const lightDef = {};
+    if (light.name) lightDef.name = light.name;
+    lightDef.color = light.color.toArray();
+    lightDef.intensity = light.intensity;
+    if (light.isDirectionalLight) {
+      lightDef.type = "directional";
+    } else if (light.isPointLight) {
+      lightDef.type = "point";
+      if (light.distance > 0) lightDef.range = light.distance;
+    } else if (light.isSpotLight) {
+      lightDef.type = "spot";
+      if (light.distance > 0) lightDef.range = light.distance;
+      lightDef.spot = {};
+      lightDef.spot.innerConeAngle = (1 - light.penumbra) * light.angle;
+      lightDef.spot.outerConeAngle = light.angle;
+    }
+    if (light.decay !== void 0 && light.decay !== 2) {
+      console.warn("THREE.GLTFExporter: Light decay may be lost. glTF is physically-based, and expects light.decay=2.");
+    }
+    if (light.target && (light.target.parent !== light || light.target.position.x !== 0 || light.target.position.y !== 0 || light.target.position.z !== -1)) {
+      console.warn("THREE.GLTFExporter: Light direction may be lost. For best results, make light.target a child of the light with position 0,0,-1.");
+    }
+    if (!extensionsUsed[this.name]) {
+      json.extensions = json.extensions || {};
+      json.extensions[this.name] = { lights: [] };
+      extensionsUsed[this.name] = true;
+    }
+    const lights = json.extensions[this.name].lights;
+    lights.push(lightDef);
+    nodeDef.extensions = nodeDef.extensions || {};
+    nodeDef.extensions[this.name] = { light: lights.length - 1 };
+  }
+};
+var GLTFMaterialsUnlitExtension = class {
+  constructor(writer) {
+    this.writer = writer;
+    this.name = "KHR_materials_unlit";
+  }
+  writeMaterial(material, materialDef) {
+    if (!material.isMeshBasicMaterial) return;
+    const writer = this.writer;
+    const extensionsUsed = writer.extensionsUsed;
+    materialDef.extensions = materialDef.extensions || {};
+    materialDef.extensions[this.name] = {};
+    extensionsUsed[this.name] = true;
+    materialDef.pbrMetallicRoughness.metallicFactor = 0;
+    materialDef.pbrMetallicRoughness.roughnessFactor = 0.9;
+  }
+};
+var GLTFMaterialsClearcoatExtension = class {
+  constructor(writer) {
+    this.writer = writer;
+    this.name = "KHR_materials_clearcoat";
+  }
+  writeMaterial(material, materialDef) {
+    if (!material.isMeshPhysicalMaterial || material.clearcoat === 0) return;
+    const writer = this.writer;
+    const extensionsUsed = writer.extensionsUsed;
+    const extensionDef = {};
+    extensionDef.clearcoatFactor = material.clearcoat;
+    if (material.clearcoatMap) {
+      const clearcoatMapDef = {
+        index: writer.processTexture(material.clearcoatMap),
+        texCoord: material.clearcoatMap.channel
+      };
+      writer.applyTextureTransform(clearcoatMapDef, material.clearcoatMap);
+      extensionDef.clearcoatTexture = clearcoatMapDef;
+    }
+    extensionDef.clearcoatRoughnessFactor = material.clearcoatRoughness;
+    if (material.clearcoatRoughnessMap) {
+      const clearcoatRoughnessMapDef = {
+        index: writer.processTexture(material.clearcoatRoughnessMap),
+        texCoord: material.clearcoatRoughnessMap.channel
+      };
+      writer.applyTextureTransform(clearcoatRoughnessMapDef, material.clearcoatRoughnessMap);
+      extensionDef.clearcoatRoughnessTexture = clearcoatRoughnessMapDef;
+    }
+    if (material.clearcoatNormalMap) {
+      const clearcoatNormalMapDef = {
+        index: writer.processTexture(material.clearcoatNormalMap),
+        texCoord: material.clearcoatNormalMap.channel
+      };
+      writer.applyTextureTransform(clearcoatNormalMapDef, material.clearcoatNormalMap);
+      extensionDef.clearcoatNormalTexture = clearcoatNormalMapDef;
+    }
+    materialDef.extensions = materialDef.extensions || {};
+    materialDef.extensions[this.name] = extensionDef;
+    extensionsUsed[this.name] = true;
+  }
+};
+var GLTFMaterialsIridescenceExtension = class {
+  constructor(writer) {
+    this.writer = writer;
+    this.name = "KHR_materials_iridescence";
+  }
+  writeMaterial(material, materialDef) {
+    if (!material.isMeshPhysicalMaterial || material.iridescence === 0) return;
+    const writer = this.writer;
+    const extensionsUsed = writer.extensionsUsed;
+    const extensionDef = {};
+    extensionDef.iridescenceFactor = material.iridescence;
+    if (material.iridescenceMap) {
+      const iridescenceMapDef = {
+        index: writer.processTexture(material.iridescenceMap),
+        texCoord: material.iridescenceMap.channel
+      };
+      writer.applyTextureTransform(iridescenceMapDef, material.iridescenceMap);
+      extensionDef.iridescenceTexture = iridescenceMapDef;
+    }
+    extensionDef.iridescenceIor = material.iridescenceIOR;
+    extensionDef.iridescenceThicknessMinimum = material.iridescenceThicknessRange[0];
+    extensionDef.iridescenceThicknessMaximum = material.iridescenceThicknessRange[1];
+    if (material.iridescenceThicknessMap) {
+      const iridescenceThicknessMapDef = {
+        index: writer.processTexture(material.iridescenceThicknessMap),
+        texCoord: material.iridescenceThicknessMap.channel
+      };
+      writer.applyTextureTransform(iridescenceThicknessMapDef, material.iridescenceThicknessMap);
+      extensionDef.iridescenceThicknessTexture = iridescenceThicknessMapDef;
+    }
+    materialDef.extensions = materialDef.extensions || {};
+    materialDef.extensions[this.name] = extensionDef;
+    extensionsUsed[this.name] = true;
+  }
+};
+var GLTFMaterialsTransmissionExtension = class {
+  constructor(writer) {
+    this.writer = writer;
+    this.name = "KHR_materials_transmission";
+  }
+  writeMaterial(material, materialDef) {
+    if (!material.isMeshPhysicalMaterial || material.transmission === 0) return;
+    const writer = this.writer;
+    const extensionsUsed = writer.extensionsUsed;
+    const extensionDef = {};
+    extensionDef.transmissionFactor = material.transmission;
+    if (material.transmissionMap) {
+      const transmissionMapDef = {
+        index: writer.processTexture(material.transmissionMap),
+        texCoord: material.transmissionMap.channel
+      };
+      writer.applyTextureTransform(transmissionMapDef, material.transmissionMap);
+      extensionDef.transmissionTexture = transmissionMapDef;
+    }
+    materialDef.extensions = materialDef.extensions || {};
+    materialDef.extensions[this.name] = extensionDef;
+    extensionsUsed[this.name] = true;
+  }
+};
+var GLTFMaterialsVolumeExtension = class {
+  constructor(writer) {
+    this.writer = writer;
+    this.name = "KHR_materials_volume";
+  }
+  writeMaterial(material, materialDef) {
+    if (!material.isMeshPhysicalMaterial || material.transmission === 0) return;
+    const writer = this.writer;
+    const extensionsUsed = writer.extensionsUsed;
+    const extensionDef = {};
+    extensionDef.thicknessFactor = material.thickness;
+    if (material.thicknessMap) {
+      const thicknessMapDef = {
+        index: writer.processTexture(material.thicknessMap),
+        texCoord: material.thicknessMap.channel
+      };
+      writer.applyTextureTransform(thicknessMapDef, material.thicknessMap);
+      extensionDef.thicknessTexture = thicknessMapDef;
+    }
+    extensionDef.attenuationDistance = material.attenuationDistance;
+    extensionDef.attenuationColor = material.attenuationColor.toArray();
+    materialDef.extensions = materialDef.extensions || {};
+    materialDef.extensions[this.name] = extensionDef;
+    extensionsUsed[this.name] = true;
+  }
+};
+var GLTFMaterialsIorExtension = class {
+  constructor(writer) {
+    this.writer = writer;
+    this.name = "KHR_materials_ior";
+  }
+  writeMaterial(material, materialDef) {
+    if (!material.isMeshPhysicalMaterial || material.ior === 1.5) return;
+    const writer = this.writer;
+    const extensionsUsed = writer.extensionsUsed;
+    const extensionDef = {};
+    extensionDef.ior = material.ior;
+    materialDef.extensions = materialDef.extensions || {};
+    materialDef.extensions[this.name] = extensionDef;
+    extensionsUsed[this.name] = true;
+  }
+};
+var GLTFMaterialsSpecularExtension = class {
+  constructor(writer) {
+    this.writer = writer;
+    this.name = "KHR_materials_specular";
+  }
+  writeMaterial(material, materialDef) {
+    if (!material.isMeshPhysicalMaterial || material.specularIntensity === 1 && material.specularColor.equals(DEFAULT_SPECULAR_COLOR) && !material.specularIntensityMap && !material.specularColorTexture) return;
+    const writer = this.writer;
+    const extensionsUsed = writer.extensionsUsed;
+    const extensionDef = {};
+    if (material.specularIntensityMap) {
+      const specularIntensityMapDef = {
+        index: writer.processTexture(material.specularIntensityMap),
+        texCoord: material.specularIntensityMap.channel
+      };
+      writer.applyTextureTransform(specularIntensityMapDef, material.specularIntensityMap);
+      extensionDef.specularTexture = specularIntensityMapDef;
+    }
+    if (material.specularColorMap) {
+      const specularColorMapDef = {
+        index: writer.processTexture(material.specularColorMap),
+        texCoord: material.specularColorMap.channel
+      };
+      writer.applyTextureTransform(specularColorMapDef, material.specularColorMap);
+      extensionDef.specularColorTexture = specularColorMapDef;
+    }
+    extensionDef.specularFactor = material.specularIntensity;
+    extensionDef.specularColorFactor = material.specularColor.toArray();
+    materialDef.extensions = materialDef.extensions || {};
+    materialDef.extensions[this.name] = extensionDef;
+    extensionsUsed[this.name] = true;
+  }
+};
+var GLTFMaterialsSheenExtension = class {
+  constructor(writer) {
+    this.writer = writer;
+    this.name = "KHR_materials_sheen";
+  }
+  writeMaterial(material, materialDef) {
+    if (!material.isMeshPhysicalMaterial || material.sheen == 0) return;
+    const writer = this.writer;
+    const extensionsUsed = writer.extensionsUsed;
+    const extensionDef = {};
+    if (material.sheenRoughnessMap) {
+      const sheenRoughnessMapDef = {
+        index: writer.processTexture(material.sheenRoughnessMap),
+        texCoord: material.sheenRoughnessMap.channel
+      };
+      writer.applyTextureTransform(sheenRoughnessMapDef, material.sheenRoughnessMap);
+      extensionDef.sheenRoughnessTexture = sheenRoughnessMapDef;
+    }
+    if (material.sheenColorMap) {
+      const sheenColorMapDef = {
+        index: writer.processTexture(material.sheenColorMap),
+        texCoord: material.sheenColorMap.channel
+      };
+      writer.applyTextureTransform(sheenColorMapDef, material.sheenColorMap);
+      extensionDef.sheenColorTexture = sheenColorMapDef;
+    }
+    extensionDef.sheenRoughnessFactor = material.sheenRoughness;
+    extensionDef.sheenColorFactor = material.sheenColor.toArray();
+    materialDef.extensions = materialDef.extensions || {};
+    materialDef.extensions[this.name] = extensionDef;
+    extensionsUsed[this.name] = true;
+  }
+};
+var GLTFMaterialsAnisotropyExtension = class {
+  constructor(writer) {
+    this.writer = writer;
+    this.name = "KHR_materials_anisotropy";
+  }
+  writeMaterial(material, materialDef) {
+    if (!material.isMeshPhysicalMaterial || material.anisotropy == 0) return;
+    const writer = this.writer;
+    const extensionsUsed = writer.extensionsUsed;
+    const extensionDef = {};
+    if (material.anisotropyMap) {
+      const anisotropyMapDef = { index: writer.processTexture(material.anisotropyMap) };
+      writer.applyTextureTransform(anisotropyMapDef, material.anisotropyMap);
+      extensionDef.anisotropyTexture = anisotropyMapDef;
+    }
+    extensionDef.anisotropyStrength = material.anisotropy;
+    extensionDef.anisotropyRotation = material.anisotropyRotation;
+    materialDef.extensions = materialDef.extensions || {};
+    materialDef.extensions[this.name] = extensionDef;
+    extensionsUsed[this.name] = true;
+  }
+};
+var GLTFMaterialsEmissiveStrengthExtension = class {
+  constructor(writer) {
+    this.writer = writer;
+    this.name = "KHR_materials_emissive_strength";
+  }
+  writeMaterial(material, materialDef) {
+    if (!material.isMeshStandardMaterial || material.emissiveIntensity === 1) return;
+    const writer = this.writer;
+    const extensionsUsed = writer.extensionsUsed;
+    const extensionDef = {};
+    extensionDef.emissiveStrength = material.emissiveIntensity;
+    materialDef.extensions = materialDef.extensions || {};
+    materialDef.extensions[this.name] = extensionDef;
+    extensionsUsed[this.name] = true;
+  }
+};
+var GLTFMeshGpuInstancing = class {
+  constructor(writer) {
+    this.writer = writer;
+    this.name = "EXT_mesh_gpu_instancing";
+  }
+  writeNode(object, nodeDef) {
+    if (!object.isInstancedMesh) return;
+    const writer = this.writer;
+    const mesh = object;
+    const translationAttr = new Float32Array(mesh.count * 3);
+    const rotationAttr = new Float32Array(mesh.count * 4);
+    const scaleAttr = new Float32Array(mesh.count * 3);
+    const matrix = new Matrix44();
+    const position = new Vector38();
+    const quaternion = new Quaternion4();
+    const scale = new Vector38();
+    for (let i = 0; i < mesh.count; i++) {
+      mesh.getMatrixAt(i, matrix);
+      matrix.decompose(position, quaternion, scale);
+      position.toArray(translationAttr, i * 3);
+      quaternion.toArray(rotationAttr, i * 4);
+      scale.toArray(scaleAttr, i * 3);
+    }
+    const attributes = {
+      TRANSLATION: writer.processAccessor(new BufferAttribute3(translationAttr, 3)),
+      ROTATION: writer.processAccessor(new BufferAttribute3(rotationAttr, 4)),
+      SCALE: writer.processAccessor(new BufferAttribute3(scaleAttr, 3))
+    };
+    if (mesh.instanceColor)
+      attributes._COLOR_0 = writer.processAccessor(mesh.instanceColor);
+    nodeDef.extensions = nodeDef.extensions || {};
+    nodeDef.extensions[this.name] = { attributes };
+    writer.extensionsUsed[this.name] = true;
+    writer.extensionsRequired[this.name] = true;
+  }
+};
+GLTFExporter.Utils = {
+  insertKeyframe: function(track, time) {
+    const tolerance = 1e-3;
+    const valueSize = track.getValueSize();
+    const times = new track.TimeBufferType(track.times.length + 1);
+    const values = new track.ValueBufferType(track.values.length + valueSize);
+    const interpolant = track.createInterpolant(new track.ValueBufferType(valueSize));
+    let index;
+    if (track.times.length === 0) {
+      times[0] = time;
+      for (let i = 0; i < valueSize; i++) {
+        values[i] = 0;
+      }
+      index = 0;
+    } else if (time < track.times[0]) {
+      if (Math.abs(track.times[0] - time) < tolerance) return 0;
+      times[0] = time;
+      times.set(track.times, 1);
+      values.set(interpolant.evaluate(time), 0);
+      values.set(track.values, valueSize);
+      index = 0;
+    } else if (time > track.times[track.times.length - 1]) {
+      if (Math.abs(track.times[track.times.length - 1] - time) < tolerance) {
+        return track.times.length - 1;
+      }
+      times[times.length - 1] = time;
+      times.set(track.times, 0);
+      values.set(track.values, 0);
+      values.set(interpolant.evaluate(time), track.values.length);
+      index = times.length - 1;
+    } else {
+      for (let i = 0; i < track.times.length; i++) {
+        if (Math.abs(track.times[i] - time) < tolerance) return i;
+        if (track.times[i] < time && track.times[i + 1] > time) {
+          times.set(track.times.slice(0, i + 1), 0);
+          times[i + 1] = time;
+          times.set(track.times.slice(i + 1), i + 2);
+          values.set(track.values.slice(0, (i + 1) * valueSize), 0);
+          values.set(interpolant.evaluate(time), (i + 1) * valueSize);
+          values.set(track.values.slice((i + 1) * valueSize), (i + 2) * valueSize);
+          index = i + 1;
+          break;
+        }
+      }
+    }
+    track.times = times;
+    track.values = values;
+    return index;
+  },
+  mergeMorphTargetTracks: function(clip, root) {
+    const tracks = [];
+    const mergedTracks = {};
+    const sourceTracks = clip.tracks;
+    for (let i = 0; i < sourceTracks.length; ++i) {
+      let sourceTrack = sourceTracks[i];
+      const sourceTrackBinding = PropertyBinding.parseTrackName(sourceTrack.name);
+      const sourceTrackNode = PropertyBinding.findNode(root, sourceTrackBinding.nodeName);
+      if (sourceTrackBinding.propertyName !== "morphTargetInfluences" || sourceTrackBinding.propertyIndex === void 0) {
+        tracks.push(sourceTrack);
+        continue;
+      }
+      if (sourceTrack.createInterpolant !== sourceTrack.InterpolantFactoryMethodDiscrete && sourceTrack.createInterpolant !== sourceTrack.InterpolantFactoryMethodLinear) {
+        if (sourceTrack.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline) {
+          throw new Error("THREE.GLTFExporter: Cannot merge tracks with glTF CUBICSPLINE interpolation.");
+        }
+        console.warn("THREE.GLTFExporter: Morph target interpolation mode not yet supported. Using LINEAR instead.");
+        sourceTrack = sourceTrack.clone();
+        sourceTrack.setInterpolation(InterpolateLinear);
+      }
+      const targetCount = sourceTrackNode.morphTargetInfluences.length;
+      const targetIndex = sourceTrackNode.morphTargetDictionary[sourceTrackBinding.propertyIndex];
+      if (targetIndex === void 0) {
+        throw new Error("THREE.GLTFExporter: Morph target name not found: " + sourceTrackBinding.propertyIndex);
+      }
+      let mergedTrack;
+      if (mergedTracks[sourceTrackNode.uuid] === void 0) {
+        mergedTrack = sourceTrack.clone();
+        const values = new mergedTrack.ValueBufferType(targetCount * mergedTrack.times.length);
+        for (let j = 0; j < mergedTrack.times.length; j++) {
+          values[j * targetCount + targetIndex] = mergedTrack.values[j];
+        }
+        mergedTrack.name = (sourceTrackBinding.nodeName || "") + ".morphTargetInfluences";
+        mergedTrack.values = values;
+        mergedTracks[sourceTrackNode.uuid] = mergedTrack;
+        tracks.push(mergedTrack);
+        continue;
+      }
+      const sourceInterpolant = sourceTrack.createInterpolant(new sourceTrack.ValueBufferType(1));
+      mergedTrack = mergedTracks[sourceTrackNode.uuid];
+      for (let j = 0; j < mergedTrack.times.length; j++) {
+        mergedTrack.values[j * targetCount + targetIndex] = sourceInterpolant.evaluate(mergedTrack.times[j]);
+      }
+      for (let j = 0; j < sourceTrack.times.length; j++) {
+        const keyframeIndex = this.insertKeyframe(mergedTrack, sourceTrack.times[j]);
+        mergedTrack.values[keyframeIndex * targetCount + targetIndex] = sourceTrack.values[j];
+      }
+    }
+    clip.tracks = tracks;
+    return clip;
+  }
+};
+
+// src/export/SceneExporter.ts
+init_MineRenderError();
+init_DisplayTransforms();
+init_CanvasCompat();
+var SceneExporter = class {
+  /** Returns OBJ geometry with normals and UVs; material files and textures are not included. */
+  static toObj(root) {
+    const snapshot = createSnapshot(root, false);
+    try {
+      return new OBJExporter().parse(snapshot.scene);
+    } finally {
+      snapshot.dispose();
+    }
+  }
+  /** Returns PLY geometry with vertex colors and UVs; texture images are not included. */
+  static toPLY(root, options) {
+    const snapshot = createSnapshot(root, false, true);
+    try {
+      const result = new PLYExporter().parse(snapshot.scene, void 0, options);
+      if (result === null) throw new MineRenderError("The scene could not be exported as PLY");
+      return result;
+    } finally {
+      snapshot.dispose();
+    }
+  }
+  /**
+   * Exports a static glTF/GLB snapshot in a browser. Atlas textures and vertex tints are retained;
+   * MineRender's custom directional lighting is not baked into the exported materials.
+   */
+  static async toGLTF(root, options = {}) {
+    if (typeof document === "undefined" || typeof FileReader === "undefined") {
+      throw new MineRenderError("glTF export requires a browser with canvas and FileReader support");
+    }
+    if (options.maxTextureSize !== void 0 && !(options.maxTextureSize >= 1)) {
+      throw new MineRenderError("maxTextureSize must be at least 1 pixel");
+    }
+    const snapshot = createSnapshot(root, true);
+    try {
+      return await new GLTFExporter().parseAsync(snapshot.scene, {
+        binary: options.binary ?? false,
+        maxTextureSize: options.maxTextureSize ?? Infinity
+      });
+    } finally {
+      snapshot.dispose();
+    }
+  }
+};
+function localMatrix(object) {
+  return object.matrixAutoUpdate ? new Matrix45().compose(object.position, object.quaternion, object.scale) : object.matrix.clone();
+}
+function createSnapshot(root, gltf, bakeColors = false) {
+  const scene = new Scene4();
+  const geometries = [];
+  const materials = [];
+  const textures = [];
+  const textureCopies = /* @__PURE__ */ new Map();
+  const dispose = () => {
+    for (const geometry of geometries) geometry.dispose();
+    for (const material of materials) material.dispose();
+    for (const texture of textures) texture.dispose();
+  };
+  const copyMaterial = (source, geometry) => {
+    let material;
+    const shader = source;
+    if (shader.isShaderMaterial && gltf) {
+      const uniforms = shader.uniforms;
+      if (!uniforms.map?.value?.isTexture || !uniforms.SHADE || !uniforms.BRIGHTNESS || !uniforms.EMISSIVE) {
+        throw new MineRenderError("glTF export does not support this custom ShaderMaterial");
+      }
+      material = new MeshBasicMaterial2({
+        map: uniforms.map.value,
+        vertexColors: source.vertexColors,
+        transparent: source.transparent,
+        side: source.side,
+        alphaTest: 0.01,
+        depthWrite: source.depthWrite
+      });
+      material.name = source.name;
+    } else if (shader.isShaderMaterial) {
+      material = new MeshBasicMaterial2({ vertexColors: source.vertexColors });
+      material.name = source.name;
+    } else {
+      const copySource = Object.create(source);
+      copySource.userData = {};
+      material = source.clone.call(copySource);
+    }
+    materials.push(material);
+    if (gltf) {
+      selectAlphaMode(material, geometry);
+      for (const [key, value] of Object.entries(material)) {
+        if (value?.isDataTexture) {
+          let texture = textureCopies.get(value);
+          if (!texture) {
+            texture = copyDataTexture(value);
+            textureCopies.set(value, texture);
+            textures.push(texture);
+          }
+          material[key] = texture;
+        }
+      }
+    }
+    return material;
+  };
+  const addMesh = (mesh, world, instanceColor) => {
+    if (world.determinant() === 0 || !mesh.geometry.getAttribute("position")) return;
+    const source = mesh.geometry;
+    const count = source.index?.count ?? source.getAttribute("position").count;
+    const groups = Array.isArray(mesh.material) ? source.groups : [{ start: 0, count, materialIndex: 0 }];
+    for (const group of groups) {
+      const sourceMaterial = Array.isArray(mesh.material) ? mesh.material[group.materialIndex ?? 0] : mesh.material;
+      if (!sourceMaterial?.visible) continue;
+      const start = Math.max(group.start, source.drawRange.start);
+      const end = Math.min(count, group.start + group.count, source.drawRange.start + source.drawRange.count);
+      const indices = [];
+      for (let i = start; i + 2 < end; i += 3) {
+        for (let corner = 0; corner < 3; corner++) indices.push(source.index?.getX(i + corner) ?? i + corner);
+      }
+      if (!indices.length) continue;
+      let geometry = source.clone();
+      geometry.setIndex(indices);
+      if (new Set(indices).size < geometry.getAttribute("position").count) {
+        const compact = geometry.toNonIndexed();
+        geometry.dispose();
+        geometry = compact;
+      }
+      geometries.push(geometry);
+      geometry.userData = {};
+      geometry.clearGroups();
+      geometry.setDrawRange(0, Infinity);
+      DisplayTransforms.apply(geometry, world);
+      const material = copyMaterial(sourceMaterial, geometry);
+      if (!sourceMaterial.vertexColors) geometry.deleteAttribute("color");
+      if (bakeColors || instanceColor) {
+        const tint = (material.color ?? new Color6()).clone();
+        if (instanceColor) tint.multiply(instanceColor);
+        if (bakeColors) {
+          const original = geometry.getAttribute("color");
+          const colors = new Float32BufferAttribute3(new Float32Array(geometry.getAttribute("position").count * 3), 3);
+          for (let i = 0; i < colors.count; i++) {
+            colors.setXYZ(i, (original?.getX(i) ?? 1) * tint.r, (original?.getY(i) ?? 1) * tint.g, (original?.getZ(i) ?? 1) * tint.b);
+          }
+          geometry.setAttribute("color", colors);
+        } else if (material.color) {
+          material.color.copy(tint);
+        }
+      }
+      const copy = new Mesh5(geometry, material);
+      copy.name = mesh.name;
+      copy.renderOrder = mesh.renderOrder;
+      scene.add(copy);
+    }
+  };
+  const visit = (object, parentWorld) => {
+    if (!object.visible) return;
+    const world = parentWorld.clone().multiply(localMatrix(object));
+    const mesh = object;
+    if (mesh.isMesh) {
+      const instanced = mesh;
+      if (instanced.isInstancedMesh) {
+        for (let i = 0; i < instanced.count; i++) {
+          const matrix = new Matrix45();
+          instanced.getMatrixAt(i, matrix);
+          const color = instanced.instanceColor ? new Color6().fromBufferAttribute(instanced.instanceColor, i) : void 0;
+          addMesh(mesh, world.clone().multiply(matrix), color);
+        }
+      } else {
+        addMesh(mesh, world);
+      }
+    }
+    for (const child of object.children) visit(child, world);
+  };
+  try {
+    const ancestors = [];
+    for (let parent = root.parent; parent; parent = parent.parent) ancestors.unshift(parent);
+    const world = new Matrix45();
+    for (const ancestor of ancestors) {
+      if (!ancestor.visible) return { scene, dispose };
+      world.multiply(localMatrix(ancestor));
+    }
+    visit(root, world);
+    return { scene, dispose };
+  } catch (error) {
+    dispose();
+    throw error;
+  }
+}
+function selectAlphaMode(material, geometry) {
+  const texture = material.map;
+  if (material.type !== "MeshBasicMaterial" || !material.transparent || !material.depthWrite || material.opacity !== 1 || material.alphaMap || !texture?.isDataTexture || texture.format !== RGBAFormat3 || texture.type !== UnsignedByteType || texture.wrapS !== ClampToEdgeWrapping2 || texture.wrapT !== ClampToEdgeWrapping2 || texture.magFilter !== NearestFilter3 || texture.minFilter !== NearestFilter3 || texture.anisotropy > 1 || texture.offset.x !== 0 || texture.offset.y !== 0 || texture.repeat.x !== 1 || texture.repeat.y !== 1 || texture.rotation !== 0 || !texture.matrixAutoUpdate && !texture.matrix.elements.every((value, i) => value === (i % 4 === 0 ? 1 : 0))) return;
+  const uv = geometry.getAttribute(texture.channel === 0 ? "uv" : `uv${texture.channel}`);
+  const colors = geometry.getAttribute("color");
+  if (!uv || material.vertexColors && colors?.itemSize === 4) return;
+  const { data, width, height } = texture.image;
+  if (!data || width < 1 || height < 1 || data.length < width * height * 4) return;
+  const count = geometry.index?.count ?? uv.count;
+  let holes = false;
+  for (let i = 0; i + 2 < count; i += 3) {
+    let minU = Infinity, maxU = -Infinity, minV = Infinity, maxV = -Infinity;
+    for (let corner = 0; corner < 3; corner++) {
+      const index = geometry.index?.getX(i + corner) ?? i + corner;
+      const u = uv.getX(index), v = texture.flipY ? 1 - uv.getY(index) : uv.getY(index);
+      if (!Number.isFinite(u) || !Number.isFinite(v)) return;
+      minU = Math.min(minU, u);
+      maxU = Math.max(maxU, u);
+      minV = Math.min(minV, v);
+      maxV = Math.max(maxV, v);
+    }
+    const minX = Math.max(0, Math.min(width - 1, Math.floor(minU * width)));
+    const maxX = Math.max(minX, Math.min(width - 1, Math.ceil(maxU * width) - 1));
+    const minY = Math.max(0, Math.min(height - 1, Math.floor(minV * height)));
+    const maxY = Math.max(minY, Math.min(height - 1, Math.ceil(maxV * height) - 1));
+    for (let y = minY; y <= maxY; y++) {
+      for (let x = minX; x <= maxX; x++) {
+        const alpha = data[(y * width + x) * 4 + 3];
+        if (alpha === 255) continue;
+        if (alpha !== 0 && alpha / 255 >= material.alphaTest) return;
+        holes = true;
+      }
+    }
+  }
+  material.transparent = false;
+  if (holes && material.alphaTest === 0) material.alphaTest = 1 / 255;
+}
+function copyDataTexture(source) {
+  const image = source.image;
+  if (source.format !== RGBAFormat3 || source.type !== UnsignedByteType) {
+    throw new MineRenderError("glTF export requires RGBA unsigned-byte data textures");
+  }
+  const canvas = createCanvas2(image.width, image.height);
+  const context = canvas.getContext("2d");
+  if (!context) throw new MineRenderError("glTF export could not create a 2D canvas context");
+  const pixels = context.createImageData(image.width, image.height);
+  pixels.data.set(image.data);
+  context.putImageData(pixels, 0, 0);
+  const copySource = Object.create(source);
+  copySource.userData = {};
+  copySource.source = new Source2(canvas);
+  return new Texture4().copy(copySource);
+}
+
 // src/gui/GuiHelper.ts
 var GuiHelper = class {
   static inventorySlot(slot, origin = [0, 0], offset = [18, 18], rowSize = 9) {
@@ -4971,7 +7551,7 @@ init_ModelTextures();
 init_Caching();
 init_SceneObject();
 init_Materials();
-import { Box2, Mesh as Mesh4, PlaneGeometry, Vector2 as Vector22 } from "three";
+import { Box2, Mesh as Mesh6, PlaneGeometry as PlaneGeometry2, Vector2 as Vector23 } from "three";
 var GuiObject = class extends SceneObject {
   constructor(textureLayers, options) {
     super({ ...options, instanceMeshes: false, mergeMeshes: false });
@@ -4993,7 +7573,7 @@ var GuiObject = class extends SceneObject {
         const [cropX, cropY, cropWidth, cropHeight] = layer.crop ?? [0, 0, image.width, image.height];
         const [width, height] = layer.size ?? [cropWidth, cropHeight];
         const [x, y] = layer.position ?? [0, 0];
-        const geometry = new PlaneGeometry(width, height);
+        const geometry = new PlaneGeometry2(width, height);
         this.geometries.add(geometry);
         const uv = geometry.getAttribute("uv");
         for (let i = 0; i < uv.count; i++) {
@@ -5003,13 +7583,13 @@ var GuiObject = class extends SceneObject {
             1 - (cropY + (1 - uv.getY(i)) * cropHeight) / image.height
           );
         }
-        const mesh = new Mesh4(geometry, material);
+        const mesh = new Mesh6(geometry, material);
         mesh.name = `mesh:${layer.name ?? index}`;
         mesh.position.set(x + width / 2, -y - height / 2, 0);
         mesh.renderOrder = index;
         this.add(mesh);
-        this.bounds.expandByPoint(new Vector22(x, y));
-        this.bounds.expandByPoint(new Vector22(x + width, y + height));
+        this.bounds.expandByPoint(new Vector23(x, y));
+        this.bounds.expandByPoint(new Vector23(x + width, y + height));
       }
       this.initialized = true;
       this.notifyDirty();
@@ -5058,7 +7638,7 @@ init_image();
 // src/inspector/SceneInspector.ts
 init_SceneObject();
 init_util();
-import { Raycaster, Vector2 as Vector23 } from "three";
+import { Raycaster, Vector2 as Vector24 } from "three";
 init_log();
 init_three();
 var p7 = prefix("SceneInspector");
@@ -5066,7 +7646,7 @@ var help = "<span>Ctrl/Cmd+Click to Select<br/></span><br/>";
 var SceneInspector = class {
   constructor(renderer) {
     this.renderer = renderer;
-    this.mouse = new Vector23();
+    this.mouse = new Vector24();
     this.listeners = new AbortController();
     this.objectInfoContainer = document.createElement("div");
     this.objectControlsContainer = document.createElement("div");
@@ -5674,7 +8254,7 @@ var import_ts_deepmerge6 = __toESM(require_dist());
 init_MineRenderError();
 init_InstanceReference();
 init_AssetKey();
-import { Euler as Euler7, Matrix4 as Matrix45, Quaternion as Quaternion4, Vector3 as Vector38 } from "three";
+import { Euler as Euler7, Matrix4 as Matrix47, Quaternion as Quaternion5, Vector3 as Vector311 } from "three";
 init_ModelCulling();
 init_FluidGeometry();
 var BlockObject = class _BlockObject extends SceneObject {
@@ -5740,11 +8320,11 @@ var BlockObject = class _BlockObject extends SceneObject {
   getModelCullMask(model, worldMask) {
     const object = isInstanceReference(model) ? model.instanceable : model;
     if (object.options.displayPosition) return 0;
-    const position = new Vector38();
-    const rotation = new Quaternion4();
-    const scale = new Vector38();
+    const position = new Vector311();
+    const rotation = new Quaternion5();
+    const scale = new Vector311();
     this.getModelMatrix(model).decompose(position, rotation, scale);
-    if (position.distanceToSquared(this.position) > 1e-10 || scale.distanceToSquared(new Vector38(1, 1, 1)) > 1e-10) return 0;
+    if (position.distanceToSquared(this.position) > 1e-10 || scale.distanceToSquared(new Vector311(1, 1, 1)) > 1e-10) return 0;
     return ModelCulling.toLocalMask(worldMask, new Euler7().setFromQuaternion(rotation));
   }
   async setCullMask(worldMask) {
@@ -5807,7 +8387,7 @@ var BlockObject = class _BlockObject extends SceneObject {
       () => new FluidModelObject2(kind, surface.sample, this.blockState.key, this.options)
     );
     const previous = this._fluidModel;
-    const matrix = previous ? this.getModelMatrix(previous) : new Matrix45().makeTranslation(...this.position.toArray());
+    const matrix = previous ? this.getModelMatrix(previous) : new Matrix47().makeTranslation(...this.position.toArray());
     if (isInstanceReference(replacement)) replacement.setMatrix(matrix);
     else matrix.decompose(replacement.position, replacement.quaternion, replacement.scale);
     this._models = this._models.filter((model) => model !== previous);
@@ -5938,7 +8518,7 @@ var BlockObject = class _BlockObject extends SceneObject {
   setPositionRotationScaleAt(index, position, rotation, scale) {
     super.setPositionRotationScaleAt(index, position, rotation, scale);
   }
-  getMatrixAt(index, matrix = new Matrix45()) {
+  getMatrixAt(index, matrix = new Matrix47()) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const child = this._models[0];
     if (child && isModelObject(child)) {
@@ -7807,7 +10387,7 @@ init_nbt();
 init_SceneObject();
 var import_ts_deepmerge8 = __toESM(require_dist());
 init_ModelObject();
-import { Scene as Scene2 } from "three";
+import { Scene as Scene5 } from "three";
 
 // src/skin/scene/SkinObject.ts
 init_SceneObject();
@@ -8540,7 +11120,7 @@ init_util();
 init_Caching();
 init_CacheKey();
 init_MineRenderError();
-import { DataTexture, DoubleSide as DoubleSide3, FrontSide as FrontSide2, MeshBasicMaterial as MeshBasicMaterial4, SRGBColorSpace as SRGBColorSpace3 } from "three";
+import { DataTexture as DataTexture2, DoubleSide as DoubleSide4, FrontSide as FrontSide2, MeshBasicMaterial as MeshBasicMaterial5, SRGBColorSpace as SRGBColorSpace5 } from "three";
 
 // src/skin/SkinImage.ts
 init_Caching();
@@ -8621,11 +11201,11 @@ var SkinTextures = class {
     });
   }
   static createMaterial(pixels, width, height, transparent = true) {
-    const texture = Textures.initTextureProps(new DataTexture(pixels, width, height));
-    texture.colorSpace = SRGBColorSpace3;
+    const texture = Textures.initTextureProps(new DataTexture2(pixels, width, height));
+    texture.colorSpace = SRGBColorSpace5;
     texture.flipY = true;
     texture.needsUpdate = true;
-    return new MeshBasicMaterial4({ map: texture, transparent, side: transparent ? DoubleSide3 : FrontSide2, alphaTest: transparent ? 0.1 : 0 });
+    return new MeshBasicMaterial5({ map: texture, transparent, side: transparent ? DoubleSide4 : FrontSide2, alphaTest: transparent ? 0.1 : 0 });
   }
   static isSlim(image, scale) {
     for (const [x, y] of [[46, 52], [54, 20]]) {
@@ -8852,7 +11432,7 @@ var SkinObject = class extends SceneObject {
 };
 
 // src/renderer/MineRenderScene.ts
-var MineRenderScene = class _MineRenderScene extends Scene2 {
+var MineRenderScene = class _MineRenderScene extends Scene5 {
   constructor(options) {
     super();
     this.isMineRenderScene = true;
@@ -8985,7 +11565,7 @@ function isMineRenderScene(obj) {
 }
 
 // src/renderer/Renderer.ts
-import { AxesHelper as AxesHelper2, GridHelper, OrthographicCamera, PCFSoftShadowMap, PerspectiveCamera, SRGBColorSpace as SRGBColorSpace4, Vector3 as Vector310, WebGLRenderer } from "three";
+import { AxesHelper as AxesHelper2, GridHelper, OrthographicCamera, PCFSoftShadowMap, PerspectiveCamera as PerspectiveCamera2, SRGBColorSpace as SRGBColorSpace6, Vector3 as Vector313, WebGLRenderer as WebGLRenderer2 } from "three";
 var import_ts_deepmerge9 = __toESM(require_dist());
 init_util();
 import Stats from "stats.js";
@@ -8996,11 +11576,11 @@ init_three();
 import {
   EventDispatcher,
   MOUSE,
-  Quaternion as Quaternion5,
+  Quaternion as Quaternion6,
   Spherical,
   TOUCH,
-  Vector2 as Vector24,
-  Vector3 as Vector39
+  Vector2 as Vector25,
+  Vector3 as Vector312
 } from "three";
 var _changeEvent = { type: "change" };
 var _startEvent = { type: "start" };
@@ -9014,7 +11594,7 @@ var OrbitControls = class extends EventDispatcher {
     this.domElement = domElement;
     this.domElement.style.touchAction = "none";
     this.enabled = true;
-    this.target = new Vector39();
+    this.target = new Vector312();
     this.minDistance = 0;
     this.maxDistance = Infinity;
     this.minZoom = 0;
@@ -9066,11 +11646,11 @@ var OrbitControls = class extends EventDispatcher {
       state = STATE.NONE;
     };
     this.update = function() {
-      const offset = new Vector39();
-      const quat = new Quaternion5().setFromUnitVectors(object.up, new Vector39(0, 1, 0));
+      const offset = new Vector312();
+      const quat = new Quaternion6().setFromUnitVectors(object.up, new Vector312(0, 1, 0));
       const quatInverse = quat.clone().invert();
-      const lastPosition = new Vector39();
-      const lastQuaternion = new Quaternion5();
+      const lastPosition = new Vector312();
+      const lastQuaternion = new Quaternion6();
       const twoPI = 2 * Math.PI;
       return function update() {
         const position = scope.object.position;
@@ -9159,17 +11739,17 @@ var OrbitControls = class extends EventDispatcher {
     const spherical = new Spherical();
     const sphericalDelta = new Spherical();
     let scale = 1;
-    const panOffset = new Vector39();
+    const panOffset = new Vector312();
     let zoomChanged = false;
-    const rotateStart = new Vector24();
-    const rotateEnd = new Vector24();
-    const rotateDelta = new Vector24();
-    const panStart = new Vector24();
-    const panEnd = new Vector24();
-    const panDelta = new Vector24();
-    const dollyStart = new Vector24();
-    const dollyEnd = new Vector24();
-    const dollyDelta = new Vector24();
+    const rotateStart = new Vector25();
+    const rotateEnd = new Vector25();
+    const rotateDelta = new Vector25();
+    const panStart = new Vector25();
+    const panEnd = new Vector25();
+    const panDelta = new Vector25();
+    const dollyStart = new Vector25();
+    const dollyEnd = new Vector25();
+    const dollyDelta = new Vector25();
     const pointers = [];
     const pointerPositions = {};
     function getAutoRotationAngle() {
@@ -9185,7 +11765,7 @@ var OrbitControls = class extends EventDispatcher {
       sphericalDelta.phi -= angle;
     }
     const panLeft = function() {
-      const v = new Vector39();
+      const v = new Vector312();
       return function panLeft2(distance, objectMatrix) {
         v.setFromMatrixColumn(objectMatrix, 0);
         v.multiplyScalar(-distance);
@@ -9193,7 +11773,7 @@ var OrbitControls = class extends EventDispatcher {
       };
     }();
     const panUp = function() {
-      const v = new Vector39();
+      const v = new Vector312();
       return function panUp2(distance, objectMatrix) {
         if (scope.screenSpacePanning === true) {
           v.setFromMatrixColumn(objectMatrix, 1);
@@ -9206,7 +11786,7 @@ var OrbitControls = class extends EventDispatcher {
       };
     }();
     const pan = function() {
-      const offset = new Vector39();
+      const offset = new Vector312();
       return function pan2(deltaX, deltaY) {
         const element = scope.domElement;
         if (scope.object.isPerspectiveCamera) {
@@ -9615,7 +12195,7 @@ var OrbitControls = class extends EventDispatcher {
     function trackPointer(event) {
       let position = pointerPositions[event.pointerId];
       if (position === void 0) {
-        position = new Vector24();
+        position = new Vector25();
         pointerPositions[event.pointerId] = position;
       }
       position.set(event.pageX, event.pageY);
@@ -9687,8 +12267,8 @@ var Renderer = class _Renderer {
           top: void 0,
           bottom: void 0
         },
-        position: new Vector310(50, 50, 50),
-        lookingAt: new Vector310(0, 0, 0)
+        position: new Vector313(50, 50, 50),
+        lookingAt: new Vector313(0, 0, 0)
       },
       render: {
         fpsLimit: 60,
@@ -9719,7 +12299,7 @@ var Renderer = class _Renderer {
     switch (this.options.camera.type) {
       case "perspective":
       default:
-        return new PerspectiveCamera(
+        return new PerspectiveCamera2(
           this.options.camera.perspective.fov,
           this.options.camera.perspective.aspect ?? this.viewWidth / this.viewHeight,
           this.options.camera.near,
@@ -9737,7 +12317,7 @@ var Renderer = class _Renderer {
     }
   }
   createRenderer() {
-    const renderer = new WebGLRenderer({
+    const renderer = new WebGLRenderer2({
       antialias: this.options.render.antialias,
       alpha: true,
       powerPreference: "high-performance",
@@ -9746,7 +12326,7 @@ var Renderer = class _Renderer {
     renderer.setClearColor(0, 0);
     renderer.shadowMap.enabled = true;
     renderer.shadowMap.type = PCFSoftShadowMap;
-    renderer.outputColorSpace = SRGBColorSpace4;
+    renderer.outputColorSpace = SRGBColorSpace6;
     renderer.setPixelRatio(this.options.render.pixelRatio ?? 1);
     renderer.setSize(this.viewWidth, this.viewHeight);
     return renderer;
@@ -9938,6 +12518,9 @@ var Renderer = class _Renderer {
       if (next !== void 0 && t + 0.1 < next) return;
       this._nextFrameTime = next !== void 0 && t - next < interval ? next + interval : t + interval;
     }
+    this.drawFrame();
+  }
+  drawFrame() {
     if (this._stats) {
       this._stats.begin();
     }
@@ -9952,8 +12535,28 @@ var Renderer = class _Renderer {
     }
   }
   //</editor-fold>
-  toImage() {
-    return this.renderer.domElement.toDataURL();
+  /**
+   * Renders a fresh frame and returns an image data URL, including while the animation loop is stopped.
+   * Trimming removes transparent borders; an empty image becomes one transparent pixel.
+   * MIME type support and lossy quality (0–1) follow the canvas encoder.
+   */
+  toImage(trim = false, mime = "image/png", quality) {
+    if (this._disposed) throw new Error("Cannot export an image from a disposed renderer");
+    if (this._controls?.enabled) {
+      this._controls.update();
+    }
+    this.drawFrame();
+    const canvas = trim ? trimCanvas(this.renderer.domElement) : this.renderer.domElement;
+    return canvas.toDataURL(mime, quality);
+  }
+  toObj() {
+    return SceneExporter.toObj(this.scene);
+  }
+  toPLY(options) {
+    return SceneExporter.toPLY(this.scene, options);
+  }
+  toGLTF(options) {
+    return SceneExporter.toGLTF(this.scene, options);
   }
   ///
   get attachedToBody() {
@@ -10424,12 +13027,12 @@ var AnvilParser = class {
 };
 
 // src/world/Chunk.ts
-import { Vector3 as Vector313 } from "three";
+import { Vector3 as Vector316 } from "three";
 init_BlockStates();
 init_AssetKey();
 
 // src/world/MineRenderWorld.ts
-import { Vector3 as Vector312 } from "three";
+import { Vector3 as Vector315 } from "three";
 init_BatchedExecutor();
 init_AssetKey();
 init_BlockStates();
@@ -10439,7 +13042,7 @@ init_CubeFace();
 init_AssetKey();
 init_Models();
 init_CubeFace();
-import { Matrix4 as Matrix46, Vector3 as Vector311 } from "three";
+import { Matrix4 as Matrix48, Vector3 as Vector314 } from "three";
 init_ModelCulling();
 init_ModelObject();
 init_UVMapper();
@@ -10502,12 +13105,12 @@ var SectionModels = class {
         });
         await object.init();
         const geometry = object.children[0].geometry;
-        geometry.applyMatrix4(new Matrix46().makeRotationFromEuler(rotation));
+        geometry.applyMatrix4(new Matrix48().makeRotationFromEuler(rotation));
         object.clear();
         const cullFaces = CUBE_FACES.map((face) => {
           const local = CUBE_FACES.findIndex((name) => name === atlas.model.elements[0].faces[face]?.cullface);
           if (local < 0) return 0;
-          const normal = new Vector311(...CUBE_FACE_OFFSETS[local]).applyEuler(rotation);
+          const normal = new Vector314(...CUBE_FACE_OFFSETS[local]).applyEuler(rotation);
           const world = CUBE_FACE_OFFSETS.findIndex(([x, y, z]) => Math.abs(normal.x - x) < 1e-6 && Math.abs(normal.y - y) < 1e-6 && Math.abs(normal.z - z) < 1e-6);
           return 1 << world;
         });
@@ -10537,20 +13140,20 @@ var MineRenderWorld = class {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new Vector312(posOrX, y, z));
+      return this.getBlockAt(new Vector315(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new Vector312(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new Vector315(posOrX[0], posOrX[1], posOrX[2]));
     }
     this.validatePosBounds(posOrX);
     return this.getChunkAt(posOrX)?.getBlockAt(posOrX);
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new Vector312(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new Vector315(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new Vector312(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new Vector315(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     return this.placeBlock(posOrX, yOrBlock);
   }
@@ -10571,7 +13174,7 @@ var MineRenderWorld = class {
     const collect = async (positions2) => {
       for (const pos of positions2) changes.set(pos.toArray().join(","), pos);
     };
-    const place = (block) => this.placeBlock(new Vector312(...block.position), block, collect);
+    const place = (block) => this.placeBlock(new Vector315(...block.position), block, collect);
     const keys = /* @__PURE__ */ new Map();
     for (const block of multiblock.blocks) {
       if (Chunk.isAir(block)) continue;
@@ -10649,13 +13252,13 @@ var MineRenderWorld = class {
     for (const pos of positions) {
       this.pendingCulling.set(pos.toArray().join(","), pos.clone());
       for (const offset of CUBE_FACE_OFFSETS) {
-        const neighbor = pos.clone().add(new Vector312(...offset));
+        const neighbor = pos.clone().add(new Vector315(...offset));
         this.pendingCulling.set(neighbor.toArray().join(","), neighbor);
       }
       for (let y = -1; y <= 1; y++) {
         for (let z = -1; z <= 1; z++) {
           for (let x = -1; x <= 1; x++) {
-            const neighbor = pos.clone().add(new Vector312(x, y, z));
+            const neighbor = pos.clone().add(new Vector315(x, y, z));
             if (this.getBlockAt(neighbor)?.object?.fluidKind) {
               this.pendingCulling.set(neighbor.toArray().join(","), neighbor);
             }
@@ -10677,7 +13280,7 @@ var MineRenderWorld = class {
             if (!block) continue;
             if (block.object?.fluidKind) {
               await block.object.updateFluid((x, y, z) => {
-                const neighbor = pos.clone().add(new Vector312(x, y, z));
+                const neighbor = pos.clone().add(new Vector315(x, y, z));
                 const section = this.getChunkAt(neighbor);
                 const object = section?.getBlockAt(neighbor)?.object;
                 return {
@@ -10689,7 +13292,7 @@ var MineRenderWorld = class {
             }
             let mask = 0;
             for (const [face, offset] of CUBE_FACE_OFFSETS.entries()) {
-              const neighbor = pos.clone().add(new Vector312(...offset));
+              const neighbor = pos.clone().add(new Vector315(...offset));
               if (this.getChunkAt(neighbor)?.isOccludingAt(neighbor)) {
                 mask |= 1 << face;
               }
@@ -10723,14 +13326,14 @@ var MineRenderWorld = class {
     return this._chunks.get(this.worldPosToChunkKey(pos));
   }
   static worldToScenePosition(pos) {
-    return new Vector312(
+    return new Vector315(
       pos.x * 16,
       pos.y * 16,
       pos.z * 16
     );
   }
   static sceneToWorldPosition(pos) {
-    return new Vector312(
+    return new Vector315(
       pos.x / 16,
       pos.y / 16,
       pos.z / 16
@@ -10752,7 +13355,7 @@ var MineRenderWorld = class {
 // src/world/SectionMesh.ts
 init_CanvasCompat();
 init_Materials();
-import { BufferGeometry as BufferGeometry4, Float32BufferAttribute as Float32BufferAttribute5, Group, Mesh as Mesh8 } from "three";
+import { BufferGeometry as BufferGeometry5, Float32BufferAttribute as Float32BufferAttribute6, Group, Mesh as Mesh10 } from "three";
 var SectionMesh = class _SectionMesh extends Group {
   constructor() {
     super(...arguments);
@@ -10826,18 +13429,18 @@ var SectionMesh = class _SectionMesh extends Group {
           for (let corner = 0; corner < 6; corner++) indices.push(start + sourceIndices.getX(face * 6 + corner) - face * 4);
         }
       }
-      const geometry = new BufferGeometry4();
-      geometry.setAttribute("position", new Float32BufferAttribute5(positions, 3));
-      geometry.setAttribute("normal", new Float32BufferAttribute5(normals, 3));
-      geometry.setAttribute("uv", new Float32BufferAttribute5(uvs, 2));
-      geometry.setAttribute("color", new Float32BufferAttribute5(colors, 3));
+      const geometry = new BufferGeometry5();
+      geometry.setAttribute("position", new Float32BufferAttribute6(positions, 3));
+      geometry.setAttribute("normal", new Float32BufferAttribute6(normals, 3));
+      geometry.setAttribute("uv", new Float32BufferAttribute6(uvs, 2));
+      geometry.setAttribute("color", new Float32BufferAttribute6(colors, 3));
       geometry.setIndex(indices);
       geometry.computeBoundingBox();
       geometry.computeBoundingSphere();
       const material = Materials.createShadedCanvasMaterial(canvas, false);
       material.vertexColors = true;
       const texture = material.uniforms?.map?.value ?? material.map;
-      const mesh = new Mesh8(geometry, material);
+      const mesh = new Mesh10(geometry, material);
       section.add(mesh);
       section.ownedMeshes.push({ mesh, texture });
     }
@@ -10871,10 +13474,10 @@ var Chunk = class _Chunk {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new Vector313(posOrX, y, z));
+      return this.getBlockAt(new Vector316(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new Vector313(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new Vector316(posOrX[0], posOrX[1], posOrX[2]));
     }
     const pos = this.worldPosToChunkPos(posOrX);
     const index = _Chunk.chunkPosToBlockIndex(pos);
@@ -10882,10 +13485,10 @@ var Chunk = class _Chunk {
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new Vector313(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new Vector316(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new Vector313(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new Vector316(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     const worldPos = posOrX;
     const pos = this.worldPosToChunkPos(worldPos);
@@ -10970,7 +13573,7 @@ var Chunk = class _Chunk {
   }
   async clear(onBlocksChanged = this.onBlocksChanged) {
     const positions = [...this.renderedBlocks.keys()].map((index) => this.chunkPosToWorldPos(
-      new Vector313(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
+      new Vector316(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
     ));
     for (const info of this.renderedBlocks.values()) info.object?.removeFromScene();
     this.sectionBlocks.clear();
@@ -10994,14 +13597,14 @@ var Chunk = class _Chunk {
     return pos.y * 16 * 16 + pos.z * 16 + pos.x;
   }
   worldPosToChunkPos(pos) {
-    return new Vector313(
+    return new Vector316(
       pos.x - this.x * 16,
       pos.y - this.y * 16,
       pos.z - this.z * 16
     );
   }
   chunkPosToWorldPos(pos) {
-    return new Vector313(
+    return new Vector316(
       this.x * 16 + pos.x,
       this.y * 16 + pos.y,
       this.z * 16 + pos.z
@@ -11080,6 +13683,7 @@ export {
   RequestError,
   Requests,
   SKIN_PARTS,
+  SceneExporter,
   SceneInspector,
   SceneObject,
   SceneStats,
@@ -11168,6 +13772,7 @@ export {
   timingStart,
   toDegrees,
   toRadians,
-  toTrianglesDrawMode
+  toTrianglesDrawMode,
+  trimCanvas
 };
 //# sourceMappingURL=index.mjs.map