minerender 2.1.0-alpha.20 → 2.1.0-alpha.22

package/dist/browser/index.js

@@ -140,6 +140,7 @@ __export(index_browser_exports, {
   BlockEntityModels: () => BlockEntityModels,
   BlockObject: () => BlockObject,
   BlockStates: () => BlockStates,
+  BlockTints: () => BlockTints,
   BrowserArchiveProxy: () => BrowserArchiveProxy,
   BrowserCache: () => BrowserCache,
   BrowserEnv: () => BrowserEnv,
@@ -156,6 +157,7 @@ __export(index_browser_exports, {
   DISPLAY_POSITIONS: () => DISPLAY_POSITIONS,
   DefaultBlockStates: () => DefaultBlockStates,
   DisplayPosition: () => DisplayPosition,
+  DisplayTransforms: () => DisplayTransforms,
   Entities: () => Entities,
   EntityModels: () => EntityModels,
   EntityObject: () => EntityObject,
@@ -568,6 +570,7 @@ var _Caching = class _Caching {
       this.blockStateCache,
       this.listAssetCache,
       this.defaultBlockStatesCache,
+      this.blockTintCache,
       this.entityModelsCache
     ];
   }
@@ -610,6 +613,7 @@ _Caching.modelTextureAtlasCache = import_loading_cache.Caches.builder().expireAf
 _Caching.blockStateCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
 _Caching.listAssetCache = _Caching.createAssetCache();
 _Caching.defaultBlockStatesCache = _Caching.createAssetCache();
+_Caching.blockTintCache = _Caching.createAssetCache();
 _Caching.entityModelsCache = _Caching.createAssetCache();
 var Caching = _Caching;
 
@@ -1247,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());
@@ -1338,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;
@@ -1601,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 */:
@@ -1628,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));
@@ -1638,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);
 }
 
@@ -2217,12 +2283,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) {
@@ -2319,7 +2385,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");
@@ -2397,32 +2463,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];
@@ -2569,7 +2635,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);
@@ -2803,7 +2869,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 {
@@ -2862,7 +2928,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;
@@ -2900,7 +2966,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}`;
     }
@@ -2950,7 +3016,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}`;
     }
@@ -2962,7 +3028,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}`;
@@ -3040,7 +3106,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);
@@ -3057,7 +3123,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)) {
@@ -3076,16 +3142,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);
@@ -3094,7 +3160,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);
@@ -3104,7 +3170,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);
@@ -3114,7 +3180,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);
@@ -3236,7 +3302,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) {
@@ -3274,7 +3340,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;
@@ -3328,16 +3394,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() {
@@ -3740,20 +3806,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";
@@ -3776,11 +3828,96 @@ function isQuadArray(obj) {
   return Array.isArray(obj) && obj.length === 4;
 }
 
+// src/model/block/blockTints.json
+var blockTints_default = {
+  "minecraft:large_fern": { source: "grass" },
+  "minecraft:tall_grass": { source: "grass" },
+  "minecraft:grass_block": { source: "grass" },
+  "minecraft:fern": { source: "grass" },
+  "minecraft:grass": { source: "grass" },
+  "minecraft:short_grass": { source: "grass" },
+  "minecraft:potted_fern": { source: "grass" },
+  "minecraft:bush": { source: "grass" },
+  "minecraft:pink_petals": { source: "grass", untinted: [0] },
+  "minecraft:wildflowers": { source: "grass", untinted: [0] },
+  "minecraft:spruce_leaves": { source: "constant", color: 6396257 },
+  "minecraft:birch_leaves": { source: "constant", color: 8431445 },
+  "minecraft:oak_leaves": { source: "constant", color: 4764952 },
+  "minecraft:jungle_leaves": { source: "constant", color: 4764952 },
+  "minecraft:acacia_leaves": { source: "constant", color: 4764952 },
+  "minecraft:dark_oak_leaves": { source: "constant", color: 4764952 },
+  "minecraft:vine": { source: "constant", color: 4764952 },
+  "minecraft:mangrove_leaves": { source: "constant", color: 4764952 },
+  "minecraft:leaf_litter": { source: "constant", color: 6044722 },
+  "minecraft:water_cauldron": { source: "constant", color: 4159204 },
+  "minecraft:redstone_wire": { source: "redstone" },
+  "minecraft:attached_melon_stem": { source: "constant", color: 14731036 },
+  "minecraft:attached_pumpkin_stem": { source: "constant", color: 14731036 },
+  "minecraft:melon_stem": { source: "stem" },
+  "minecraft:pumpkin_stem": { source: "stem" },
+  "minecraft:lily_pad": { source: "constant", color: 7455580 }
+};
+
+// src/model/block/BlockTints.ts
+var rules = blockTints_default;
+var BlockTints = class {
+  /** Resolves block preview colors without biome context; explicit tints take precedence. */
+  static async get(key, state, model, tints) {
+    const rule = key && rules[key.toNamespacedString()];
+    if (!key || !rule) return tints;
+    const indices = /* @__PURE__ */ new Set();
+    for (const element of model.elements ?? []) {
+      for (const face of Object.values(element.faces)) {
+        const index = face?.tintindex;
+        if (index !== void 0 && index >= 0 && tints?.[index] === void 0 && !rule.untinted?.includes(index)) {
+          indices.add(index);
+        }
+      }
+    }
+    if (!indices.size) return tints;
+    let color;
+    switch (rule.source) {
+      case "constant":
+        color = rule.color;
+        break;
+      case "grass":
+        color = await this.grassColor(key);
+        break;
+      case "redstone": {
+        const power = Number(state.power ?? 0) / 15;
+        const red = power * 0.6 + (power > 0 ? 0.4 : 0.3);
+        const green = Math.max(0, power * power * 0.7 - 0.5);
+        const blue = Math.max(0, power * power * 0.6 - 0.7);
+        color = Math.floor(red * 255) << 16 | Math.floor(green * 255) << 8 | Math.floor(blue * 255);
+        break;
+      }
+      case "stem": {
+        const age = Number(state.age ?? 0);
+        color = age * 32 << 16 | 255 - age * 8 << 8 | age * 4;
+        break;
+      }
+    }
+    return { ...Object.fromEntries([...indices].map((index) => [index, color])), ...tints };
+  }
+  static async grassColor(origin) {
+    const key = AssetKey.parse("textures", "minecraft:colormap/grass", origin);
+    return await Caching.blockTintCache.get(key.serialize(), async () => {
+      const image = await ModelTextures.get(key);
+      if (!image) throw new MineRenderError(`Missing grass colormap: ${key.toNamespacedString()}`);
+      if (image.width !== 256 || image.height !== 256) {
+        throw new MineRenderError("Grass colormaps must be 256 \xD7 256 pixels");
+      }
+      const [red, green, blue] = image.data.getImageData(127, 127, 1, 1).data;
+      return red << 16 | green << 8 | blue;
+    });
+  }
+};
+
 // 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.");
@@ -3792,7 +3929,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];
@@ -3916,7 +4053,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;
@@ -3932,7 +4069,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"];
@@ -3941,7 +4078,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++) {
@@ -4025,13 +4162,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;
       }
     }
@@ -4040,11 +4177,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 = [];
@@ -4062,7 +4199,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));
@@ -4098,15 +4235,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);
@@ -4301,8 +4438,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,
@@ -4343,13 +4480,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);
@@ -4358,19 +4496,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 {
@@ -4391,7 +4530,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;
@@ -4445,7 +4585,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]) => {
@@ -4502,7 +4642,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();
@@ -4563,7 +4703,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();
       }
@@ -4600,7 +4740,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));
     }
@@ -4610,6 +4750,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
     const model = await Models.getMerged(AssetKey.parse("models", variant.model));
     const options = {
       ...this.options,
+      tints: model ? await BlockTints.get(this.blockState.key, this.state, model, this.options.tints) : this.options.tints,
       uvLockRotation: variant.uvlock && (rotation.x !== 0 || rotation.y !== 0) ? [rotation.x, rotation.y, rotation.z] : void 0
     };
     const obj = await this.scene.addModel(model, options);
@@ -4686,7 +4827,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)) {
@@ -4765,7 +4906,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
@@ -5609,7 +5750,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;
@@ -5682,7 +5823,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)}`;
@@ -5731,17 +5873,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.');
@@ -5750,7 +5892,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;
@@ -5772,8 +5914,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;
@@ -5802,11 +5944,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;
@@ -5892,20 +6034,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() {
@@ -5921,7 +6063,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);
@@ -5929,7 +6071,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);
@@ -5942,7 +6084,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) {
@@ -6191,12 +6333,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);
@@ -6207,7 +6349,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);
@@ -6263,12 +6405,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;
@@ -6279,12 +6421,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;
@@ -6351,7 +6493,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);
@@ -6371,10 +6513,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;
   }
 };
 
@@ -6411,14 +6553,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,
@@ -6429,7 +6571,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",
@@ -6437,8 +6579,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;
   }
@@ -6472,20 +6614,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);
     }
@@ -6689,8 +6831,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,
@@ -6884,10 +7026,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;
@@ -6898,10 +7040,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") {
@@ -6912,10 +7054,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);
@@ -6961,14 +7103,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
@@ -7005,12 +7147,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
@@ -7018,10 +7160,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);
@@ -7029,10 +7171,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);
@@ -7078,7 +7220,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++) {
@@ -7097,14 +7239,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