minerender 2.1.0-alpha.48 → 2.1.0-alpha.49

package/dist/browser/index.js

@@ -839,6 +839,31 @@ var init_Materials = __esm({
           alphaTest: 0.5
         });
       }
+      static createGuiCanvasMaterial(canvas) {
+        const material = new import_three5.MeshBasicMaterial({
+          map: Textures.createCanvasTexture(canvas),
+          transparent: true,
+          depthWrite: false,
+          side: import_three5.DoubleSide,
+          toneMapped: false
+        });
+        material.onBeforeCompile = (shader) => {
+          for (const [stage, direction] of [["vertex", "out"], ["fragment", "in"]]) {
+            const chunk = `uv_pars_${stage}`;
+            shader[`${stage}Shader`] = shader[`${stage}Shader`].replace(
+              `#include <${chunk}>`,
+              import_three5.ShaderChunk[chunk].replace("varying vec2 vMapUv;", `
+                        #if __VERSION__ >= 300
+                        centroid ${direction} vec2 vMapUv;
+                        #else
+                        varying vec2 vMapUv;
+                        #endif
+                    `)
+            );
+          }
+        };
+        return material;
+      }
       static createShadedCanvasMaterial(canvas, transparent = false, shade = false) {
         const vertShader = `
             uniform bool SHADE;
@@ -2985,6 +3010,10 @@ var init_SceneObject = __esm({
       async init() {
       }
       notifyDirty() {
+        this.traverseAncestors((parent) => {
+          const scene = parent;
+          if (scene.isMineRenderScene) scene.dirty = true;
+        });
         this.dispatchEvent(changeEvent);
       }
       //<editor-fold desc="GROUPS">
@@ -3328,6 +3357,7 @@ var init_SceneObject = __esm({
           } else {
             object.visible = !object.visible;
           }
+          this.notifyDirty();
           return object.visible;
         }
         this.notifyDirty();
@@ -3360,8 +3390,8 @@ var init_SceneObject = __esm({
         this.notifyDirty();
       }
       removeFromScene() {
-        this._scene?.remove(this);
         this.notifyDirty();
+        this.removeFromParent();
       }
       //</editor-fold>
     };
@@ -3376,16 +3406,16 @@ var init_SceneObject = __esm({
 });
 
 // src/model/ModelCulling.ts
-var import_three16, ModelCulling;
+var import_three17, ModelCulling;
 var init_ModelCulling = __esm({
   "src/model/ModelCulling.ts"() {
-    import_three16 = require("three");
+    import_three17 = require("three");
     init_CubeFace();
     ModelCulling = class {
       static toLocalMask(worldMask, rotation) {
         let localMask = 0;
         for (const [localFace, offset] of CUBE_FACE_OFFSETS.entries()) {
-          const normal = new import_three16.Vector3(...offset).applyEuler(rotation);
+          const normal = new import_three17.Vector3(...offset).applyEuler(rotation);
           const worldFace = CUBE_FACE_OFFSETS.findIndex(([x, y, z]) => Math.abs(normal.x - x) < 1e-6 && Math.abs(normal.y - y) < 1e-6 && Math.abs(normal.z - z) < 1e-6);
           if (worldFace < 0) return 0;
           if (worldMask & 1 << worldFace) localMask |= 1 << localFace;
@@ -3429,7 +3459,7 @@ function mergeBufferGeometries(geometries, useGroups = false) {
   const attributes = {};
   const morphAttributes = {};
   const morphTargetsRelative = geometries[0].morphTargetsRelative;
-  const mergedGeometry = new import_three18.BufferGeometry();
+  const mergedGeometry = new import_three19.BufferGeometry();
   let offset = 0;
   for (let i = 0; i < geometries.length; ++i) {
     const geometry = geometries[i];
@@ -3553,7 +3583,7 @@ function mergeBufferAttributes(attributes) {
     array.set(attributes[i].array, offset);
     offset += attributes[i].array.length;
   }
-  return new import_three18.BufferAttribute(array, itemSize, normalized);
+  return new import_three19.BufferAttribute(array, itemSize, normalized);
 }
 function interleaveAttributes(attributes) {
   let TypedArray;
@@ -3569,7 +3599,7 @@ function interleaveAttributes(attributes) {
     arrayLength += attribute.array.length;
     stride += attribute.itemSize;
   }
-  const interleavedBuffer = new import_three18.InterleavedBuffer(new TypedArray(arrayLength), stride);
+  const interleavedBuffer = new import_three19.InterleavedBuffer(new TypedArray(arrayLength), stride);
   let offset = 0;
   const res = [];
   const getters = ["getX", "getY", "getZ", "getW"];
@@ -3578,7 +3608,7 @@ function interleaveAttributes(attributes) {
     const attribute = attributes[j];
     const itemSize = attribute.itemSize;
     const count = attribute.count;
-    const iba = new import_three18.InterleavedBufferAttribute(interleavedBuffer, itemSize, offset, attribute.normalized);
+    const iba = new import_three19.InterleavedBufferAttribute(interleavedBuffer, itemSize, offset, attribute.normalized);
     res.push(iba);
     offset += itemSize;
     for (let c = 0; c < count; c++) {
@@ -3662,13 +3692,13 @@ function mergeVertices(geometry, tolerance = 1e-4) {
     const name = attributeNames[i];
     const oldAttribute = geometry.getAttribute(name);
     const buffer = new oldAttribute.array.constructor(attrArrays[name]);
-    const attribute = new import_three18.BufferAttribute(buffer, oldAttribute.itemSize, oldAttribute.normalized);
+    const attribute = new import_three19.BufferAttribute(buffer, oldAttribute.itemSize, oldAttribute.normalized);
     result.setAttribute(name, attribute);
     if (name in morphAttrsArrays) {
       for (let j = 0; j < morphAttrsArrays[name].length; j++) {
         const oldMorphAttribute = geometry.morphAttributes[name][j];
         const buffer2 = new oldMorphAttribute.array.constructor(morphAttrsArrays[name][j]);
-        const morphAttribute = new import_three18.BufferAttribute(buffer2, oldMorphAttribute.itemSize, oldMorphAttribute.normalized);
+        const morphAttribute = new import_three19.BufferAttribute(buffer2, oldMorphAttribute.itemSize, oldMorphAttribute.normalized);
         result.morphAttributes[name][j] = morphAttribute;
       }
     }
@@ -3677,11 +3707,11 @@ function mergeVertices(geometry, tolerance = 1e-4) {
   return result;
 }
 function toTrianglesDrawMode(geometry, drawMode) {
-  if (drawMode === import_three18.TrianglesDrawMode) {
+  if (drawMode === import_three19.TrianglesDrawMode) {
     console.warn("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles.");
     return geometry;
   }
-  if (drawMode === import_three18.TriangleFanDrawMode || drawMode === import_three18.TriangleStripDrawMode) {
+  if (drawMode === import_three19.TriangleFanDrawMode || drawMode === import_three19.TriangleStripDrawMode) {
     let index = geometry.getIndex();
     if (index === null) {
       const indices = [];
@@ -3699,7 +3729,7 @@ function toTrianglesDrawMode(geometry, drawMode) {
     }
     const numberOfTriangles = index.count - 2;
     const newIndices = [];
-    if (drawMode === import_three18.TriangleFanDrawMode) {
+    if (drawMode === import_three19.TriangleFanDrawMode) {
       for (let i = 1; i <= numberOfTriangles; i++) {
         newIndices.push(index.getX(0));
         newIndices.push(index.getX(i));
@@ -3735,15 +3765,15 @@ function computeMorphedAttributes(object) {
     console.error("THREE.BufferGeometryUtils: Geometry is not of type BufferGeometry.");
     return null;
   }
-  const _vA = new import_three18.Vector3();
-  const _vB = new import_three18.Vector3();
-  const _vC = new import_three18.Vector3();
-  const _tempA = new import_three18.Vector3();
-  const _tempB = new import_three18.Vector3();
-  const _tempC = new import_three18.Vector3();
-  const _morphA = new import_three18.Vector3();
-  const _morphB = new import_three18.Vector3();
-  const _morphC = new import_three18.Vector3();
+  const _vA = new import_three19.Vector3();
+  const _vB = new import_three19.Vector3();
+  const _vC = new import_three19.Vector3();
+  const _tempA = new import_three19.Vector3();
+  const _tempB = new import_three19.Vector3();
+  const _tempC = new import_three19.Vector3();
+  const _morphA = new import_three19.Vector3();
+  const _morphB = new import_three19.Vector3();
+  const _morphC = new import_three19.Vector3();
   function _calculateMorphedAttributeData(object2, material2, attribute, morphAttribute, morphTargetsRelative2, a2, b2, c2, modifiedAttributeArray) {
     _vA.fromBufferAttribute(attribute, a2);
     _vB.fromBufferAttribute(attribute, b2);
@@ -3938,8 +3968,8 @@ function computeMorphedAttributes(object) {
       }
     }
   }
-  const morphedPositionAttribute = new import_three18.Float32BufferAttribute(modifiedPosition, 3);
-  const morphedNormalAttribute = new import_three18.Float32BufferAttribute(modifiedNormal, 3);
+  const morphedPositionAttribute = new import_three19.Float32BufferAttribute(modifiedPosition, 3);
+  const morphedNormalAttribute = new import_three19.Float32BufferAttribute(modifiedNormal, 3);
   return {
     positionAttribute,
     normalAttribute,
@@ -3947,10 +3977,10 @@ function computeMorphedAttributes(object) {
     morphedNormalAttribute
   };
 }
-var import_three18;
+var import_three19;
 var init_BufferGeometryUtils = __esm({
   "src/three/BufferGeometryUtils.js"() {
-    import_three18 = require("three");
+    import_three19 = require("three");
   }
 });
 
@@ -3958,13 +3988,13 @@ var init_BufferGeometryUtils = __esm({
 function isModelObject(obj) {
   return obj.isModelObject;
 }
-var import_three19, import_ts_deepmerge5, p9, _ModelObject, ModelObject;
+var import_three20, import_ts_deepmerge5, p9, _ModelObject, ModelObject;
 var init_ModelObject = __esm({
   "src/model/scene/ModelObject.ts"() {
     init_SceneObject();
     init_Materials();
     init_UVMapper();
-    import_three19 = require("three");
+    import_three20 = require("three");
     init_BufferGeometryUtils();
     init_model();
     import_ts_deepmerge5 = __toESM(require_dist());
@@ -4019,7 +4049,7 @@ var init_ModelObject = __esm({
                 elGeo.clearGroups();
               }
               if (this.options.uvLockRotation) {
-                UVMapper.lockUvs(elGeo, el.faces, this.atlas, new import_three19.Euler(...this.options.uvLockRotation));
+                UVMapper.lockUvs(elGeo, el.faces, this.atlas, new import_three20.Euler(...this.options.uvLockRotation));
               }
               if (this.options.tints) {
                 const colors = new Float32Array(elGeo.getAttribute("position").count * 3).fill(1);
@@ -4028,19 +4058,19 @@ var init_ModelObject = __esm({
                   if (tintIndex === void 0 || tintIndex < 0) continue;
                   const tint = this.options.tints[tintIndex];
                   if (tint === void 0) continue;
-                  const color = new import_three19.Color(tint);
+                  const color = new import_three20.Color(tint);
                   for (let vertex = 0; vertex < 4; vertex++) {
                     color.toArray(colors, (faceIndex * 4 + vertex) * 3);
                   }
                 }
-                elGeo.setAttribute("color", new import_three19.BufferAttribute(colors, 3));
+                elGeo.setAttribute("color", new import_three20.BufferAttribute(colors, 3));
               }
-              elGeo.applyMatrix4(new import_three19.Matrix4().makeTranslation((el.to[0] - el.from[0]) / 2, (el.to[1] - el.from[1]) / 2, (el.to[2] - el.from[2]) / 2));
-              elGeo.applyMatrix4(new import_three19.Matrix4().makeTranslation(el.from[0], el.from[1], el.from[2]));
+              elGeo.applyMatrix4(new import_three20.Matrix4().makeTranslation((el.to[0] - el.from[0]) / 2, (el.to[1] - el.from[1]) / 2, (el.to[2] - el.from[2]) / 2));
+              elGeo.applyMatrix4(new import_three20.Matrix4().makeTranslation(el.from[0], el.from[1], el.from[2]));
               if (el.rotation) {
                 applyElementRotation(el.rotation, elGeo);
               }
-              elGeo.applyMatrix4(new import_three19.Matrix4().makeTranslation(-8, -8, -8));
+              elGeo.applyMatrix4(new import_three20.Matrix4().makeTranslation(-8, -8, -8));
               if (displayTransform) DisplayTransforms.apply(elGeo, displayTransform);
               if (this.options.mergeMeshes) {
                 allGeos.push(elGeo);
@@ -4062,7 +4092,7 @@ var init_ModelObject = __esm({
           if (allGeos.length > 0) {
             combinedGeo = mergeBufferGeometries(allGeos);
           } else {
-            combinedGeo = new import_three19.BoxGeometry(16, 16, 16);
+            combinedGeo = new import_three20.BoxGeometry(16, 16, 16);
             if (displayTransform) DisplayTransforms.apply(combinedGeo, displayTransform);
           }
           combinedGeo.computeBoundingBox();
@@ -4172,7 +4202,7 @@ function ownHeight(sample) {
   return (level === 0 || level >= 8 ? 8 : 8 - level) / 9;
 }
 function createFluidGeometry(kind, sample) {
-  const geometry = new import_three20.BufferGeometry();
+  const geometry = new import_three21.BufferGeometry();
   const positions = [], normals = [], uvs = [], indices = [];
   const self = sample(0, 0, 0);
   const height = (x, z) => {
@@ -4271,16 +4301,16 @@ function createFluidGeometry(kind, sample) {
       1
     );
   }
-  geometry.setAttribute("position", new import_three20.Float32BufferAttribute(positions, 3));
-  geometry.setAttribute("normal", new import_three20.Float32BufferAttribute(normals, 3));
-  geometry.setAttribute("uv", new import_three20.Float32BufferAttribute(uvs, 2));
+  geometry.setAttribute("position", new import_three21.Float32BufferAttribute(positions, 3));
+  geometry.setAttribute("normal", new import_three21.Float32BufferAttribute(normals, 3));
+  geometry.setAttribute("uv", new import_three21.Float32BufferAttribute(uvs, 2));
   geometry.setIndex(indices);
   return geometry;
 }
-var import_three20, fluidRules, HORIZONTAL, EPSILON;
+var import_three21, fluidRules, HORIZONTAL, EPSILON;
 var init_FluidGeometry = __esm({
   "src/model/fluid/FluidGeometry.ts"() {
-    import_three20 = require("three");
+    import_three21 = require("three");
     init_fluidBlocks();
     fluidRules = fluidBlocks_default;
     HORIZONTAL = [[0, -1], [0, 1], [-1, 0], [1, 0]];
@@ -4309,10 +4339,10 @@ function sampleFluid(kind, sample) {
   }
   return { key: key.join(""), sample: (x, y, z) => cells[(y + 1) * 9 + (z + 1) * 3 + x + 1] };
 }
-var import_three21, FluidModelObject;
+var import_three22, FluidModelObject;
 var init_FluidModelObject = __esm({
   "src/model/fluid/FluidModelObject.ts"() {
-    import_three21 = require("three");
+    import_three22 = require("three");
     init_AssetKey();
     init_Materials();
     init_ModelObject();
@@ -4345,10 +4375,10 @@ var init_FluidModelObject = __esm({
           }
         }
         geometry.clearGroups();
-        const color = new import_three21.Color(this.options.tints?.[0] ?? (this.kind === "water" ? 4159204 : 16777215));
+        const color = new import_three22.Color(this.options.tints?.[0] ?? (this.kind === "water" ? 4159204 : 16777215));
         const colors = new Float32Array(geometry.getAttribute("position").count * 3);
         for (let i = 0; i < colors.length; i += 3) color.toArray(colors, i);
-        geometry.setAttribute("color", new import_three21.BufferAttribute(colors, 3));
+        geometry.setAttribute("color", new import_three22.BufferAttribute(colors, 3));
         geometry.computeBoundingBox();
         geometry.computeBoundingSphere();
         if (this.options.instanceMeshes) {
@@ -4362,7 +4392,7 @@ var init_FluidModelObject = __esm({
         super.applyTextures();
         this.iterateAllMeshes((mesh) => {
           const material = mesh.material;
-          material.side = import_three21.DoubleSide;
+          material.side = import_three22.DoubleSide;
           material.forceSinglePass = true;
           material.depthWrite = !material.transparent;
         });
@@ -4421,6 +4451,7 @@ __export(index_browser_exports, {
   Env: () => Env,
   FluidModelObject: () => FluidModelObject,
   Geometries: () => Geometries,
+  GuiHelper: () => GuiHelper,
   GuiLight: () => GuiLight,
   GuiObject: () => GuiObject,
   HostedAssetSource: () => HostedAssetSource,
@@ -4498,6 +4529,7 @@ __export(index_browser_exports, {
   isDisposable: () => isDisposable,
   isDoubleArray: () => isDoubleArray,
   isEntityObject: () => isEntityObject,
+  isGuiObject: () => isGuiObject,
   isInstanceManager: () => isInstanceManager,
   isInstanceReference: () => isInstanceReference,
   isInstanceable: () => isInstanceable,
@@ -5038,17 +5070,106 @@ function isEntityObject(obj) {
 // src/error/index.ts
 init_MineRenderError();
 
+// src/gui/GuiHelper.ts
+var GuiHelper = class {
+  static inventorySlot(slot, origin = [0, 0], offset = [18, 18], rowSize = 9) {
+    const [column, row] = typeof slot === "number" ? [slot % rowSize, Math.floor(slot / rowSize)] : slot;
+    return [origin[0] + column * offset[0], origin[1] + row * offset[1]];
+  }
+};
+
 // src/gui/scene/GuiObject.ts
+var import_three14 = require("three");
+init_AssetKey();
+init_ModelTextures();
+init_Caching();
 init_SceneObject();
+init_Materials();
 var GuiObject = class extends SceneObject {
-  //TODO
+  constructor(textureLayers, options) {
+    super({ ...options, instanceMeshes: false, mergeMeshes: false });
+    this.textureLayers = textureLayers;
+    this.isGuiObject = true;
+    /** Local bounds in GUI pixels, with y growing down from the origin. */
+    this.bounds = new import_three14.Box2();
+    this.geometries = /* @__PURE__ */ new Set();
+    this.ownedMaterials = /* @__PURE__ */ new Set();
+    this.initialized = false;
+  }
+  async init() {
+    if (this.initialized) return;
+    try {
+      for (const [index, layer] of this.textureLayers.entries()) {
+        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 [x, y] = layer.position ?? [0, 0];
+        const geometry = new import_three14.PlaneGeometry(width, height);
+        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_three14.Mesh(geometry, material);
+        mesh.name = `mesh:${layer.name ?? index}`;
+        mesh.position.set(x + width / 2, -y - height / 2, 0);
+        mesh.renderOrder = index;
+        this.add(mesh);
+        this.bounds.expandByPoint(new import_three14.Vector2(x, y));
+        this.bounds.expandByPoint(new import_three14.Vector2(x + width, y + height));
+      }
+      this.initialized = true;
+      this.notifyDirty();
+    } catch (error) {
+      this.disposeAndRemoveAllChildren();
+      throw error;
+    }
+  }
+  async loadMaterial(key) {
+    const assetKey = key.serialize();
+    const materialKey = `gui:${assetKey}`;
+    const cached2 = Caching.materialCache.getIfPresent(materialKey);
+    if (cached2) return cached2;
+    const pending = ModelTextures.get(key);
+    const cachedAsset = Caching.textureAssetCache.getIfPresent(assetKey);
+    const image = await pending;
+    if (!image) throw new Error(`Could not load GUI texture ${key.toNamespacedString()}`);
+    const create = () => Materials.createGuiCanvasMaterial(image.data.canvas);
+    if (cachedAsset && Caching.textureAssetCache.getIfPresent(assetKey) === cachedAsset) {
+      return Caching.materialCache.get(materialKey, create);
+    }
+    const material = create();
+    this.ownedMaterials.add(material);
+    return material;
+  }
+  disposeAndRemoveAllChildren() {
+    for (const geometry of this.geometries) geometry.dispose();
+    this.geometries.clear();
+    for (const material of this.ownedMaterials) {
+      material.map.dispose();
+      material.dispose();
+    }
+    this.ownedMaterials.clear();
+    this.bounds.makeEmpty();
+    this.initialized = false;
+    super.disposeAndRemoveAllChildren();
+  }
 };
+function isGuiObject(obj) {
+  return obj.isGuiObject;
+}
 
 // src/index.ts
 init_image();
 
 // src/inspector/SceneInspector.ts
-var import_three14 = require("three");
+var import_three15 = require("three");
 init_SceneObject();
 init_util();
 init_log();
@@ -5058,11 +5179,11 @@ var help = "<span>Ctrl/Cmd+Click to Select<br/></span><br/>";
 var SceneInspector = class {
   constructor(renderer) {
     this.renderer = renderer;
-    this.mouse = new import_three14.Vector2();
+    this.mouse = new import_three15.Vector2();
     this.listeners = new AbortController();
     this.objectInfoContainer = document.createElement("div");
     this.objectControlsContainer = document.createElement("div");
-    this.raycaster = new import_three14.Raycaster();
+    this.raycaster = new import_three15.Raycaster();
     this.init();
   }
   init() {
@@ -5478,7 +5599,7 @@ init_ModelGenerator();
 init_ModelMerger();
 
 // src/model/block/BlockStateResolver.ts
-var import_three17 = require("three");
+var import_three18 = require("three");
 init_BlockStates();
 init_MineRenderError();
 init_util();
@@ -5556,7 +5677,7 @@ var BlockStateResolver = class {
     return variants[variants.length - 1];
   }
   static rotation(variant) {
-    const rotation = new import_three17.Euler();
+    const rotation = new import_three18.Euler();
     if (typeof variant.x !== "undefined") {
       rotation.x = toRadians(clampRotationDegrees(variant.x));
     }
@@ -5663,7 +5784,7 @@ init_SceneObject();
 init_ModelObject();
 init_Models();
 var import_ts_deepmerge6 = __toESM(require_dist());
-var import_three22 = require("three");
+var import_three23 = require("three");
 init_MineRenderError();
 init_InstanceReference();
 init_AssetKey();
@@ -5727,12 +5848,12 @@ var _BlockObject = class _BlockObject extends SceneObject {
   getModelCullMask(model, worldMask) {
     const object = isInstanceReference(model) ? model.instanceable : model;
     if (object.options.displayPosition) return 0;
-    const position = new import_three22.Vector3();
-    const rotation = new import_three22.Quaternion();
-    const scale = new import_three22.Vector3();
+    const position = new import_three23.Vector3();
+    const rotation = new import_three23.Quaternion();
+    const scale = new import_three23.Vector3();
     this.getModelMatrix(model).decompose(position, rotation, scale);
-    if (position.distanceToSquared(this.position) > 1e-10 || scale.distanceToSquared(new import_three22.Vector3(1, 1, 1)) > 1e-10) return 0;
-    return ModelCulling.toLocalMask(worldMask, new import_three22.Euler().setFromQuaternion(rotation));
+    if (position.distanceToSquared(this.position) > 1e-10 || scale.distanceToSquared(new import_three23.Vector3(1, 1, 1)) > 1e-10) return 0;
+    return ModelCulling.toLocalMask(worldMask, new import_three23.Euler().setFromQuaternion(rotation));
   }
   async setCullMask(worldMask) {
     worldMask &= 63;
@@ -5794,7 +5915,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
       () => new FluidModelObject2(kind, surface.sample, this.blockState.key, this.options)
     );
     const previous = this._fluidModel;
-    const matrix = previous ? this.getModelMatrix(previous) : new import_three22.Matrix4().makeTranslation(...this.position.toArray());
+    const matrix = previous ? this.getModelMatrix(previous) : new import_three23.Matrix4().makeTranslation(...this.position.toArray());
     if (isInstanceReference(replacement)) replacement.setMatrix(matrix);
     else matrix.decompose(replacement.position, replacement.quaternion, replacement.scale);
     this._models = this._models.filter((model) => model !== previous);
@@ -5925,7 +6046,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
   setPositionRotationScaleAt(index, position, rotation, scale) {
     super.setPositionRotationScaleAt(index, position, rotation, scale);
   }
-  getMatrixAt(index, matrix = new import_three22.Matrix4()) {
+  getMatrixAt(index, matrix = new import_three23.Matrix4()) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const child = this._models[0];
     if (child && isModelObject(child)) {
@@ -7795,7 +7916,7 @@ init_ModelObject();
 init_nbt();
 
 // src/renderer/MineRenderScene.ts
-var import_three24 = require("three");
+var import_three25 = require("three");
 init_SceneObject();
 var import_ts_deepmerge8 = __toESM(require_dist());
 init_ModelObject();
@@ -8528,7 +8649,7 @@ var import_ts_deepmerge7 = __toESM(require_dist());
 init_util();
 
 // src/skin/SkinTextures.ts
-var import_three23 = require("three");
+var import_three24 = require("three");
 init_Caching();
 init_CacheKey();
 init_MineRenderError();
@@ -8612,11 +8733,11 @@ var SkinTextures = class {
     });
   }
   static createMaterial(pixels, width, height, transparent = true) {
-    const texture = Textures.initTextureProps(new import_three23.DataTexture(pixels, width, height));
-    texture.colorSpace = import_three23.SRGBColorSpace;
+    const texture = Textures.initTextureProps(new import_three24.DataTexture(pixels, width, height));
+    texture.colorSpace = import_three24.SRGBColorSpace;
     texture.flipY = true;
     texture.needsUpdate = true;
-    return new import_three23.MeshBasicMaterial({ map: texture, transparent, side: transparent ? import_three23.DoubleSide : import_three23.FrontSide, alphaTest: transparent ? 0.1 : 0 });
+    return new import_three24.MeshBasicMaterial({ map: texture, transparent, side: transparent ? import_three24.DoubleSide : import_three24.FrontSide, alphaTest: transparent ? 0.1 : 0 });
   }
   static isSlim(image, scale) {
     for (const [x, y] of [[46, 52], [54, 20]]) {
@@ -8843,7 +8964,7 @@ var SkinObject = class extends SceneObject {
 };
 
 // src/renderer/MineRenderScene.ts
-var _MineRenderScene = class _MineRenderScene extends import_three24.Scene {
+var _MineRenderScene = class _MineRenderScene extends import_three25.Scene {
   constructor(options) {
     super();
     this.isMineRenderScene = true;
@@ -8959,6 +9080,14 @@ var _MineRenderScene = class _MineRenderScene extends import_three24.Scene {
   async addEntity(entity, options, parent = this) {
     return this.addSceneObject(entity, () => new EntityObject(entity, options), options, parent);
   }
+  async addGui(layers, options, parent = this) {
+    const obj = new GuiObject(layers, options);
+    obj.scene = this;
+    await obj.init();
+    parent.add(obj);
+    this.dirty = true;
+    return obj;
+  }
 };
 _MineRenderScene.DEFAULT_OPTIONS = (0, import_ts_deepmerge8.default)({}, {});
 var MineRenderScene = _MineRenderScene;
@@ -8967,7 +9096,7 @@ function isMineRenderScene(obj) {
 }
 
 // src/renderer/Renderer.ts
-var import_three26 = require("three");
+var import_three27 = require("three");
 var import_ts_deepmerge9 = __toESM(require_dist());
 var import_stats = __toESM(require("stats.js"));
 var import_postprocessing = require("postprocessing");
@@ -8975,11 +9104,11 @@ init_util();
 init_three();
 
 // src/three/OrbitControls.js
-var import_three25 = require("three");
+var import_three26 = require("three");
 var _changeEvent = { type: "change" };
 var _startEvent = { type: "start" };
 var _endEvent = { type: "end" };
-var OrbitControls = class extends import_three25.EventDispatcher {
+var OrbitControls = class extends import_three26.EventDispatcher {
   constructor(object, domElement) {
     super();
     if (domElement === void 0) console.warn('THREE.OrbitControls: The second parameter "domElement" is now mandatory.');
@@ -8988,7 +9117,7 @@ var OrbitControls = class extends import_three25.EventDispatcher {
     this.domElement = domElement;
     this.domElement.style.touchAction = "none";
     this.enabled = true;
-    this.target = new import_three25.Vector3();
+    this.target = new import_three26.Vector3();
     this.minDistance = 0;
     this.maxDistance = Infinity;
     this.minZoom = 0;
@@ -9010,8 +9139,8 @@ var OrbitControls = class extends import_three25.EventDispatcher {
     this.autoRotate = false;
     this.autoRotateSpeed = 2;
     this.keys = { LEFT: "ArrowLeft", UP: "ArrowUp", RIGHT: "ArrowRight", BOTTOM: "ArrowDown" };
-    this.mouseButtons = { LEFT: import_three25.MOUSE.ROTATE, MIDDLE: import_three25.MOUSE.DOLLY, RIGHT: import_three25.MOUSE.PAN };
-    this.touches = { ONE: import_three25.TOUCH.ROTATE, TWO: import_three25.TOUCH.DOLLY_PAN };
+    this.mouseButtons = { LEFT: import_three26.MOUSE.ROTATE, MIDDLE: import_three26.MOUSE.DOLLY, RIGHT: import_three26.MOUSE.PAN };
+    this.touches = { ONE: import_three26.TOUCH.ROTATE, TWO: import_three26.TOUCH.DOLLY_PAN };
     this.target0 = this.target.clone();
     this.position0 = this.object.position.clone();
     this.zoom0 = this.object.zoom;
@@ -9040,11 +9169,11 @@ var OrbitControls = class extends import_three25.EventDispatcher {
       state = STATE.NONE;
     };
     this.update = function() {
-      const offset = new import_three25.Vector3();
-      const quat = new import_three25.Quaternion().setFromUnitVectors(object.up, new import_three25.Vector3(0, 1, 0));
+      const offset = new import_three26.Vector3();
+      const quat = new import_three26.Quaternion().setFromUnitVectors(object.up, new import_three26.Vector3(0, 1, 0));
       const quatInverse = quat.clone().invert();
-      const lastPosition = new import_three25.Vector3();
-      const lastQuaternion = new import_three25.Quaternion();
+      const lastPosition = new import_three26.Vector3();
+      const lastQuaternion = new import_three26.Quaternion();
       const twoPI = 2 * Math.PI;
       return function update() {
         const position = scope.object.position;
@@ -9130,20 +9259,20 @@ var OrbitControls = class extends import_three25.EventDispatcher {
     };
     let state = STATE.NONE;
     const EPS = 1e-6;
-    const spherical = new import_three25.Spherical();
-    const sphericalDelta = new import_three25.Spherical();
+    const spherical = new import_three26.Spherical();
+    const sphericalDelta = new import_three26.Spherical();
     let scale = 1;
-    const panOffset = new import_three25.Vector3();
+    const panOffset = new import_three26.Vector3();
     let zoomChanged = false;
-    const rotateStart = new import_three25.Vector2();
-    const rotateEnd = new import_three25.Vector2();
-    const rotateDelta = new import_three25.Vector2();
-    const panStart = new import_three25.Vector2();
-    const panEnd = new import_three25.Vector2();
-    const panDelta = new import_three25.Vector2();
-    const dollyStart = new import_three25.Vector2();
-    const dollyEnd = new import_three25.Vector2();
-    const dollyDelta = new import_three25.Vector2();
+    const rotateStart = new import_three26.Vector2();
+    const rotateEnd = new import_three26.Vector2();
+    const rotateDelta = new import_three26.Vector2();
+    const panStart = new import_three26.Vector2();
+    const panEnd = new import_three26.Vector2();
+    const panDelta = new import_three26.Vector2();
+    const dollyStart = new import_three26.Vector2();
+    const dollyEnd = new import_three26.Vector2();
+    const dollyDelta = new import_three26.Vector2();
     const pointers = [];
     const pointerPositions = {};
     function getAutoRotationAngle() {
@@ -9159,7 +9288,7 @@ var OrbitControls = class extends import_three25.EventDispatcher {
       sphericalDelta.phi -= angle;
     }
     const panLeft = function() {
-      const v = new import_three25.Vector3();
+      const v = new import_three26.Vector3();
       return function panLeft2(distance, objectMatrix) {
         v.setFromMatrixColumn(objectMatrix, 0);
         v.multiplyScalar(-distance);
@@ -9167,7 +9296,7 @@ var OrbitControls = class extends import_three25.EventDispatcher {
       };
     }();
     const panUp = function() {
-      const v = new import_three25.Vector3();
+      const v = new import_three26.Vector3();
       return function panUp2(distance, objectMatrix) {
         if (scope.screenSpacePanning === true) {
           v.setFromMatrixColumn(objectMatrix, 1);
@@ -9180,7 +9309,7 @@ var OrbitControls = class extends import_three25.EventDispatcher {
       };
     }();
     const pan = function() {
-      const offset = new import_three25.Vector3();
+      const offset = new import_three26.Vector3();
       return function pan2(deltaX, deltaY) {
         const element = scope.domElement;
         if (scope.object.isPerspectiveCamera) {
@@ -9429,12 +9558,12 @@ var OrbitControls = class extends import_three25.EventDispatcher {
           mouseAction = -1;
       }
       switch (mouseAction) {
-        case import_three25.MOUSE.DOLLY:
+        case import_three26.MOUSE.DOLLY:
           if (scope.enableZoom === false) return;
           handleMouseDownDolly(event);
           state = STATE.DOLLY;
           break;
-        case import_three25.MOUSE.ROTATE:
+        case import_three26.MOUSE.ROTATE:
           if (event.ctrlKey || event.metaKey || event.shiftKey) {
             if (scope.enablePan === false) return;
             handleMouseDownPan(event);
@@ -9445,7 +9574,7 @@ var OrbitControls = class extends import_three25.EventDispatcher {
             state = STATE.ROTATE;
           }
           break;
-        case import_three25.MOUSE.PAN:
+        case import_three26.MOUSE.PAN:
           if (event.ctrlKey || event.metaKey || event.shiftKey) {
             if (scope.enableRotate === false) return;
             handleMouseDownRotate(event);
@@ -9501,12 +9630,12 @@ var OrbitControls = class extends import_three25.EventDispatcher {
       switch (pointers.length) {
         case 1:
           switch (scope.touches.ONE) {
-            case import_three25.TOUCH.ROTATE:
+            case import_three26.TOUCH.ROTATE:
               if (scope.enableRotate === false) return;
               handleTouchStartRotate();
               state = STATE.TOUCH_ROTATE;
               break;
-            case import_three25.TOUCH.PAN:
+            case import_three26.TOUCH.PAN:
               if (scope.enablePan === false) return;
               handleTouchStartPan();
               state = STATE.TOUCH_PAN;
@@ -9517,12 +9646,12 @@ var OrbitControls = class extends import_three25.EventDispatcher {
           break;
         case 2:
           switch (scope.touches.TWO) {
-            case import_three25.TOUCH.DOLLY_PAN:
+            case import_three26.TOUCH.DOLLY_PAN:
               if (scope.enableZoom === false && scope.enablePan === false) return;
               handleTouchStartDollyPan();
               state = STATE.TOUCH_DOLLY_PAN;
               break;
-            case import_three25.TOUCH.DOLLY_ROTATE:
+            case import_three26.TOUCH.DOLLY_ROTATE:
               if (scope.enableZoom === false && scope.enableRotate === false) return;
               handleTouchStartDollyRotate();
               state = STATE.TOUCH_DOLLY_ROTATE;
@@ -9589,7 +9718,7 @@ var OrbitControls = class extends import_three25.EventDispatcher {
     function trackPointer(event) {
       let position = pointerPositions[event.pointerId];
       if (position === void 0) {
-        position = new import_three25.Vector2();
+        position = new import_three26.Vector2();
         pointerPositions[event.pointerId] = position;
       }
       position.set(event.pageX, event.pageY);
@@ -9609,10 +9738,10 @@ var MapControls = class extends OrbitControls {
   constructor(object, domElement) {
     super(object, domElement);
     this.screenSpacePanning = false;
-    this.mouseButtons.LEFT = import_three25.MOUSE.PAN;
-    this.mouseButtons.RIGHT = import_three25.MOUSE.ROTATE;
-    this.touches.ONE = import_three25.TOUCH.PAN;
-    this.touches.TWO = import_three25.TOUCH.DOLLY_ROTATE;
+    this.mouseButtons.LEFT = import_three26.MOUSE.PAN;
+    this.mouseButtons.RIGHT = import_three26.MOUSE.ROTATE;
+    this.touches.ONE = import_three26.TOUCH.PAN;
+    this.touches.TWO = import_three26.TOUCH.DOLLY_ROTATE;
   }
 };
 
@@ -9653,14 +9782,14 @@ var _Renderer = class _Renderer {
     switch (this.options.camera.type) {
       case "perspective":
       default:
-        return new import_three26.PerspectiveCamera(
+        return new import_three27.PerspectiveCamera(
           this.options.camera.perspective.fov,
           this.options.camera.perspective.aspect ?? this.viewWidth / this.viewHeight,
           this.options.camera.near,
           this.options.camera.far
         );
       case "orthographic":
-        return new import_three26.OrthographicCamera(
+        return new import_three27.OrthographicCamera(
           this.options.camera.orthographic.left ?? this.viewWidth / -2,
           this.options.camera.orthographic.right ?? this.viewWidth / 2,
           this.options.camera.orthographic.top ?? this.viewHeight / 2,
@@ -9671,7 +9800,7 @@ var _Renderer = class _Renderer {
     }
   }
   createRenderer() {
-    const renderer = new import_three26.WebGLRenderer({
+    const renderer = new import_three27.WebGLRenderer({
       antialias: this.options.render.antialias,
       alpha: true,
       powerPreference: "high-performance",
@@ -9679,8 +9808,8 @@ var _Renderer = class _Renderer {
     });
     renderer.setClearColor(0, 0);
     renderer.shadowMap.enabled = true;
-    renderer.shadowMap.type = import_three26.PCFSoftShadowMap;
-    renderer.outputColorSpace = import_three26.SRGBColorSpace;
+    renderer.shadowMap.type = import_three27.PCFSoftShadowMap;
+    renderer.outputColorSpace = import_three27.SRGBColorSpace;
     renderer.setPixelRatio(this.options.render.pixelRatio ?? 1);
     renderer.setSize(this.viewWidth, this.viewHeight);
     return renderer;
@@ -9715,20 +9844,20 @@ var _Renderer = class _Renderer {
       window["__THREE_DEVTOOLS__"].dispatchEvent(new CustomEvent("observe", { detail: this.scene }));
     }
     if (this.options.debug.grid) {
-      const gridHelper = new import_three26.GridHelper(128, 16);
+      const gridHelper = new import_three27.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper);
       this.scene.add(gridHelper);
-      const gridHelper2 = new import_three26.GridHelper(128, 16);
+      const gridHelper2 = new import_three27.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper2);
       gridHelper2.rotation.x = 90 * (Math.PI / 180);
       this.scene.add(gridHelper2);
-      const gridHelper3 = new import_three26.GridHelper(128, 16);
+      const gridHelper3 = new import_three27.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper3);
       gridHelper3.rotation.z = 90 * (Math.PI / 180);
       this.scene.add(gridHelper3);
     }
     if (this.options.debug.axes) {
-      const axesHelper = new import_three26.AxesHelper(64);
+      const axesHelper = new import_three27.AxesHelper(64);
       this._debugHelpers.push(axesHelper);
       this.scene.add(axesHelper);
     }
@@ -9932,8 +10061,8 @@ _Renderer.DEFAULT_OPTIONS = (0, import_ts_deepmerge9.default)({}, {
       top: void 0,
       bottom: void 0
     },
-    position: new import_three26.Vector3(50, 50, 50),
-    lookingAt: new import_three26.Vector3(0, 0, 0)
+    position: new import_three27.Vector3(50, 50, 50),
+    lookingAt: new import_three27.Vector3(0, 0, 0)
   },
   render: {
     fpsLimit: 60,
@@ -10397,19 +10526,19 @@ var AnvilParser = class {
 };
 
 // src/world/Chunk.ts
-var import_three31 = require("three");
+var import_three32 = require("three");
 init_BlockStates();
 init_AssetKey();
 
 // src/world/MineRenderWorld.ts
-var import_three29 = require("three");
+var import_three30 = require("three");
 init_BatchedExecutor();
 init_AssetKey();
 init_BlockStates();
 init_CubeFace();
 
 // src/world/SectionModels.ts
-var import_three28 = require("three");
+var import_three29 = require("three");
 init_AssetKey();
 init_Models();
 init_CubeFace();
@@ -10475,12 +10604,12 @@ var SectionModels = class {
         });
         await object.init();
         const geometry = object.children[0].geometry;
-        geometry.applyMatrix4(new import_three28.Matrix4().makeRotationFromEuler(rotation));
+        geometry.applyMatrix4(new import_three29.Matrix4().makeRotationFromEuler(rotation));
         object.clear();
         const cullFaces = CUBE_FACES.map((face) => {
           const local = CUBE_FACES.findIndex((name) => name === atlas.model.elements[0].faces[face]?.cullface);
           if (local < 0) return 0;
-          const normal = new import_three28.Vector3(...CUBE_FACE_OFFSETS[local]).applyEuler(rotation);
+          const normal = new import_three29.Vector3(...CUBE_FACE_OFFSETS[local]).applyEuler(rotation);
           const world = CUBE_FACE_OFFSETS.findIndex(([x, y, z]) => Math.abs(normal.x - x) < 1e-6 && Math.abs(normal.y - y) < 1e-6 && Math.abs(normal.z - z) < 1e-6);
           return 1 << world;
         });
@@ -10510,20 +10639,20 @@ var MineRenderWorld = class {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new import_three29.Vector3(posOrX, y, z));
+      return this.getBlockAt(new import_three30.Vector3(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new import_three29.Vector3(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new import_three30.Vector3(posOrX[0], posOrX[1], posOrX[2]));
     }
     this.validatePosBounds(posOrX);
     return this.getChunkAt(posOrX)?.getBlockAt(posOrX);
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new import_three29.Vector3(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new import_three30.Vector3(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new import_three29.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new import_three30.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     return this.placeBlock(posOrX, yOrBlock);
   }
@@ -10544,7 +10673,7 @@ var MineRenderWorld = class {
     const collect = async (positions2) => {
       for (const pos of positions2) changes.set(pos.toArray().join(","), pos);
     };
-    const place = (block) => this.placeBlock(new import_three29.Vector3(...block.position), block, collect);
+    const place = (block) => this.placeBlock(new import_three30.Vector3(...block.position), block, collect);
     const keys = /* @__PURE__ */ new Map();
     for (const block of multiblock.blocks) {
       if (Chunk.isAir(block)) continue;
@@ -10622,13 +10751,13 @@ var MineRenderWorld = class {
     for (const pos of positions) {
       this.pendingCulling.set(pos.toArray().join(","), pos.clone());
       for (const offset of CUBE_FACE_OFFSETS) {
-        const neighbor = pos.clone().add(new import_three29.Vector3(...offset));
+        const neighbor = pos.clone().add(new import_three30.Vector3(...offset));
         this.pendingCulling.set(neighbor.toArray().join(","), neighbor);
       }
       for (let y = -1; y <= 1; y++) {
         for (let z = -1; z <= 1; z++) {
           for (let x = -1; x <= 1; x++) {
-            const neighbor = pos.clone().add(new import_three29.Vector3(x, y, z));
+            const neighbor = pos.clone().add(new import_three30.Vector3(x, y, z));
             if (this.getBlockAt(neighbor)?.object?.fluidKind) {
               this.pendingCulling.set(neighbor.toArray().join(","), neighbor);
             }
@@ -10650,7 +10779,7 @@ var MineRenderWorld = class {
             if (!block) continue;
             if (block.object?.fluidKind) {
               await block.object.updateFluid((x, y, z) => {
-                const neighbor = pos.clone().add(new import_three29.Vector3(x, y, z));
+                const neighbor = pos.clone().add(new import_three30.Vector3(x, y, z));
                 const section = this.getChunkAt(neighbor);
                 const object = section?.getBlockAt(neighbor)?.object;
                 return {
@@ -10662,7 +10791,7 @@ var MineRenderWorld = class {
             }
             let mask = 0;
             for (const [face, offset] of CUBE_FACE_OFFSETS.entries()) {
-              const neighbor = pos.clone().add(new import_three29.Vector3(...offset));
+              const neighbor = pos.clone().add(new import_three30.Vector3(...offset));
               if (this.getChunkAt(neighbor)?.isOccludingAt(neighbor)) {
                 mask |= 1 << face;
               }
@@ -10696,14 +10825,14 @@ var MineRenderWorld = class {
     return this._chunks.get(this.worldPosToChunkKey(pos));
   }
   static worldToScenePosition(pos) {
-    return new import_three29.Vector3(
+    return new import_three30.Vector3(
       pos.x * 16,
       pos.y * 16,
       pos.z * 16
     );
   }
   static sceneToWorldPosition(pos) {
-    return new import_three29.Vector3(
+    return new import_three30.Vector3(
       pos.x / 16,
       pos.y / 16,
       pos.z / 16
@@ -10723,10 +10852,10 @@ var MineRenderWorld = class {
 };
 
 // src/world/SectionMesh.ts
-var import_three30 = require("three");
+var import_three31 = require("three");
 init_CanvasCompat();
 init_Materials();
-var SectionMesh = class _SectionMesh extends import_three30.Group {
+var SectionMesh = class _SectionMesh extends import_three31.Group {
   constructor() {
     super(...arguments);
     this.ownedMeshes = [];
@@ -10799,18 +10928,18 @@ var SectionMesh = class _SectionMesh extends import_three30.Group {
           for (let corner = 0; corner < 6; corner++) indices.push(start + sourceIndices.getX(face * 6 + corner) - face * 4);
         }
       }
-      const geometry = new import_three30.BufferGeometry();
-      geometry.setAttribute("position", new import_three30.Float32BufferAttribute(positions, 3));
-      geometry.setAttribute("normal", new import_three30.Float32BufferAttribute(normals, 3));
-      geometry.setAttribute("uv", new import_three30.Float32BufferAttribute(uvs, 2));
-      geometry.setAttribute("color", new import_three30.Float32BufferAttribute(colors, 3));
+      const geometry = new import_three31.BufferGeometry();
+      geometry.setAttribute("position", new import_three31.Float32BufferAttribute(positions, 3));
+      geometry.setAttribute("normal", new import_three31.Float32BufferAttribute(normals, 3));
+      geometry.setAttribute("uv", new import_three31.Float32BufferAttribute(uvs, 2));
+      geometry.setAttribute("color", new import_three31.Float32BufferAttribute(colors, 3));
       geometry.setIndex(indices);
       geometry.computeBoundingBox();
       geometry.computeBoundingSphere();
       const material = Materials.createShadedCanvasMaterial(canvas, false);
       material.vertexColors = true;
       const texture = material.uniforms?.map?.value ?? material.map;
-      const mesh = new import_three30.Mesh(geometry, material);
+      const mesh = new import_three31.Mesh(geometry, material);
       section.add(mesh);
       section.ownedMeshes.push({ mesh, texture });
     }
@@ -10844,10 +10973,10 @@ var Chunk = class _Chunk {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new import_three31.Vector3(posOrX, y, z));
+      return this.getBlockAt(new import_three32.Vector3(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new import_three31.Vector3(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new import_three32.Vector3(posOrX[0], posOrX[1], posOrX[2]));
     }
     const pos = this.worldPosToChunkPos(posOrX);
     const index = _Chunk.chunkPosToBlockIndex(pos);
@@ -10855,10 +10984,10 @@ var Chunk = class _Chunk {
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new import_three31.Vector3(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new import_three32.Vector3(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new import_three31.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new import_three32.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     const worldPos = posOrX;
     const pos = this.worldPosToChunkPos(worldPos);
@@ -10943,7 +11072,7 @@ var Chunk = class _Chunk {
   }
   async clear(onBlocksChanged = this.onBlocksChanged) {
     const positions = [...this.renderedBlocks.keys()].map((index) => this.chunkPosToWorldPos(
-      new import_three31.Vector3(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
+      new import_three32.Vector3(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
     ));
     for (const info of this.renderedBlocks.values()) info.object?.removeFromScene();
     this.sectionBlocks.clear();
@@ -10967,14 +11096,14 @@ var Chunk = class _Chunk {
     return pos.y * 16 * 16 + pos.z * 16 + pos.x;
   }
   worldPosToChunkPos(pos) {
-    return new import_three31.Vector3(
+    return new import_three32.Vector3(
       pos.x - this.x * 16,
       pos.y - this.y * 16,
       pos.z - this.z * 16
     );
   }
   chunkPosToWorldPos(pos) {
-    return new import_three31.Vector3(
+    return new import_three32.Vector3(
       this.x * 16 + pos.x,
       this.y * 16 + pos.y,
       this.z * 16 + pos.z