minerender 2.1.0-alpha.31 → 2.1.0-alpha.33

package/dist/node/index.js

@@ -445,19 +445,19 @@ function isDisposable(obj) {
 var import_three2 = require("three");
 
 // src/util/util.ts
-var CryptoJS = __toESM(require("crypto-js"));
+var import_crypto_js = __toESM(require("crypto-js"));
 var changeEvent = { type: "change" };
 function md5(str) {
-  return CryptoJS.MD5(str).toString(CryptoJS.enc.Hex);
+  return import_crypto_js.default.MD5(str).toString(import_crypto_js.default.enc.Hex);
 }
 function sha1(str) {
-  return CryptoJS.SHA1(str).toString(CryptoJS.enc.Hex);
+  return import_crypto_js.default.SHA1(str).toString(import_crypto_js.default.enc.Hex);
 }
 function sha256(str) {
-  return CryptoJS.SHA256(str).toString(CryptoJS.enc.Hex);
+  return import_crypto_js.default.SHA256(str).toString(import_crypto_js.default.enc.Hex);
 }
 function sha512(str) {
-  return CryptoJS.SHA512(str).toString(CryptoJS.enc.Hex);
+  return import_crypto_js.default.SHA512(str).toString(import_crypto_js.default.enc.Hex);
 }
 function base64encode(str) {
   if (typeof btoa !== "undefined") {
@@ -2922,26 +2922,40 @@ var Entities = class {
     };
     return collect("");
   }
-  static async getEntity(modelKey, textureKey, options) {
+  static async getModelFile(modelKey) {
     const path = isAssetKey(modelKey) ? modelKey.getFullPath() : modelKey.path;
     const key = new AssetKey(modelKey.namespace, path, void 0, void 0, "entity-models", ".json");
-    const model = await Caching.entityModelCache.get(key.serialize(), () => AssetLoader.get(key, "json" /* JSON */));
+    return Caching.entityModelCache.get(key.serialize(), () => AssetLoader.get(key, "json" /* JSON */));
+  }
+  static async getLayerList(modelKey) {
+    return Object.keys((await this.getModelFile(modelKey))?.layers ?? {});
+  }
+  static async getEntity(modelKey, textureKey, options) {
+    const model = await this.getModelFile(modelKey);
     if (!model) return void 0;
-    const layerName = options?.layer ?? "main";
-    const layer = model.layers[layerName];
-    if (!layer) {
-      throw new MineRenderError(`Entity ${model.id} has no layer "${layerName}". Available layers: ${Object.keys(model.layers).join(", ")}`);
-    }
-    let texture;
-    if (textureKey) {
-      const path2 = isAssetKey(textureKey) ? textureKey.getFullPath() : textureKey.path;
-      texture = isAssetKey(textureKey) && textureKey.assetType === "textures" && path2.startsWith("entity/") ? textureKey : new AssetKey(textureKey.namespace, path2, "textures", "entity", "assets", ".png", isAssetKey(textureKey) ? textureKey.root : void 0);
-    } else if (layer.textureLocation !== void 0) {
-      texture = AssetKey.parse("textures", layer.textureLocation.replace(/^([^:]+:)?textures\//, "$1"));
-    } else {
-      texture = await this.resolveTexture(modelKey);
-    }
-    return { key: textureKey ?? modelKey, texture, layer, id: model.id };
+    const names = [...new Set(options?.layers ?? [options?.layer ?? "main"])];
+    if (names.length === 0) throw new MineRenderError(`Entity ${model.id} requires at least one layer`);
+    const selected = names.map((name) => {
+      const layer = model.layers[name];
+      if (!layer) {
+        throw new MineRenderError(`Entity ${model.id} has no layer "${name}". Available layers: ${Object.keys(model.layers).join(", ")}`);
+      }
+      return { name, layer };
+    });
+    const layers = Object.fromEntries(await Promise.all(selected.map(async ({ name, layer }, index) => {
+      const override = options?.textures?.[name] ?? (index === 0 ? textureKey : void 0);
+      let texture;
+      if (override) {
+        const path = isAssetKey(override) ? override.getFullPath() : override.path;
+        texture = isAssetKey(override) && override.assetType === "textures" && path.startsWith("entity/") ? override : new AssetKey(override.namespace, path, "textures", "entity", "assets", ".png", isAssetKey(override) ? override.root : void 0);
+      } else if (layer.textureLocation !== void 0) {
+        texture = AssetKey.parse("textures", layer.textureLocation.replace(/^([^:]+:)?textures\//, "$1"));
+      } else {
+        texture = await this.resolveTexture(modelKey);
+      }
+      return [name, { key: override ?? modelKey, texture, layer }];
+    })));
+    return { ...layers[names[0]], id: model.id, layers };
   }
   static async resolveTexture(modelKey) {
     const path = isAssetKey(modelKey) ? modelKey.getFullPath() : modelKey.path;
@@ -3410,9 +3424,21 @@ var EntityObject = class _EntityObject extends SceneObject {
   dispose() {
     super.dispose();
   }
-  get textureKey() {
-    if (this.entity.texture) return this.entity.texture;
-    const key = this.entity.key;
+  getLayerGroup(name) {
+    return super.getGroupByName(`layer:${name}`);
+  }
+  getGroupByName(name, layerName) {
+    return layerName === void 0 ? super.getGroupByName(name) : this.getLayerGroup(layerName)?.getObjectByName(`group:${name}`);
+  }
+  getMeshByName(name, layerName) {
+    return layerName === void 0 ? super.getMeshByName(name) : this.getLayerGroup(layerName)?.getObjectByName(`mesh:${name}`);
+  }
+  get entityLayers() {
+    return this.entity.layers ?? { main: this.entity };
+  }
+  getTextureKey(layer) {
+    if (layer.texture) return layer.texture;
+    const key = layer.key;
     return new AssetKey(
       key.namespace,
       isAssetKey(key) ? key.getFullPath() : key.path,
@@ -3422,18 +3448,22 @@ var EntityObject = class _EntityObject extends SceneObject {
       ".png"
     );
   }
-  async loadTextures() {
-    this.imageData = await ModelTextures.get(this.textureKey);
+  async loadTextures(layer = this.entity) {
+    return ModelTextures.get(this.getTextureKey(layer));
   }
   createMeshes(force = false) {
     if (this.meshesCreated && !force) return;
     const modelRoot = new import_three12.Object3D();
     if (this.options.flip) modelRoot.scale.set(-1, -1, 1);
     this.add(modelRoot);
-    this.createPart("root", this.entity.layer.root, modelRoot, this.entity.layer.texture, Materials.MISSING_TEXTURE);
+    Object.entries(this.entityLayers).forEach(([name, layer], index) => {
+      const group = this.createGroup(`layer:${name}`);
+      modelRoot.add(group);
+      this.createPart("root", layer.layer.root, group, layer.layer.texture, Materials.MISSING_TEXTURE, index);
+    });
     this.meshesCreated = true;
   }
-  createPart(name, part, parent, textureSize, material) {
+  createPart(name, part, parent, textureSize, material, renderOrder) {
     const anchor = this.createGroup(name);
     anchor.position.fromArray(part.pose.offset);
     anchor.rotation.set(...part.pose.rotation, "ZYX");
@@ -3453,30 +3483,31 @@ var EntityObject = class _EntityObject extends SceneObject {
       ).clone();
       geometry.translate(cube.origin[0] + width / 2, cube.origin[1] + height / 2, cube.origin[2] + depth / 2);
       const mesh = this.createMesh(name, geometry, material);
+      mesh.renderOrder = renderOrder;
       anchor.add(mesh);
       if (this.options.wireframe) addWireframeToMesh(geometry, mesh);
     }
     for (const [childName, child] of Object.entries(part.children)) {
-      this.createPart(childName, child, anchor, size, material);
+      this.createPart(childName, child, anchor, size, material, renderOrder);
     }
   }
   async applyTextures() {
-    const assetKeyStr = this.textureKey.serialize();
-    const keyStr = `entity:${assetKeyStr}`;
-    let mat = Caching.materialCache.getIfPresent(keyStr);
-    if (!mat) {
-      const pending = this.loadTextures();
-      const cachedAsset = Caching.textureAssetCache.getIfPresent(assetKeyStr);
-      await pending;
-      if (!this.imageData) return;
-      const canvas = this.imageData.data.canvas;
-      const createMaterial = () => Materials.createBasicCanvasMaterial(canvas);
-      mat = cachedAsset && Caching.textureAssetCache.getIfPresent(assetKeyStr) === cachedAsset ? Caching.materialCache.get(keyStr, createMaterial) : createMaterial();
-      this.imageData = void 0;
-    }
-    this.iterateAllMeshes((mesh) => {
-      mesh.material = mat;
-    });
+    await Promise.all(Object.entries(this.entityLayers).map(async ([name, layer]) => {
+      const assetKeyStr = this.getTextureKey(layer).serialize();
+      const keyStr = `entity:${assetKeyStr}`;
+      let mat = Caching.materialCache.getIfPresent(keyStr);
+      if (!mat) {
+        const cachedAsset = Caching.textureAssetCache.getIfPresent(assetKeyStr);
+        const imageData = await this.loadTextures(layer);
+        if (!imageData) return;
+        const canvas = imageData.data.canvas;
+        const createMaterial = () => Materials.createBasicCanvasMaterial(canvas);
+        mat = cachedAsset && Caching.textureAssetCache.getIfPresent(assetKeyStr) === cachedAsset ? Caching.materialCache.get(keyStr, createMaterial) : createMaterial();
+      }
+      this.getLayerGroup(name)?.traverse((object) => {
+        if (isMesh(object)) object.material = mat;
+      });
+    }));
     this.notifyDirty();
   }
 };
@@ -3490,16 +3521,16 @@ var GuiObject = class extends SceneObject {
 };
 
 // src/inspector/SceneInspector.ts
-var import_three13 = require("three");
+var import_three14 = require("three");
 var p7 = prefix("SceneInspector");
 var help = "<span>Ctrl+Click to Select<br/></span><br/>";
 var SceneInspector = class {
   constructor(renderer) {
     this.renderer = renderer;
-    this.mouse = new import_three13.Vector2();
+    this.mouse = new import_three14.Vector2();
     this.objectInfoContainer = document.createElement("div");
     this.objectControlsContainer = document.createElement("div");
-    this.raycaster = new import_three13.Raycaster();
+    this.raycaster = new import_three14.Raycaster();
     this.init();
   }
   init() {
@@ -4010,10 +4041,10 @@ var BlockTints = class {
 };
 
 // src/model/scene/ModelObject.ts
-var import_three16 = require("three");
+var import_three17 = require("three");
 
 // src/three/BufferGeometryUtils.js
-var import_three15 = require("three");
+var import_three16 = require("three");
 function computeTangents(geometry) {
   geometry.computeTangents();
   console.warn("THREE.BufferGeometryUtils: .computeTangents() has been removed. Use BufferGeometry.computeTangents() instead.");
@@ -4025,7 +4056,7 @@ function mergeBufferGeometries(geometries, useGroups = false) {
   const attributes = {};
   const morphAttributes = {};
   const morphTargetsRelative = geometries[0].morphTargetsRelative;
-  const mergedGeometry = new import_three15.BufferGeometry();
+  const mergedGeometry = new import_three16.BufferGeometry();
   let offset = 0;
   for (let i = 0; i < geometries.length; ++i) {
     const geometry = geometries[i];
@@ -4149,7 +4180,7 @@ function mergeBufferAttributes(attributes) {
     array.set(attributes[i].array, offset);
     offset += attributes[i].array.length;
   }
-  return new import_three15.BufferAttribute(array, itemSize, normalized);
+  return new import_three16.BufferAttribute(array, itemSize, normalized);
 }
 function interleaveAttributes(attributes) {
   let TypedArray;
@@ -4165,7 +4196,7 @@ function interleaveAttributes(attributes) {
     arrayLength += attribute.array.length;
     stride += attribute.itemSize;
   }
-  const interleavedBuffer = new import_three15.InterleavedBuffer(new TypedArray(arrayLength), stride);
+  const interleavedBuffer = new import_three16.InterleavedBuffer(new TypedArray(arrayLength), stride);
   let offset = 0;
   const res = [];
   const getters = ["getX", "getY", "getZ", "getW"];
@@ -4174,7 +4205,7 @@ function interleaveAttributes(attributes) {
     const attribute = attributes[j];
     const itemSize = attribute.itemSize;
     const count = attribute.count;
-    const iba = new import_three15.InterleavedBufferAttribute(interleavedBuffer, itemSize, offset, attribute.normalized);
+    const iba = new import_three16.InterleavedBufferAttribute(interleavedBuffer, itemSize, offset, attribute.normalized);
     res.push(iba);
     offset += itemSize;
     for (let c = 0; c < count; c++) {
@@ -4258,13 +4289,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_three15.BufferAttribute(buffer, oldAttribute.itemSize, oldAttribute.normalized);
+    const attribute = new import_three16.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_three15.BufferAttribute(buffer2, oldMorphAttribute.itemSize, oldMorphAttribute.normalized);
+        const morphAttribute = new import_three16.BufferAttribute(buffer2, oldMorphAttribute.itemSize, oldMorphAttribute.normalized);
         result.morphAttributes[name][j] = morphAttribute;
       }
     }
@@ -4273,11 +4304,11 @@ function mergeVertices(geometry, tolerance = 1e-4) {
   return result;
 }
 function toTrianglesDrawMode(geometry, drawMode) {
-  if (drawMode === import_three15.TrianglesDrawMode) {
+  if (drawMode === import_three16.TrianglesDrawMode) {
     console.warn("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles.");
     return geometry;
   }
-  if (drawMode === import_three15.TriangleFanDrawMode || drawMode === import_three15.TriangleStripDrawMode) {
+  if (drawMode === import_three16.TriangleFanDrawMode || drawMode === import_three16.TriangleStripDrawMode) {
     let index = geometry.getIndex();
     if (index === null) {
       const indices = [];
@@ -4295,7 +4326,7 @@ function toTrianglesDrawMode(geometry, drawMode) {
     }
     const numberOfTriangles = index.count - 2;
     const newIndices = [];
-    if (drawMode === import_three15.TriangleFanDrawMode) {
+    if (drawMode === import_three16.TriangleFanDrawMode) {
       for (let i = 1; i <= numberOfTriangles; i++) {
         newIndices.push(index.getX(0));
         newIndices.push(index.getX(i));
@@ -4331,15 +4362,15 @@ function computeMorphedAttributes(object) {
     console.error("THREE.BufferGeometryUtils: Geometry is not of type BufferGeometry.");
     return null;
   }
-  const _vA = new import_three15.Vector3();
-  const _vB = new import_three15.Vector3();
-  const _vC = new import_three15.Vector3();
-  const _tempA = new import_three15.Vector3();
-  const _tempB = new import_three15.Vector3();
-  const _tempC = new import_three15.Vector3();
-  const _morphA = new import_three15.Vector3();
-  const _morphB = new import_three15.Vector3();
-  const _morphC = new import_three15.Vector3();
+  const _vA = new import_three16.Vector3();
+  const _vB = new import_three16.Vector3();
+  const _vC = new import_three16.Vector3();
+  const _tempA = new import_three16.Vector3();
+  const _tempB = new import_three16.Vector3();
+  const _tempC = new import_three16.Vector3();
+  const _morphA = new import_three16.Vector3();
+  const _morphB = new import_three16.Vector3();
+  const _morphC = new import_three16.Vector3();
   function _calculateMorphedAttributeData(object2, material2, attribute, morphAttribute, morphTargetsRelative2, a2, b2, c2, modifiedAttributeArray) {
     _vA.fromBufferAttribute(attribute, a2);
     _vB.fromBufferAttribute(attribute, b2);
@@ -4534,8 +4565,8 @@ function computeMorphedAttributes(object) {
       }
     }
   }
-  const morphedPositionAttribute = new import_three15.Float32BufferAttribute(modifiedPosition, 3);
-  const morphedNormalAttribute = new import_three15.Float32BufferAttribute(modifiedNormal, 3);
+  const morphedPositionAttribute = new import_three16.Float32BufferAttribute(modifiedPosition, 3);
+  const morphedNormalAttribute = new import_three16.Float32BufferAttribute(modifiedNormal, 3);
   return {
     positionAttribute,
     normalAttribute,
@@ -4586,7 +4617,7 @@ var ModelObject = class _ModelObject extends SceneObject {
         this.atlas.model.elements?.forEach((el) => {
           const elGeo = this._getBoxGeometryFromElement(el).clone();
           if (this.options.uvLockRotation) {
-            UVMapper.lockUvs(elGeo, el.faces, this.atlas, new import_three16.Euler(...this.options.uvLockRotation));
+            UVMapper.lockUvs(elGeo, el.faces, this.atlas, new import_three17.Euler(...this.options.uvLockRotation));
           }
           if (this.options.tints) {
             const colors = new Float32Array(elGeo.getAttribute("position").count * 3).fill(1);
@@ -4595,19 +4626,19 @@ var ModelObject = class _ModelObject extends SceneObject {
               if (tintIndex === void 0 || tintIndex < 0) continue;
               const tint = this.options.tints[tintIndex];
               if (tint === void 0) continue;
-              const color = new import_three16.Color(tint);
+              const color = new import_three17.Color(tint);
               for (let vertex = 0; vertex < 4; vertex++) {
                 color.toArray(colors, (faceIndex * 4 + vertex) * 3);
               }
             }
-            elGeo.setAttribute("color", new import_three16.BufferAttribute(colors, 3));
+            elGeo.setAttribute("color", new import_three17.BufferAttribute(colors, 3));
           }
-          elGeo.applyMatrix4(new import_three16.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_three16.Matrix4().makeTranslation(el.from[0], el.from[1], el.from[2]));
+          elGeo.applyMatrix4(new import_three17.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_three17.Matrix4().makeTranslation(el.from[0], el.from[1], el.from[2]));
           if (el.rotation) {
             applyElementRotation(el.rotation, elGeo);
           }
-          elGeo.applyMatrix4(new import_three16.Matrix4().makeTranslation(-8, -8, -8));
+          elGeo.applyMatrix4(new import_three17.Matrix4().makeTranslation(-8, -8, -8));
           if (displayTransform) DisplayTransforms.apply(elGeo, displayTransform);
           if (this.options.mergeMeshes) {
             allGeos.push(elGeo);
@@ -4629,7 +4660,7 @@ var ModelObject = class _ModelObject extends SceneObject {
       if (allGeos.length > 0) {
         combinedGeo = mergeBufferGeometries(allGeos);
       } else {
-        combinedGeo = new import_three16.BoxGeometry(16, 16, 16);
+        combinedGeo = new import_three17.BoxGeometry(16, 16, 16);
         if (displayTransform) DisplayTransforms.apply(combinedGeo, displayTransform);
       }
       combinedGeo.computeBoundingBox();
@@ -4682,7 +4713,7 @@ function isModelObject(obj) {
 
 // src/model/block/scene/BlockObject.ts
 var import_ts_deepmerge6 = __toESM(require_dist());
-var import_three17 = require("three");
+var import_three18 = require("three");
 var p10 = prefix("BlockObject");
 function matchesCondition(condition, state) {
   return Object.entries(condition).every(([key, value]) => {
@@ -4744,7 +4775,7 @@ var BlockObject = class _BlockObject extends SceneObject {
       if (isModelObject(model)) {
         model.removeFromScene();
       } else if (isInstanceReference(model)) {
-        model.setScale(new import_three17.Vector3(0, 0, 0));
+        model.setScale(new import_three18.Vector3(0, 0, 0));
       }
     }
     super.removeFromScene();
@@ -4805,7 +4836,7 @@ var BlockObject = class _BlockObject extends SceneObject {
     }
     for (let model of this._models) {
       if (isInstanceReference(model)) {
-        model.setScale(new import_three17.Vector3(0, 0, 0));
+        model.setScale(new import_three18.Vector3(0, 0, 0));
       } else {
         model.dispose();
       }
@@ -4842,7 +4873,7 @@ var BlockObject = class _BlockObject extends SceneObject {
     await this.createVariant(variant);
   }
   async createVariant(variant) {
-    const rotation = new import_three17.Euler();
+    const rotation = new import_three18.Euler();
     if (typeof variant.x !== "undefined") {
       rotation.x = toRadians(clampRotationDegrees(variant.x));
     }
@@ -4931,7 +4962,7 @@ var BlockObject = class _BlockObject extends SceneObject {
   setPositionRotationScaleAt(index, position, rotation, scale) {
     super.setPositionRotationScaleAt(index, position, rotation, scale);
   }
-  getMatrixAt(index, matrix = new import_three17.Matrix4()) {
+  getMatrixAt(index, matrix = new import_three18.Matrix4()) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const child = this._models[0];
     if (child && isModelObject(child)) {
@@ -5006,7 +5037,7 @@ var StructureParser = class {
 };
 
 // src/renderer/MineRenderScene.ts
-var import_three19 = require("three");
+var import_three20 = require("three");
 var import_ts_deepmerge8 = __toESM(require_dist());
 
 // src/skin/SkinPart.ts
@@ -5731,7 +5762,7 @@ var slimSkinGeometries = {
 var import_ts_deepmerge7 = __toESM(require_dist());
 
 // src/skin/SkinTextures.ts
-var import_three18 = require("three");
+var import_three19 = require("three");
 
 // src/skin/SkinImage.ts
 var SkinImage = class {
@@ -5808,11 +5839,11 @@ var SkinTextures = class {
     });
   }
   static createMaterial(pixels, width, height, transparent = true) {
-    const texture = Textures.initTextureProps(new import_three18.DataTexture(pixels, width, height));
-    texture.colorSpace = import_three18.SRGBColorSpace;
+    const texture = Textures.initTextureProps(new import_three19.DataTexture(pixels, width, height));
+    texture.colorSpace = import_three19.SRGBColorSpace;
     texture.flipY = true;
     texture.needsUpdate = true;
-    return new import_three18.MeshBasicMaterial({ map: texture, transparent, side: transparent ? import_three18.DoubleSide : import_three18.FrontSide, alphaTest: transparent ? 0.1 : 0 });
+    return new import_three19.MeshBasicMaterial({ map: texture, transparent, side: transparent ? import_three19.DoubleSide : import_three19.FrontSide, alphaTest: transparent ? 0.1 : 0 });
   }
   static isSlim(image, scale) {
     for (const [x, y] of [[46, 52], [54, 20]]) {
@@ -6039,7 +6070,7 @@ var SkinObject = class extends SceneObject {
 };
 
 // src/renderer/MineRenderScene.ts
-var MineRenderScene = class _MineRenderScene extends import_three19.Scene {
+var MineRenderScene = class _MineRenderScene extends import_three20.Scene {
   constructor(options) {
     super();
     this.isMineRenderScene = true;
@@ -6163,17 +6194,17 @@ function isMineRenderScene(obj) {
 }
 
 // src/renderer/Renderer.ts
-var import_three21 = require("three");
+var import_three22 = require("three");
 var import_ts_deepmerge9 = __toESM(require_dist());
 var import_stats = __toESM(require("stats.js"));
 var import_postprocessing = require("postprocessing");
 
 // src/three/OrbitControls.js
-var import_three20 = require("three");
+var import_three21 = require("three");
 var _changeEvent = { type: "change" };
 var _startEvent = { type: "start" };
 var _endEvent = { type: "end" };
-var OrbitControls = class extends import_three20.EventDispatcher {
+var OrbitControls = class extends import_three21.EventDispatcher {
   constructor(object, domElement) {
     super();
     if (domElement === void 0) console.warn('THREE.OrbitControls: The second parameter "domElement" is now mandatory.');
@@ -6182,7 +6213,7 @@ var OrbitControls = class extends import_three20.EventDispatcher {
     this.domElement = domElement;
     this.domElement.style.touchAction = "none";
     this.enabled = true;
-    this.target = new import_three20.Vector3();
+    this.target = new import_three21.Vector3();
     this.minDistance = 0;
     this.maxDistance = Infinity;
     this.minZoom = 0;
@@ -6204,8 +6235,8 @@ var OrbitControls = class extends import_three20.EventDispatcher {
     this.autoRotate = false;
     this.autoRotateSpeed = 2;
     this.keys = { LEFT: "ArrowLeft", UP: "ArrowUp", RIGHT: "ArrowRight", BOTTOM: "ArrowDown" };
-    this.mouseButtons = { LEFT: import_three20.MOUSE.ROTATE, MIDDLE: import_three20.MOUSE.DOLLY, RIGHT: import_three20.MOUSE.PAN };
-    this.touches = { ONE: import_three20.TOUCH.ROTATE, TWO: import_three20.TOUCH.DOLLY_PAN };
+    this.mouseButtons = { LEFT: import_three21.MOUSE.ROTATE, MIDDLE: import_three21.MOUSE.DOLLY, RIGHT: import_three21.MOUSE.PAN };
+    this.touches = { ONE: import_three21.TOUCH.ROTATE, TWO: import_three21.TOUCH.DOLLY_PAN };
     this.target0 = this.target.clone();
     this.position0 = this.object.position.clone();
     this.zoom0 = this.object.zoom;
@@ -6234,11 +6265,11 @@ var OrbitControls = class extends import_three20.EventDispatcher {
       state = STATE.NONE;
     };
     this.update = function() {
-      const offset = new import_three20.Vector3();
-      const quat = new import_three20.Quaternion().setFromUnitVectors(object.up, new import_three20.Vector3(0, 1, 0));
+      const offset = new import_three21.Vector3();
+      const quat = new import_three21.Quaternion().setFromUnitVectors(object.up, new import_three21.Vector3(0, 1, 0));
       const quatInverse = quat.clone().invert();
-      const lastPosition = new import_three20.Vector3();
-      const lastQuaternion = new import_three20.Quaternion();
+      const lastPosition = new import_three21.Vector3();
+      const lastQuaternion = new import_three21.Quaternion();
       const twoPI = 2 * Math.PI;
       return function update() {
         const position = scope.object.position;
@@ -6324,20 +6355,20 @@ var OrbitControls = class extends import_three20.EventDispatcher {
     };
     let state = STATE.NONE;
     const EPS = 1e-6;
-    const spherical = new import_three20.Spherical();
-    const sphericalDelta = new import_three20.Spherical();
+    const spherical = new import_three21.Spherical();
+    const sphericalDelta = new import_three21.Spherical();
     let scale = 1;
-    const panOffset = new import_three20.Vector3();
+    const panOffset = new import_three21.Vector3();
     let zoomChanged = false;
-    const rotateStart = new import_three20.Vector2();
-    const rotateEnd = new import_three20.Vector2();
-    const rotateDelta = new import_three20.Vector2();
-    const panStart = new import_three20.Vector2();
-    const panEnd = new import_three20.Vector2();
-    const panDelta = new import_three20.Vector2();
-    const dollyStart = new import_three20.Vector2();
-    const dollyEnd = new import_three20.Vector2();
-    const dollyDelta = new import_three20.Vector2();
+    const rotateStart = new import_three21.Vector2();
+    const rotateEnd = new import_three21.Vector2();
+    const rotateDelta = new import_three21.Vector2();
+    const panStart = new import_three21.Vector2();
+    const panEnd = new import_three21.Vector2();
+    const panDelta = new import_three21.Vector2();
+    const dollyStart = new import_three21.Vector2();
+    const dollyEnd = new import_three21.Vector2();
+    const dollyDelta = new import_three21.Vector2();
     const pointers = [];
     const pointerPositions = {};
     function getAutoRotationAngle() {
@@ -6353,7 +6384,7 @@ var OrbitControls = class extends import_three20.EventDispatcher {
       sphericalDelta.phi -= angle;
     }
     const panLeft = function() {
-      const v = new import_three20.Vector3();
+      const v = new import_three21.Vector3();
       return function panLeft2(distance, objectMatrix) {
         v.setFromMatrixColumn(objectMatrix, 0);
         v.multiplyScalar(-distance);
@@ -6361,7 +6392,7 @@ var OrbitControls = class extends import_three20.EventDispatcher {
       };
     }();
     const panUp = function() {
-      const v = new import_three20.Vector3();
+      const v = new import_three21.Vector3();
       return function panUp2(distance, objectMatrix) {
         if (scope.screenSpacePanning === true) {
           v.setFromMatrixColumn(objectMatrix, 1);
@@ -6374,7 +6405,7 @@ var OrbitControls = class extends import_three20.EventDispatcher {
       };
     }();
     const pan = function() {
-      const offset = new import_three20.Vector3();
+      const offset = new import_three21.Vector3();
       return function pan2(deltaX, deltaY) {
         const element = scope.domElement;
         if (scope.object.isPerspectiveCamera) {
@@ -6623,12 +6654,12 @@ var OrbitControls = class extends import_three20.EventDispatcher {
           mouseAction = -1;
       }
       switch (mouseAction) {
-        case import_three20.MOUSE.DOLLY:
+        case import_three21.MOUSE.DOLLY:
           if (scope.enableZoom === false) return;
           handleMouseDownDolly(event);
           state = STATE.DOLLY;
           break;
-        case import_three20.MOUSE.ROTATE:
+        case import_three21.MOUSE.ROTATE:
           if (event.ctrlKey || event.metaKey || event.shiftKey) {
             if (scope.enablePan === false) return;
             handleMouseDownPan(event);
@@ -6639,7 +6670,7 @@ var OrbitControls = class extends import_three20.EventDispatcher {
             state = STATE.ROTATE;
           }
           break;
-        case import_three20.MOUSE.PAN:
+        case import_three21.MOUSE.PAN:
           if (event.ctrlKey || event.metaKey || event.shiftKey) {
             if (scope.enableRotate === false) return;
             handleMouseDownRotate(event);
@@ -6695,12 +6726,12 @@ var OrbitControls = class extends import_three20.EventDispatcher {
       switch (pointers.length) {
         case 1:
           switch (scope.touches.ONE) {
-            case import_three20.TOUCH.ROTATE:
+            case import_three21.TOUCH.ROTATE:
               if (scope.enableRotate === false) return;
               handleTouchStartRotate();
               state = STATE.TOUCH_ROTATE;
               break;
-            case import_three20.TOUCH.PAN:
+            case import_three21.TOUCH.PAN:
               if (scope.enablePan === false) return;
               handleTouchStartPan();
               state = STATE.TOUCH_PAN;
@@ -6711,12 +6742,12 @@ var OrbitControls = class extends import_three20.EventDispatcher {
           break;
         case 2:
           switch (scope.touches.TWO) {
-            case import_three20.TOUCH.DOLLY_PAN:
+            case import_three21.TOUCH.DOLLY_PAN:
               if (scope.enableZoom === false && scope.enablePan === false) return;
               handleTouchStartDollyPan();
               state = STATE.TOUCH_DOLLY_PAN;
               break;
-            case import_three20.TOUCH.DOLLY_ROTATE:
+            case import_three21.TOUCH.DOLLY_ROTATE:
               if (scope.enableZoom === false && scope.enableRotate === false) return;
               handleTouchStartDollyRotate();
               state = STATE.TOUCH_DOLLY_ROTATE;
@@ -6783,7 +6814,7 @@ var OrbitControls = class extends import_three20.EventDispatcher {
     function trackPointer(event) {
       let position = pointerPositions[event.pointerId];
       if (position === void 0) {
-        position = new import_three20.Vector2();
+        position = new import_three21.Vector2();
         pointerPositions[event.pointerId] = position;
       }
       position.set(event.pageX, event.pageY);
@@ -6803,10 +6834,10 @@ var MapControls = class extends OrbitControls {
   constructor(object, domElement) {
     super(object, domElement);
     this.screenSpacePanning = false;
-    this.mouseButtons.LEFT = import_three20.MOUSE.PAN;
-    this.mouseButtons.RIGHT = import_three20.MOUSE.ROTATE;
-    this.touches.ONE = import_three20.TOUCH.PAN;
-    this.touches.TWO = import_three20.TOUCH.DOLLY_ROTATE;
+    this.mouseButtons.LEFT = import_three21.MOUSE.PAN;
+    this.mouseButtons.RIGHT = import_three21.MOUSE.ROTATE;
+    this.touches.ONE = import_three21.TOUCH.PAN;
+    this.touches.TWO = import_three21.TOUCH.DOLLY_ROTATE;
   }
 };
 
@@ -6851,8 +6882,8 @@ var Renderer = class _Renderer {
           top: void 0,
           bottom: void 0
         },
-        position: new import_three21.Vector3(50, 50, 50),
-        lookingAt: new import_three21.Vector3(0, 0, 0)
+        position: new import_three22.Vector3(50, 50, 50),
+        lookingAt: new import_three22.Vector3(0, 0, 0)
       },
       render: {
         fpsLimit: 60,
@@ -6882,14 +6913,14 @@ var Renderer = class _Renderer {
     switch (this.options.camera.type) {
       case "perspective":
       default:
-        return new import_three21.PerspectiveCamera(
+        return new import_three22.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_three21.OrthographicCamera(
+        return new import_three22.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,
@@ -6900,7 +6931,7 @@ var Renderer = class _Renderer {
     }
   }
   createRenderer() {
-    const renderer = new import_three21.WebGLRenderer({
+    const renderer = new import_three22.WebGLRenderer({
       antialias: this.options.render.antialias,
       alpha: true,
       powerPreference: "high-performance",
@@ -6908,8 +6939,8 @@ var Renderer = class _Renderer {
     });
     renderer.setClearColor(0, 0);
     renderer.shadowMap.enabled = true;
-    renderer.shadowMap.type = import_three21.PCFSoftShadowMap;
-    renderer.outputColorSpace = import_three21.SRGBColorSpace;
+    renderer.shadowMap.type = import_three22.PCFSoftShadowMap;
+    renderer.outputColorSpace = import_three22.SRGBColorSpace;
     renderer.setSize(this.viewWidth, this.viewHeight);
     return renderer;
   }
@@ -6943,20 +6974,20 @@ var Renderer = class _Renderer {
       window["__THREE_DEVTOOLS__"].dispatchEvent(new CustomEvent("observe", { detail: this.scene }));
     }
     if (this.options.debug.grid) {
-      const gridHelper = new import_three21.GridHelper(128, 16);
+      const gridHelper = new import_three22.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper);
       this.scene.add(gridHelper);
-      const gridHelper2 = new import_three21.GridHelper(128, 16);
+      const gridHelper2 = new import_three22.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper2);
       gridHelper2.rotation.x = 90 * (Math.PI / 180);
       this.scene.add(gridHelper2);
-      const gridHelper3 = new import_three21.GridHelper(128, 16);
+      const gridHelper3 = new import_three22.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_three21.AxesHelper(64);
+      const axesHelper = new import_three22.AxesHelper(64);
       this._debugHelpers.push(axesHelper);
       this.scene.add(axesHelper);
     }
@@ -7311,10 +7342,10 @@ var Skins = class {
 };
 
 // src/world/Chunk.ts
-var import_three24 = require("three");
+var import_three25 = require("three");
 
 // src/world/MineRenderWorld.ts
-var import_three23 = require("three");
+var import_three24 = require("three");
 var MineRenderWorld = class {
   constructor(scene) {
     this._size = 4;
@@ -7325,10 +7356,10 @@ var MineRenderWorld = class {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new import_three23.Vector3(posOrX, y, z));
+      return this.getBlockAt(new import_three24.Vector3(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new import_three23.Vector3(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new import_three24.Vector3(posOrX[0], posOrX[1], posOrX[2]));
     }
     const chunk = this.getChunkAt(posOrX);
     if (typeof chunk === "undefined") {
@@ -7339,10 +7370,10 @@ var MineRenderWorld = class {
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new import_three23.Vector3(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new import_three24.Vector3(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new import_three23.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new import_three24.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     this.validatePosBounds(posOrX);
     const chunk = this.getOrCreateChunkAt(posOrX);
@@ -7388,14 +7419,14 @@ var MineRenderWorld = class {
     return this._chunks[index];
   }
   static worldToScenePosition(pos) {
-    return new import_three23.Vector3(
+    return new import_three24.Vector3(
       pos.x * 16,
       pos.y * 16,
       pos.z * 16
     );
   }
   static sceneToWorldPosition(pos) {
-    return new import_three23.Vector3(
+    return new import_three24.Vector3(
       pos.x / 16,
       pos.y / 16,
       pos.z / 16
@@ -7432,12 +7463,12 @@ var Chunk = class _Chunk {
     this.x = x;
     this.y = y;
     this.z = z;
-    let anchor = new import_three24.Object3D();
+    let anchor = new import_three25.Object3D();
     this._anchor = anchor;
     scene.add(anchor);
     anchor.position.set(this.x * 256 + 128 - 8, this.y * 256 + 128 - 8, this.z * 256 + 128 - 8);
     addBox3WireframeToObject(
-      new import_three24.Box3(new import_three24.Vector3(0, 0, 0), new import_three24.Vector3(256, 256, 256)),
+      new import_three25.Box3(new import_three25.Vector3(0, 0, 0), new import_three25.Vector3(256, 256, 256)),
       anchor,
       16776960,
       4
@@ -7445,10 +7476,10 @@ var Chunk = class _Chunk {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new import_three24.Vector3(posOrX, y, z));
+      return this.getBlockAt(new import_three25.Vector3(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new import_three24.Vector3(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new import_three25.Vector3(posOrX[0], posOrX[1], posOrX[2]));
     }
     const pos = this.worldPosToChunkPos(posOrX);
     const index = _Chunk.chunkPosToBlockIndex(pos);
@@ -7456,10 +7487,10 @@ var Chunk = class _Chunk {
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new import_three24.Vector3(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new import_three25.Vector3(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new import_three24.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new import_three25.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     const worldPos = posOrX;
     const pos = this.worldPosToChunkPos(worldPos);
@@ -7505,7 +7536,7 @@ var Chunk = class _Chunk {
   }
   async clear() {
     let promises = [];
-    let pos = new import_three24.Vector3();
+    let pos = new import_three25.Vector3();
     for (let x = 0; x < 16; x++) {
       for (let z = 0; z < 16; z++) {
         for (let y = 0; y < 16; y++) {
@@ -7524,14 +7555,14 @@ var Chunk = class _Chunk {
     return pos.y * 16 * 16 + pos.z * 16 + pos.x;
   }
   worldPosToChunkPos(pos) {
-    return new import_three24.Vector3(
+    return new import_three25.Vector3(
       pos.x - this.x * 16,
       pos.y - this.y * 16,
       pos.z - this.z * 16
     );
   }
   chunkPosToWorldPos(pos) {
-    return new import_three24.Vector3(
+    return new import_three25.Vector3(
       this.x * 16 + pos.x,
       this.y * 16 + pos.y,
       this.z * 16 + pos.z