minerender 2.1.0-alpha.21 → 2.1.0-alpha.23

package/dist/browser/index.js

@@ -157,6 +157,7 @@ __export(index_browser_exports, {
   DISPLAY_POSITIONS: () => DISPLAY_POSITIONS,
   DefaultBlockStates: () => DefaultBlockStates,
   DisplayPosition: () => DisplayPosition,
+  DisplayTransforms: () => DisplayTransforms,
   Entities: () => Entities,
   EntityModels: () => EntityModels,
   EntityObject: () => EntityObject,
@@ -1250,7 +1251,7 @@ var Meshes = class _Meshes {
 };
 
 // src/UVMapper.ts
-var import_three8 = require("three");
+var import_three9 = require("three");
 
 // src/model/ModelMerger.ts
 var import_ts_deepmerge = __toESM(require_dist());
@@ -1341,15 +1342,77 @@ function isAssetKey(obj) {
   return isBasicAssetKey(obj) && obj.isAssetKey === true;
 }
 
+// src/model/DisplayTransforms.ts
+var import_three7 = require("three");
+
+// src/model/DisplayPosition.ts
+var DisplayPosition = /* @__PURE__ */ ((DisplayPosition2) => {
+  DisplayPosition2["THIRDPERSON_RIGHTHAND"] = "thirdperson_righthand";
+  DisplayPosition2["THIRDPERSON_LEFTHAND"] = "thirdperson_lefthand";
+  DisplayPosition2["FIRSTPERSON_RIGHTHAND"] = "firstperson_righthand";
+  DisplayPosition2["FIRSTPERSON_LEFTHAND"] = "firstperson_lefthand";
+  DisplayPosition2["GUI"] = "gui";
+  DisplayPosition2["HEAD"] = "head";
+  DisplayPosition2["GROUND"] = "ground";
+  DisplayPosition2["FIXED"] = "fixed";
+  DisplayPosition2["ON_SHELF"] = "on_shelf";
+  return DisplayPosition2;
+})(DisplayPosition || {});
+var DISPLAY_POSITIONS = Object.values(DisplayPosition);
+
+// src/model/DisplayTransforms.ts
+var DisplayTransforms = class {
+  /** Resolve hand fallbacks within one model, before inheriting parent display entries. */
+  static withHandFallbacks(display) {
+    if (!display) return void 0;
+    const resolved = { ...display };
+    for (const [left, right] of [
+      ["thirdperson_lefthand" /* THIRDPERSON_LEFTHAND */, "thirdperson_righthand" /* THIRDPERSON_RIGHTHAND */],
+      ["firstperson_lefthand" /* FIRSTPERSON_LEFTHAND */, "firstperson_righthand" /* FIRSTPERSON_RIGHTHAND */]
+    ]) {
+      if (resolved[left] === void 0 && resolved[right] !== void 0) resolved[left] = resolved[right];
+    }
+    return resolved;
+  }
+  /** Build a display pose for geometry already centered at the model's [8, 8, 8] pivot. */
+  static getMatrix(display, position) {
+    const transform = this.withHandFallbacks(display)?.[position] ?? {};
+    const left = position === "firstperson_lefthand" /* FIRSTPERSON_LEFTHAND */ || position === "thirdperson_lefthand" /* THIRDPERSON_LEFTHAND */;
+    const sign = left ? -1 : 1;
+    const [x, y, z] = transform.rotation ?? [0, 0, 0];
+    const rotation = new import_three7.Quaternion().setFromEuler(new import_three7.Euler(toRadians(x), sign * toRadians(y), sign * toRadians(z), "XYZ"));
+    const translation = new import_three7.Vector3(...transform.translation ?? [0, 0, 0]).clampScalar(-80, 80);
+    translation.x *= sign;
+    const scale = new import_three7.Vector3(...transform.scale ?? [1, 1, 1]).clampScalar(-4, 4);
+    return new import_three7.Matrix4().compose(translation, rotation, scale);
+  }
+  static apply(geometry, matrix) {
+    geometry.applyMatrix4(matrix);
+    if (matrix.determinant() < 0) {
+      if (!geometry.index) geometry.setIndex(Array.from({ length: geometry.getAttribute("position").count }, (_, i) => i));
+      const index = geometry.index;
+      for (let i = 0; i < index.count; i += 3) {
+        const second = index.getX(i + 1);
+        index.setX(i + 1, index.getX(i + 2));
+        index.setX(i + 2, second);
+      }
+      index.needsUpdate = true;
+    }
+  }
+};
+
 // src/model/ModelMerger.ts
 var ModelMerger = class {
   static async mergeWithParents(model) {
     const models = await this.collectAllParents(model);
     let merged = {};
-    for (let parentModel of models) {
-      merged = import_ts_deepmerge.default.withOptions({ mergeArrays: false }, merged, parentModel);
+    for (const source of [...models, model]) {
+      const inheritedDisplay = merged.display;
+      merged = import_ts_deepmerge.default.withOptions({ mergeArrays: false }, merged, source);
+      if (source.display) {
+        merged.display = { ...inheritedDisplay, ...DisplayTransforms.withHandFallbacks(source.display) };
+      }
     }
-    merged = import_ts_deepmerge.default.withOptions({ mergeArrays: false }, merged, model);
     merged.hierarchy = models.map((m) => m.parent).filter((p12) => `${p12}`);
     merged.hierarchy.push(`${merged.parent}`);
     return merged;
@@ -1495,7 +1558,7 @@ var BlockStates = class {
       void 0,
       "assets",
       ".json",
-      DEFAULT_ROOT
+      AssetLoader.ROOT
     );
     return Caching.listAssetCache.get(key.serialize(), () => {
       return AssetLoader.get(key, "list" /* LIST */);
@@ -1604,9 +1667,9 @@ var BatchedExecutor = class {
 };
 
 // src/util/model.ts
-var import_three7 = require("three");
+var import_three8 = require("three");
 function applyElementRotation(rotation, geometry) {
-  const origin = new import_three7.Vector3(rotation.origin[0], rotation.origin[1], rotation.origin[2]);
+  const origin = new import_three8.Vector3(rotation.origin[0], rotation.origin[1], rotation.origin[2]);
   geometry.translate(-origin.x, -origin.y, -origin.z);
   switch (rotation.axis) {
     case "x" /* X */:
@@ -1631,7 +1694,7 @@ function applyElementRotation(rotation, geometry) {
   geometry.translate(origin.x, origin.y, origin.z);
 }
 function applyModelPartRotation(modelPart, geometry) {
-  const origin = new import_three7.Vector3(modelPart.pivotX, modelPart.pivotY, modelPart.pivotZ);
+  const origin = new import_three8.Vector3(modelPart.pivotX, modelPart.pivotY, modelPart.pivotZ);
   geometry.translate(-origin.x, -origin.y, -origin.z);
   geometry.rotateX(toRadians(modelPart.pitch));
   geometry.rotateY(toRadians(modelPart.yaw));
@@ -1641,42 +1704,42 @@ function applyModelPartRotation(modelPart, geometry) {
 function applyGenericRotation(axis, rotation, obj) {
   switch (axis) {
     case "x" /* X */:
-      obj.rotateOnAxis(new import_three7.Vector3(1, 0, 0), toRadians(rotation));
+      obj.rotateOnAxis(new import_three8.Vector3(1, 0, 0), toRadians(rotation));
       break;
     case "y" /* Y */:
-      obj.rotateOnAxis(new import_three7.Vector3(0, 1, 0), toRadians(rotation));
+      obj.rotateOnAxis(new import_three8.Vector3(0, 1, 0), toRadians(rotation));
       break;
     case "z" /* Z */:
-      obj.rotateOnAxis(new import_three7.Vector3(0, 0, 1), toRadians(rotation));
+      obj.rotateOnAxis(new import_three8.Vector3(0, 0, 1), toRadians(rotation));
       break;
   }
 }
 function addBox3WireframeToObject(box, obj, color = 16777215, w = 2) {
-  let size = new import_three7.Vector3();
+  let size = new import_three8.Vector3();
   box.getSize(size);
-  let boxGeo = new import_three7.BoxGeometry(size.x, size.y, size.z, 1, 1, 1);
-  let wireGeo = new import_three7.EdgesGeometry(boxGeo);
-  let wireMat = new import_three7.LineBasicMaterial({ color, linewidth: w });
-  let wireframe = new import_three7.LineSegments(wireGeo, wireMat);
+  let boxGeo = new import_three8.BoxGeometry(size.x, size.y, size.z, 1, 1, 1);
+  let wireGeo = new import_three8.EdgesGeometry(boxGeo);
+  let wireMat = new import_three8.LineBasicMaterial({ color, linewidth: w });
+  let wireframe = new import_three8.LineSegments(wireGeo, wireMat);
   obj.add(wireframe);
-  let axes = new import_three7.AxesHelper(1);
+  let axes = new import_three8.AxesHelper(1);
   obj.add(axes);
 }
 function addWireframeToObject(obj, color = 16777215, w = 2) {
-  let boxGeo = new import_three7.BoxGeometry(16, 16, 16, 1, 1, 1);
-  let wireGeo = new import_three7.EdgesGeometry(boxGeo);
-  let wireMat = new import_three7.LineBasicMaterial({ color, linewidth: w });
-  let wireframe = new import_three7.LineSegments(wireGeo, wireMat);
+  let boxGeo = new import_three8.BoxGeometry(16, 16, 16, 1, 1, 1);
+  let wireGeo = new import_three8.EdgesGeometry(boxGeo);
+  let wireMat = new import_three8.LineBasicMaterial({ color, linewidth: w });
+  let wireframe = new import_three8.LineSegments(wireGeo, wireMat);
   obj.add(wireframe);
-  let axes = new import_three7.AxesHelper(1);
+  let axes = new import_three8.AxesHelper(1);
   obj.add(axes);
 }
 function addWireframeToMesh(geo, mesh, color = 16777215, w = 2) {
-  let wireGeo = new import_three7.EdgesGeometry(geo);
-  let wireMat = new import_three7.LineBasicMaterial({ color, linewidth: w });
-  let wireframe = new import_three7.LineSegments(wireGeo, wireMat);
+  let wireGeo = new import_three8.EdgesGeometry(geo);
+  let wireMat = new import_three8.LineBasicMaterial({ color, linewidth: w });
+  let wireframe = new import_three8.LineSegments(wireGeo, wireMat);
   mesh.add(wireframe);
-  let axes = new import_three7.AxesHelper(1);
+  let axes = new import_three8.AxesHelper(1);
   mesh.add(axes);
 }
 
@@ -1736,17 +1799,17 @@ var _HostedAssetSource = class _HostedAssetSource extends AssetSource {
       if (typeof namespaced !== "undefined") {
         return namespaced;
       }
-      if (typeof key.root !== "undefined" && key.root !== DEFAULT_ROOT || typeof this.root !== "undefined" && this.root !== DEFAULT_ROOT) {
+      if (typeof key.root !== "undefined" && key.root !== AssetLoader.ROOT || typeof this.root !== "undefined" && this.root !== AssetLoader.ROOT) {
         console.info(p3, "Retrying", key, "with default root+namespace");
-        const namespacedRootedKey = new AssetKey(DEFAULT_NAMESPACE, key.path, key.assetType, key.type, key.rootType, key.extension, DEFAULT_ROOT);
+        const namespacedRootedKey = new AssetKey(DEFAULT_NAMESPACE, key.path, key.assetType, key.type, key.rootType, key.extension, AssetLoader.ROOT);
         const namespacedRooted = await this.load(namespacedRootedKey, parser);
         if (typeof namespacedRooted !== "undefined") {
           return namespacedRooted;
         }
       }
-    } else if (typeof key.root !== "undefined" && key.root !== DEFAULT_ROOT || typeof this.root !== "undefined" && this.root !== DEFAULT_ROOT) {
+    } else if (typeof key.root !== "undefined" && key.root !== AssetLoader.ROOT || typeof this.root !== "undefined" && this.root !== AssetLoader.ROOT) {
       console.info(p3, "Retrying", key, "with default root");
-      const rootKey = new AssetKey(key.namespace, key.path, key.assetType, key.type, key.rootType, key.extension, DEFAULT_ROOT);
+      const rootKey = new AssetKey(key.namespace, key.path, key.assetType, key.type, key.rootType, key.extension, AssetLoader.ROOT);
       const rooted = await this.load(rootKey, parser);
       if (typeof rooted !== "undefined") {
         return rooted;
@@ -1935,6 +1998,20 @@ var ArchiveAssetSource = class _ArchiveAssetSource extends AssetSource {
 // src/assets/AssetLoader.ts
 var p4 = prefix("AssetLoader");
 var _AssetLoader = class _AssetLoader {
+  static get version() {
+    return this.ROOT.substring(this.ROOT.lastIndexOf("/") + 1);
+  }
+  static setVersion(version) {
+    this.ROOT = `https://assets.mcasset.cloud/${version}`;
+    const source = new HostedAssetSource(this.ROOT, { retryDefaults: false });
+    const index = this._SOURCES.findIndex((s) => s.key === "mcassets");
+    if (index !== -1) {
+      this._SOURCES[index] = { key: "mcassets", source };
+    } else {
+      this.addSource("mcassets", source);
+    }
+    Caching.clear();
+  }
   static addSource(key, source, override = true) {
     if (override) {
       const existing = this.removeSource(key);
@@ -1997,7 +2074,7 @@ 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 }));
-_AssetLoader.addSource("mcassets", new HostedAssetSource(DEFAULT_ROOT, { retryDefaults: false }));
+_AssetLoader.addSource("mcassets", new HostedAssetSource(_AssetLoader.ROOT, { retryDefaults: false }));
 var AssetLoader = _AssetLoader;
 
 // src/assets/ModelTextures.ts
@@ -2220,12 +2297,12 @@ var X = 0;
 var Y = 1;
 var Z = 2;
 var FACE_UV_AXES = {
-  east: [new import_three8.Vector3(0, 0, -1), new import_three8.Vector3(0, -1, 0)],
-  west: [new import_three8.Vector3(0, 0, 1), new import_three8.Vector3(0, -1, 0)],
-  up: [new import_three8.Vector3(1, 0, 0), new import_three8.Vector3(0, 0, 1)],
-  down: [new import_three8.Vector3(1, 0, 0), new import_three8.Vector3(0, 0, -1)],
-  south: [new import_three8.Vector3(1, 0, 0), new import_three8.Vector3(0, -1, 0)],
-  north: [new import_three8.Vector3(-1, 0, 0), new import_three8.Vector3(0, -1, 0)]
+  east: [new import_three9.Vector3(0, 0, -1), new import_three9.Vector3(0, -1, 0)],
+  west: [new import_three9.Vector3(0, 0, 1), new import_three9.Vector3(0, -1, 0)],
+  up: [new import_three9.Vector3(1, 0, 0), new import_three9.Vector3(0, 0, 1)],
+  down: [new import_three9.Vector3(1, 0, 0), new import_three9.Vector3(0, 0, -1)],
+  south: [new import_three9.Vector3(1, 0, 0), new import_three9.Vector3(0, -1, 0)],
+  north: [new import_three9.Vector3(-1, 0, 0), new import_three9.Vector3(0, -1, 0)]
 };
 var UVMapper = class {
   static makeUv(uvCoord, originalTextureSize, actualTextureSize) {
@@ -2322,7 +2399,7 @@ var UVMapper = class {
     return array;
   }
   static facesToUv(faces, originalTextureSize, actualTextureSize) {
-    return new import_three8.Float32BufferAttribute(this.facesToUvArray(faces, originalTextureSize, actualTextureSize), 2);
+    return new import_three9.Float32BufferAttribute(this.facesToUvArray(faces, originalTextureSize, actualTextureSize), 2);
   }
   static lockUvs(geometry, faces, atlas, rotation) {
     const uv = geometry.getAttribute("uv");
@@ -2400,32 +2477,32 @@ var UVMapper = class {
     v1 *= scaleV;
     u2 *= scaleU;
     v2 *= scaleV;
-    let tl = new import_three8.Vector2(u1, v1);
-    let tr = new import_three8.Vector2(u2, v1);
-    let bl = new import_three8.Vector2(u1, v2);
-    let br = new import_three8.Vector2(u2, v2);
+    let tl = new import_three9.Vector2(u1, v1);
+    let tr = new import_three9.Vector2(u2, v1);
+    let bl = new import_three9.Vector2(u1, v2);
+    let br = new import_three9.Vector2(u2, v2);
     switch (rotation) {
       case 0:
       case 360:
       default:
         break;
       case 90:
-        tl = new import_three8.Vector2(u1, v2);
-        tr = new import_three8.Vector2(u1, v1);
-        bl = new import_three8.Vector2(u2, v2);
-        br = new import_three8.Vector2(u2, v1);
+        tl = new import_three9.Vector2(u1, v2);
+        tr = new import_three9.Vector2(u1, v1);
+        bl = new import_three9.Vector2(u2, v2);
+        br = new import_three9.Vector2(u2, v1);
         break;
       case 180:
-        tl = new import_three8.Vector2(u2, v2);
-        tr = new import_three8.Vector2(u1, v2);
-        bl = new import_three8.Vector2(u2, v1);
-        br = new import_three8.Vector2(u1, v1);
+        tl = new import_three9.Vector2(u2, v2);
+        tr = new import_three9.Vector2(u1, v2);
+        bl = new import_three9.Vector2(u2, v1);
+        br = new import_three9.Vector2(u1, v1);
         break;
       case 270:
-        tl = new import_three8.Vector2(u2, v1);
-        tr = new import_three8.Vector2(u2, v2);
-        bl = new import_three8.Vector2(u1, v1);
-        br = new import_three8.Vector2(u1, v2);
+        tl = new import_three9.Vector2(u2, v1);
+        tr = new import_three9.Vector2(u2, v2);
+        bl = new import_three9.Vector2(u1, v1);
+        br = new import_three9.Vector2(u1, v2);
         break;
     }
     return [tl, tr, bl, br];
@@ -2572,7 +2649,7 @@ var UVMapper = class {
             const faceTexture = face.texture.substr(1);
             const texPosition = positions[faceTexture] || [0, 0];
             const texSize = sizes[faceTexture] || [16, 16];
-            let texPosV = new import_three8.Vector2(texPosition[0], texPosition[1]);
+            let texPosV = new import_three9.Vector2(texPosition[0], texPosition[1]);
             const [tl, tr, bl, br] = this.expandAndRotateMcUvs(face.uv, face.rotation, texSize[0], texSize[1]);
             tl.add(texPosV);
             tr.add(texPosV);
@@ -2806,7 +2883,7 @@ var BlockEntityModels = class {
 };
 
 // src/renderer/SceneObject.ts
-var import_three9 = require("three");
+var import_three10 = require("three");
 
 // src/instance/InstanceReference.ts
 var InstanceReference = class {
@@ -2865,7 +2942,7 @@ var MineRenderError = class _MineRenderError extends Error {
 // src/renderer/SceneObject.ts
 var import_ts_deepmerge3 = __toESM(require_dist());
 var p6 = prefix("SceneObject");
-var _SceneObject = class _SceneObject extends import_three9.Object3D {
+var _SceneObject = class _SceneObject extends import_three10.Object3D {
   constructor(options) {
     super();
     this.isSceneObject = true;
@@ -2903,7 +2980,7 @@ var _SceneObject = class _SceneObject extends import_three9.Object3D {
     return group;
   }
   createGroup(name, x = 0, y = 0, z = 0, offsetAxis, offset = 0) {
-    const obj = new import_three9.Object3D();
+    const obj = new import_three10.Object3D();
     if (name) {
       obj.name = `group:${name}`;
     }
@@ -2953,7 +3030,7 @@ var _SceneObject = class _SceneObject extends import_three9.Object3D {
     return mesh;
   }
   createMesh(name, geometry, material, offsetAxis, offset = 0) {
-    const mesh = new import_three9.Mesh(geometry, material);
+    const mesh = new import_three10.Mesh(geometry, material);
     if (name) {
       mesh.name = `mesh:${name}`;
     }
@@ -2965,7 +3042,7 @@ var _SceneObject = class _SceneObject extends import_three9.Object3D {
     return mesh;
   }
   createInstancedMesh(name, geometry, material, count) {
-    const mesh = new import_three9.InstancedMesh(geometry, material, count);
+    const mesh = new import_three10.InstancedMesh(geometry, material, count);
     mesh.count = 0;
     if (name) {
       mesh.name = `mesh:${name}`;
@@ -3043,7 +3120,7 @@ var _SceneObject = class _SceneObject extends import_three9.Object3D {
   nextInstance() {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const i = this._instanceCounter++;
-    this.setMatrixAt(i, new import_three9.Matrix4());
+    this.setMatrixAt(i, new import_three10.Matrix4());
     const mesh = this.children[0];
     if (mesh && isInstancedMesh(mesh)) {
       mesh.count = Math.min(this._instanceCounter, mesh.instanceMatrix.count);
@@ -3060,7 +3137,7 @@ var _SceneObject = class _SceneObject extends import_three9.Object3D {
   }
   //</editor-fold>
   //<editor-fold desc="TRANSFORMATION">
-  getMatrixAt(index, matrix = new import_three9.Matrix4()) {
+  getMatrixAt(index, matrix = new import_three10.Matrix4()) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const child = this.children[0];
     if (child && isInstancedMesh(child)) {
@@ -3079,16 +3156,16 @@ var _SceneObject = class _SceneObject extends import_three9.Object3D {
   }
   setPositionRotationScaleAt(index, position, rotation, scale) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
-    const oldPosition = new import_three9.Vector3();
-    const oldRotation = new import_three9.Quaternion();
-    const oldScale = new import_three9.Vector3();
-    const matrix = new import_three9.Matrix4();
+    const oldPosition = new import_three10.Vector3();
+    const oldRotation = new import_three10.Quaternion();
+    const oldScale = new import_three10.Vector3();
+    const matrix = new import_three10.Matrix4();
     if (!scale || !rotation || !position) {
       this.getMatrixAt(index, matrix).decompose(oldPosition, oldRotation, oldScale);
     }
     matrix.compose(
       position ? position : oldPosition,
-      rotation ? new import_three9.Quaternion().setFromEuler(rotation) : oldRotation,
+      rotation ? new import_three10.Quaternion().setFromEuler(rotation) : oldRotation,
       scale ? scale : oldScale
     );
     this.setMatrixAt(index, matrix);
@@ -3097,7 +3174,7 @@ var _SceneObject = class _SceneObject extends import_three9.Object3D {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     this.setPositionRotationScaleAt(index, position);
   }
-  getPositionAt(index, vector = new import_three9.Vector3()) {
+  getPositionAt(index, vector = new import_three10.Vector3()) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const matrix = this.getMatrixAt(index);
     vector.setFromMatrixPosition(matrix);
@@ -3107,7 +3184,7 @@ var _SceneObject = class _SceneObject extends import_three9.Object3D {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     this.setPositionRotationScaleAt(index, void 0, rotation, void 0);
   }
-  getRotationAt(index, euler = new import_three9.Euler()) {
+  getRotationAt(index, euler = new import_three10.Euler()) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const matrix = this.getMatrixAt(index);
     euler.setFromRotationMatrix(matrix);
@@ -3117,7 +3194,7 @@ var _SceneObject = class _SceneObject extends import_three9.Object3D {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     this.setPositionRotationScaleAt(index, void 0, void 0, scale);
   }
-  getScaleAt(index, vector = new import_three9.Vector3()) {
+  getScaleAt(index, vector = new import_three10.Vector3()) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const matrix = this.getMatrixAt(index);
     vector.setFromMatrixScale(matrix);
@@ -3239,7 +3316,7 @@ function isSceneObject(obj) {
 
 // src/entity/scene/EntityObject.ts
 var import_ts_deepmerge4 = __toESM(require_dist());
-var import_three11 = require("three");
+var import_three12 = require("three");
 var THREE3 = __toESM(require("three"));
 var EntityObject = class extends SceneObject {
   constructor(entity, options) {
@@ -3277,7 +3354,7 @@ var EntityObject = class extends SceneObject {
     for (let partName in this.entity.parts) {
       const part = this.entity.parts[partName];
       const texture = new MinecraftCubeTexture(part.textureOffsetU, part.textureOffsetV, part.textureWidth, part.textureHeight);
-      const partAnchor = new import_three11.Object3D();
+      const partAnchor = new import_three12.Object3D();
       partAnchor.position.x = part.pivotX;
       partAnchor.position.y = part.pivotY;
       partAnchor.position.z = part.pivotZ;
@@ -3331,16 +3408,16 @@ var GuiObject = class extends SceneObject {
 };
 
 // src/inspector/SceneInspector.ts
-var import_three12 = require("three");
+var import_three13 = 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_three12.Vector2();
+    this.mouse = new import_three13.Vector2();
     this.objectInfoContainer = document.createElement("div");
     this.objectControlsContainer = document.createElement("div");
-    this.raycaster = new import_three12.Raycaster();
+    this.raycaster = new import_three13.Raycaster();
     this.init();
   }
   init() {
@@ -3743,20 +3820,6 @@ function isInstanceable(obj) {
   return "nextInstance" in obj;
 }
 
-// src/model/DisplayPosition.ts
-var DisplayPosition = /* @__PURE__ */ ((DisplayPosition2) => {
-  DisplayPosition2["THIRDPERSON_RIGHTHAND"] = "thirdperson_righthand";
-  DisplayPosition2["THIRDPERSON_LEFTHAND"] = "thirdperson_lefthand";
-  DisplayPosition2["FIRSTPERSON_RIGHTHAND"] = "firstperson_righthand";
-  DisplayPosition2["FIRSTPERSON_LEFTHAND"] = "firstperson_lefthand";
-  DisplayPosition2["GUI"] = "gui";
-  DisplayPosition2["HEAD"] = "head";
-  DisplayPosition2["GROUND"] = "ground";
-  DisplayPosition2["FIXED"] = "fixed";
-  return DisplayPosition2;
-})(DisplayPosition || {});
-var DISPLAY_POSITIONS = Object.values(DisplayPosition);
-
 // src/model/GuiLight.ts
 var GuiLight = /* @__PURE__ */ ((GuiLight2) => {
   GuiLight2["FRONT"] = "front";
@@ -3865,10 +3928,10 @@ var BlockTints = class {
 };
 
 // src/model/scene/ModelObject.ts
-var import_three15 = require("three");
+var import_three16 = require("three");
 
 // src/three/BufferGeometryUtils.js
-var import_three14 = require("three");
+var import_three15 = require("three");
 function computeTangents(geometry) {
   geometry.computeTangents();
   console.warn("THREE.BufferGeometryUtils: .computeTangents() has been removed. Use BufferGeometry.computeTangents() instead.");
@@ -3880,7 +3943,7 @@ function mergeBufferGeometries(geometries, useGroups = false) {
   const attributes = {};
   const morphAttributes = {};
   const morphTargetsRelative = geometries[0].morphTargetsRelative;
-  const mergedGeometry = new import_three14.BufferGeometry();
+  const mergedGeometry = new import_three15.BufferGeometry();
   let offset = 0;
   for (let i = 0; i < geometries.length; ++i) {
     const geometry = geometries[i];
@@ -4004,7 +4067,7 @@ function mergeBufferAttributes(attributes) {
     array.set(attributes[i].array, offset);
     offset += attributes[i].array.length;
   }
-  return new import_three14.BufferAttribute(array, itemSize, normalized);
+  return new import_three15.BufferAttribute(array, itemSize, normalized);
 }
 function interleaveAttributes(attributes) {
   let TypedArray;
@@ -4020,7 +4083,7 @@ function interleaveAttributes(attributes) {
     arrayLength += attribute.array.length;
     stride += attribute.itemSize;
   }
-  const interleavedBuffer = new import_three14.InterleavedBuffer(new TypedArray(arrayLength), stride);
+  const interleavedBuffer = new import_three15.InterleavedBuffer(new TypedArray(arrayLength), stride);
   let offset = 0;
   const res = [];
   const getters = ["getX", "getY", "getZ", "getW"];
@@ -4029,7 +4092,7 @@ function interleaveAttributes(attributes) {
     const attribute = attributes[j];
     const itemSize = attribute.itemSize;
     const count = attribute.count;
-    const iba = new import_three14.InterleavedBufferAttribute(interleavedBuffer, itemSize, offset, attribute.normalized);
+    const iba = new import_three15.InterleavedBufferAttribute(interleavedBuffer, itemSize, offset, attribute.normalized);
     res.push(iba);
     offset += itemSize;
     for (let c = 0; c < count; c++) {
@@ -4113,13 +4176,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_three14.BufferAttribute(buffer, oldAttribute.itemSize, oldAttribute.normalized);
+    const attribute = new import_three15.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_three14.BufferAttribute(buffer2, oldMorphAttribute.itemSize, oldMorphAttribute.normalized);
+        const morphAttribute = new import_three15.BufferAttribute(buffer2, oldMorphAttribute.itemSize, oldMorphAttribute.normalized);
         result.morphAttributes[name][j] = morphAttribute;
       }
     }
@@ -4128,11 +4191,11 @@ function mergeVertices(geometry, tolerance = 1e-4) {
   return result;
 }
 function toTrianglesDrawMode(geometry, drawMode) {
-  if (drawMode === import_three14.TrianglesDrawMode) {
+  if (drawMode === import_three15.TrianglesDrawMode) {
     console.warn("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles.");
     return geometry;
   }
-  if (drawMode === import_three14.TriangleFanDrawMode || drawMode === import_three14.TriangleStripDrawMode) {
+  if (drawMode === import_three15.TriangleFanDrawMode || drawMode === import_three15.TriangleStripDrawMode) {
     let index = geometry.getIndex();
     if (index === null) {
       const indices = [];
@@ -4150,7 +4213,7 @@ function toTrianglesDrawMode(geometry, drawMode) {
     }
     const numberOfTriangles = index.count - 2;
     const newIndices = [];
-    if (drawMode === import_three14.TriangleFanDrawMode) {
+    if (drawMode === import_three15.TriangleFanDrawMode) {
       for (let i = 1; i <= numberOfTriangles; i++) {
         newIndices.push(index.getX(0));
         newIndices.push(index.getX(i));
@@ -4186,15 +4249,15 @@ function computeMorphedAttributes(object) {
     console.error("THREE.BufferGeometryUtils: Geometry is not of type BufferGeometry.");
     return null;
   }
-  const _vA = new import_three14.Vector3();
-  const _vB = new import_three14.Vector3();
-  const _vC = new import_three14.Vector3();
-  const _tempA = new import_three14.Vector3();
-  const _tempB = new import_three14.Vector3();
-  const _tempC = new import_three14.Vector3();
-  const _morphA = new import_three14.Vector3();
-  const _morphB = new import_three14.Vector3();
-  const _morphC = new import_three14.Vector3();
+  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();
   function _calculateMorphedAttributeData(object2, material2, attribute, morphAttribute, morphTargetsRelative2, a2, b2, c2, modifiedAttributeArray) {
     _vA.fromBufferAttribute(attribute, a2);
     _vB.fromBufferAttribute(attribute, b2);
@@ -4389,8 +4452,8 @@ function computeMorphedAttributes(object) {
       }
     }
   }
-  const morphedPositionAttribute = new import_three14.Float32BufferAttribute(modifiedPosition, 3);
-  const morphedNormalAttribute = new import_three14.Float32BufferAttribute(modifiedNormal, 3);
+  const morphedPositionAttribute = new import_three15.Float32BufferAttribute(modifiedPosition, 3);
+  const morphedNormalAttribute = new import_three15.Float32BufferAttribute(modifiedNormal, 3);
   return {
     positionAttribute,
     normalAttribute,
@@ -4431,13 +4494,14 @@ var _ModelObject = class _ModelObject extends SceneObject {
   createMeshes(force = false) {
     if (this.meshesCreated && !force) return;
     const mat = Materials.MISSING_TEXTURE;
+    const displayTransform = this.options.displayPosition ? DisplayTransforms.getMatrix(this.originalModel.display, this.options.displayPosition) : void 0;
     let allGeos = [];
     if (this.atlas) {
       if (this.atlas.model.elements) {
         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_three15.Euler(...this.options.uvLockRotation));
+            UVMapper.lockUvs(elGeo, el.faces, this.atlas, new import_three16.Euler(...this.options.uvLockRotation));
           }
           if (this.options.tints) {
             const colors = new Float32Array(elGeo.getAttribute("position").count * 3).fill(1);
@@ -4446,19 +4510,20 @@ 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_three15.Color(tint);
+              const color = new import_three16.Color(tint);
               for (let vertex = 0; vertex < 4; vertex++) {
                 color.toArray(colors, (faceIndex * 4 + vertex) * 3);
               }
             }
-            elGeo.setAttribute("color", new import_three15.BufferAttribute(colors, 3));
+            elGeo.setAttribute("color", new import_three16.BufferAttribute(colors, 3));
           }
-          elGeo.applyMatrix4(new import_three15.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_three15.Matrix4().makeTranslation(el.from[0], el.from[1], el.from[2]));
+          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]));
           if (el.rotation) {
             applyElementRotation(el.rotation, elGeo);
           }
-          elGeo.applyMatrix4(new import_three15.Matrix4().makeTranslation(-8, -8, -8));
+          elGeo.applyMatrix4(new import_three16.Matrix4().makeTranslation(-8, -8, -8));
+          if (displayTransform) DisplayTransforms.apply(elGeo, displayTransform);
           if (this.options.mergeMeshes) {
             allGeos.push(elGeo);
           } else {
@@ -4479,7 +4544,8 @@ var _ModelObject = class _ModelObject extends SceneObject {
       if (allGeos.length > 0) {
         combinedGeo = mergeBufferGeometries(allGeos);
       } else {
-        combinedGeo = new import_three15.BoxGeometry(16, 16, 16);
+        combinedGeo = new import_three16.BoxGeometry(16, 16, 16);
+        if (displayTransform) DisplayTransforms.apply(combinedGeo, displayTransform);
       }
       combinedGeo.computeBoundingBox();
       let mesh;
@@ -4533,7 +4599,7 @@ function isModelObject(obj) {
 
 // src/model/block/scene/BlockObject.ts
 var import_ts_deepmerge6 = __toESM(require_dist());
-var import_three16 = require("three");
+var import_three17 = require("three");
 var p10 = prefix("BlockObject");
 function matchesCondition(condition, state) {
   return Object.entries(condition).every(([key, value]) => {
@@ -4590,7 +4656,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
       if (isModelObject(model)) {
         model.removeFromScene();
       } else if (isInstanceReference(model)) {
-        model.setScale(new import_three16.Vector3(0, 0, 0));
+        model.setScale(new import_three17.Vector3(0, 0, 0));
       }
     }
     super.removeFromScene();
@@ -4651,7 +4717,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
     }
     for (let model of this._models) {
       if (isInstanceReference(model)) {
-        model.setScale(new import_three16.Vector3(0, 0, 0));
+        model.setScale(new import_three17.Vector3(0, 0, 0));
       } else {
         model.dispose();
       }
@@ -4688,7 +4754,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
     await this.createVariant(variant);
   }
   async createVariant(variant) {
-    const rotation = new import_three16.Euler();
+    const rotation = new import_three17.Euler();
     if (typeof variant.x !== "undefined") {
       rotation.x = toRadians(clampRotationDegrees(variant.x));
     }
@@ -4775,7 +4841,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
   setPositionRotationScaleAt(index, position, rotation, scale) {
     super.setPositionRotationScaleAt(index, position, rotation, scale);
   }
-  getMatrixAt(index, matrix = new import_three16.Matrix4()) {
+  getMatrixAt(index, matrix = new import_three17.Matrix4()) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const child = this._models[0];
     if (child && isModelObject(child)) {
@@ -4854,7 +4920,7 @@ var StructureParser = class {
 };
 
 // src/renderer/MineRenderScene.ts
-var import_three17 = require("three");
+var import_three18 = require("three");
 var import_ts_deepmerge8 = __toESM(require_dist());
 
 // src/skin/SkinPart.ts
@@ -5698,7 +5764,7 @@ var SkinObject = class extends SceneObject {
 };
 
 // src/renderer/MineRenderScene.ts
-var _MineRenderScene = class _MineRenderScene extends import_three17.Scene {
+var _MineRenderScene = class _MineRenderScene extends import_three18.Scene {
   constructor(options) {
     super();
     this.isMineRenderScene = true;
@@ -5771,7 +5837,8 @@ var _MineRenderScene = class _MineRenderScene extends import_three17.Scene {
       console.log("instanceMeshes + key");
       let key = asset.key.serialize();
       if (isModelObject(obj)) {
-        const { uvLockRotation, tints } = obj.options;
+        const { displayPosition, uvLockRotation, tints } = obj.options;
+        if (displayPosition) key += `|display:${displayPosition}`;
         if (uvLockRotation) key += `|uvlock:${uvLockRotation.join(",")}`;
         const palette = Object.entries(tints ?? {}).sort(([a], [b]) => Number(a) - Number(b));
         if (palette.length) key += `|tints:${JSON.stringify(palette)}`;
@@ -5820,17 +5887,17 @@ function isMineRenderScene(obj) {
 }
 
 // src/renderer/Renderer.ts
-var import_three19 = require("three");
+var import_three20 = 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_three18 = require("three");
+var import_three19 = require("three");
 var _changeEvent = { type: "change" };
 var _startEvent = { type: "start" };
 var _endEvent = { type: "end" };
-var OrbitControls = class extends import_three18.EventDispatcher {
+var OrbitControls = class extends import_three19.EventDispatcher {
   constructor(object, domElement) {
     super();
     if (domElement === void 0) console.warn('THREE.OrbitControls: The second parameter "domElement" is now mandatory.');
@@ -5839,7 +5906,7 @@ var OrbitControls = class extends import_three18.EventDispatcher {
     this.domElement = domElement;
     this.domElement.style.touchAction = "none";
     this.enabled = true;
-    this.target = new import_three18.Vector3();
+    this.target = new import_three19.Vector3();
     this.minDistance = 0;
     this.maxDistance = Infinity;
     this.minZoom = 0;
@@ -5861,8 +5928,8 @@ var OrbitControls = class extends import_three18.EventDispatcher {
     this.autoRotate = false;
     this.autoRotateSpeed = 2;
     this.keys = { LEFT: "ArrowLeft", UP: "ArrowUp", RIGHT: "ArrowRight", BOTTOM: "ArrowDown" };
-    this.mouseButtons = { LEFT: import_three18.MOUSE.ROTATE, MIDDLE: import_three18.MOUSE.DOLLY, RIGHT: import_three18.MOUSE.PAN };
-    this.touches = { ONE: import_three18.TOUCH.ROTATE, TWO: import_three18.TOUCH.DOLLY_PAN };
+    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.target0 = this.target.clone();
     this.position0 = this.object.position.clone();
     this.zoom0 = this.object.zoom;
@@ -5891,11 +5958,11 @@ var OrbitControls = class extends import_three18.EventDispatcher {
       state = STATE.NONE;
     };
     this.update = function() {
-      const offset = new import_three18.Vector3();
-      const quat = new import_three18.Quaternion().setFromUnitVectors(object.up, new import_three18.Vector3(0, 1, 0));
+      const offset = new import_three19.Vector3();
+      const quat = new import_three19.Quaternion().setFromUnitVectors(object.up, new import_three19.Vector3(0, 1, 0));
       const quatInverse = quat.clone().invert();
-      const lastPosition = new import_three18.Vector3();
-      const lastQuaternion = new import_three18.Quaternion();
+      const lastPosition = new import_three19.Vector3();
+      const lastQuaternion = new import_three19.Quaternion();
       const twoPI = 2 * Math.PI;
       return function update() {
         const position = scope.object.position;
@@ -5981,20 +6048,20 @@ var OrbitControls = class extends import_three18.EventDispatcher {
     };
     let state = STATE.NONE;
     const EPS = 1e-6;
-    const spherical = new import_three18.Spherical();
-    const sphericalDelta = new import_three18.Spherical();
+    const spherical = new import_three19.Spherical();
+    const sphericalDelta = new import_three19.Spherical();
     let scale = 1;
-    const panOffset = new import_three18.Vector3();
+    const panOffset = new import_three19.Vector3();
     let zoomChanged = false;
-    const rotateStart = new import_three18.Vector2();
-    const rotateEnd = new import_three18.Vector2();
-    const rotateDelta = new import_three18.Vector2();
-    const panStart = new import_three18.Vector2();
-    const panEnd = new import_three18.Vector2();
-    const panDelta = new import_three18.Vector2();
-    const dollyStart = new import_three18.Vector2();
-    const dollyEnd = new import_three18.Vector2();
-    const dollyDelta = new import_three18.Vector2();
+    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 pointers = [];
     const pointerPositions = {};
     function getAutoRotationAngle() {
@@ -6010,7 +6077,7 @@ var OrbitControls = class extends import_three18.EventDispatcher {
       sphericalDelta.phi -= angle;
     }
     const panLeft = function() {
-      const v = new import_three18.Vector3();
+      const v = new import_three19.Vector3();
       return function panLeft2(distance, objectMatrix) {
         v.setFromMatrixColumn(objectMatrix, 0);
         v.multiplyScalar(-distance);
@@ -6018,7 +6085,7 @@ var OrbitControls = class extends import_three18.EventDispatcher {
       };
     }();
     const panUp = function() {
-      const v = new import_three18.Vector3();
+      const v = new import_three19.Vector3();
       return function panUp2(distance, objectMatrix) {
         if (scope.screenSpacePanning === true) {
           v.setFromMatrixColumn(objectMatrix, 1);
@@ -6031,7 +6098,7 @@ var OrbitControls = class extends import_three18.EventDispatcher {
       };
     }();
     const pan = function() {
-      const offset = new import_three18.Vector3();
+      const offset = new import_three19.Vector3();
       return function pan2(deltaX, deltaY) {
         const element = scope.domElement;
         if (scope.object.isPerspectiveCamera) {
@@ -6280,12 +6347,12 @@ var OrbitControls = class extends import_three18.EventDispatcher {
           mouseAction = -1;
       }
       switch (mouseAction) {
-        case import_three18.MOUSE.DOLLY:
+        case import_three19.MOUSE.DOLLY:
           if (scope.enableZoom === false) return;
           handleMouseDownDolly(event);
           state = STATE.DOLLY;
           break;
-        case import_three18.MOUSE.ROTATE:
+        case import_three19.MOUSE.ROTATE:
           if (event.ctrlKey || event.metaKey || event.shiftKey) {
             if (scope.enablePan === false) return;
             handleMouseDownPan(event);
@@ -6296,7 +6363,7 @@ var OrbitControls = class extends import_three18.EventDispatcher {
             state = STATE.ROTATE;
           }
           break;
-        case import_three18.MOUSE.PAN:
+        case import_three19.MOUSE.PAN:
           if (event.ctrlKey || event.metaKey || event.shiftKey) {
             if (scope.enableRotate === false) return;
             handleMouseDownRotate(event);
@@ -6352,12 +6419,12 @@ var OrbitControls = class extends import_three18.EventDispatcher {
       switch (pointers.length) {
         case 1:
           switch (scope.touches.ONE) {
-            case import_three18.TOUCH.ROTATE:
+            case import_three19.TOUCH.ROTATE:
               if (scope.enableRotate === false) return;
               handleTouchStartRotate();
               state = STATE.TOUCH_ROTATE;
               break;
-            case import_three18.TOUCH.PAN:
+            case import_three19.TOUCH.PAN:
               if (scope.enablePan === false) return;
               handleTouchStartPan();
               state = STATE.TOUCH_PAN;
@@ -6368,12 +6435,12 @@ var OrbitControls = class extends import_three18.EventDispatcher {
           break;
         case 2:
           switch (scope.touches.TWO) {
-            case import_three18.TOUCH.DOLLY_PAN:
+            case import_three19.TOUCH.DOLLY_PAN:
               if (scope.enableZoom === false && scope.enablePan === false) return;
               handleTouchStartDollyPan();
               state = STATE.TOUCH_DOLLY_PAN;
               break;
-            case import_three18.TOUCH.DOLLY_ROTATE:
+            case import_three19.TOUCH.DOLLY_ROTATE:
               if (scope.enableZoom === false && scope.enableRotate === false) return;
               handleTouchStartDollyRotate();
               state = STATE.TOUCH_DOLLY_ROTATE;
@@ -6440,7 +6507,7 @@ var OrbitControls = class extends import_three18.EventDispatcher {
     function trackPointer(event) {
       let position = pointerPositions[event.pointerId];
       if (position === void 0) {
-        position = new import_three18.Vector2();
+        position = new import_three19.Vector2();
         pointerPositions[event.pointerId] = position;
       }
       position.set(event.pageX, event.pageY);
@@ -6460,10 +6527,10 @@ var MapControls = class extends OrbitControls {
   constructor(object, domElement) {
     super(object, domElement);
     this.screenSpacePanning = false;
-    this.mouseButtons.LEFT = import_three18.MOUSE.PAN;
-    this.mouseButtons.RIGHT = import_three18.MOUSE.ROTATE;
-    this.touches.ONE = import_three18.TOUCH.PAN;
-    this.touches.TWO = import_three18.TOUCH.DOLLY_ROTATE;
+    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;
   }
 };
 
@@ -6500,14 +6567,14 @@ var _Renderer = class _Renderer {
     switch (this.options.camera.type) {
       case "perspective":
       default:
-        return new import_three19.PerspectiveCamera(
+        return new import_three20.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_three19.OrthographicCamera(
+        return new import_three20.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,
@@ -6518,7 +6585,7 @@ var _Renderer = class _Renderer {
     }
   }
   createRenderer() {
-    const renderer = new import_three19.WebGLRenderer({
+    const renderer = new import_three20.WebGLRenderer({
       antialias: this.options.render.antialias,
       alpha: true,
       powerPreference: "high-performance",
@@ -6526,8 +6593,8 @@ var _Renderer = class _Renderer {
     });
     renderer.setClearColor(0, 0);
     renderer.shadowMap.enabled = true;
-    renderer.shadowMap.type = import_three19.PCFSoftShadowMap;
-    renderer.outputColorSpace = import_three19.SRGBColorSpace;
+    renderer.shadowMap.type = import_three20.PCFSoftShadowMap;
+    renderer.outputColorSpace = import_three20.SRGBColorSpace;
     renderer.setSize(this.viewWidth, this.viewHeight);
     return renderer;
   }
@@ -6561,20 +6628,20 @@ var _Renderer = class _Renderer {
       window["__THREE_DEVTOOLS__"].dispatchEvent(new CustomEvent("observe", { detail: this.scene }));
     }
     if (this.options.debug.grid) {
-      const gridHelper = new import_three19.GridHelper(128, 16);
+      const gridHelper = new import_three20.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper);
       this.scene.add(gridHelper);
-      const gridHelper2 = new import_three19.GridHelper(128, 16);
+      const gridHelper2 = new import_three20.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper2);
       gridHelper2.rotation.x = 90 * (Math.PI / 180);
       this.scene.add(gridHelper2);
-      const gridHelper3 = new import_three19.GridHelper(128, 16);
+      const gridHelper3 = new import_three20.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_three19.AxesHelper(64);
+      const axesHelper = new import_three20.AxesHelper(64);
       this._debugHelpers.push(axesHelper);
       this.scene.add(axesHelper);
     }
@@ -6778,8 +6845,8 @@ _Renderer.DEFAULT_OPTIONS = (0, import_ts_deepmerge9.default)({}, {
       top: void 0,
       bottom: void 0
     },
-    position: new import_three19.Vector3(50, 50, 50),
-    lookingAt: new import_three19.Vector3(0, 0, 0)
+    position: new import_three20.Vector3(50, 50, 50),
+    lookingAt: new import_three20.Vector3(0, 0, 0)
   },
   render: {
     fpsLimit: 60,
@@ -6973,10 +7040,10 @@ var Skins = class {
 };
 
 // src/world/Chunk.ts
-var import_three22 = require("three");
+var import_three23 = require("three");
 
 // src/world/MineRenderWorld.ts
-var import_three21 = require("three");
+var import_three22 = require("three");
 var MineRenderWorld = class {
   constructor(scene) {
     this._size = 4;
@@ -6987,10 +7054,10 @@ var MineRenderWorld = class {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new import_three21.Vector3(posOrX, y, z));
+      return this.getBlockAt(new import_three22.Vector3(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new import_three21.Vector3(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new import_three22.Vector3(posOrX[0], posOrX[1], posOrX[2]));
     }
     const chunk = this.getChunkAt(posOrX);
     if (typeof chunk === "undefined") {
@@ -7001,10 +7068,10 @@ var MineRenderWorld = class {
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new import_three21.Vector3(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new import_three22.Vector3(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new import_three21.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new import_three22.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     this.validatePosBounds(posOrX);
     const chunk = this.getOrCreateChunkAt(posOrX);
@@ -7050,14 +7117,14 @@ var MineRenderWorld = class {
     return this._chunks[index];
   }
   static worldToScenePosition(pos) {
-    return new import_three21.Vector3(
+    return new import_three22.Vector3(
       pos.x * 16,
       pos.y * 16,
       pos.z * 16
     );
   }
   static sceneToWorldPosition(pos) {
-    return new import_three21.Vector3(
+    return new import_three22.Vector3(
       pos.x / 16,
       pos.y / 16,
       pos.z / 16
@@ -7094,12 +7161,12 @@ var Chunk = class _Chunk {
     this.x = x;
     this.y = y;
     this.z = z;
-    let anchor = new import_three22.Object3D();
+    let anchor = new import_three23.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_three22.Box3(new import_three22.Vector3(0, 0, 0), new import_three22.Vector3(256, 256, 256)),
+      new import_three23.Box3(new import_three23.Vector3(0, 0, 0), new import_three23.Vector3(256, 256, 256)),
       anchor,
       16776960,
       4
@@ -7107,10 +7174,10 @@ var Chunk = class _Chunk {
   }
   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 pos = this.worldPosToChunkPos(posOrX);
     const index = _Chunk.chunkPosToBlockIndex(pos);
@@ -7118,10 +7185,10 @@ var Chunk = class _Chunk {
   }
   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);
     }
     const worldPos = posOrX;
     const pos = this.worldPosToChunkPos(worldPos);
@@ -7167,7 +7234,7 @@ var Chunk = class _Chunk {
   }
   async clear() {
     let promises = [];
-    let pos = new import_three22.Vector3();
+    let pos = new import_three23.Vector3();
     for (let x = 0; x < 16; x++) {
       for (let z = 0; z < 16; z++) {
         for (let y = 0; y < 16; y++) {
@@ -7186,14 +7253,14 @@ var Chunk = class _Chunk {
     return pos.y * 16 * 16 + pos.z * 16 + pos.x;
   }
   worldPosToChunkPos(pos) {
-    return new import_three22.Vector3(
+    return new import_three23.Vector3(
       pos.x - this.x * 16,
       pos.y - this.y * 16,
       pos.z - this.z * 16
     );
   }
   chunkPosToWorldPos(pos) {
-    return new import_three22.Vector3(
+    return new import_three23.Vector3(
       this.x * 16 + pos.x,
       this.y * 16 + pos.y,
       this.z * 16 + pos.z