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

package/dist/node/index.mjs

@@ -1098,7 +1098,7 @@ var Meshes = class _Meshes {
 };
 
 // src/UVMapper.ts
-import { Float32BufferAttribute as Float32BufferAttribute2, Vector2, Vector3 as Vector33 } from "three";
+import { Float32BufferAttribute as Float32BufferAttribute2, Vector2, Vector3 as Vector34 } from "three";
 
 // src/model/ModelMerger.ts
 var import_ts_deepmerge = __toESM(require_dist());
@@ -1189,15 +1189,77 @@ function isAssetKey(obj) {
   return isBasicAssetKey(obj) && obj.isAssetKey === true;
 }
 
+// src/model/DisplayTransforms.ts
+import { Euler, Matrix4, Quaternion, Vector3 as Vector32 } from "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 Quaternion().setFromEuler(new Euler(toRadians(x), sign * toRadians(y), sign * toRadians(z), "XYZ"));
+    const translation = new Vector32(...transform.translation ?? [0, 0, 0]).clampScalar(-80, 80);
+    translation.x *= sign;
+    const scale = new Vector32(...transform.scale ?? [1, 1, 1]).clampScalar(-4, 4);
+    return new 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;
@@ -1343,7 +1405,7 @@ var BlockStates = class {
       void 0,
       "assets",
       ".json",
-      DEFAULT_ROOT
+      AssetLoader.ROOT
     );
     return Caching.listAssetCache.get(key.serialize(), () => {
       return AssetLoader.get(key, "list" /* LIST */);
@@ -1452,9 +1514,9 @@ var BatchedExecutor = class {
 };
 
 // src/util/model.ts
-import { AxesHelper, BoxGeometry as BoxGeometry2, EdgesGeometry, LineBasicMaterial, LineSegments, Vector3 as Vector32 } from "three";
+import { AxesHelper, BoxGeometry as BoxGeometry2, EdgesGeometry, LineBasicMaterial, LineSegments, Vector3 as Vector33 } from "three";
 function applyElementRotation(rotation, geometry) {
-  const origin = new Vector32(rotation.origin[0], rotation.origin[1], rotation.origin[2]);
+  const origin = new Vector33(rotation.origin[0], rotation.origin[1], rotation.origin[2]);
   geometry.translate(-origin.x, -origin.y, -origin.z);
   switch (rotation.axis) {
     case "x" /* X */:
@@ -1479,7 +1541,7 @@ function applyElementRotation(rotation, geometry) {
   geometry.translate(origin.x, origin.y, origin.z);
 }
 function applyModelPartRotation(modelPart, geometry) {
-  const origin = new Vector32(modelPart.pivotX, modelPart.pivotY, modelPart.pivotZ);
+  const origin = new Vector33(modelPart.pivotX, modelPart.pivotY, modelPart.pivotZ);
   geometry.translate(-origin.x, -origin.y, -origin.z);
   geometry.rotateX(toRadians(modelPart.pitch));
   geometry.rotateY(toRadians(modelPart.yaw));
@@ -1489,18 +1551,18 @@ function applyModelPartRotation(modelPart, geometry) {
 function applyGenericRotation(axis, rotation, obj) {
   switch (axis) {
     case "x" /* X */:
-      obj.rotateOnAxis(new Vector32(1, 0, 0), toRadians(rotation));
+      obj.rotateOnAxis(new Vector33(1, 0, 0), toRadians(rotation));
       break;
     case "y" /* Y */:
-      obj.rotateOnAxis(new Vector32(0, 1, 0), toRadians(rotation));
+      obj.rotateOnAxis(new Vector33(0, 1, 0), toRadians(rotation));
       break;
     case "z" /* Z */:
-      obj.rotateOnAxis(new Vector32(0, 0, 1), toRadians(rotation));
+      obj.rotateOnAxis(new Vector33(0, 0, 1), toRadians(rotation));
       break;
   }
 }
 function addBox3WireframeToObject(box, obj, color = 16777215, w = 2) {
-  let size = new Vector32();
+  let size = new Vector33();
   box.getSize(size);
   let boxGeo = new BoxGeometry2(size.x, size.y, size.z, 1, 1, 1);
   let wireGeo = new EdgesGeometry(boxGeo);
@@ -1660,17 +1722,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;
@@ -1804,6 +1866,20 @@ var AssetLoader = class {
   static {
     this._SOURCES = [];
   }
+  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);
@@ -1826,7 +1902,7 @@ var AssetLoader = class {
   }
   static {
     this.addSource("mcassets-fallback", new HostedAssetSource("https://raw.githubusercontent.com/InventivetalentDev/minerender-fallback-assets/master", { retryDefaults: false }));
-    this.addSource("mcassets", new HostedAssetSource(DEFAULT_ROOT, { retryDefaults: false }));
+    this.addSource("mcassets", new HostedAssetSource(this.ROOT, { retryDefaults: false }));
   }
   static async getAll(key, parser) {
     let promises = [];
@@ -2103,12 +2179,12 @@ var X = 0;
 var Y = 1;
 var Z = 2;
 var FACE_UV_AXES = {
-  east: [new Vector33(0, 0, -1), new Vector33(0, -1, 0)],
-  west: [new Vector33(0, 0, 1), new Vector33(0, -1, 0)],
-  up: [new Vector33(1, 0, 0), new Vector33(0, 0, 1)],
-  down: [new Vector33(1, 0, 0), new Vector33(0, 0, -1)],
-  south: [new Vector33(1, 0, 0), new Vector33(0, -1, 0)],
-  north: [new Vector33(-1, 0, 0), new Vector33(0, -1, 0)]
+  east: [new Vector34(0, 0, -1), new Vector34(0, -1, 0)],
+  west: [new Vector34(0, 0, 1), new Vector34(0, -1, 0)],
+  up: [new Vector34(1, 0, 0), new Vector34(0, 0, 1)],
+  down: [new Vector34(1, 0, 0), new Vector34(0, 0, -1)],
+  south: [new Vector34(1, 0, 0), new Vector34(0, -1, 0)],
+  north: [new Vector34(-1, 0, 0), new Vector34(0, -1, 0)]
 };
 var UVMapper = class {
   static makeUv(uvCoord, originalTextureSize, actualTextureSize) {
@@ -2689,7 +2765,7 @@ var BlockEntityModels = class {
 };
 
 // src/renderer/SceneObject.ts
-import { Euler as Euler2, InstancedMesh, MathUtils, Matrix4 as Matrix42, Mesh as Mesh3, Object3D as Object3D2, Quaternion as Quaternion2, Vector3 as Vector34 } from "three";
+import { Euler as Euler3, InstancedMesh, MathUtils, Matrix4 as Matrix43, Mesh as Mesh3, Object3D as Object3D2, Quaternion as Quaternion3, Vector3 as Vector35 } from "three";
 
 // src/instance/InstanceReference.ts
 var InstanceReference = class {
@@ -2934,7 +3010,7 @@ var SceneObject = class _SceneObject extends Object3D2 {
   nextInstance() {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const i = this._instanceCounter++;
-    this.setMatrixAt(i, new Matrix42());
+    this.setMatrixAt(i, new Matrix43());
     const mesh = this.children[0];
     if (mesh && isInstancedMesh(mesh)) {
       mesh.count = Math.min(this._instanceCounter, mesh.instanceMatrix.count);
@@ -2951,7 +3027,7 @@ var SceneObject = class _SceneObject extends Object3D2 {
   }
   //</editor-fold>
   //<editor-fold desc="TRANSFORMATION">
-  getMatrixAt(index, matrix = new Matrix42()) {
+  getMatrixAt(index, matrix = new Matrix43()) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const child = this.children[0];
     if (child && isInstancedMesh(child)) {
@@ -2970,16 +3046,16 @@ var SceneObject = class _SceneObject extends Object3D2 {
   }
   setPositionRotationScaleAt(index, position, rotation, scale) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
-    const oldPosition = new Vector34();
-    const oldRotation = new Quaternion2();
-    const oldScale = new Vector34();
-    const matrix = new Matrix42();
+    const oldPosition = new Vector35();
+    const oldRotation = new Quaternion3();
+    const oldScale = new Vector35();
+    const matrix = new Matrix43();
     if (!scale || !rotation || !position) {
       this.getMatrixAt(index, matrix).decompose(oldPosition, oldRotation, oldScale);
     }
     matrix.compose(
       position ? position : oldPosition,
-      rotation ? new Quaternion2().setFromEuler(rotation) : oldRotation,
+      rotation ? new Quaternion3().setFromEuler(rotation) : oldRotation,
       scale ? scale : oldScale
     );
     this.setMatrixAt(index, matrix);
@@ -2988,7 +3064,7 @@ var SceneObject = class _SceneObject extends Object3D2 {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     this.setPositionRotationScaleAt(index, position);
   }
-  getPositionAt(index, vector = new Vector34()) {
+  getPositionAt(index, vector = new Vector35()) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const matrix = this.getMatrixAt(index);
     vector.setFromMatrixPosition(matrix);
@@ -2998,7 +3074,7 @@ var SceneObject = class _SceneObject extends Object3D2 {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     this.setPositionRotationScaleAt(index, void 0, rotation, void 0);
   }
-  getRotationAt(index, euler = new Euler2()) {
+  getRotationAt(index, euler = new Euler3()) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const matrix = this.getMatrixAt(index);
     euler.setFromRotationMatrix(matrix);
@@ -3008,7 +3084,7 @@ var SceneObject = class _SceneObject extends Object3D2 {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     this.setPositionRotationScaleAt(index, void 0, void 0, scale);
   }
-  getScaleAt(index, vector = new Vector34()) {
+  getScaleAt(index, vector = new Vector35()) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const matrix = this.getMatrixAt(index);
     vector.setFromMatrixScale(matrix);
@@ -3629,20 +3705,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";
@@ -3751,7 +3813,7 @@ var BlockTints = class {
 };
 
 // src/model/scene/ModelObject.ts
-import { BoxGeometry as BoxGeometry5, BufferAttribute as BufferAttribute4, Color as Color3, Euler as Euler4, Matrix4 as Matrix45 } from "three";
+import { BoxGeometry as BoxGeometry5, BufferAttribute as BufferAttribute4, Color as Color3, Euler as Euler5, Matrix4 as Matrix46 } from "three";
 
 // src/three/BufferGeometryUtils.js
 import {
@@ -3763,7 +3825,7 @@ import {
   TriangleFanDrawMode,
   TriangleStripDrawMode,
   TrianglesDrawMode,
-  Vector3 as Vector36
+  Vector3 as Vector37
 } from "three";
 function computeTangents(geometry) {
   geometry.computeTangents();
@@ -4082,15 +4144,15 @@ function computeMorphedAttributes(object) {
     console.error("THREE.BufferGeometryUtils: Geometry is not of type BufferGeometry.");
     return null;
   }
-  const _vA = new Vector36();
-  const _vB = new Vector36();
-  const _vC = new Vector36();
-  const _tempA = new Vector36();
-  const _tempB = new Vector36();
-  const _tempC = new Vector36();
-  const _morphA = new Vector36();
-  const _morphB = new Vector36();
-  const _morphC = new Vector36();
+  const _vA = new Vector37();
+  const _vB = new Vector37();
+  const _vC = new Vector37();
+  const _tempA = new Vector37();
+  const _tempB = new Vector37();
+  const _tempC = new Vector37();
+  const _morphA = new Vector37();
+  const _morphB = new Vector37();
+  const _morphC = new Vector37();
   function _calculateMorphedAttributeData(object2, material2, attribute, morphAttribute, morphTargetsRelative2, a2, b2, c2, modifiedAttributeArray) {
     _vA.fromBufferAttribute(attribute, a2);
     _vB.fromBufferAttribute(attribute, b2);
@@ -4330,13 +4392,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 Euler4(...this.options.uvLockRotation));
+            UVMapper.lockUvs(elGeo, el.faces, this.atlas, new Euler5(...this.options.uvLockRotation));
           }
           if (this.options.tints) {
             const colors = new Float32Array(elGeo.getAttribute("position").count * 3).fill(1);
@@ -4352,12 +4415,13 @@ var ModelObject = class _ModelObject extends SceneObject {
             }
             elGeo.setAttribute("color", new BufferAttribute4(colors, 3));
           }
-          elGeo.applyMatrix4(new Matrix45().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 Matrix45().makeTranslation(el.from[0], el.from[1], el.from[2]));
+          elGeo.applyMatrix4(new Matrix46().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 Matrix46().makeTranslation(el.from[0], el.from[1], el.from[2]));
           if (el.rotation) {
             applyElementRotation(el.rotation, elGeo);
           }
-          elGeo.applyMatrix4(new Matrix45().makeTranslation(-8, -8, -8));
+          elGeo.applyMatrix4(new Matrix46().makeTranslation(-8, -8, -8));
+          if (displayTransform) DisplayTransforms.apply(elGeo, displayTransform);
           if (this.options.mergeMeshes) {
             allGeos.push(elGeo);
           } else {
@@ -4379,6 +4443,7 @@ var ModelObject = class _ModelObject extends SceneObject {
         combinedGeo = mergeBufferGeometries(allGeos);
       } else {
         combinedGeo = new BoxGeometry5(16, 16, 16);
+        if (displayTransform) DisplayTransforms.apply(combinedGeo, displayTransform);
       }
       combinedGeo.computeBoundingBox();
       let mesh;
@@ -4430,7 +4495,7 @@ function isModelObject(obj) {
 
 // src/model/block/scene/BlockObject.ts
 var import_ts_deepmerge6 = __toESM(require_dist());
-import { Euler as Euler5, Matrix4 as Matrix46, Vector3 as Vector37 } from "three";
+import { Euler as Euler6, Matrix4 as Matrix47, Vector3 as Vector38 } from "three";
 var p10 = prefix("BlockObject");
 function matchesCondition(condition, state) {
   return Object.entries(condition).every(([key, value]) => {
@@ -4492,7 +4557,7 @@ var BlockObject = class _BlockObject extends SceneObject {
       if (isModelObject(model)) {
         model.removeFromScene();
       } else if (isInstanceReference(model)) {
-        model.setScale(new Vector37(0, 0, 0));
+        model.setScale(new Vector38(0, 0, 0));
       }
     }
     super.removeFromScene();
@@ -4553,7 +4618,7 @@ var BlockObject = class _BlockObject extends SceneObject {
     }
     for (let model of this._models) {
       if (isInstanceReference(model)) {
-        model.setScale(new Vector37(0, 0, 0));
+        model.setScale(new Vector38(0, 0, 0));
       } else {
         model.dispose();
       }
@@ -4590,7 +4655,7 @@ var BlockObject = class _BlockObject extends SceneObject {
     await this.createVariant(variant);
   }
   async createVariant(variant) {
-    const rotation = new Euler5();
+    const rotation = new Euler6();
     if (typeof variant.x !== "undefined") {
       rotation.x = toRadians(clampRotationDegrees(variant.x));
     }
@@ -4677,7 +4742,7 @@ var BlockObject = class _BlockObject extends SceneObject {
   setPositionRotationScaleAt(index, position, rotation, scale) {
     super.setPositionRotationScaleAt(index, position, rotation, scale);
   }
-  getMatrixAt(index, matrix = new Matrix46()) {
+  getMatrixAt(index, matrix = new Matrix47()) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const child = this._models[0];
     if (child && isModelObject(child)) {
@@ -5672,7 +5737,8 @@ var MineRenderScene = class _MineRenderScene extends Scene2 {
       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)}`;
@@ -5719,7 +5785,7 @@ function isMineRenderScene(obj) {
 }
 
 // src/renderer/Renderer.ts
-import { AxesHelper as AxesHelper3, GridHelper, OrthographicCamera, PCFSoftShadowMap, PerspectiveCamera, SRGBColorSpace as SRGBColorSpace3, Vector3 as Vector39, WebGLRenderer } from "three";
+import { AxesHelper as AxesHelper3, GridHelper, OrthographicCamera, PCFSoftShadowMap, PerspectiveCamera, SRGBColorSpace as SRGBColorSpace3, Vector3 as Vector310, WebGLRenderer } from "three";
 var import_ts_deepmerge9 = __toESM(require_dist());
 import Stats from "stats.js";
 import { EffectComposer, RenderPass } from "postprocessing";
@@ -5728,11 +5794,11 @@ import { EffectComposer, RenderPass } from "postprocessing";
 import {
   EventDispatcher,
   MOUSE,
-  Quaternion as Quaternion3,
+  Quaternion as Quaternion4,
   Spherical,
   TOUCH,
   Vector2 as Vector23,
-  Vector3 as Vector38
+  Vector3 as Vector39
 } from "three";
 var _changeEvent = { type: "change" };
 var _startEvent = { type: "start" };
@@ -5746,7 +5812,7 @@ var OrbitControls = class extends EventDispatcher {
     this.domElement = domElement;
     this.domElement.style.touchAction = "none";
     this.enabled = true;
-    this.target = new Vector38();
+    this.target = new Vector39();
     this.minDistance = 0;
     this.maxDistance = Infinity;
     this.minZoom = 0;
@@ -5798,11 +5864,11 @@ var OrbitControls = class extends EventDispatcher {
       state = STATE.NONE;
     };
     this.update = function() {
-      const offset = new Vector38();
-      const quat = new Quaternion3().setFromUnitVectors(object.up, new Vector38(0, 1, 0));
+      const offset = new Vector39();
+      const quat = new Quaternion4().setFromUnitVectors(object.up, new Vector39(0, 1, 0));
       const quatInverse = quat.clone().invert();
-      const lastPosition = new Vector38();
-      const lastQuaternion = new Quaternion3();
+      const lastPosition = new Vector39();
+      const lastQuaternion = new Quaternion4();
       const twoPI = 2 * Math.PI;
       return function update() {
         const position = scope.object.position;
@@ -5891,7 +5957,7 @@ var OrbitControls = class extends EventDispatcher {
     const spherical = new Spherical();
     const sphericalDelta = new Spherical();
     let scale = 1;
-    const panOffset = new Vector38();
+    const panOffset = new Vector39();
     let zoomChanged = false;
     const rotateStart = new Vector23();
     const rotateEnd = new Vector23();
@@ -5917,7 +5983,7 @@ var OrbitControls = class extends EventDispatcher {
       sphericalDelta.phi -= angle;
     }
     const panLeft = function() {
-      const v = new Vector38();
+      const v = new Vector39();
       return function panLeft2(distance, objectMatrix) {
         v.setFromMatrixColumn(objectMatrix, 0);
         v.multiplyScalar(-distance);
@@ -5925,7 +5991,7 @@ var OrbitControls = class extends EventDispatcher {
       };
     }();
     const panUp = function() {
-      const v = new Vector38();
+      const v = new Vector39();
       return function panUp2(distance, objectMatrix) {
         if (scope.screenSpacePanning === true) {
           v.setFromMatrixColumn(objectMatrix, 1);
@@ -5938,7 +6004,7 @@ var OrbitControls = class extends EventDispatcher {
       };
     }();
     const pan = function() {
-      const offset = new Vector38();
+      const offset = new Vector39();
       return function pan2(deltaX, deltaY) {
         const element = scope.domElement;
         if (scope.object.isPerspectiveCamera) {
@@ -6415,8 +6481,8 @@ var Renderer = class _Renderer {
           top: void 0,
           bottom: void 0
         },
-        position: new Vector39(50, 50, 50),
-        lookingAt: new Vector39(0, 0, 0)
+        position: new Vector310(50, 50, 50),
+        lookingAt: new Vector310(0, 0, 0)
       },
       render: {
         fpsLimit: 60,
@@ -6881,10 +6947,10 @@ var Skins = class {
 };
 
 // src/world/Chunk.ts
-import { Box3 as Box32, Object3D as Object3D6, Vector3 as Vector311 } from "three";
+import { Box3 as Box32, Object3D as Object3D6, Vector3 as Vector312 } from "three";
 
 // src/world/MineRenderWorld.ts
-import { Vector3 as Vector310 } from "three";
+import { Vector3 as Vector311 } from "three";
 var MineRenderWorld = class {
   constructor(scene) {
     this._size = 4;
@@ -6895,10 +6961,10 @@ var MineRenderWorld = class {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new Vector310(posOrX, y, z));
+      return this.getBlockAt(new Vector311(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new Vector310(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new Vector311(posOrX[0], posOrX[1], posOrX[2]));
     }
     const chunk = this.getChunkAt(posOrX);
     if (typeof chunk === "undefined") {
@@ -6909,10 +6975,10 @@ var MineRenderWorld = class {
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new Vector310(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new Vector311(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new Vector310(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new Vector311(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     this.validatePosBounds(posOrX);
     const chunk = this.getOrCreateChunkAt(posOrX);
@@ -6958,14 +7024,14 @@ var MineRenderWorld = class {
     return this._chunks[index];
   }
   static worldToScenePosition(pos) {
-    return new Vector310(
+    return new Vector311(
       pos.x * 16,
       pos.y * 16,
       pos.z * 16
     );
   }
   static sceneToWorldPosition(pos) {
-    return new Vector310(
+    return new Vector311(
       pos.x / 16,
       pos.y / 16,
       pos.z / 16
@@ -7007,7 +7073,7 @@ var Chunk = class _Chunk {
     scene.add(anchor);
     anchor.position.set(this.x * 256 + 128 - 8, this.y * 256 + 128 - 8, this.z * 256 + 128 - 8);
     addBox3WireframeToObject(
-      new Box32(new Vector311(0, 0, 0), new Vector311(256, 256, 256)),
+      new Box32(new Vector312(0, 0, 0), new Vector312(256, 256, 256)),
       anchor,
       16776960,
       4
@@ -7015,10 +7081,10 @@ var Chunk = class _Chunk {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new Vector311(posOrX, y, z));
+      return this.getBlockAt(new Vector312(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new Vector311(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new Vector312(posOrX[0], posOrX[1], posOrX[2]));
     }
     const pos = this.worldPosToChunkPos(posOrX);
     const index = _Chunk.chunkPosToBlockIndex(pos);
@@ -7026,10 +7092,10 @@ var Chunk = class _Chunk {
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new Vector311(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new Vector312(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new Vector311(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new Vector312(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     const worldPos = posOrX;
     const pos = this.worldPosToChunkPos(worldPos);
@@ -7075,7 +7141,7 @@ var Chunk = class _Chunk {
   }
   async clear() {
     let promises = [];
-    let pos = new Vector311();
+    let pos = new Vector312();
     for (let x = 0; x < 16; x++) {
       for (let z = 0; z < 16; z++) {
         for (let y = 0; y < 16; y++) {
@@ -7094,14 +7160,14 @@ var Chunk = class _Chunk {
     return pos.y * 16 * 16 + pos.z * 16 + pos.x;
   }
   worldPosToChunkPos(pos) {
-    return new Vector311(
+    return new Vector312(
       pos.x - this.x * 16,
       pos.y - this.y * 16,
       pos.z - this.z * 16
     );
   }
   chunkPosToWorldPos(pos) {
-    return new Vector311(
+    return new Vector312(
       this.x * 16 + pos.x,
       this.y * 16 + pos.y,
       this.z * 16 + pos.z
@@ -7140,6 +7206,7 @@ export {
   DISPLAY_POSITIONS,
   DefaultBlockStates,
   DisplayPosition,
+  DisplayTransforms,
   Entities,
   EntityModels,
   EntityObject,