minerender 2.1.0-alpha.27 → 2.1.0-alpha.29

package/dist/browser/index.js

@@ -195,6 +195,7 @@ __export(index_browser_exports, {
   SchematicParser: () => SchematicParser,
   SkinObject: () => SkinObject,
   SkinPart: () => SkinPart,
+  SkinTextures: () => SkinTextures,
   Skins: () => Skins,
   StructureParser: () => StructureParser,
   TextureAtlas: () => TextureAtlas,
@@ -1467,7 +1468,7 @@ var Models = class _Models {
   }
   static async getItemModel(key) {
     const itemKey = new AssetKey(key.namespace, key.path, "items", void 0, key.rootType, ".json", key.root);
-    const model = await this.PERSISTENT_CACHE.getOrLoad(itemKey.serialize(), async () => {
+    const model = await this.PERSISTENT_CACHE.getOrLoad(AssetLoader.persistentKey(itemKey.serialize()), async () => {
       const result = await AssetLoader.getFirst([itemKey, key], "json" /* JSON */);
       if (!result) return void 0;
       if (result.key.assetType !== "items") return { ...result.asset, key };
@@ -1513,7 +1514,7 @@ var Models = class _Models {
     }
     const keyStr = key.serialize();
     return Caching.rawModelCache.get(keyStr, (k) => {
-      return this.PERSISTENT_CACHE.getOrLoad(keyStr, (k1) => {
+      return this.PERSISTENT_CACHE.getOrLoad(AssetLoader.persistentKey(keyStr), (k1) => {
         return AssetLoader.get(key, "model" /* MODEL */);
       });
     }).then((asset) => {
@@ -1585,7 +1586,7 @@ var BlockStates = class {
     }
     const keyStr = key.serialize();
     return Caching.blockStateCache.get(keyStr, (k) => {
-      return this.PERSISTENT_CACHE.getOrLoad(keyStr, (k1) => {
+      return this.PERSISTENT_CACHE.getOrLoad(AssetLoader.persistentKey(keyStr), (k1) => {
         return AssetLoader.get(key, "blockstate" /* BLOCKSTATE */);
       });
     }).then((asset) => {
@@ -1631,6 +1632,14 @@ var Assets = class {
 var AssetSource = class {
   constructor() {
   }
+  /**
+   * Identifies this source's content across sessions for persistent caching. Sources that
+   * cannot tell whether their content changed (an unnamed archive, for example) return
+   * undefined, which keeps their results out of long-lived caches.
+   */
+  get cacheId() {
+    return void 0;
+  }
 };
 var AssetLoadError = class extends Error {
   constructor(source, key, path, cause) {
@@ -1843,6 +1852,9 @@ var _HostedAssetSource = class _HostedAssetSource extends AssetSource {
   get root() {
     return this._root;
   }
+  get cacheId() {
+    return `hosted:${this._root}`;
+  }
   get options() {
     return this._options;
   }
@@ -1919,9 +1931,10 @@ var HostedAssetSource = _HostedAssetSource;
 // src/assets/source/archive/BrowserArchiveProxy.ts
 var import_zip = require("@zip.js/zip.js");
 var BrowserArchiveProxy = class {
-  constructor(blob) {
+  constructor(blob, id) {
     this._blob = blob;
     this._reader = new import_zip.ZipReader(new import_zip.BlobReader(this._blob));
+    this.id = id ?? (typeof File !== "undefined" && blob instanceof File ? `${blob.name}:${blob.size}:${blob.lastModified}` : void 0);
   }
   async getEntries() {
     return (await this._reader.getEntries()).map((e) => {
@@ -1946,6 +1959,10 @@ var ArchiveAssetSource = class _ArchiveAssetSource extends AssetSource {
   static blob(blob) {
     return new _ArchiveAssetSource(new BrowserArchiveProxy(blob));
   }
+  get cacheId() {
+    const id = this._archiveProxy.id;
+    return id === void 0 ? void 0 : `archive:${id}`;
+  }
   async getEntries() {
     return this._archiveProxy.getEntries();
   }
@@ -1988,6 +2005,7 @@ var ArchiveAssetSource = class _ArchiveAssetSource extends AssetSource {
 
 // src/assets/AssetLoader.ts
 var p4 = prefix("AssetLoader");
+var FALLBACK_ROOT = "https://raw.githubusercontent.com/InventivetalentDev/minerender-fallback-assets/master";
 var _AssetLoader = class _AssetLoader {
   static get version() {
     return this.ROOT.substring(this.ROOT.lastIndexOf("/") + 1);
@@ -2003,6 +2021,28 @@ var _AssetLoader = class _AssetLoader {
     }
     Caching.clear();
   }
+  /**
+   * Scope for persistent cache keys. Empty with only the default vanilla sources, so their
+   * entries stay valid across sessions; otherwise it names every added source (resource packs,
+   * mirrors) so their results never masquerade as vanilla assets after a reload.
+   */
+  static get persistentScope() {
+    const parts = [];
+    for (const { key, source } of this._SOURCES) {
+      const id = source.cacheId;
+      if (key === "mcassets" && id === `hosted:${this.ROOT}`) continue;
+      if (key === "mcassets-fallback" && id === `hosted:${FALLBACK_ROOT}`) continue;
+      if (id === void 0) return this.SESSION_SCOPE;
+      parts.push(`${key}=${id}`);
+    }
+    return parts.join("|");
+  }
+  /** Prefixes a persistent cache key with the current source scope. */
+  static persistentKey(key) {
+    const scope = this.persistentScope;
+    return scope ? `${scope}
+${key}` : key;
+  }
   static addSource(key, source, override = true) {
     if (override) {
       const existing = this.removeSource(key);
@@ -2064,7 +2104,9 @@ var _AssetLoader = class _AssetLoader {
 };
 _AssetLoader.ROOT = DEFAULT_ROOT;
 _AssetLoader._SOURCES = [];
-_AssetLoader.addSource("mcassets-fallback", new HostedAssetSource("https://raw.githubusercontent.com/InventivetalentDev/minerender-fallback-assets/master", { retryDefaults: false }));
+/** Used when a registered source cannot identify its content, so nothing persists past this session. */
+_AssetLoader.SESSION_SCOPE = `session:${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`;
+_AssetLoader.addSource("mcassets-fallback", new HostedAssetSource(FALLBACK_ROOT, { retryDefaults: false }));
 _AssetLoader.addSource("mcassets", new HostedAssetSource(_AssetLoader.ROOT, { retryDefaults: false }));
 var AssetLoader = _AssetLoader;
 
@@ -2107,7 +2149,7 @@ var ModelTextures = class {
     }
     const keyStr = key.serialize();
     return Caching.textureMetaCache.get(keyStr, (k) => {
-      return this.PERSISTENT_META_CACHE.getOrLoad(keyStr, (k1) => {
+      return this.PERSISTENT_META_CACHE.getOrLoad(AssetLoader.persistentKey(keyStr), (k1) => {
         return AssetLoader.get(key, "meta" /* META */).then((asset) => {
           if (asset)
             asset.key = key;
@@ -4754,7 +4796,9 @@ var _BlockObject = class _BlockObject extends SceneObject {
     if (typeof variant.y !== "undefined") {
       rotation.y = toRadians(clampRotationDegrees(typeof variant.x !== "undefined" ? variant.y : 360 - variant.y));
     }
-    const model = await Models.getMerged(AssetKey.parse("models", variant.model));
+    const modelKey = AssetKey.parse("models", variant.model);
+    modelKey.root = this.blockState.key?.root;
+    const model = await Models.getMerged(modelKey);
     const options = {
       ...this.options,
       tints: model ? await BlockTints.get(this.blockState.key, this.state, model, this.options.tints) : this.options.tints,
@@ -4913,7 +4957,7 @@ var StructureParser = class {
 };
 
 // src/renderer/MineRenderScene.ts
-var import_three18 = require("three");
+var import_three19 = require("three");
 var import_ts_deepmerge8 = __toESM(require_dist());
 
 // src/skin/SkinPart.ts
@@ -5550,56 +5594,12 @@ var baseSkinCoordinates = {
     }
   },
   cape: {
-    //TODO
-    east: {
-      uv: [
-        0,
-        36,
-        4,
-        48
-      ]
-    },
-    west: {
-      uv: [
-        8,
-        36,
-        12,
-        48
-      ]
-    },
-    north: {
-      uv: [
-        4,
-        36,
-        8,
-        48
-      ]
-    },
-    south: {
-      uv: [
-        12,
-        36,
-        16,
-        48
-      ]
-    },
-    up: {
-      uv: [
-        4,
-        32,
-        8,
-        36
-      ]
-    },
-    down: {
-      uv: [
-        8,
-        32,
-        12,
-        36
-      ],
-      rotation: 180
-    }
+    east: { uv: [0, 1, 1, 17] },
+    west: { uv: [11, 1, 12, 17] },
+    north: { uv: [1, 1, 11, 17] },
+    south: { uv: [12, 1, 22, 17] },
+    up: { uv: [11, 1, 1, 0] },
+    down: { uv: [21, 0, 11, 1] }
   }
 };
 var classicSkinTextureCoordinates = {
@@ -5680,14 +5680,110 @@ var slimSkinGeometries = {
 
 // src/skin/scene/SkinObject.ts
 var import_ts_deepmerge7 = __toESM(require_dist());
+
+// src/skin/SkinTextures.ts
+var import_three18 = require("three");
+var SkinTextures = class {
+  static async get(src, legacy) {
+    const image = await ImageLoader.getData(src);
+    const scale = image.width / 64;
+    if (!Number.isInteger(scale) || scale < 1 || image.height !== image.width && image.height !== image.width / 2) {
+      throw new MineRenderError(`Invalid skin dimensions ${image.width}x${image.height}; expected 64x64 or 64x32, or an integer-scaled equivalent`);
+    }
+    const isLegacy = legacy ?? image.height === image.width / 2;
+    if (!isLegacy && image.height !== image.width) {
+      throw new MineRenderError(`Invalid skin dimensions ${image.width}x${image.height}; non-legacy skins must be square`);
+    }
+    const slim = !isLegacy && this.isSlim(image, scale);
+    const key = `skin:${serializeImageKey({ src })}:${isLegacy}`;
+    const material = Caching.materialCache.get(key, () => {
+      const pixels = isLegacy ? this.normalizeLegacy(image, scale) : new Uint8Array(image.data);
+      return this.createMaterial(pixels, image.width, image.width);
+    });
+    return { material, slim, legacy: isLegacy };
+  }
+  static async getCape(src) {
+    const image = await ImageLoader.getData(src);
+    const scale = image.width / 64;
+    if (!Number.isInteger(scale) || scale < 1 || image.height !== image.width / 2) {
+      throw new MineRenderError(`Invalid cape dimensions ${image.width}x${image.height}; expected 64x32 or an integer-scaled equivalent`);
+    }
+    return Caching.materialCache.get(`cape:${serializeImageKey({ src })}`, () => {
+      return this.createMaterial(new Uint8Array(image.data), image.width, image.height, false);
+    });
+  }
+  static createMaterial(pixels, width, height, transparent = true) {
+    const texture = Textures.initTextureProps(new import_three18.DataTexture(pixels, width, height));
+    texture.colorSpace = import_three18.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.5 : 0 });
+  }
+  static isSlim(image, scale) {
+    for (const [x, y] of [[46, 52], [54, 20]]) {
+      for (let row = y * scale; row < (y + 12) * scale; row++) {
+        for (let column = x * scale; column < (x + 1) * scale; column++) {
+          if (image.data[(row * image.width + column) * 4 + 3] !== 0) return false;
+        }
+      }
+    }
+    return true;
+  }
+  static normalizeLegacy(image, scale) {
+    const pixels = new Uint8Array(image.width * image.width * 4);
+    pixels.set(image.data.subarray(0, image.width * image.width / 2 * 4));
+    for (const [sx, sy, dx, dy, width, height] of [
+      [4, 16, 20, 48, 4, 4],
+      [8, 16, 24, 48, 4, 4],
+      [0, 20, 24, 52, 4, 12],
+      [4, 20, 20, 52, 4, 12],
+      [8, 20, 16, 52, 4, 12],
+      [12, 20, 28, 52, 4, 12],
+      [44, 16, 36, 48, 4, 4],
+      [48, 16, 40, 48, 4, 4],
+      [40, 20, 40, 52, 4, 12],
+      [44, 20, 36, 52, 4, 12],
+      [48, 20, 32, 52, 4, 12],
+      [52, 20, 44, 52, 4, 12]
+    ]) {
+      for (let y = 0; y < height * scale; y++) {
+        for (let x = 0; x < width * scale; x++) {
+          const source = ((sy * scale + y) * image.width + sx * scale + x) * 4;
+          const target = ((dy * scale + y) * image.width + (dx + width) * scale - 1 - x) * 4;
+          pixels.set(image.data.subarray(source, source + 4), target);
+        }
+      }
+    }
+    let clearHat = true;
+    for (let y = 0; y < 32 * scale; y++) {
+      for (let x = 32 * scale; x < image.width; x++) {
+        if (pixels[(y * image.width + x) * 4 + 3] < 128) clearHat = false;
+      }
+    }
+    for (let y = 0; y < image.width; y++) {
+      for (let x = 0; x < image.width; x++) {
+        const alpha = (y * image.width + x) * 4 + 3;
+        if (x < 32 * scale && y < 16 * scale || y >= 16 * scale && y < 32 * scale || x >= 16 * scale && x < 48 * scale && y >= 48 * scale) {
+          pixels[alpha] = 255;
+        } else if (clearHat && x >= 32 * scale && y < 32 * scale) {
+          pixels[alpha] = 0;
+        }
+      }
+    }
+    return pixels;
+  }
+};
+
+// src/skin/scene/SkinObject.ts
 var SkinObject = class extends SceneObject {
   constructor(options) {
     super();
     this.slim = false;
-    this.legacy = false;
-    this.skinTextureWidth = 64;
-    this.skinTextureHeight = 64;
+    this.detectedSlim = false;
+    this.skinLoad = 0;
+    this.capeLoad = 0;
     this.options = (0, import_ts_deepmerge7.default)({}, SceneObject.DEFAULT_OPTIONS, options ?? {});
+    this.slim = this.options.slim ?? false;
   }
   async init() {
     this.createMeshes();
@@ -5696,15 +5792,13 @@ var SkinObject = class extends SceneObject {
   }
   createMeshes() {
     console.log("#createMeshes");
-    const mat = Materials.MISSING_TEXTURE;
+    const mat = this.skinMaterial ?? Materials.MISSING_TEXTURE;
     {
       const headGroup = this.createAndAddGroup("head", 0, 28, 0, "y" /* Y */, -4);
       const headGeo = this.getBoxGeometry("head" /* HEAD */);
       const head = this.createAndAddMesh("head", headGroup, headGeo, mat, "y" /* Y */, 4);
-      if (!this.legacy) {
-        const hatGeo = this.getBoxGeometry("hat" /* HAT */);
-        const hat = this.createAndAddMesh("hat", headGroup, hatGeo, mat, "y" /* Y */, 4);
-      }
+      const hatGeo = this.getBoxGeometry("hat" /* HAT */);
+      const hat = this.createAndAddMesh("hat", headGroup, hatGeo, mat, "y" /* Y */, 4);
     }
     {
       const bodyGroup = this.createAndAddGroup("body", 0, 18, 0);
@@ -5747,21 +5841,58 @@ var SkinObject = class extends SceneObject {
     }
     console.log("#createMeshes done");
   }
-  setSkinTexture(src) {
+  async setSkinTexture(src) {
     if (typeof src === "undefined") return;
-    const mat = Materials.getImage({
-      texture: { src },
-      transparent: true
-    });
-    for (let part of SKIN_PARTS) {
-      let mesh = this.getMeshByName(part);
+    this.skinTextureSrc = src;
+    const load = ++this.skinLoad;
+    const texture = await SkinTextures.get(src, this.options.legacy);
+    if (load !== this.skinLoad) return;
+    this.skinMaterial = texture.material;
+    this.detectedSlim = texture.slim;
+    this.updateSlim(this.options.slim ?? this.detectedSlim);
+    for (const part of SKIN_PARTS) {
+      if (part === "cape" /* CAPE */) continue;
+      const mesh = this.getMeshByName(part);
       if (mesh) {
-        mesh.material = mat;
+        mesh.material = texture.material;
       }
     }
+    this.notifyDirty();
   }
-  //TODO: cape
+  /** Load a vanilla cape texture, or pass undefined to remove the cape. */
+  async setCapeTexture(src) {
+    const load = ++this.capeLoad;
+    if (src === void 0) {
+      const group = this.getGroupByName("cape" /* CAPE */);
+      if (group) this.remove(group);
+      this.notifyDirty();
+      return;
+    }
+    const material = await SkinTextures.getCape(src);
+    if (load !== this.capeLoad) return;
+    const mesh = this.getMeshByName("cape" /* CAPE */);
+    if (mesh) {
+      mesh.material = material;
+    } else {
+      const group = this.createAndAddGroup("cape" /* CAPE */, 0, 24, 2);
+      group.rotation.set(toRadians(-6), Math.PI, 0);
+      const geometry = this._getBoxGeometryFromDimensions(
+        classicSkinGeometries.cape,
+        classicSkinTextureCoordinates.cape,
+        [64, 32],
+        [64, 32]
+      );
+      const cape = this.createAndAddMesh("cape" /* CAPE */, group, geometry, material);
+      cape.position.set(0, -8, -0.5);
+    }
+    this.notifyDirty();
+  }
+  /** Select the arm model, or pass undefined to use texture detection. */
   setSlim(slim) {
+    this.options.slim = slim;
+    this.updateSlim(slim ?? this.detectedSlim);
+  }
+  updateSlim(slim) {
     if (slim === this.slim) return;
     this.slim = slim;
     for (const part of ["leftArm" /* LEFT_ARM */, "leftSleeve" /* LEFT_SLEEVE */, "rightArm" /* RIGHT_ARM */, "rightSleeve" /* RIGHT_SLEEVE */]) {
@@ -5775,22 +5906,28 @@ var SkinObject = class extends SceneObject {
     if (rightArm) rightArm.position.x -= offset;
     this.notifyDirty();
   }
-  setLegacy(legacy) {
-    if (legacy !== this.legacy) {
-    }
-    this.legacy = legacy;
+  /** Select the texture layout, or pass undefined to detect it from image dimensions. */
+  async setLegacy(legacy) {
+    if (legacy === this.options.legacy) return;
+    this.options.legacy = legacy;
+    if (this.skinTextureSrc) await this.setSkinTexture(this.skinTextureSrc);
+  }
+  dispose() {
+    this.skinLoad++;
+    this.capeLoad++;
+    super.dispose();
   }
   //TODO: layer toggles
   getBoxGeometry(part) {
     console.log("slim", this.slim);
     const coordinates = this.slim ? slimSkinTextureCoordinates : classicSkinTextureCoordinates;
     const geometries = this.slim ? slimSkinGeometries : classicSkinGeometries;
-    return this._getBoxGeometryFromDimensions(geometries[part], coordinates[part], [64, 64], [this.skinTextureWidth, this.skinTextureHeight]);
+    return this._getBoxGeometryFromDimensions(geometries[part], coordinates[part], [64, 64], [64, 64]);
   }
 };
 
 // src/renderer/MineRenderScene.ts
-var _MineRenderScene = class _MineRenderScene extends import_three18.Scene {
+var _MineRenderScene = class _MineRenderScene extends import_three19.Scene {
   constructor(options) {
     super();
     this.isMineRenderScene = true;
@@ -5895,10 +6032,10 @@ var _MineRenderScene = class _MineRenderScene extends import_three18.Scene {
     this.dirty = true;
     const obj = new SkinObject(options);
     obj.scene = this;
-    await obj.init();
     if (skin) {
-      obj.setSkinTexture(skin);
+      await obj.setSkinTexture(skin);
     }
+    await obj.init();
     parent.add(obj);
     return obj;
   }
@@ -5913,17 +6050,17 @@ function isMineRenderScene(obj) {
 }
 
 // src/renderer/Renderer.ts
-var import_three20 = require("three");
+var import_three21 = 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_three19 = require("three");
+var import_three20 = require("three");
 var _changeEvent = { type: "change" };
 var _startEvent = { type: "start" };
 var _endEvent = { type: "end" };
-var OrbitControls = class extends import_three19.EventDispatcher {
+var OrbitControls = class extends import_three20.EventDispatcher {
   constructor(object, domElement) {
     super();
     if (domElement === void 0) console.warn('THREE.OrbitControls: The second parameter "domElement" is now mandatory.');
@@ -5932,7 +6069,7 @@ var OrbitControls = class extends import_three19.EventDispatcher {
     this.domElement = domElement;
     this.domElement.style.touchAction = "none";
     this.enabled = true;
-    this.target = new import_three19.Vector3();
+    this.target = new import_three20.Vector3();
     this.minDistance = 0;
     this.maxDistance = Infinity;
     this.minZoom = 0;
@@ -5954,8 +6091,8 @@ var OrbitControls = class extends import_three19.EventDispatcher {
     this.autoRotate = false;
     this.autoRotateSpeed = 2;
     this.keys = { LEFT: "ArrowLeft", UP: "ArrowUp", RIGHT: "ArrowRight", BOTTOM: "ArrowDown" };
-    this.mouseButtons = { LEFT: import_three19.MOUSE.ROTATE, MIDDLE: import_three19.MOUSE.DOLLY, RIGHT: import_three19.MOUSE.PAN };
-    this.touches = { ONE: import_three19.TOUCH.ROTATE, TWO: import_three19.TOUCH.DOLLY_PAN };
+    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.target0 = this.target.clone();
     this.position0 = this.object.position.clone();
     this.zoom0 = this.object.zoom;
@@ -5984,11 +6121,11 @@ var OrbitControls = class extends import_three19.EventDispatcher {
       state = STATE.NONE;
     };
     this.update = function() {
-      const offset = new import_three19.Vector3();
-      const quat = new import_three19.Quaternion().setFromUnitVectors(object.up, new import_three19.Vector3(0, 1, 0));
+      const offset = new import_three20.Vector3();
+      const quat = new import_three20.Quaternion().setFromUnitVectors(object.up, new import_three20.Vector3(0, 1, 0));
       const quatInverse = quat.clone().invert();
-      const lastPosition = new import_three19.Vector3();
-      const lastQuaternion = new import_three19.Quaternion();
+      const lastPosition = new import_three20.Vector3();
+      const lastQuaternion = new import_three20.Quaternion();
       const twoPI = 2 * Math.PI;
       return function update() {
         const position = scope.object.position;
@@ -6074,20 +6211,20 @@ var OrbitControls = class extends import_three19.EventDispatcher {
     };
     let state = STATE.NONE;
     const EPS = 1e-6;
-    const spherical = new import_three19.Spherical();
-    const sphericalDelta = new import_three19.Spherical();
+    const spherical = new import_three20.Spherical();
+    const sphericalDelta = new import_three20.Spherical();
     let scale = 1;
-    const panOffset = new import_three19.Vector3();
+    const panOffset = new import_three20.Vector3();
     let zoomChanged = false;
-    const rotateStart = new import_three19.Vector2();
-    const rotateEnd = new import_three19.Vector2();
-    const rotateDelta = new import_three19.Vector2();
-    const panStart = new import_three19.Vector2();
-    const panEnd = new import_three19.Vector2();
-    const panDelta = new import_three19.Vector2();
-    const dollyStart = new import_three19.Vector2();
-    const dollyEnd = new import_three19.Vector2();
-    const dollyDelta = new import_three19.Vector2();
+    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 pointers = [];
     const pointerPositions = {};
     function getAutoRotationAngle() {
@@ -6103,7 +6240,7 @@ var OrbitControls = class extends import_three19.EventDispatcher {
       sphericalDelta.phi -= angle;
     }
     const panLeft = function() {
-      const v = new import_three19.Vector3();
+      const v = new import_three20.Vector3();
       return function panLeft2(distance, objectMatrix) {
         v.setFromMatrixColumn(objectMatrix, 0);
         v.multiplyScalar(-distance);
@@ -6111,7 +6248,7 @@ var OrbitControls = class extends import_three19.EventDispatcher {
       };
     }();
     const panUp = function() {
-      const v = new import_three19.Vector3();
+      const v = new import_three20.Vector3();
       return function panUp2(distance, objectMatrix) {
         if (scope.screenSpacePanning === true) {
           v.setFromMatrixColumn(objectMatrix, 1);
@@ -6124,7 +6261,7 @@ var OrbitControls = class extends import_three19.EventDispatcher {
       };
     }();
     const pan = function() {
-      const offset = new import_three19.Vector3();
+      const offset = new import_three20.Vector3();
       return function pan2(deltaX, deltaY) {
         const element = scope.domElement;
         if (scope.object.isPerspectiveCamera) {
@@ -6373,12 +6510,12 @@ var OrbitControls = class extends import_three19.EventDispatcher {
           mouseAction = -1;
       }
       switch (mouseAction) {
-        case import_three19.MOUSE.DOLLY:
+        case import_three20.MOUSE.DOLLY:
           if (scope.enableZoom === false) return;
           handleMouseDownDolly(event);
           state = STATE.DOLLY;
           break;
-        case import_three19.MOUSE.ROTATE:
+        case import_three20.MOUSE.ROTATE:
           if (event.ctrlKey || event.metaKey || event.shiftKey) {
             if (scope.enablePan === false) return;
             handleMouseDownPan(event);
@@ -6389,7 +6526,7 @@ var OrbitControls = class extends import_three19.EventDispatcher {
             state = STATE.ROTATE;
           }
           break;
-        case import_three19.MOUSE.PAN:
+        case import_three20.MOUSE.PAN:
           if (event.ctrlKey || event.metaKey || event.shiftKey) {
             if (scope.enableRotate === false) return;
             handleMouseDownRotate(event);
@@ -6445,12 +6582,12 @@ var OrbitControls = class extends import_three19.EventDispatcher {
       switch (pointers.length) {
         case 1:
           switch (scope.touches.ONE) {
-            case import_three19.TOUCH.ROTATE:
+            case import_three20.TOUCH.ROTATE:
               if (scope.enableRotate === false) return;
               handleTouchStartRotate();
               state = STATE.TOUCH_ROTATE;
               break;
-            case import_three19.TOUCH.PAN:
+            case import_three20.TOUCH.PAN:
               if (scope.enablePan === false) return;
               handleTouchStartPan();
               state = STATE.TOUCH_PAN;
@@ -6461,12 +6598,12 @@ var OrbitControls = class extends import_three19.EventDispatcher {
           break;
         case 2:
           switch (scope.touches.TWO) {
-            case import_three19.TOUCH.DOLLY_PAN:
+            case import_three20.TOUCH.DOLLY_PAN:
               if (scope.enableZoom === false && scope.enablePan === false) return;
               handleTouchStartDollyPan();
               state = STATE.TOUCH_DOLLY_PAN;
               break;
-            case import_three19.TOUCH.DOLLY_ROTATE:
+            case import_three20.TOUCH.DOLLY_ROTATE:
               if (scope.enableZoom === false && scope.enableRotate === false) return;
               handleTouchStartDollyRotate();
               state = STATE.TOUCH_DOLLY_ROTATE;
@@ -6533,7 +6670,7 @@ var OrbitControls = class extends import_three19.EventDispatcher {
     function trackPointer(event) {
       let position = pointerPositions[event.pointerId];
       if (position === void 0) {
-        position = new import_three19.Vector2();
+        position = new import_three20.Vector2();
         pointerPositions[event.pointerId] = position;
       }
       position.set(event.pageX, event.pageY);
@@ -6553,10 +6690,10 @@ var MapControls = class extends OrbitControls {
   constructor(object, domElement) {
     super(object, domElement);
     this.screenSpacePanning = false;
-    this.mouseButtons.LEFT = import_three19.MOUSE.PAN;
-    this.mouseButtons.RIGHT = import_three19.MOUSE.ROTATE;
-    this.touches.ONE = import_three19.TOUCH.PAN;
-    this.touches.TWO = import_three19.TOUCH.DOLLY_ROTATE;
+    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;
   }
 };
 
@@ -6593,14 +6730,14 @@ var _Renderer = class _Renderer {
     switch (this.options.camera.type) {
       case "perspective":
       default:
-        return new import_three20.PerspectiveCamera(
+        return new import_three21.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_three20.OrthographicCamera(
+        return new import_three21.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,
@@ -6611,7 +6748,7 @@ var _Renderer = class _Renderer {
     }
   }
   createRenderer() {
-    const renderer = new import_three20.WebGLRenderer({
+    const renderer = new import_three21.WebGLRenderer({
       antialias: this.options.render.antialias,
       alpha: true,
       powerPreference: "high-performance",
@@ -6619,8 +6756,8 @@ var _Renderer = class _Renderer {
     });
     renderer.setClearColor(0, 0);
     renderer.shadowMap.enabled = true;
-    renderer.shadowMap.type = import_three20.PCFSoftShadowMap;
-    renderer.outputColorSpace = import_three20.SRGBColorSpace;
+    renderer.shadowMap.type = import_three21.PCFSoftShadowMap;
+    renderer.outputColorSpace = import_three21.SRGBColorSpace;
     renderer.setSize(this.viewWidth, this.viewHeight);
     return renderer;
   }
@@ -6654,20 +6791,20 @@ var _Renderer = class _Renderer {
       window["__THREE_DEVTOOLS__"].dispatchEvent(new CustomEvent("observe", { detail: this.scene }));
     }
     if (this.options.debug.grid) {
-      const gridHelper = new import_three20.GridHelper(128, 16);
+      const gridHelper = new import_three21.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper);
       this.scene.add(gridHelper);
-      const gridHelper2 = new import_three20.GridHelper(128, 16);
+      const gridHelper2 = new import_three21.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper2);
       gridHelper2.rotation.x = 90 * (Math.PI / 180);
       this.scene.add(gridHelper2);
-      const gridHelper3 = new import_three20.GridHelper(128, 16);
+      const gridHelper3 = new import_three21.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_three20.AxesHelper(64);
+      const axesHelper = new import_three21.AxesHelper(64);
       this._debugHelpers.push(axesHelper);
       this.scene.add(axesHelper);
     }
@@ -6871,8 +7008,8 @@ _Renderer.DEFAULT_OPTIONS = (0, import_ts_deepmerge9.default)({}, {
       top: void 0,
       bottom: void 0
     },
-    position: new import_three20.Vector3(50, 50, 50),
-    lookingAt: new import_three20.Vector3(0, 0, 0)
+    position: new import_three21.Vector3(50, 50, 50),
+    lookingAt: new import_three21.Vector3(0, 0, 0)
   },
   render: {
     fpsLimit: 60,
@@ -7066,10 +7203,10 @@ var Skins = class {
 };
 
 // src/world/Chunk.ts
-var import_three23 = require("three");
+var import_three24 = require("three");
 
 // src/world/MineRenderWorld.ts
-var import_three22 = require("three");
+var import_three23 = require("three");
 var MineRenderWorld = class {
   constructor(scene) {
     this._size = 4;
@@ -7080,10 +7217,10 @@ var MineRenderWorld = class {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new import_three22.Vector3(posOrX, y, z));
+      return this.getBlockAt(new import_three23.Vector3(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new import_three22.Vector3(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new import_three23.Vector3(posOrX[0], posOrX[1], posOrX[2]));
     }
     const chunk = this.getChunkAt(posOrX);
     if (typeof chunk === "undefined") {
@@ -7094,10 +7231,10 @@ var MineRenderWorld = class {
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new import_three22.Vector3(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new import_three23.Vector3(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new import_three22.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new import_three23.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     this.validatePosBounds(posOrX);
     const chunk = this.getOrCreateChunkAt(posOrX);
@@ -7143,14 +7280,14 @@ var MineRenderWorld = class {
     return this._chunks[index];
   }
   static worldToScenePosition(pos) {
-    return new import_three22.Vector3(
+    return new import_three23.Vector3(
       pos.x * 16,
       pos.y * 16,
       pos.z * 16
     );
   }
   static sceneToWorldPosition(pos) {
-    return new import_three22.Vector3(
+    return new import_three23.Vector3(
       pos.x / 16,
       pos.y / 16,
       pos.z / 16
@@ -7187,12 +7324,12 @@ var Chunk = class _Chunk {
     this.x = x;
     this.y = y;
     this.z = z;
-    let anchor = new import_three23.Object3D();
+    let anchor = new import_three24.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_three23.Box3(new import_three23.Vector3(0, 0, 0), new import_three23.Vector3(256, 256, 256)),
+      new import_three24.Box3(new import_three24.Vector3(0, 0, 0), new import_three24.Vector3(256, 256, 256)),
       anchor,
       16776960,
       4
@@ -7200,10 +7337,10 @@ var Chunk = class _Chunk {
   }
   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 pos = this.worldPosToChunkPos(posOrX);
     const index = _Chunk.chunkPosToBlockIndex(pos);
@@ -7211,10 +7348,10 @@ var Chunk = class _Chunk {
   }
   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);
     }
     const worldPos = posOrX;
     const pos = this.worldPosToChunkPos(worldPos);
@@ -7260,7 +7397,7 @@ var Chunk = class _Chunk {
   }
   async clear() {
     let promises = [];
-    let pos = new import_three23.Vector3();
+    let pos = new import_three24.Vector3();
     for (let x = 0; x < 16; x++) {
       for (let z = 0; z < 16; z++) {
         for (let y = 0; y < 16; y++) {
@@ -7279,14 +7416,14 @@ var Chunk = class _Chunk {
     return pos.y * 16 * 16 + pos.z * 16 + pos.x;
   }
   worldPosToChunkPos(pos) {
-    return new import_three23.Vector3(
+    return new import_three24.Vector3(
       pos.x - this.x * 16,
       pos.y - this.y * 16,
       pos.z - this.z * 16
     );
   }
   chunkPosToWorldPos(pos) {
-    return new import_three23.Vector3(
+    return new import_three24.Vector3(
       this.x * 16 + pos.x,
       this.y * 16 + pos.y,
       this.z * 16 + pos.z