minerender 2.1.0-alpha.66 → 2.1.0-alpha.68

package/dist/node/index.js

@@ -4036,6 +4036,7 @@ var init_SceneObject = __esm({
       dispose() {
         this.disposeAndRemoveAllChildren();
         this.notifyDirty();
+        super.dispose();
       }
       disposeAndRemoveAllChildren() {
         if (this.instanceMesh) {
@@ -4249,6 +4250,7 @@ var init_EntityObject = __esm({
             else matrix.makeRotationFromEuler(new import_three14.Euler(...op.rotate, "ZYX"));
             modelRoot.matrix.multiply(matrix);
           }
+          modelRoot.matrixWorldNeedsUpdate = true;
           modelRoot.matrixAutoUpdate = false;
         } else if (this.options.flip ?? true) {
           modelRoot.scale.set(-1, -1, 1);
@@ -5156,6 +5158,7 @@ var init_ModelObject = __esm({
             for (const part of parts) {
               const object = new EntityObject(part.model, { flip: false, wireframe: this.options.wireframe });
               object.matrix.copy(transform).multiply(part.transform);
+              object.matrixWorldNeedsUpdate = true;
               object.matrixAutoUpdate = false;
               this.add(object);
               await object.init();
@@ -5689,6 +5692,7 @@ __export(index_node_exports, {
   computeTangents: () => computeTangents,
   createCanvas: () => createCanvas2,
   createFluidGeometry: () => createFluidGeometry,
+  createGuiTextureGeometry: () => createGuiTextureGeometry,
   createImage: () => createImage,
   entityAnimationTime: () => entityAnimationTime,
   estimateBytesUsed: () => estimateBytesUsed,
@@ -6004,11 +6008,19 @@ init_EntityObject();
 init_MineRenderError();
 
 // src/export/SceneExporter.ts
-var import_three20 = require("three");
+var import_three19 = require("three");
 
 // ../../node_modules/three/examples/jsm/exporters/OBJExporter.js
 var import_three16 = require("three");
 var OBJExporter = class {
+  /**
+   * Parses the given 3D object and generates the OBJ output.
+   *
+   * If the 3D object is composed of multiple children and geometry, they are merged into a single mesh in the file.
+   *
+   * @param {Object3D} object - The 3D object to export.
+   * @return {string} The exported OBJ.
+   */
   parse(object) {
     let output = "";
     let indexVertex = 0;
@@ -6114,7 +6126,8 @@ var OBJExporter = class {
           vertex.applyMatrix4(points.matrixWorld);
           output += "v " + vertex.x + " " + vertex.y + " " + vertex.z;
           if (colors !== void 0) {
-            color.fromBufferAttribute(colors, i).convertLinearToSRGB();
+            color.fromBufferAttribute(colors, i);
+            import_three16.ColorManagement.workingToColorSpace(color, import_three16.SRGBColorSpace);
             output += " " + color.r + " " + color.g + " " + color.b;
           }
           output += "\n";
@@ -6145,6 +6158,16 @@ var OBJExporter = class {
 // ../../node_modules/three/examples/jsm/exporters/PLYExporter.js
 var import_three17 = require("three");
 var PLYExporter = class {
+  /**
+   * Parses the given 3D object and generates the PLY output.
+   *
+   * If the 3D object is composed of multiple children and geometry, they are merged into a single mesh in the file.
+   *
+   * @param {Object3D} object - The 3D object to export.
+   * @param {PLYExporter~OnDone} onDone - A callback function that is executed when the export has finished.
+   * @param {PLYExporter~Options} options - The export options.
+   * @return {?(string|ArrayBuffer)} The exported PLY.
+   */
   parse(object, onDone, options = {}) {
     function traverseMeshes(cb) {
       object.traverse(function(child) {
@@ -6161,14 +6184,23 @@ var PLYExporter = class {
       binary: false,
       excludeAttributes: [],
       // normal, uv, color, index
-      littleEndian: false
+      littleEndian: false,
+      customPropertyMapping: {}
     };
     options = Object.assign(defaultOptions, options);
     const excludeAttributes = options.excludeAttributes;
+    const customPropertyMapping = options.customPropertyMapping;
+    const customAttributeNames = Object.keys(customPropertyMapping);
     let includeIndices = true;
     let includeNormals = false;
     let includeColors = false;
     let includeUVs = false;
+    let positionType = "float";
+    let normalType = "float";
+    let uvType = "float";
+    let colorType = "uchar";
+    const customTypes = {};
+    for (const name of customAttributeNames) customTypes[name] = "float";
     let vertexCount = 0;
     let faceCount = 0;
     object.traverse(function(child) {
@@ -6185,9 +6217,23 @@ var PLYExporter = class {
         }
         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;
+        positionType = getPlyType(vertices.array);
+        if (normals !== void 0) {
+          includeNormals = true;
+          normalType = getPlyType(normals.array);
+        }
+        if (uvs !== void 0) {
+          includeUVs = true;
+          uvType = getPlyType(uvs.array);
+        }
+        if (colors !== void 0) {
+          includeColors = true;
+          colorType = getPlyType(colors.array);
+        }
+        for (const name of customAttributeNames) {
+          const attr = geometry.getAttribute(name);
+          if (attr !== void 0) customTypes[name] = getPlyType(attr.array);
+        }
       } else if (child.isPoints) {
         const mesh = child;
         const geometry = mesh.geometry;
@@ -6195,8 +6241,19 @@ var PLYExporter = class {
         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;
+        positionType = getPlyType(vertices.array);
+        if (normals !== void 0) {
+          includeNormals = true;
+          normalType = getPlyType(normals.array);
+        }
+        if (colors !== void 0) {
+          includeColors = true;
+          colorType = getPlyType(colors.array);
+        }
+        for (const name of customAttributeNames) {
+          const attr = geometry.getAttribute(name);
+          if (attr !== void 0) customTypes[name] = getPlyType(attr.array);
+        }
         includeIndices = false;
       }
     });
@@ -6215,18 +6272,33 @@ var PLYExporter = class {
     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
+property ${positionType} x
+property ${positionType} y
+property ${positionType} z
 `;
     if (includeNormals === true) {
-      header += "property float nx\nproperty float ny\nproperty float nz\n";
+      header += `property ${normalType} nx
+property ${normalType} ny
+property ${normalType} nz
+`;
     }
     if (includeUVs === true) {
-      header += "property float s\nproperty float t\n";
+      header += `property ${uvType} s
+property ${uvType} t
+`;
     }
     if (includeColors === true) {
-      header += "property uchar red\nproperty uchar green\nproperty uchar blue\n";
+      header += `property ${colorType} red
+property ${colorType} green
+property ${colorType} blue
+`;
+    }
+    for (const name of customAttributeNames) {
+      const type = customTypes[name];
+      for (const propName of customPropertyMapping[name]) {
+        header += `property ${type} ${propName}
+`;
+      }
     }
     if (includeIndices === true) {
       header += `element face ${faceCount}
@@ -6239,7 +6311,23 @@ property list uchar int vertex_index
     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 posWriter = getBinaryWriter(positionType);
+      const normalWriter = includeNormals ? getBinaryWriter(normalType) : null;
+      const uvWriter = includeUVs ? getBinaryWriter(uvType) : null;
+      const colorWriter = includeColors ? getBinaryWriter(colorType) : null;
+      const colorIsFloat = isFloatType(colorType);
+      const colorScale = getColorScale(colorType);
+      const customWriters = {};
+      const customIsFloat = {};
+      let customStride = 0;
+      for (const name of customAttributeNames) {
+        const type = customTypes[name];
+        const writer = getBinaryWriter(type);
+        customWriters[name] = writer;
+        customIsFloat[name] = isFloatType(type);
+        customStride += customPropertyMapping[name].length * writer.size;
+      }
+      const vertexListLength = vertexCount * (3 * posWriter.size + (includeNormals ? 3 * normalWriter.size : 0) + (includeUVs ? 2 * uvWriter.size : 0) + (includeColors ? 3 * colorWriter.size : 0) + customStride);
       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);
@@ -6256,60 +6344,76 @@ property list uchar int vertex_index
         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;
+          posWriter.write(output, vOffset, vertex.x, options.littleEndian);
+          vOffset += posWriter.size;
+          posWriter.write(output, vOffset, vertex.y, options.littleEndian);
+          vOffset += posWriter.size;
+          posWriter.write(output, vOffset, vertex.z, options.littleEndian);
+          vOffset += posWriter.size;
           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;
+              normalWriter.write(output, vOffset, vertex.x, options.littleEndian);
+              vOffset += normalWriter.size;
+              normalWriter.write(output, vOffset, vertex.y, options.littleEndian);
+              vOffset += normalWriter.size;
+              normalWriter.write(output, vOffset, vertex.z, options.littleEndian);
+              vOffset += normalWriter.size;
             } 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;
+              normalWriter.write(output, vOffset, 0, options.littleEndian);
+              vOffset += normalWriter.size;
+              normalWriter.write(output, vOffset, 0, options.littleEndian);
+              vOffset += normalWriter.size;
+              normalWriter.write(output, vOffset, 0, options.littleEndian);
+              vOffset += normalWriter.size;
             }
           }
           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;
+              uvWriter.write(output, vOffset, uvs.getX(i), options.littleEndian);
+              vOffset += uvWriter.size;
+              uvWriter.write(output, vOffset, uvs.getY(i), options.littleEndian);
+              vOffset += uvWriter.size;
             } else {
-              output.setFloat32(vOffset, 0, options.littleEndian);
-              vOffset += 4;
-              output.setFloat32(vOffset, 0, options.littleEndian);
-              vOffset += 4;
+              uvWriter.write(output, vOffset, 0, options.littleEndian);
+              vOffset += uvWriter.size;
+              uvWriter.write(output, vOffset, 0, options.littleEndian);
+              vOffset += uvWriter.size;
             }
           }
           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;
+              tempColor.fromBufferAttribute(colors, i);
+              import_three17.ColorManagement.workingToColorSpace(tempColor, import_three17.SRGBColorSpace);
+              const r = colorIsFloat ? tempColor.r : Math.round(tempColor.r * colorScale);
+              const g = colorIsFloat ? tempColor.g : Math.round(tempColor.g * colorScale);
+              const b = colorIsFloat ? tempColor.b : Math.round(tempColor.b * colorScale);
+              colorWriter.write(output, vOffset, r, options.littleEndian);
+              vOffset += colorWriter.size;
+              colorWriter.write(output, vOffset, g, options.littleEndian);
+              vOffset += colorWriter.size;
+              colorWriter.write(output, vOffset, b, options.littleEndian);
+              vOffset += colorWriter.size;
             } else {
-              output.setUint8(vOffset, 255);
-              vOffset += 1;
-              output.setUint8(vOffset, 255);
-              vOffset += 1;
-              output.setUint8(vOffset, 255);
-              vOffset += 1;
+              const white = colorIsFloat ? 1 : colorScale;
+              colorWriter.write(output, vOffset, white, options.littleEndian);
+              vOffset += colorWriter.size;
+              colorWriter.write(output, vOffset, white, options.littleEndian);
+              vOffset += colorWriter.size;
+              colorWriter.write(output, vOffset, white, options.littleEndian);
+              vOffset += colorWriter.size;
+            }
+          }
+          for (const name of customAttributeNames) {
+            const writer = customWriters[name];
+            const propCount = customPropertyMapping[name].length;
+            const attr = geometry.getAttribute(name);
+            const isFloat = customIsFloat[name];
+            for (let c = 0; c < propCount; c++) {
+              const raw = attr != null ? getAttributeComponent(attr, i, c) : 0;
+              writer.write(output, vOffset, isFloat ? raw : Math.round(raw), options.littleEndian);
+              vOffset += writer.size;
             }
           }
         }
@@ -6345,6 +6449,14 @@ property list uchar int vertex_index
       let writtenVertices = 0;
       let vertexList = "";
       let faceList = "";
+      const positionIsFloat = isFloatType(positionType);
+      const normalIsFloat = isFloatType(normalType);
+      const uvIsFloat = isFloatType(uvType);
+      const colorIsFloat = isFloatType(colorType);
+      const colorScale = getColorScale(colorType);
+      const customIsFloat = {};
+      for (const name of customAttributeNames) customIsFloat[name] = isFloatType(customTypes[name]);
+      const encode = (v, isFloat) => isFloat ? v : Math.round(v);
       traverseMeshes(function(mesh, geometry) {
         const vertices = geometry.getAttribute("position");
         const normals = geometry.getAttribute("normal");
@@ -6355,29 +6467,43 @@ property list uchar int vertex_index
         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;
+          let line = encode(vertex.x, positionIsFloat) + " " + encode(vertex.y, positionIsFloat) + " " + encode(vertex.z, positionIsFloat);
           if (includeNormals === true) {
             if (normals != null) {
               vertex.fromBufferAttribute(normals, i);
               vertex.applyMatrix3(normalMatrixWorld).normalize();
-              line += " " + vertex.x + " " + vertex.y + " " + vertex.z;
+              line += " " + encode(vertex.x, normalIsFloat) + " " + encode(vertex.y, normalIsFloat) + " " + encode(vertex.z, normalIsFloat);
             } else {
               line += " 0 0 0";
             }
           }
           if (includeUVs === true) {
             if (uvs != null) {
-              line += " " + uvs.getX(i) + " " + uvs.getY(i);
+              line += " " + encode(uvs.getX(i), uvIsFloat) + " " + encode(uvs.getY(i), uvIsFloat);
             } 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);
+              tempColor.fromBufferAttribute(colors, i);
+              import_three17.ColorManagement.workingToColorSpace(tempColor, import_three17.SRGBColorSpace);
+              const r = colorIsFloat ? tempColor.r : Math.round(tempColor.r * colorScale);
+              const g = colorIsFloat ? tempColor.g : Math.round(tempColor.g * colorScale);
+              const b = colorIsFloat ? tempColor.b : Math.round(tempColor.b * colorScale);
+              line += ` ${r} ${g} ${b}`;
             } else {
-              line += " 255 255 255";
+              const white = colorIsFloat ? 1 : colorScale;
+              line += ` ${white} ${white} ${white}`;
+            }
+          }
+          for (const name of customAttributeNames) {
+            const propCount = customPropertyMapping[name].length;
+            const attr = geometry.getAttribute(name);
+            const isFloat = customIsFloat[name];
+            for (let c = 0; c < propCount; c++) {
+              const raw = attr != null ? getAttributeComponent(attr, i, c) : 0;
+              line += " " + encode(raw, isFloat);
             }
           }
           vertexList += line + "\n";
@@ -6407,70 +6533,65 @@ property list uchar int vertex_index
     return result;
   }
 };
-
-// ../../node_modules/three/examples/jsm/exporters/GLTFExporter.js
-var import_three19 = require("three");
-
-// ../../node_modules/three/examples/jsm/utils/TextureUtils.js
-var import_three18 = require("three");
-var _renderer;
-var fullscreenQuadGeometry;
-var fullscreenQuadMaterial;
-var fullscreenQuad;
-function decompress(texture, maxTextureSize = Infinity, renderer = null) {
-  if (!fullscreenQuadGeometry) fullscreenQuadGeometry = new import_three18.PlaneGeometry(2, 2, 1, 1);
-  if (!fullscreenQuadMaterial) fullscreenQuadMaterial = new import_three18.ShaderMaterial({
-    uniforms: { blitTexture: new import_three18.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 == import_three18.SRGBColorSpace;
-  fullscreenQuadMaterial.needsUpdate = true;
-  if (!fullscreenQuad) {
-    fullscreenQuad = new import_three18.Mesh(fullscreenQuadGeometry, fullscreenQuadMaterial);
-    fullscreenQuad.frustrumCulled = false;
-  }
-  const _camera = new import_three18.PerspectiveCamera();
-  const _scene = new import_three18.Scene();
-  _scene.add(fullscreenQuad);
-  if (!renderer) {
-    renderer = _renderer = new import_three18.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 import_three18.Texture(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;
+function getPlyType(array) {
+  if (array instanceof Int8Array) return "char";
+  if (array instanceof Uint8Array || array instanceof Uint8ClampedArray) return "uchar";
+  if (array instanceof Int16Array) return "short";
+  if (array instanceof Uint16Array) return "ushort";
+  if (array instanceof Int32Array) return "int";
+  if (array instanceof Uint32Array) return "uint";
+  if (array instanceof Float32Array) return "float";
+  if (array instanceof Float64Array) return "double";
+  return "float";
+}
+function getBinaryWriter(type) {
+  switch (type) {
+    case "char":
+      return { write: (dv, at, v) => dv.setInt8(at, v), size: 1 };
+    case "uchar":
+      return { write: (dv, at, v) => dv.setUint8(at, v), size: 1 };
+    case "short":
+      return { write: (dv, at, v, le) => dv.setInt16(at, v, le), size: 2 };
+    case "ushort":
+      return { write: (dv, at, v, le) => dv.setUint16(at, v, le), size: 2 };
+    case "int":
+      return { write: (dv, at, v, le) => dv.setInt32(at, v, le), size: 4 };
+    case "uint":
+      return { write: (dv, at, v, le) => dv.setUint32(at, v, le), size: 4 };
+    case "float":
+      return { write: (dv, at, v, le) => dv.setFloat32(at, v, le), size: 4 };
+    case "double":
+      return { write: (dv, at, v, le) => dv.setFloat64(at, v, le), size: 8 };
+  }
+}
+function isFloatType(type) {
+  return type === "float" || type === "double";
+}
+function getAttributeComponent(attr, i, c) {
+  switch (c) {
+    case 0:
+      return attr.getX(i);
+    case 1:
+      return attr.getY(i);
+    case 2:
+      return attr.getZ(i);
+    case 3:
+      return attr.getW(i);
+  }
+}
+function getColorScale(type) {
+  switch (type) {
+    case "uchar":
+      return 255;
+    case "ushort":
+      return 65535;
+    default:
+      return 1;
+  }
 }
 
 // ../../node_modules/three/examples/jsm/exporters/GLTFExporter.js
+var import_three18 = require("three");
 var KHR_mesh_quantization_ExtraAttrTypes = {
   POSITION: [
     "byte",
@@ -6500,7 +6621,11 @@ var KHR_mesh_quantization_ExtraAttrTypes = {
   ]
 };
 var GLTFExporter = class {
+  /**
+   * Constructs a new glTF exporter.
+   */
   constructor() {
+    this.textureUtils = null;
     this.pluginCallbacks = [];
     this.register(function(writer) {
       return new GLTFLightExtension(writer);
@@ -6523,6 +6648,9 @@ var GLTFExporter = class {
     this.register(function(writer) {
       return new GLTFMaterialsClearcoatExtension(writer);
     });
+    this.register(function(writer) {
+      return new GLTFMaterialsDispersionExtension(writer);
+    });
     this.register(function(writer) {
       return new GLTFMaterialsIridescenceExtension(writer);
     });
@@ -6535,16 +6663,33 @@ var GLTFExporter = class {
     this.register(function(writer) {
       return new GLTFMaterialsEmissiveStrengthExtension(writer);
     });
+    this.register(function(writer) {
+      return new GLTFMaterialsBumpExtension(writer);
+    });
     this.register(function(writer) {
       return new GLTFMeshGpuInstancing(writer);
     });
   }
+  /**
+   * Registers a plugin callback. This API is internally used to implement the various
+   * glTF extensions but can also used by third-party code to add additional logic
+   * to the exporter.
+   *
+   * @param {function(writer:GLTFWriter)} callback - The callback function to register.
+   * @return {GLTFExporter} A reference to this exporter.
+   */
   register(callback) {
     if (this.pluginCallbacks.indexOf(callback) === -1) {
       this.pluginCallbacks.push(callback);
     }
     return this;
   }
+  /**
+   * Unregisters a plugin callback.
+   *
+   * @param {Function} callback - The callback function to unregister.
+   * @return {GLTFExporter} A reference to this exporter.
+   */
   unregister(callback) {
     if (this.pluginCallbacks.indexOf(callback) !== -1) {
       this.pluginCallbacks.splice(this.pluginCallbacks.indexOf(callback), 1);
@@ -6552,11 +6697,25 @@ var GLTFExporter = class {
     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
+   * Sets the texture utils for this exporter. Only relevant when compressed textures have to be exported.
+   *
+   * Depending on whether you use {@link WebGLRenderer} or {@link WebGPURenderer}, you must inject the
+   * corresponding texture utils {@link module:WebGLTextureUtils} or {@link module:WebGPUTextureUtils}.
+   *
+   * @param {WebGLTextureUtils|WebGPUTextureUtils} utils - The texture utils.
+   * @return {GLTFExporter} A reference to this exporter.
+   */
+  setTextureUtils(utils) {
+    this.textureUtils = utils;
+    return this;
+  }
+  /**
+   * Parses the given scenes and generates the glTF output.
+   *
+   * @param {Scene|Array<Scene>} input - A scene or an array of scenes.
+   * @param {GLTFExporter~OnDone} onDone - A callback function that is executed when the export has finished.
+   * @param {GLTFExporter~OnError} onError - A callback function that is executed when an error happens.
+   * @param {GLTFExporter~Options} options - options
    */
   parse(input, onDone, onError, options) {
     const writer = new GLTFWriter();
@@ -6565,8 +6724,16 @@ var GLTFExporter = class {
       plugins.push(this.pluginCallbacks[i](writer));
     }
     writer.setPlugins(plugins);
-    writer.write(input, onDone, options).catch(onError);
+    writer.setTextureUtils(this.textureUtils);
+    writer.writeAsync(input, onDone, options).catch(onError);
   }
+  /**
+   * Async version of {@link GLTFExporter#parse}.
+   *
+   * @param {Scene|Array<Scene>} input - A scene or an array of scenes.
+   * @param {GLTFExporter~Options} options - options.
+   * @return {Promise<ArrayBuffer|string>} A Promise that resolved with the exported glTF data.
+   */
   parseAsync(input, options) {
     const scope = this;
     return new Promise(function(resolve, reject) {
@@ -6603,22 +6770,22 @@ var WEBGL_CONSTANTS = {
 };
 var KHR_MESH_QUANTIZATION = "KHR_mesh_quantization";
 var THREE_TO_WEBGL = {};
-THREE_TO_WEBGL[import_three19.NearestFilter] = WEBGL_CONSTANTS.NEAREST;
-THREE_TO_WEBGL[import_three19.NearestMipmapNearestFilter] = WEBGL_CONSTANTS.NEAREST_MIPMAP_NEAREST;
-THREE_TO_WEBGL[import_three19.NearestMipmapLinearFilter] = WEBGL_CONSTANTS.NEAREST_MIPMAP_LINEAR;
-THREE_TO_WEBGL[import_three19.LinearFilter] = WEBGL_CONSTANTS.LINEAR;
-THREE_TO_WEBGL[import_three19.LinearMipmapNearestFilter] = WEBGL_CONSTANTS.LINEAR_MIPMAP_NEAREST;
-THREE_TO_WEBGL[import_three19.LinearMipmapLinearFilter] = WEBGL_CONSTANTS.LINEAR_MIPMAP_LINEAR;
-THREE_TO_WEBGL[import_three19.ClampToEdgeWrapping] = WEBGL_CONSTANTS.CLAMP_TO_EDGE;
-THREE_TO_WEBGL[import_three19.RepeatWrapping] = WEBGL_CONSTANTS.REPEAT;
-THREE_TO_WEBGL[import_three19.MirroredRepeatWrapping] = WEBGL_CONSTANTS.MIRRORED_REPEAT;
+THREE_TO_WEBGL[import_three18.NearestFilter] = WEBGL_CONSTANTS.NEAREST;
+THREE_TO_WEBGL[import_three18.NearestMipmapNearestFilter] = WEBGL_CONSTANTS.NEAREST_MIPMAP_NEAREST;
+THREE_TO_WEBGL[import_three18.NearestMipmapLinearFilter] = WEBGL_CONSTANTS.NEAREST_MIPMAP_LINEAR;
+THREE_TO_WEBGL[import_three18.LinearFilter] = WEBGL_CONSTANTS.LINEAR;
+THREE_TO_WEBGL[import_three18.LinearMipmapNearestFilter] = WEBGL_CONSTANTS.LINEAR_MIPMAP_NEAREST;
+THREE_TO_WEBGL[import_three18.LinearMipmapLinearFilter] = WEBGL_CONSTANTS.LINEAR_MIPMAP_LINEAR;
+THREE_TO_WEBGL[import_three18.ClampToEdgeWrapping] = WEBGL_CONSTANTS.CLAMP_TO_EDGE;
+THREE_TO_WEBGL[import_three18.RepeatWrapping] = WEBGL_CONSTANTS.REPEAT;
+THREE_TO_WEBGL[import_three18.MirroredRepeatWrapping] = WEBGL_CONSTANTS.MIRRORED_REPEAT;
 var PATH_PROPERTIES = {
   scale: "scale",
   position: "translation",
   quaternion: "rotation",
   morphTargetInfluences: "weights"
 };
-var DEFAULT_SPECULAR_COLOR = new import_three19.Color();
+var DEFAULT_SPECULAR_COLOR = new import_three18.Color();
 var GLB_HEADER_BYTES = 12;
 var GLB_HEADER_MAGIC = 1179937895;
 var GLB_VERSION = 2;
@@ -6652,7 +6819,7 @@ function getMinMax(attribute, start, count) {
         else if (a === 2) value = attribute.getZ(i);
         else if (a === 3) value = attribute.getW(i);
         if (attribute.normalized === true) {
-          value = import_three19.MathUtils.normalize(value, attribute.array);
+          value = import_three18.MathUtils.normalize(value, attribute.array);
         }
       }
       output.min[a] = Math.min(output.min[a], value);
@@ -6685,19 +6852,20 @@ function getCanvas() {
   return document.createElement("canvas");
 }
 function getToBlobPromise(canvas, mimeType) {
-  if (canvas.toBlob !== void 0) {
+  if (typeof OffscreenCanvas !== "undefined" && canvas instanceof OffscreenCanvas) {
+    let quality;
+    if (mimeType === "image/jpeg") {
+      quality = 0.92;
+    } else if (mimeType === "image/webp") {
+      quality = 0.8;
+    }
+    return canvas.convertToBlob({
+      type: mimeType,
+      quality
+    });
+  } else {
     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() {
@@ -6716,7 +6884,7 @@ var GLTFWriter = class {
     this.json = {
       asset: {
         version: "2.0",
-        generator: "THREE.GLTFExporter"
+        generator: "THREE.GLTFExporter r" + import_three18.REVISION
       }
     };
     this.cache = {
@@ -6725,19 +6893,25 @@ var GLTFWriter = class {
       attributesNormalized: /* @__PURE__ */ new Map(),
       materials: /* @__PURE__ */ new Map(),
       textures: /* @__PURE__ */ new Map(),
-      images: /* @__PURE__ */ new Map()
+      images: /* @__PURE__ */ new Map(),
+      normalMaps: /* @__PURE__ */ new Map()
     };
+    this.textureUtils = null;
   }
   setPlugins(plugins) {
     this.plugins = plugins;
   }
+  setTextureUtils(utils) {
+    this.textureUtils = utils;
+  }
   /**
    * 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
+   *
+   * @param {Scene|Array<Scene>} input Scene or Array of THREE.Scenes
+   * @param {Function} onDone Callback on completed
+   * @param {Object} options options
    */
-  async write(input, onDone, options = {}) {
+  async writeAsync(input, onDone, options = {}) {
     this.options = Object.assign({
       // default options
       binary: false,
@@ -6745,12 +6919,13 @@ var GLTFWriter = class {
       onlyVisible: true,
       maxTextureSize: Infinity,
       animations: [],
-      includeCustomExtensions: false
+      includeCustomExtensions: false,
+      copyright: null
     }, options);
     if (this.options.animations.length > 0) {
       this.options.trs = true;
     }
-    this.processInput(input);
+    await this.processInputAsync(input);
     await Promise.all(this.pending);
     const writer = this;
     const buffers = writer.buffers;
@@ -6764,6 +6939,7 @@ var GLTFWriter = class {
     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.copyright) json.asset.copyright = options.copyright;
     if (options.binary === true) {
       const reader = new FileReader();
       reader.readAsArrayBuffer(blob);
@@ -6812,7 +6988,7 @@ var GLTFWriter = class {
   /**
    * Serializes a userData.
    *
-   * @param {THREE.Object3D|THREE.Material} object
+   * @param {THREE.Object3D|THREE.Material|THREE.BufferGeometry|THREE.AnimationClip} object
    * @param {Object} objectDef
    */
   serializeUserData(object, objectDef) {
@@ -6836,8 +7012,10 @@ var GLTFWriter = class {
   }
   /**
    * Returns ids for buffer attributes.
-   * @param  {Object} object
-   * @return {Integer}
+   *
+   * @param {Object} attribute
+   * @param {boolean} [isRelativeCopy=false]
+   * @return {number} An integer
    */
   getUID(attribute, isRelativeCopy = false) {
     if (this.uids.has(attribute) === false) {
@@ -6853,12 +7031,12 @@ var GLTFWriter = class {
    * Checks if normal attribute values are normalized.
    *
    * @param {BufferAttribute} normal
-   * @returns {Boolean}
+   * @returns {boolean}
    */
   isNormalizedNormalAttribute(normal) {
     const cache = this.cache;
     if (cache.attributesNormalized.has(normal)) return false;
-    const v = new import_three19.Vector3();
+    const v = new import_three18.Vector3();
     for (let i = 0, il = normal.count; i < il; i++) {
       if (Math.abs(v.fromBufferAttribute(normal, i).length() - 1) > 5e-4) return false;
     }
@@ -6875,7 +7053,7 @@ var GLTFWriter = class {
     const cache = this.cache;
     if (cache.attributesNormalized.has(normal)) return cache.attributesNormalized.get(normal);
     const attribute = normal.clone();
-    const v = new import_three19.Vector3();
+    const v = new import_three18.Vector3();
     for (let i = 0, il = attribute.count; i < il; i++) {
       v.fromBufferAttribute(attribute, i);
       if (v.x === 0 && v.y === 0 && v.z === 0) {
@@ -6916,10 +7094,10 @@ var GLTFWriter = class {
       this.extensionsUsed["KHR_texture_transform"] = true;
     }
   }
-  buildMetalRoughTexture(metalnessMap, roughnessMap) {
+  async buildMetalRoughTextureAsync(metalnessMap, roughnessMap) {
     if (metalnessMap === roughnessMap) return metalnessMap;
     function getEncodingConversion(map) {
-      if (map.colorSpace === import_three19.SRGBColorSpace) {
+      if (map.colorSpace === import_three18.SRGBColorSpace) {
         return function SRGBToLinear(c) {
           return c < 0.04045 ? c * 0.0773993808 : Math.pow(c * 0.9478672986 + 0.0521327014, 2.4);
         };
@@ -6928,12 +7106,11 @@ var GLTFWriter = class {
         return c;
       };
     }
-    console.warn("THREE.GLTFExporter: Merged metalnessMap and roughnessMap textures.");
-    if (metalnessMap instanceof import_three19.CompressedTexture) {
-      metalnessMap = decompress(metalnessMap);
+    if (metalnessMap instanceof import_three18.CompressedTexture) {
+      metalnessMap = await this.decompressTextureAsync(metalnessMap);
     }
-    if (roughnessMap instanceof import_three19.CompressedTexture) {
-      roughnessMap = decompress(roughnessMap);
+    if (roughnessMap instanceof import_three18.CompressedTexture) {
+      roughnessMap = await this.decompressTextureAsync(roughnessMap);
     }
     const metalness = metalnessMap ? metalnessMap.image : null;
     const roughness = roughnessMap ? roughnessMap.image : null;
@@ -6942,7 +7119,9 @@ var GLTFWriter = class {
     const canvas = getCanvas();
     canvas.width = width;
     canvas.height = height;
-    const context = canvas.getContext("2d");
+    const context = canvas.getContext("2d", {
+      willReadFrequently: true
+    });
     context.fillStyle = "#00ffff";
     context.fillRect(0, 0, width, height);
     const composite = context.getImageData(0, 0, width, height);
@@ -6965,18 +7144,60 @@ var GLTFWriter = class {
     context.putImageData(composite, 0, 0);
     const reference = metalnessMap || roughnessMap;
     const texture = reference.clone();
-    texture.source = new import_three19.Source(canvas);
-    texture.colorSpace = import_three19.NoColorSpace;
+    texture.source = new import_three18.TextureSource(canvas);
+    texture.colorSpace = import_three18.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.");
     }
+    console.warn("THREE.GLTFExporter: Merged metalnessMap and roughnessMap textures.");
+    return texture;
+  }
+  /**
+   * Builds a copy of the given normal map with the red and/or green channels
+   * inverted (`color = 255 - color`). This is used to bake the sign of
+   * `material.normalScale` and the tangent-space convention into the texture,
+   * since glTF only supports OpenGL-style normal maps with a univariate,
+   * positive scale.
+   *
+   * @param {THREE.Texture} normalMap The source normal map.
+   * @param {boolean} flipX Whether to invert the red channel (normal X).
+   * @param {boolean} flipY Whether to invert the green channel (normal Y).
+   * @return {Promise<THREE.Texture>} The derived normal map texture.
+   */
+  async buildNormalMapTextureAsync(normalMap, flipX, flipY) {
+    if (normalMap instanceof import_three18.CompressedTexture) {
+      normalMap = await this.decompressTextureAsync(normalMap);
+    }
+    const image = normalMap.image;
+    const canvas = getCanvas();
+    canvas.width = image.width;
+    canvas.height = image.height;
+    const context = canvas.getContext("2d", {
+      willReadFrequently: true
+    });
+    context.drawImage(image, 0, 0, canvas.width, canvas.height);
+    const imageData = context.getImageData(0, 0, canvas.width, canvas.height);
+    const data = imageData.data;
+    for (let i = 0; i < data.length; i += 4) {
+      if (flipX) data[i + 0] = 255 - data[i + 0];
+      if (flipY) data[i + 1] = 255 - data[i + 1];
+    }
+    context.putImageData(imageData, 0, 0);
+    const texture = normalMap.clone();
+    texture.source = new import_three18.TextureSource(canvas);
     return texture;
   }
+  async decompressTextureAsync(texture, maxTextureSize = Infinity) {
+    if (this.textureUtils === null) {
+      throw new Error("THREE.GLTFExporter: setTextureUtils() must be called to process compressed textures.");
+    }
+    return await this.textureUtils.decompress(texture, maxTextureSize);
+  }
   /**
    * Process a buffer to append to the default one.
-   * @param  {ArrayBuffer} buffer
-   * @return {Integer}
+   * @param {ArrayBuffer} buffer
+   * @return {0}
    */
   processBuffer(buffer) {
     const json = this.json;
@@ -6987,11 +7208,11 @@ var GLTFWriter = class {
   }
   /**
    * 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
+   * @param {BufferAttribute} attribute
+   * @param {number} componentType
+   * @param {number} start
+   * @param {number} count
+   * @param {number} [target] Target usage of the BufferView
    * @return {Object}
    */
   processBufferView(attribute, componentType, start, count, target) {
@@ -7010,7 +7231,11 @@ var GLTFWriter = class {
       default:
         componentSize = 4;
     }
-    const byteLength = getPaddedBufferSize(count * attribute.itemSize * componentSize);
+    let byteStride = attribute.itemSize * componentSize;
+    if (target === WEBGL_CONSTANTS.ARRAY_BUFFER) {
+      byteStride = Math.ceil(byteStride / 4) * 4;
+    }
+    const byteLength = getPaddedBufferSize(count * byteStride);
     const dataView = new DataView(new ArrayBuffer(byteLength));
     let offset = 0;
     for (let i = start; i < start + count; i++) {
@@ -7024,7 +7249,7 @@ var GLTFWriter = class {
           else if (a === 2) value = attribute.getZ(i);
           else if (a === 3) value = attribute.getW(i);
           if (attribute.normalized === true) {
-            value = import_three19.MathUtils.normalize(value, attribute.array);
+            value = import_three18.MathUtils.normalize(value, attribute.array);
           }
         }
         if (componentType === WEBGL_CONSTANTS.FLOAT) {
@@ -7044,6 +7269,9 @@ var GLTFWriter = class {
         }
         offset += componentSize;
       }
+      if (offset % byteStride !== 0) {
+        offset += byteStride - offset % byteStride;
+      }
     }
     const bufferViewDef = {
       buffer: this.processBuffer(dataView.buffer),
@@ -7052,7 +7280,7 @@ var GLTFWriter = class {
     };
     if (target !== void 0) bufferViewDef.target = target;
     if (target === WEBGL_CONSTANTS.ARRAY_BUFFER) {
-      bufferViewDef.byteStride = attribute.itemSize * componentSize;
+      bufferViewDef.byteStride = byteStride;
     }
     this.byteOffset += byteLength;
     json.bufferViews.push(bufferViewDef);
@@ -7065,7 +7293,7 @@ var GLTFWriter = class {
   /**
    * Process and generate a BufferView from an image Blob.
    * @param {Blob} blob
-   * @return {Promise<Integer>}
+   * @return {Promise<number>} An integer
    */
   processBufferViewImage(blob) {
     const writer = this;
@@ -7088,11 +7316,11 @@ var GLTFWriter = class {
   }
   /**
    * 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
+   * @param {BufferAttribute} attribute Attribute to process
+   * @param {?BufferGeometry} [geometry] Geometry used for truncated draw range
+   * @param {number} [start=0]
+   * @param {number} [count=Infinity]
+   * @return {?number} Index of the processed accessor on the "accessors" array
    */
   processAccessor(attribute, geometry, start, count) {
     const json = this.json;
@@ -7146,11 +7374,11 @@ var GLTFWriter = class {
   }
   /**
    * 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
+   * @param {Image} image to process
+   * @param {number} format Identifier of the format (RGBAFormat)
+   * @param {boolean} flipY before writing out the image
+   * @param {string} mimeType export format
+   * @return {number}     Index of the processed texture in the "images" array
    */
   processImage(image, format, flipY, mimeType = "image/png") {
     if (image !== null) {
@@ -7168,13 +7396,15 @@ var GLTFWriter = class {
       const canvas = getCanvas();
       canvas.width = Math.min(image.width, options.maxTextureSize);
       canvas.height = Math.min(image.height, options.maxTextureSize);
-      const ctx = canvas.getContext("2d");
+      const ctx = canvas.getContext("2d", {
+        willReadFrequently: true
+      });
       if (flipY === true) {
         ctx.translate(0, canvas.height);
         ctx.scale(1, -1);
       }
       if (image.data !== void 0) {
-        if (format !== import_three19.RGBAFormat) {
+        if (format !== import_three18.RGBAFormat) {
           console.error("GLTFExporter: Only RGBAFormat is supported.", format);
         }
         if (image.width > options.maxTextureSize || image.height > options.maxTextureSize) {
@@ -7189,7 +7419,11 @@ var GLTFWriter = class {
         }
         ctx.putImageData(new ImageData(data, image.width, image.height), 0, 0);
       } else {
-        ctx.drawImage(image, 0, 0, canvas.width, canvas.height);
+        if (typeof HTMLImageElement !== "undefined" && image instanceof HTMLImageElement || typeof HTMLCanvasElement !== "undefined" && image instanceof HTMLCanvasElement || typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap || typeof OffscreenCanvas !== "undefined" && image instanceof OffscreenCanvas) {
+          ctx.drawImage(image, 0, 0, canvas.width, canvas.height);
+        } else {
+          throw new Error("THREE.GLTFExporter: Invalid image type. Use HTMLImageElement, HTMLCanvasElement, ImageBitmap or OffscreenCanvas.");
+        }
       }
       if (options.binary === true) {
         pending.push(
@@ -7198,15 +7432,7 @@ var GLTFWriter = class {
           })
         );
       } 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;
-            })
-          );
-        }
+        imageDef.uri = import_three18.ImageUtils.getDataURL(canvas, mimeType);
       }
       const index = json.images.push(imageDef) - 1;
       cachedImages[key] = index;
@@ -7217,8 +7443,8 @@ var GLTFWriter = class {
   }
   /**
    * Process sampler
-   * @param  {Texture} map Texture to process
-   * @return {Integer}     Index of the processed texture in the "samplers" array
+   * @param {Texture} map Texture to process
+   * @return {number}      Index of the processed texture in the "samplers" array
    */
   processSampler(map) {
     const json = this.json;
@@ -7233,28 +7459,37 @@ var GLTFWriter = class {
   }
   /**
    * Process texture
-   * @param  {Texture} map Map to process
-   * @return {Integer} Index of the processed texture in the "textures" array
+   * @param {Texture} map Map to process
+   * @return {Promise<number>} Index of the processed texture in the "textures" array
    */
-  processTexture(map) {
+  async processTextureAsync(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 import_three19.CompressedTexture) {
-      map = decompress(map, options.maxTextureSize);
+    if (map instanceof import_three18.CompressedTexture) {
+      map = await this.decompressTextureAsync(map, options.maxTextureSize);
     }
-    let mimeType = map.userData.mimeType;
-    if (mimeType === "image/webp") mimeType = "image/png";
+    const mimeType = map.userData.mimeType;
+    const imageIndex = this.processImage(map.image, map.format, map.flipY, mimeType);
     const textureDef = {
-      sampler: this.processSampler(map),
-      source: this.processImage(map.image, map.format, map.flipY, mimeType)
+      sampler: this.processSampler(map)
     };
+    if (mimeType === "image/webp") {
+      textureDef.extensions = textureDef.extensions || {};
+      textureDef.extensions["EXT_texture_webp"] = {
+        source: imageIndex
+      };
+      this.extensionsUsed["EXT_texture_webp"] = true;
+      this.extensionsRequired["EXT_texture_webp"] = true;
+    } else {
+      textureDef.source = imageIndex;
+    }
     if (map.name) textureDef.name = map.name;
-    this._invokeAll(function(ext) {
-      ext.writeTexture && ext.writeTexture(map, textureDef);
+    await this._invokeAllAsync(async function(ext) {
+      ext.writeTexture && await ext.writeTexture(map, textureDef);
     });
     const index = json.textures.push(textureDef) - 1;
     cache.textures.set(map, index);
@@ -7262,13 +7497,16 @@ var GLTFWriter = class {
   }
   /**
    * Process material
-   * @param  {THREE.Material} material Material to process
-   * @return {Integer|null} Index of the processed material in the "materials" array
+   * @param {THREE.Material} material Material to process
+   * @param {THREE.BufferGeometry} [geometry] Geometry the material is used with.
+   * @return {Promise<?number>} Index of the processed material in the "materials" array
    */
-  processMaterial(material) {
+  async processMaterialAsync(material, geometry) {
     const cache = this.cache;
     const json = this.json;
-    if (cache.materials.has(material)) return cache.materials.get(material);
+    const hasTangent = geometry !== void 0 && geometry.hasAttribute("tangent");
+    const cacheKey = material.normalMap ? material.uuid + ":" + hasTangent : material.uuid;
+    if (cache.materials.has(cacheKey)) return cache.materials.get(cacheKey);
     if (material.isShaderMaterial) {
       console.warn("GLTFExporter: THREE.ShaderMaterial not supported.");
       return null;
@@ -7286,21 +7524,21 @@ var GLTFWriter = class {
       materialDef.pbrMetallicRoughness.metallicFactor = material.metalness;
       materialDef.pbrMetallicRoughness.roughnessFactor = material.roughness;
     } else {
-      materialDef.pbrMetallicRoughness.metallicFactor = 0.5;
-      materialDef.pbrMetallicRoughness.roughnessFactor = 0.5;
+      materialDef.pbrMetallicRoughness.metallicFactor = 0;
+      materialDef.pbrMetallicRoughness.roughnessFactor = 1;
     }
     if (material.metalnessMap || material.roughnessMap) {
-      const metalRoughTexture = this.buildMetalRoughTexture(material.metalnessMap, material.roughnessMap);
+      const metalRoughTexture = await this.buildMetalRoughTextureAsync(material.metalnessMap, material.roughnessMap);
       const metalRoughMapDef = {
-        index: this.processTexture(metalRoughTexture),
-        channel: metalRoughTexture.channel
+        index: await this.processTextureAsync(metalRoughTexture),
+        texCoord: metalRoughTexture.channel
       };
       this.applyTextureTransform(metalRoughMapDef, metalRoughTexture);
       materialDef.pbrMetallicRoughness.metallicRoughnessTexture = metalRoughMapDef;
     }
     if (material.map) {
       const baseColorMapDef = {
-        index: this.processTexture(material.map),
+        index: await this.processTextureAsync(material.map),
         texCoord: material.map.channel
       };
       this.applyTextureTransform(baseColorMapDef, material.map);
@@ -7314,7 +7552,7 @@ var GLTFWriter = class {
       }
       if (material.emissiveMap) {
         const emissiveMapDef = {
-          index: this.processTexture(material.emissiveMap),
+          index: await this.processTextureAsync(material.emissiveMap),
           texCoord: material.emissiveMap.channel
         };
         this.applyTextureTransform(emissiveMapDef, material.emissiveMap);
@@ -7322,19 +7560,32 @@ var GLTFWriter = class {
       }
     }
     if (material.normalMap) {
+      const normalScale = material.normalScale;
+      const flipX = normalScale.x < 0;
+      const flipY = hasTangent ? normalScale.y < 0 : normalScale.y > 0;
+      let normalMap = material.normalMap;
+      if (flipX || flipY) {
+        if (cache.normalMaps.has(material.normalMap) === false) cache.normalMaps.set(material.normalMap, {});
+        const cachedVariants = cache.normalMaps.get(material.normalMap);
+        const cacheKey2 = `${flipX}:${flipY}`;
+        if (cachedVariants[cacheKey2] === void 0) {
+          cachedVariants[cacheKey2] = await this.buildNormalMapTextureAsync(material.normalMap, flipX, flipY);
+        }
+        normalMap = cachedVariants[cacheKey2];
+      }
       const normalMapDef = {
-        index: this.processTexture(material.normalMap),
+        index: await this.processTextureAsync(normalMap),
         texCoord: material.normalMap.channel
       };
-      if (material.normalScale && material.normalScale.x !== 1) {
-        normalMapDef.scale = material.normalScale.x;
+      if (Math.abs(normalScale.x) !== 1) {
+        normalMapDef.scale = Math.abs(normalScale.x);
       }
       this.applyTextureTransform(normalMapDef, material.normalMap);
       materialDef.normalTexture = normalMapDef;
     }
     if (material.aoMap) {
       const occlusionMapDef = {
-        index: this.processTexture(material.aoMap),
+        index: await this.processTextureAsync(material.aoMap),
         texCoord: material.aoMap.channel
       };
       if (material.aoMapIntensity !== 1) {
@@ -7351,22 +7602,22 @@ var GLTFWriter = class {
         materialDef.alphaCutoff = material.alphaTest;
       }
     }
-    if (material.side === import_three19.DoubleSide) materialDef.doubleSided = true;
+    if (material.side === import_three18.DoubleSide) materialDef.doubleSided = true;
     if (material.name !== "") materialDef.name = material.name;
     this.serializeUserData(material, materialDef);
-    this._invokeAll(function(ext) {
-      ext.writeMaterial && ext.writeMaterial(material, materialDef);
+    await this._invokeAllAsync(async function(ext) {
+      ext.writeMaterialAsync && await ext.writeMaterialAsync(material, materialDef);
     });
     const index = json.materials.push(materialDef) - 1;
-    cache.materials.set(material, index);
+    cache.materials.set(cacheKey, index);
     return index;
   }
   /**
    * Process mesh
-   * @param  {THREE.Mesh} mesh Mesh to process
-   * @return {Integer|null} Index of the processed mesh in the "meshes" array
+   * @param {THREE.Mesh} mesh Mesh to process
+   * @return {Promise<?number>} Index of the processed mesh in the "meshes" array
    */
-  processMesh(mesh) {
+  async processMeshAsync(mesh) {
     const cache = this.cache;
     const json = this.json;
     const meshCacheKeyParts = [mesh.geometry.uuid];
@@ -7416,7 +7667,7 @@ var GLTFWriter = class {
       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 (!validVertexAttributes.test(attributeName) && !attributeName.startsWith("_")) attributeName = "_" + attributeName;
       if (cache.attributes.has(this.getUID(attribute))) {
         attributes[attributeName] = cache.attributes.get(this.getUID(attribute));
         continue;
@@ -7425,7 +7676,10 @@ var GLTFWriter = class {
       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 import_three19.BufferAttribute(new Uint16Array(array), attribute.itemSize, attribute.normalized);
+        modifiedAttribute = GLTFExporter.Utils.toTypedBufferAttribute(attribute, Uint16Array);
+      } else if ((array instanceof Uint32Array || array instanceof Int32Array) && !attributeName.startsWith("_")) {
+        console.warn(`GLTFExporter: Attribute "${attributeName}" converted to type FLOAT.`);
+        modifiedAttribute = GLTFExporter.Utils.toTypedBufferAttribute(attribute, Float32Array);
       }
       const accessor = this.processAccessor(modifiedAttribute || attribute, geometry);
       if (accessor !== null) {
@@ -7491,6 +7745,15 @@ var GLTFWriter = class {
     }
     const isMultiMaterial = Array.isArray(mesh.material);
     if (isMultiMaterial && geometry.groups.length === 0) return null;
+    let didForceIndices = false;
+    if (isMultiMaterial && geometry.index === null) {
+      const indices = [];
+      for (let i = 0, il = geometry.attributes.position.count; i < il; i++) {
+        indices[i] = i;
+      }
+      geometry.setIndex(indices);
+      didForceIndices = true;
+    }
     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++) {
@@ -7513,13 +7776,16 @@ var GLTFWriter = class {
         }
         if (primitive.indices === null) delete primitive.indices;
       }
-      const material = this.processMaterial(materials[groups[i].materialIndex]);
+      const material = await this.processMaterialAsync(materials[groups[i].materialIndex], geometry);
       if (material !== null) primitive.material = material;
       primitives.push(primitive);
     }
+    if (didForceIndices === true) {
+      geometry.setIndex(null);
+    }
     meshDef.primitives = primitives;
     if (!json.meshes) json.meshes = [];
-    this._invokeAll(function(ext) {
+    await this._invokeAllAsync(function(ext) {
       ext.writeMesh && ext.writeMesh(mesh, meshDef);
     });
     const index = json.meshes.push(meshDef) - 1;
@@ -7565,8 +7831,8 @@ var GLTFWriter = class {
   }
   /**
    * Process camera
-   * @param  {THREE.Camera} camera Camera to process
-   * @return {Integer}      Index of the processed mesh in the "camera" array
+   * @param {THREE.Camera} camera Camera to process
+   * @return {number} Index of the processed mesh in the "camera" array
    */
   processCamera(camera) {
     const json = this.json;
@@ -7585,7 +7851,7 @@ var GLTFWriter = class {
     } else {
       cameraDef.perspective = {
         aspectRatio: camera.aspect,
-        yfov: import_three19.MathUtils.degToRad(camera.fov),
+        yfov: import_three18.MathUtils.degToRad(camera.fov),
         zfar: camera.far <= 0 ? 1e-3 : camera.far,
         znear: camera.near < 0 ? 0 : camera.near
       };
@@ -7601,7 +7867,7 @@ var GLTFWriter = class {
    *
    * @param {THREE.AnimationClip} clip
    * @param {THREE.Object3D} root
-   * @return {number|null}
+   * @return {?number}
    */
   processAnimation(clip, root) {
     const json = this.json;
@@ -7613,8 +7879,8 @@ var GLTFWriter = class {
     const samplers = [];
     for (let i = 0; i < tracks.length; ++i) {
       const track = tracks[i];
-      const trackBinding = import_three19.PropertyBinding.parseTrackName(track.name);
-      let trackNode = import_three19.PropertyBinding.findNode(root, trackBinding.nodeName);
+      const trackBinding = import_three18.PropertyBinding.parseTrackName(track.name);
+      let trackNode = import_three18.PropertyBinding.findNode(root, trackBinding.nodeName);
       const trackProperty = PATH_PROPERTIES[trackBinding.propertyName];
       if (trackBinding.objectName === "bones") {
         if (trackNode.isSkinnedMesh === true) {
@@ -7625,7 +7891,7 @@ var GLTFWriter = class {
       }
       if (!trackNode || !trackProperty) {
         console.warn('THREE.GLTFExporter: Could not export animation track "%s".', track.name);
-        return null;
+        continue;
       }
       const inputItemSize = 1;
       let outputItemSize = track.values.length / track.times.length;
@@ -7636,14 +7902,14 @@ var GLTFWriter = class {
       if (track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline === true) {
         interpolation = "CUBICSPLINE";
         outputItemSize /= 3;
-      } else if (track.getInterpolation() === import_three19.InterpolateDiscrete) {
+      } else if (track.getInterpolation() === import_three18.InterpolateDiscrete) {
         interpolation = "STEP";
       } else {
         interpolation = "LINEAR";
       }
       samplers.push({
-        input: this.processAccessor(new import_three19.BufferAttribute(track.times, inputItemSize)),
-        output: this.processAccessor(new import_three19.BufferAttribute(track.values, outputItemSize)),
+        input: this.processAccessor(new import_three18.BufferAttribute(track.times, inputItemSize)),
+        output: this.processAccessor(new import_three18.BufferAttribute(track.values, outputItemSize)),
         interpolation
       });
       channels.push({
@@ -7654,16 +7920,18 @@ var GLTFWriter = class {
         }
       });
     }
-    json.animations.push({
+    const animationDef = {
       name: clip.name || "clip_" + json.animations.length,
       samplers,
       channels
-    });
+    };
+    this.serializeUserData(clip, animationDef);
+    json.animations.push(animationDef);
     return json.animations.length - 1;
   }
   /**
    * @param {THREE.Object3D} object
-   * @return {number|null}
+   * @return {?number}
    */
   processSkin(object) {
     const json = this.json;
@@ -7675,7 +7943,7 @@ var GLTFWriter = class {
     if (rootJoint === void 0) return null;
     const joints = [];
     const inverseBindMatrices = new Float32Array(skeleton.bones.length * 16);
-    const temporaryBoneInverse = new import_three19.Matrix4();
+    const temporaryBoneInverse = new import_three18.Matrix4();
     for (let i = 0; i < skeleton.bones.length; ++i) {
       joints.push(nodeMap.get(skeleton.bones[i]));
       temporaryBoneInverse.copy(skeleton.boneInverses[i]);
@@ -7683,7 +7951,7 @@ var GLTFWriter = class {
     }
     if (json.skins === void 0) json.skins = [];
     json.skins.push({
-      inverseBindMatrices: this.processAccessor(new import_three19.BufferAttribute(inverseBindMatrices, 16)),
+      inverseBindMatrices: this.processAccessor(new import_three18.BufferAttribute(inverseBindMatrices, 16)),
       joints,
       skeleton: nodeMap.get(rootJoint)
     });
@@ -7692,14 +7960,17 @@ var GLTFWriter = class {
   }
   /**
    * Process Object3D node
-   * @param  {THREE.Object3D} node Object3D to processNode
-   * @return {Integer} Index of the node in the nodes list
+   * @param {THREE.Object3D} object Object3D to processNodeAsync
+   * @return {Promise<number>} Index of the node in the nodes list
    */
-  processNode(object) {
+  async processNodeAsync(object) {
     const json = this.json;
     const options = this.options;
     const nodeMap = this.nodeMap;
     if (!json.nodes) json.nodes = [];
+    if (object.pivot !== null) {
+      return await this._processNodeWithPivotAsync(object);
+    }
     const nodeDef = {};
     if (options.trs) {
       const rotation = object.quaternion.toArray();
@@ -7725,35 +7996,98 @@ var GLTFWriter = class {
     if (object.name !== "") nodeDef.name = String(object.name);
     this.serializeUserData(object, nodeDef);
     if (object.isMesh || object.isLine || object.isPoints) {
-      const meshIndex = this.processMesh(object);
+      const meshIndex = await this.processMeshAsync(object);
       if (meshIndex !== null) nodeDef.mesh = meshIndex;
     } else if (object.isCamera) {
       nodeDef.camera = this.processCamera(object);
     }
     if (object.isSkinnedMesh) this.skins.push(object);
+    const nodeIndex = json.nodes.push(nodeDef) - 1;
+    nodeMap.set(object, nodeIndex);
     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);
+          const childNodeIndex = await this.processNodeAsync(child);
+          if (childNodeIndex !== null) children.push(childNodeIndex);
         }
       }
       if (children.length > 0) nodeDef.children = children;
     }
-    this._invokeAll(function(ext) {
+    await this._invokeAllAsync(function(ext) {
       ext.writeNode && ext.writeNode(object, nodeDef);
     });
-    const nodeIndex = json.nodes.push(nodeDef) - 1;
-    nodeMap.set(object, nodeIndex);
     return nodeIndex;
   }
+  /**
+   * Process Object3D node with pivot using container approach
+   * @param {THREE.Object3D} object Object3D with pivot
+   * @return {Promise<number>} Index of the container node
+   */
+  async _processNodeWithPivotAsync(object) {
+    const json = this.json;
+    const options = this.options;
+    const nodeMap = this.nodeMap;
+    const pivot = object.pivot;
+    const containerDef = {};
+    const rotation = object.quaternion.toArray();
+    const position = [
+      object.position.x + pivot.x,
+      object.position.y + pivot.y,
+      object.position.z + pivot.z
+    ];
+    const scale = object.scale.toArray();
+    if (!equalArray(rotation, [0, 0, 0, 1])) {
+      containerDef.rotation = rotation;
+    }
+    if (!equalArray(position, [0, 0, 0])) {
+      containerDef.translation = position;
+    }
+    if (!equalArray(scale, [1, 1, 1])) {
+      containerDef.scale = scale;
+    }
+    containerDef.extras = { pivot: pivot.toArray() };
+    if (object.name !== "") containerDef.name = String(object.name);
+    this.serializeUserData(object, containerDef);
+    const containerIndex = json.nodes.push(containerDef) - 1;
+    nodeMap.set(object, containerIndex);
+    const childDef = {};
+    const childPosition = [-pivot.x, -pivot.y, -pivot.z];
+    if (!equalArray(childPosition, [0, 0, 0])) {
+      childDef.translation = childPosition;
+    }
+    if (object.isMesh || object.isLine || object.isPoints) {
+      const meshIndex = await this.processMeshAsync(object);
+      if (meshIndex !== null) childDef.mesh = meshIndex;
+    } else if (object.isCamera) {
+      childDef.camera = this.processCamera(object);
+    }
+    if (object.isSkinnedMesh) this.skins.push(object);
+    const childIndex = json.nodes.push(childDef) - 1;
+    const containerChildren = [childIndex];
+    if (object.children.length > 0) {
+      const grandchildren = [];
+      for (let i = 0, l = object.children.length; i < l; i++) {
+        const child = object.children[i];
+        if (child.visible || options.onlyVisible === false) {
+          const childNodeIndex = await this.processNodeAsync(child);
+          if (childNodeIndex !== null) grandchildren.push(childNodeIndex);
+        }
+      }
+      if (grandchildren.length > 0) childDef.children = grandchildren;
+    }
+    containerDef.children = containerChildren;
+    await this._invokeAllAsync(function(ext) {
+      ext.writeNode && ext.writeNode(object, containerDef);
+    });
+    return containerIndex;
+  }
   /**
    * Process Scene
-   * @param  {Scene} node Scene to process
+   * @param {Scene} scene Scene to process
    */
-  processScene(scene) {
+  async processSceneAsync(scene) {
     const json = this.json;
     const options = this.options;
     if (!json.scenes) {
@@ -7767,7 +8101,7 @@ var GLTFWriter = class {
     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);
+        const nodeIndex = await this.processNodeAsync(child);
         if (nodeIndex !== null) nodes.push(nodeIndex);
       }
     }
@@ -7776,47 +8110,58 @@ var GLTFWriter = class {
   }
   /**
    * Creates a Scene to hold a list of objects and parse it
-   * @param  {Array} objects List of objects to process
+   * @param {Array<THREE.Object3D>} objects List of objects to process
    */
-  processObjects(objects) {
-    const scene = new import_three19.Scene();
+  async processObjectsAsync(objects) {
+    const scene = new import_three18.Scene();
     scene.name = "AuxScene";
     for (let i = 0; i < objects.length; i++) {
       scene.children.push(objects[i]);
     }
-    this.processScene(scene);
+    await this.processSceneAsync(scene);
   }
   /**
    * @param {THREE.Object3D|Array<THREE.Object3D>} input
    */
-  processInput(input) {
+  async processInputAsync(input) {
     const options = this.options;
     input = input instanceof Array ? input : [input];
-    this._invokeAll(function(ext) {
+    await this._invokeAllAsync(function(ext) {
       ext.beforeParse && ext.beforeParse(input);
     });
     const objectsWithoutScene = [];
     for (let i = 0; i < input.length; i++) {
-      if (input[i] instanceof import_three19.Scene) {
-        this.processScene(input[i]);
+      if (input[i] instanceof import_three18.Scene) {
+        await this.processSceneAsync(input[i]);
       } else {
         objectsWithoutScene.push(input[i]);
       }
     }
-    if (objectsWithoutScene.length > 0) this.processObjects(objectsWithoutScene);
+    if (objectsWithoutScene.length > 0) {
+      await this.processObjectsAsync(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]);
+    if (input.length === 1) {
+      for (let i = 0; i < options.animations.length; ++i) {
+        this.processAnimation(options.animations[i], input[0]);
+      }
+    } else {
+      for (let i = 0; i < input.length; i++) {
+        const animations = options.animations[i] || [];
+        for (let j = 0; j < animations.length; ++j) {
+          this.processAnimation(animations[j], input[i]);
+        }
+      }
     }
-    this._invokeAll(function(ext) {
+    await this._invokeAllAsync(function(ext) {
       ext.afterParse && ext.afterParse(input);
     });
   }
-  _invokeAll(func) {
+  async _invokeAllAsync(func) {
     for (let i = 0, il = this.plugins.length; i < il; i++) {
-      func(this.plugins[i]);
+      await func(this.plugins[i]);
     }
   }
 };
@@ -7872,7 +8217,7 @@ var GLTFMaterialsUnlitExtension = class {
     this.writer = writer;
     this.name = "KHR_materials_unlit";
   }
-  writeMaterial(material, materialDef) {
+  async writeMaterialAsync(material, materialDef) {
     if (!material.isMeshBasicMaterial) return;
     const writer = this.writer;
     const extensionsUsed = writer.extensionsUsed;
@@ -7888,7 +8233,7 @@ var GLTFMaterialsClearcoatExtension = class {
     this.writer = writer;
     this.name = "KHR_materials_clearcoat";
   }
-  writeMaterial(material, materialDef) {
+  async writeMaterialAsync(material, materialDef) {
     if (!material.isMeshPhysicalMaterial || material.clearcoat === 0) return;
     const writer = this.writer;
     const extensionsUsed = writer.extensionsUsed;
@@ -7896,7 +8241,7 @@ var GLTFMaterialsClearcoatExtension = class {
     extensionDef.clearcoatFactor = material.clearcoat;
     if (material.clearcoatMap) {
       const clearcoatMapDef = {
-        index: writer.processTexture(material.clearcoatMap),
+        index: await writer.processTextureAsync(material.clearcoatMap),
         texCoord: material.clearcoatMap.channel
       };
       writer.applyTextureTransform(clearcoatMapDef, material.clearcoatMap);
@@ -7905,7 +8250,7 @@ var GLTFMaterialsClearcoatExtension = class {
     extensionDef.clearcoatRoughnessFactor = material.clearcoatRoughness;
     if (material.clearcoatRoughnessMap) {
       const clearcoatRoughnessMapDef = {
-        index: writer.processTexture(material.clearcoatRoughnessMap),
+        index: await writer.processTextureAsync(material.clearcoatRoughnessMap),
         texCoord: material.clearcoatRoughnessMap.channel
       };
       writer.applyTextureTransform(clearcoatRoughnessMapDef, material.clearcoatRoughnessMap);
@@ -7913,9 +8258,10 @@ var GLTFMaterialsClearcoatExtension = class {
     }
     if (material.clearcoatNormalMap) {
       const clearcoatNormalMapDef = {
-        index: writer.processTexture(material.clearcoatNormalMap),
+        index: await writer.processTextureAsync(material.clearcoatNormalMap),
         texCoord: material.clearcoatNormalMap.channel
       };
+      if (material.clearcoatNormalScale.x !== 1) clearcoatNormalMapDef.scale = material.clearcoatNormalScale.x;
       writer.applyTextureTransform(clearcoatNormalMapDef, material.clearcoatNormalMap);
       extensionDef.clearcoatNormalTexture = clearcoatNormalMapDef;
     }
@@ -7924,12 +8270,28 @@ var GLTFMaterialsClearcoatExtension = class {
     extensionsUsed[this.name] = true;
   }
 };
+var GLTFMaterialsDispersionExtension = class {
+  constructor(writer) {
+    this.writer = writer;
+    this.name = "KHR_materials_dispersion";
+  }
+  async writeMaterialAsync(material, materialDef) {
+    if (!material.isMeshPhysicalMaterial || material.dispersion === 0) return;
+    const writer = this.writer;
+    const extensionsUsed = writer.extensionsUsed;
+    const extensionDef = {};
+    extensionDef.dispersion = material.dispersion;
+    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) {
+  async writeMaterialAsync(material, materialDef) {
     if (!material.isMeshPhysicalMaterial || material.iridescence === 0) return;
     const writer = this.writer;
     const extensionsUsed = writer.extensionsUsed;
@@ -7937,7 +8299,7 @@ var GLTFMaterialsIridescenceExtension = class {
     extensionDef.iridescenceFactor = material.iridescence;
     if (material.iridescenceMap) {
       const iridescenceMapDef = {
-        index: writer.processTexture(material.iridescenceMap),
+        index: await writer.processTextureAsync(material.iridescenceMap),
         texCoord: material.iridescenceMap.channel
       };
       writer.applyTextureTransform(iridescenceMapDef, material.iridescenceMap);
@@ -7948,7 +8310,7 @@ var GLTFMaterialsIridescenceExtension = class {
     extensionDef.iridescenceThicknessMaximum = material.iridescenceThicknessRange[1];
     if (material.iridescenceThicknessMap) {
       const iridescenceThicknessMapDef = {
-        index: writer.processTexture(material.iridescenceThicknessMap),
+        index: await writer.processTextureAsync(material.iridescenceThicknessMap),
         texCoord: material.iridescenceThicknessMap.channel
       };
       writer.applyTextureTransform(iridescenceThicknessMapDef, material.iridescenceThicknessMap);
@@ -7964,7 +8326,7 @@ var GLTFMaterialsTransmissionExtension = class {
     this.writer = writer;
     this.name = "KHR_materials_transmission";
   }
-  writeMaterial(material, materialDef) {
+  async writeMaterialAsync(material, materialDef) {
     if (!material.isMeshPhysicalMaterial || material.transmission === 0) return;
     const writer = this.writer;
     const extensionsUsed = writer.extensionsUsed;
@@ -7972,7 +8334,7 @@ var GLTFMaterialsTransmissionExtension = class {
     extensionDef.transmissionFactor = material.transmission;
     if (material.transmissionMap) {
       const transmissionMapDef = {
-        index: writer.processTexture(material.transmissionMap),
+        index: await writer.processTextureAsync(material.transmissionMap),
         texCoord: material.transmissionMap.channel
       };
       writer.applyTextureTransform(transmissionMapDef, material.transmissionMap);
@@ -7988,7 +8350,7 @@ var GLTFMaterialsVolumeExtension = class {
     this.writer = writer;
     this.name = "KHR_materials_volume";
   }
-  writeMaterial(material, materialDef) {
+  async writeMaterialAsync(material, materialDef) {
     if (!material.isMeshPhysicalMaterial || material.transmission === 0) return;
     const writer = this.writer;
     const extensionsUsed = writer.extensionsUsed;
@@ -7996,13 +8358,15 @@ var GLTFMaterialsVolumeExtension = class {
     extensionDef.thicknessFactor = material.thickness;
     if (material.thicknessMap) {
       const thicknessMapDef = {
-        index: writer.processTexture(material.thicknessMap),
+        index: await writer.processTextureAsync(material.thicknessMap),
         texCoord: material.thicknessMap.channel
       };
       writer.applyTextureTransform(thicknessMapDef, material.thicknessMap);
       extensionDef.thicknessTexture = thicknessMapDef;
     }
-    extensionDef.attenuationDistance = material.attenuationDistance;
+    if (material.attenuationDistance !== Infinity) {
+      extensionDef.attenuationDistance = material.attenuationDistance;
+    }
     extensionDef.attenuationColor = material.attenuationColor.toArray();
     materialDef.extensions = materialDef.extensions || {};
     materialDef.extensions[this.name] = extensionDef;
@@ -8014,7 +8378,7 @@ var GLTFMaterialsIorExtension = class {
     this.writer = writer;
     this.name = "KHR_materials_ior";
   }
-  writeMaterial(material, materialDef) {
+  async writeMaterialAsync(material, materialDef) {
     if (!material.isMeshPhysicalMaterial || material.ior === 1.5) return;
     const writer = this.writer;
     const extensionsUsed = writer.extensionsUsed;
@@ -8030,14 +8394,14 @@ var GLTFMaterialsSpecularExtension = class {
     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;
+  async writeMaterialAsync(material, materialDef) {
+    if (!material.isMeshPhysicalMaterial || material.specularIntensity === 1 && material.specularColor.equals(DEFAULT_SPECULAR_COLOR) && !material.specularIntensityMap && !material.specularColorMap) return;
     const writer = this.writer;
     const extensionsUsed = writer.extensionsUsed;
     const extensionDef = {};
     if (material.specularIntensityMap) {
       const specularIntensityMapDef = {
-        index: writer.processTexture(material.specularIntensityMap),
+        index: await writer.processTextureAsync(material.specularIntensityMap),
         texCoord: material.specularIntensityMap.channel
       };
       writer.applyTextureTransform(specularIntensityMapDef, material.specularIntensityMap);
@@ -8045,7 +8409,7 @@ var GLTFMaterialsSpecularExtension = class {
     }
     if (material.specularColorMap) {
       const specularColorMapDef = {
-        index: writer.processTexture(material.specularColorMap),
+        index: await writer.processTextureAsync(material.specularColorMap),
         texCoord: material.specularColorMap.channel
       };
       writer.applyTextureTransform(specularColorMapDef, material.specularColorMap);
@@ -8063,14 +8427,14 @@ var GLTFMaterialsSheenExtension = class {
     this.writer = writer;
     this.name = "KHR_materials_sheen";
   }
-  writeMaterial(material, materialDef) {
+  async writeMaterialAsync(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),
+        index: await writer.processTextureAsync(material.sheenRoughnessMap),
         texCoord: material.sheenRoughnessMap.channel
       };
       writer.applyTextureTransform(sheenRoughnessMapDef, material.sheenRoughnessMap);
@@ -8078,7 +8442,7 @@ var GLTFMaterialsSheenExtension = class {
     }
     if (material.sheenColorMap) {
       const sheenColorMapDef = {
-        index: writer.processTexture(material.sheenColorMap),
+        index: await writer.processTextureAsync(material.sheenColorMap),
         texCoord: material.sheenColorMap.channel
       };
       writer.applyTextureTransform(sheenColorMapDef, material.sheenColorMap);
@@ -8096,13 +8460,13 @@ var GLTFMaterialsAnisotropyExtension = class {
     this.writer = writer;
     this.name = "KHR_materials_anisotropy";
   }
-  writeMaterial(material, materialDef) {
+  async writeMaterialAsync(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) };
+      const anisotropyMapDef = { index: await writer.processTextureAsync(material.anisotropyMap) };
       writer.applyTextureTransform(anisotropyMapDef, material.anisotropyMap);
       extensionDef.anisotropyTexture = anisotropyMapDef;
     }
@@ -8118,7 +8482,7 @@ var GLTFMaterialsEmissiveStrengthExtension = class {
     this.writer = writer;
     this.name = "KHR_materials_emissive_strength";
   }
-  writeMaterial(material, materialDef) {
+  async writeMaterialAsync(material, materialDef) {
     if (!material.isMeshStandardMaterial || material.emissiveIntensity === 1) return;
     const writer = this.writer;
     const extensionsUsed = writer.extensionsUsed;
@@ -8129,6 +8493,30 @@ var GLTFMaterialsEmissiveStrengthExtension = class {
     extensionsUsed[this.name] = true;
   }
 };
+var GLTFMaterialsBumpExtension = class {
+  constructor(writer) {
+    this.writer = writer;
+    this.name = "EXT_materials_bump";
+  }
+  async writeMaterialAsync(material, materialDef) {
+    if (!material.isMeshStandardMaterial || material.bumpScale === 1 && !material.bumpMap) return;
+    const writer = this.writer;
+    const extensionsUsed = writer.extensionsUsed;
+    const extensionDef = {};
+    if (material.bumpMap) {
+      const bumpMapDef = {
+        index: await writer.processTextureAsync(material.bumpMap),
+        texCoord: material.bumpMap.channel
+      };
+      writer.applyTextureTransform(bumpMapDef, material.bumpMap);
+      extensionDef.bumpTexture = bumpMapDef;
+    }
+    extensionDef.bumpFactor = material.bumpScale;
+    materialDef.extensions = materialDef.extensions || {};
+    materialDef.extensions[this.name] = extensionDef;
+    extensionsUsed[this.name] = true;
+  }
+};
 var GLTFMeshGpuInstancing = class {
   constructor(writer) {
     this.writer = writer;
@@ -8141,10 +8529,10 @@ var GLTFMeshGpuInstancing = class {
     const translationAttr = new Float32Array(mesh.count * 3);
     const rotationAttr = new Float32Array(mesh.count * 4);
     const scaleAttr = new Float32Array(mesh.count * 3);
-    const matrix = new import_three19.Matrix4();
-    const position = new import_three19.Vector3();
-    const quaternion = new import_three19.Quaternion();
-    const scale = new import_three19.Vector3();
+    const matrix = new import_three18.Matrix4();
+    const position = new import_three18.Vector3();
+    const quaternion = new import_three18.Quaternion();
+    const scale = new import_three18.Vector3();
     for (let i = 0; i < mesh.count; i++) {
       mesh.getMatrixAt(i, matrix);
       matrix.decompose(position, quaternion, scale);
@@ -8153,9 +8541,9 @@ var GLTFMeshGpuInstancing = class {
       scale.toArray(scaleAttr, i * 3);
     }
     const attributes = {
-      TRANSLATION: writer.processAccessor(new import_three19.BufferAttribute(translationAttr, 3)),
-      ROTATION: writer.processAccessor(new import_three19.BufferAttribute(rotationAttr, 4)),
-      SCALE: writer.processAccessor(new import_three19.BufferAttribute(scaleAttr, 3))
+      TRANSLATION: writer.processAccessor(new import_three18.BufferAttribute(translationAttr, 3)),
+      ROTATION: writer.processAccessor(new import_three18.BufferAttribute(rotationAttr, 4)),
+      SCALE: writer.processAccessor(new import_three18.BufferAttribute(scaleAttr, 3))
     };
     if (mesh.instanceColor)
       attributes._COLOR_0 = writer.processAccessor(mesh.instanceColor);
@@ -8220,8 +8608,8 @@ GLTFExporter.Utils = {
     const sourceTracks = clip.tracks;
     for (let i = 0; i < sourceTracks.length; ++i) {
       let sourceTrack = sourceTracks[i];
-      const sourceTrackBinding = import_three19.PropertyBinding.parseTrackName(sourceTrack.name);
-      const sourceTrackNode = import_three19.PropertyBinding.findNode(root, sourceTrackBinding.nodeName);
+      const sourceTrackBinding = import_three18.PropertyBinding.parseTrackName(sourceTrack.name);
+      const sourceTrackNode = import_three18.PropertyBinding.findNode(root, sourceTrackBinding.nodeName);
       if (sourceTrackBinding.propertyName !== "morphTargetInfluences" || sourceTrackBinding.propertyIndex === void 0) {
         tracks.push(sourceTrack);
         continue;
@@ -8232,7 +8620,7 @@ GLTFExporter.Utils = {
         }
         console.warn("THREE.GLTFExporter: Morph target interpolation mode not yet supported. Using LINEAR instead.");
         sourceTrack = sourceTrack.clone();
-        sourceTrack.setInterpolation(import_three19.InterpolateLinear);
+        sourceTrack.setInterpolation(import_three18.InterpolateLinear);
       }
       const targetCount = sourceTrackNode.morphTargetInfluences.length;
       const targetIndex = sourceTrackNode.morphTargetDictionary[sourceTrackBinding.propertyIndex];
@@ -8264,6 +8652,19 @@ GLTFExporter.Utils = {
     }
     clip.tracks = tracks;
     return clip;
+  },
+  toTypedBufferAttribute: function(srcAttribute, TypedArray) {
+    const dstAttribute = new import_three18.BufferAttribute(new TypedArray(srcAttribute.count * srcAttribute.itemSize), srcAttribute.itemSize, false);
+    if (!srcAttribute.normalized && !srcAttribute.isInterleavedBufferAttribute) {
+      dstAttribute.array.set(srcAttribute.array);
+      return dstAttribute;
+    }
+    for (let i = 0, il = srcAttribute.count; i < il; i++) {
+      for (let j = 0; j < srcAttribute.itemSize; j++) {
+        dstAttribute.setComponent(i, j, srcAttribute.getComponent(i, j));
+      }
+    }
+    return dstAttribute;
   }
 };
 
@@ -8315,10 +8716,10 @@ var SceneExporter = class {
   }
 };
 function localMatrix(object) {
-  return object.matrixAutoUpdate ? new import_three20.Matrix4().compose(object.position, object.quaternion, object.scale) : object.matrix.clone();
+  return object.matrixAutoUpdate ? new import_three19.Matrix4().compose(object.position, object.quaternion, object.scale) : object.matrix.clone();
 }
 function createSnapshot(root, gltf, bakeColors = false) {
-  const scene = new import_three20.Scene();
+  const scene = new import_three19.Scene();
   const geometries = [];
   const materials = [];
   const textures = [];
@@ -8336,7 +8737,7 @@ function createSnapshot(root, gltf, bakeColors = false) {
       if (!uniforms.map?.value?.isTexture || !uniforms.SHADE || !uniforms.BRIGHTNESS || !uniforms.EMISSIVE) {
         throw new MineRenderError("glTF export does not support this custom ShaderMaterial");
       }
-      material = new import_three20.MeshBasicMaterial({
+      material = new import_three19.MeshBasicMaterial({
         map: uniforms.map.value,
         vertexColors: source.vertexColors,
         transparent: source.transparent,
@@ -8346,7 +8747,7 @@ function createSnapshot(root, gltf, bakeColors = false) {
       });
       material.name = source.name;
     } else if (shader.isShaderMaterial) {
-      material = new import_three20.MeshBasicMaterial({ vertexColors: source.vertexColors });
+      material = new import_three19.MeshBasicMaterial({ vertexColors: source.vertexColors });
       material.name = source.name;
     } else {
       const copySource = Object.create(source);
@@ -8400,11 +8801,11 @@ function createSnapshot(root, gltf, bakeColors = false) {
       const material = copyMaterial(sourceMaterial, geometry);
       if (!sourceMaterial.vertexColors) geometry.deleteAttribute("color");
       if (bakeColors || instanceColor) {
-        const tint = (material.color ?? new import_three20.Color()).clone();
+        const tint = (material.color ?? new import_three19.Color()).clone();
         if (instanceColor) tint.multiply(instanceColor);
         if (bakeColors) {
           const original = geometry.getAttribute("color");
-          const colors = new import_three20.Float32BufferAttribute(new Float32Array(geometry.getAttribute("position").count * 3), 3);
+          const colors = new import_three19.Float32BufferAttribute(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);
           }
@@ -8413,7 +8814,7 @@ function createSnapshot(root, gltf, bakeColors = false) {
           material.color.copy(tint);
         }
       }
-      const copy = new import_three20.Mesh(geometry, material);
+      const copy = new import_three19.Mesh(geometry, material);
       copy.name = mesh.name;
       copy.renderOrder = mesh.renderOrder;
       scene.add(copy);
@@ -8427,9 +8828,9 @@ function createSnapshot(root, gltf, bakeColors = false) {
       const instanced = mesh;
       if (instanced.isInstancedMesh) {
         for (let i = 0; i < instanced.count; i++) {
-          const matrix = new import_three20.Matrix4();
+          const matrix = new import_three19.Matrix4();
           instanced.getMatrixAt(i, matrix);
-          const color = instanced.instanceColor ? new import_three20.Color().fromBufferAttribute(instanced.instanceColor, i) : void 0;
+          const color = instanced.instanceColor ? new import_three19.Color().fromBufferAttribute(instanced.instanceColor, i) : void 0;
           addMesh(mesh, world.clone().multiply(matrix), color);
         }
       } else {
@@ -8441,7 +8842,7 @@ function createSnapshot(root, gltf, bakeColors = false) {
   try {
     const ancestors = [];
     for (let parent = root.parent; parent; parent = parent.parent) ancestors.unshift(parent);
-    const world = new import_three20.Matrix4();
+    const world = new import_three19.Matrix4();
     for (const ancestor of ancestors) {
       if (!ancestor.visible) return { scene, dispose };
       world.multiply(localMatrix(ancestor));
@@ -8455,7 +8856,7 @@ function createSnapshot(root, gltf, bakeColors = false) {
 }
 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 !== import_three20.RGBAFormat || texture.type !== import_three20.UnsignedByteType || texture.wrapS !== import_three20.ClampToEdgeWrapping || texture.wrapT !== import_three20.ClampToEdgeWrapping || texture.magFilter !== import_three20.NearestFilter || texture.minFilter !== import_three20.NearestFilter || 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;
+  if (material.type !== "MeshBasicMaterial" || !material.transparent || !material.depthWrite || material.opacity !== 1 || material.alphaMap || !texture?.isDataTexture || texture.format !== import_three19.RGBAFormat || texture.type !== import_three19.UnsignedByteType || texture.wrapS !== import_three19.ClampToEdgeWrapping || texture.wrapT !== import_three19.ClampToEdgeWrapping || texture.magFilter !== import_three19.NearestFilter || texture.minFilter !== import_three19.NearestFilter || 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;
@@ -8492,7 +8893,7 @@ function selectAlphaMode(material, geometry) {
 }
 function copyDataTexture(source) {
   const image = source.image;
-  if (source.format !== import_three20.RGBAFormat || source.type !== import_three20.UnsignedByteType) {
+  if (!image.data || source.format !== import_three19.RGBAFormat || source.type !== import_three19.UnsignedByteType) {
     throw new MineRenderError("glTF export requires RGBA unsigned-byte data textures");
   }
   const canvas = createCanvas2(image.width, image.height);
@@ -8503,8 +8904,8 @@ function copyDataTexture(source) {
   context.putImageData(pixels, 0, 0);
   const copySource = Object.create(source);
   copySource.userData = {};
-  copySource.source = new import_three20.Source(canvas);
-  return new import_three20.Texture().copy(copySource);
+  copySource.source = new import_three19.TextureSource(canvas);
+  return new import_three19.Texture().copy(copySource);
 }
 
 // src/gui/GuiHelper.ts
@@ -8573,6 +8974,85 @@ var GuiHelper = class {
   }
 };
 
+// src/gui/GuiTextureGeometry.ts
+var import_three20 = require("three");
+function createGuiTextureGeometry(width, height, imageWidth, imageHeight, crop, scaling) {
+  if (crop || !scaling || scaling.type === "stretch") {
+    const [x, y, w, h] = crop ?? [0, 0, imageWidth, imageHeight];
+    const geometry = new import_three20.PlaneGeometry(width, height);
+    const uv = geometry.getAttribute("uv");
+    for (let i = 0; i < uv.count; i++) {
+      uv.setXY(
+        i,
+        (x + uv.getX(i) * w) / imageWidth,
+        1 - (y + (1 - uv.getY(i)) * h) / imageHeight
+      );
+    }
+    return geometry;
+  }
+  const sw = scaling.width, sh = scaling.height;
+  if (![sw, sh].every((value) => Number.isInteger(value) && value > 0)) {
+    throw new Error("GUI sprite dimensions must be positive integers");
+  }
+  if (![width, height].every((value) => Number.isFinite(value) && value >= 0)) {
+    throw new Error("GUI output dimensions must be finite and nonnegative");
+  }
+  const positions = [], uvs = [], normals = [], indices = [];
+  function quad(x, y, w, h, u, v, uw, vh) {
+    if (w <= 0 || h <= 0) return;
+    const index = positions.length / 3;
+    const left = x - width / 2, top = height / 2 - y;
+    positions.push(left, top, 0, left + w, top, 0, left, top - h, 0, left + w, top - h, 0);
+    uvs.push(
+      u / sw,
+      1 - v / sh,
+      (u + uw) / sw,
+      1 - v / sh,
+      u / sw,
+      1 - (v + vh) / sh,
+      (u + uw) / sw,
+      1 - (v + vh) / sh
+    );
+    normals.push(0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1);
+    indices.push(index, index + 2, index + 1, index + 2, index + 3, index + 1);
+  }
+  function tile(x, y, w, h, u, v, tw, th) {
+    for (let dy = 0; dy < h; dy += th) {
+      for (let dx = 0; dx < w; dx += tw) {
+        const cw = Math.min(tw, w - dx), ch = Math.min(th, h - dy);
+        quad(x + dx, y + dy, cw, ch, u, v, cw, ch);
+      }
+    }
+  }
+  if (scaling.type === "tile") {
+    tile(0, 0, width, height, 0, 0, sw, sh);
+  } else {
+    let segments = function(size, sourceSize, start, end) {
+      if (size === sourceSize) return [[0, size, 0, sourceSize]];
+      start = Math.min(start, Math.floor(size / 2));
+      end = Math.min(end, Math.floor(size / 2));
+      return [
+        [0, start, 0, start],
+        [start, size - start - end, start, sourceSize - start - end],
+        [size - end, end, sourceSize - end, end]
+      ];
+    };
+    const border = typeof scaling.border === "number" ? { left: scaling.border, top: scaling.border, right: scaling.border, bottom: scaling.border } : scaling.border;
+    if (!border || typeof scaling.border === "number" && scaling.border <= 0 || ![border.left, border.top, border.right, border.bottom].every((value) => Number.isInteger(value) && value >= 0) || border.left + border.right >= sw || border.top + border.bottom >= sh) {
+      throw new Error("GUI nine-slice borders must be nonnegative integers with a nonempty center");
+    }
+    const columns = segments(width, sw, border.left, border.right);
+    const rows = segments(height, sh, border.top, border.bottom);
+    for (const [y, h, v, vh] of rows) {
+      for (const [x, w, u, uw] of columns) {
+        if (w <= 0 || h <= 0) continue;
+        (scaling.stretch_inner ? quad : tile)(x, y, w, h, u, v, uw, vh);
+      }
+    }
+  }
+  return new import_three20.BufferGeometry().setAttribute("position", new import_three20.Float32BufferAttribute(positions, 3)).setAttribute("normal", new import_three20.Float32BufferAttribute(normals, 3)).setAttribute("uv", new import_three20.Float32BufferAttribute(uvs, 2)).setIndex(indices);
+}
+
 // src/gui/scene/GuiObject.ts
 var import_three25 = require("three");
 init_AssetKey();
@@ -8624,18 +9104,10 @@ var GuiObject = class extends SceneObject {
         const key = typeof layer.texture === "string" ? AssetKey.parse("textures", layer.texture) : layer.texture;
         const material = await this.loadMaterial(key);
         const image = material.map.image;
-        const [cropX, cropY, cropWidth, cropHeight] = layer.crop ?? [0, 0, image.width, image.height];
-        const [width, height] = layer.size ?? [cropWidth, cropHeight];
-        const geometry = new import_three25.PlaneGeometry(width, height);
+        const scaling = layer.crop ? void 0 : (await ModelTextures.getMeta(key))?.gui?.scaling;
+        const [width, height] = layer.size ?? (layer.crop ? layer.crop.slice(2) : scaling && scaling.type !== "stretch" ? [scaling.width, scaling.height] : [image.width, image.height]);
+        const geometry = createGuiTextureGeometry(width, height, image.width, image.height, layer.crop, scaling);
         this.geometries.add(geometry);
-        const uv = geometry.getAttribute("uv");
-        for (let i = 0; i < uv.count; i++) {
-          uv.setXY(
-            i,
-            (cropX + uv.getX(i) * cropWidth) / image.width,
-            1 - (cropY + (1 - uv.getY(i)) * cropHeight) / image.height
-          );
-        }
         const mesh = new import_three25.Mesh(geometry, material);
         mesh.name = `mesh:${layer.name ?? index}`;
         mesh.position.set(x + width / 2, -y - height / 2, depth);
@@ -9478,6 +9950,7 @@ var BlockObject = class _BlockObject extends SceneObject {
           replacement.setMatrix(matrix);
         } else {
           replacement.matrix.copy(matrix);
+          replacement.matrixWorldNeedsUpdate = true;
           matrix.decompose(replacement.position, replacement.quaternion, replacement.scale);
           replacement.matrixAutoUpdate = object.matrixAutoUpdate;
           replacement.visible = object.visible;
@@ -12630,12 +13103,13 @@ var MineRenderScene = class _MineRenderScene extends import_three33.Scene {
   }
   updateObjectRegistration(object, attached) {
     if (this.observedObjects.has(object) === attached) return;
+    const observable = object;
     if (attached) {
       this.observedObjects.add(object);
-      object.addEventListener("change", this.onObjectChange);
+      observable.addEventListener("change", this.onObjectChange);
     } else {
       this.observedObjects.delete(object);
-      object.removeEventListener("change", this.onObjectChange);
+      observable.removeEventListener("change", this.onObjectChange);
     }
     const change = attached ? 1 : -1;
     this.stats.objectCount += change;
@@ -13476,7 +13950,7 @@ var Renderer = class _Renderer {
     });
     renderer.setClearColor(0, 0);
     renderer.shadowMap.enabled = true;
-    renderer.shadowMap.type = import_three35.PCFSoftShadowMap;
+    renderer.shadowMap.type = import_three35.PCFShadowMap;
     renderer.outputColorSpace = import_three35.SRGBColorSpace;
     renderer.setPixelRatio(this.options.render.pixelRatio ?? 1);
     renderer.setSize(this.viewWidth, this.viewHeight);
@@ -14654,6 +15128,7 @@ var SectionMesh = class _SectionMesh extends import_three39.Group {
       texture?.dispose();
     }
     this.removeFromParent();
+    super.dispose();
   }
 };
 
@@ -14958,6 +15433,7 @@ var Chunk = class _Chunk {
   computeTangents,
   createCanvas,
   createFluidGeometry,
+  createGuiTextureGeometry,
   createImage,
   entityAnimationTime,
   estimateBytesUsed,