minerender 2.1.0-alpha.59 → 2.1.0-alpha.60

package/dist/node/index.mjs

@@ -1133,6 +1133,26 @@ var init_Materials = __esm({
   }
 });
 
+// src/model/Model.ts
+function isDoubleArray(obj) {
+  return Array.isArray(obj) && obj.length === 2;
+}
+function isTripleArray(obj) {
+  return Array.isArray(obj) && obj.length === 3;
+}
+function isQuadArray(obj) {
+  return Array.isArray(obj) && obj.length === 4;
+}
+var ITEM_GENERATED, BUILTIN_GENERATED, BUILTIN_ENTITY, DEFAULT_ELEMENTS;
+var init_Model = __esm({
+  "src/model/Model.ts"() {
+    ITEM_GENERATED = "item/generated";
+    BUILTIN_GENERATED = "builtin/generated";
+    BUILTIN_ENTITY = "builtin/entity";
+    DEFAULT_ELEMENTS = [];
+  }
+});
+
 // ../../node_modules/ts-deepmerge/dist/index.js
 var require_dist = __commonJS({
   "../../node_modules/ts-deepmerge/dist/index.js"(exports) {
@@ -1391,6 +1411,7 @@ var init_DisplayTransforms = __esm({
 var import_ts_deepmerge, ModelMerger;
 var init_ModelMerger = __esm({
   "src/model/ModelMerger.ts"() {
+    init_Model();
     init_Models();
     import_ts_deepmerge = __toESM(require_dist());
     init_AssetKey();
@@ -1416,6 +1437,7 @@ var init_ModelMerger = __esm({
         }
         const models = [];
         const parentKey = AssetKey.parse("models", model.parent);
+        if (parentKey.namespace === "minecraft" && parentKey.getFullPath() === BUILTIN_ENTITY) return models;
         parentKey.root = model.key?.root;
         const parentModel = await Models.getRaw(parentKey);
         if (parentModel) {
@@ -1482,12 +1504,12 @@ var init_Models = __esm({
           const result = await AssetLoader.getFirst([itemKey, key], "json" /* JSON */);
           if (!result) return void 0;
           if (result.key.assetType !== "items") return { ...result.asset, key };
-          const reference = this.defaultItemModel(result.asset.model, key);
-          const modelKey = AssetKey.parse("models", reference);
+          const selected = this.defaultItemModel(result.asset.model, key);
+          const modelKey = AssetKey.parse("models", selected.model);
           modelKey.root = key.root;
           const model2 = await this.getRaw(modelKey);
-          if (!model2) throw new Error(`Item ${key.toNamespacedString()} references missing model ${reference}`);
-          return model2;
+          if (!model2) throw new Error(`Item ${key.toNamespacedString()} references missing model ${selected.model}`);
+          return selected.special ? { ...model2, special: selected.special } : model2;
         });
         return model ? { ...model, key: Object.assign(new AssetKey("", ""), model.key) } : void 0;
       }
@@ -1498,8 +1520,25 @@ var init_Models = __esm({
         }
         switch (node.type.replace(/^minecraft:/, "")) {
           case "model":
-            if (typeof node.model === "string" && node.model) return node.model;
+            if (typeof node.model === "string" && node.model) return { model: node.model };
             break;
+          case "special": {
+            if (!node.base || !node.model || typeof node.model !== "object") break;
+            const special = node.model;
+            switch (special.type) {
+              case "chest":
+              case "minecraft:chest":
+              case "bed":
+              case "minecraft:bed":
+                if (typeof special.texture === "string" && special.texture) return { model: node.base, special };
+                break;
+              case "head":
+              case "minecraft:head":
+                if (typeof special.kind === "string" && special.kind) return { model: node.base, special };
+                break;
+            }
+            throw new Error(`Unsupported special item renderer ${special.type} for ${key.toNamespacedString()}`);
+          }
           case "condition":
             return this.defaultItemModel(node.on_false, key);
           case "select": {
@@ -3098,6 +3137,102 @@ var init_UVMapper = __esm({
   }
 });
 
+// src/MinecraftCubeTexture.ts
+var MinecraftCubeTexture;
+var init_MinecraftCubeTexture = __esm({
+  "src/MinecraftCubeTexture.ts"() {
+    init_UVMapper();
+    init_CubeFace();
+    MinecraftCubeTexture = class {
+      constructor(u, v, width, height) {
+        this.u = u;
+        this.v = v;
+        this.width = width;
+        this.height = height;
+      }
+      mapW(x) {
+        return x / this.width;
+      }
+      mapH(x) {
+        return 1 - x / this.height;
+      }
+      getUvEast(w, h, l) {
+        return [
+          [this.mapW(this.u + l + w + l), this.mapH(this.v + l + h)],
+          [this.mapW(this.u + l + w), this.mapH(this.v + l + h)],
+          [this.mapW(this.u + l + w + l), this.mapH(this.v + l)],
+          [this.mapW(this.u + l + w), this.mapH(this.v + l)]
+        ];
+      }
+      getUvWest(w, h, l) {
+        return [
+          [this.mapW(this.u + l), this.mapH(this.v + l + h)],
+          [this.mapW(this.u), this.mapH(this.v + l + h)],
+          [this.mapW(this.u + l), this.mapH(this.v + l)],
+          [this.mapW(this.u), this.mapH(this.v + l)]
+        ];
+      }
+      getUvUp(w, h, l) {
+        return [
+          [this.mapW(this.u + l + w), this.mapH(this.v + l)],
+          [this.mapW(this.u + l + w + w), this.mapH(this.v + l)],
+          [this.mapW(this.u + l + w), this.mapH(this.v)],
+          [this.mapW(this.u + l + w + w), this.mapH(this.v)]
+        ];
+      }
+      getUvDown(w, h, l) {
+        return [
+          [this.mapW(this.u + l), this.mapH(this.v)],
+          [this.mapW(this.u + l + w), this.mapH(this.v)],
+          [this.mapW(this.u + l), this.mapH(this.v + l)],
+          [this.mapW(this.u + l + w), this.mapH(this.v + l)]
+        ];
+      }
+      getUvSouth(w, h, l) {
+        return [
+          [this.mapW(this.u + l + w + l + w), this.mapH(this.v + l + h)],
+          [this.mapW(this.u + l + w + l), this.mapH(this.v + l + h)],
+          [this.mapW(this.u + l + w + l + w), this.mapH(this.v + l)],
+          [this.mapW(this.u + l + w + l), this.mapH(this.v + l)]
+        ];
+      }
+      getUvNorth(w, h, l) {
+        return [
+          [this.mapW(this.u + l + w), this.mapH(this.v + l + h)],
+          [this.mapW(this.u + l), this.mapH(this.v + l + h)],
+          [this.mapW(this.u + l + w), this.mapH(this.v + l)],
+          [this.mapW(this.u + l), this.mapH(this.v + l)]
+        ];
+      }
+      getFaceUv(face, w, h, l) {
+        switch (face) {
+          case "east" /* EAST */:
+            return this.getUvEast(w, h, l);
+          case "west" /* WEST */:
+            return this.getUvWest(w, h, l);
+          case "up" /* UP */:
+            return this.getUvUp(w, h, l);
+          case "down" /* DOWN */:
+            return this.getUvDown(w, h, l);
+          case "south" /* SOUTH */:
+            return this.getUvSouth(w, h, l);
+          case "north" /* NORTH */:
+            return this.getUvNorth(w, h, l);
+        }
+      }
+      toUvArray(w, h, l, mirror = false) {
+        const uv = [];
+        for (let i = 0; i < CUBE_FACES.length; i++) {
+          const face = mirror && i < 2 ? CUBE_FACES[1 - i] : CUBE_FACES[i];
+          const corners = this.getFaceUv(face, w, h, l);
+          UVMapper.setFaceUvInArray(uv, i * 4, mirror ? [corners[1], corners[0], corners[3], corners[2]] : corners);
+        }
+        return uv;
+      }
+    };
+  }
+});
+
 // src/error/MineRenderError.ts
 var MineRenderError;
 var init_MineRenderError = __esm({
@@ -3114,6 +3249,248 @@ var init_MineRenderError = __esm({
   }
 });
 
+// src/assets/Entities.ts
+var Entities;
+var init_Entities = __esm({
+  "src/assets/Entities.ts"() {
+    init_AssetKey();
+    init_AssetLoader();
+    init_source();
+    init_Caching();
+    init_Assets();
+    init_MineRenderError();
+    init_ModelTextures();
+    Entities = class {
+      static async getEntityList() {
+        const collect = async (path) => {
+          const prefix2 = path ? `${path}/` : "";
+          const key = new AssetKey(DEFAULT_NAMESPACE, `${prefix2}_list`, void 0, void 0, "entity-models", ".json");
+          const list = await Caching.listAssetCache.get(key.serialize(), () => AssetLoader.get(key, "list" /* LIST */));
+          if (!list) return [];
+          const files = list.files.filter((file) => file.endsWith(".json") && file !== "_list.json").map((file) => `${prefix2}${file.slice(0, -5)}`);
+          const children = await Promise.all(list.directories.map((directory) => collect(`${prefix2}${directory}`)));
+          return [...files, ...children.flat()];
+        };
+        return collect("");
+      }
+      static async getModelFile(modelKey) {
+        const path = isAssetKey(modelKey) ? modelKey.getFullPath() : modelKey.path;
+        const key = new AssetKey(modelKey.namespace, path, void 0, void 0, "entity-models", ".json", isAssetKey(modelKey) ? modelKey.root : void 0);
+        return Caching.entityModelCache.get(key.serialize(), () => AssetLoader.get(key, "json" /* JSON */));
+      }
+      static async getLayerList(modelKey) {
+        return Object.keys((await this.getModelFile(modelKey))?.layers ?? {});
+      }
+      /** The dataset's extra draws on top of `main`; their `when` labels are the states `EntityModelOptions.when` can enable. */
+      static async getPassList(modelKey) {
+        return (await this.getModelFile(modelKey))?.passes ?? [];
+      }
+      static async getEntity(modelKey, textureKey, options) {
+        const model = await this.getModelFile(modelKey);
+        if (!model) return void 0;
+        const passes = options?.layers || options?.layer !== void 0 ? [] : (model.passes ?? []).filter((pass) => pass.when === void 0 || options?.when?.includes(pass.when));
+        const draws = [...new Set(options?.layers ?? [options?.layer ?? "main"])].map((layer) => ({ layer }));
+        if (draws.length === 0) throw new MineRenderError(`Entity ${model.id} requires at least one layer`);
+        draws.push(...passes);
+        const names = [];
+        const selected = draws.map((pass) => {
+          const layer = model.layers[pass.layer];
+          if (!layer) {
+            throw new MineRenderError(`Entity ${model.id} has no layer "${pass.layer}". Available layers: ${Object.keys(model.layers).join(", ")}`);
+          }
+          let name = pass.layer;
+          for (let n = 2; names.includes(name); n++) name = `${pass.layer}#${n}`;
+          names.push(name);
+          return { name, layer, pass };
+        });
+        const layers = Object.fromEntries(await Promise.all(selected.map(async ({ name, layer, pass }, index) => {
+          const override = options?.textures?.[name] ?? (index === 0 ? textureKey : void 0);
+          const textureLocation = pass.textureLocation ?? layer.textureLocation;
+          let texture;
+          if (override) {
+            const path = isAssetKey(override) ? override.getFullPath() : override.path;
+            texture = isAssetKey(override) && override.assetType === "textures" && path.startsWith("entity/") ? override : new AssetKey(override.namespace, path, "textures", "entity", "assets", ".png", isAssetKey(override) ? override.root : void 0);
+          } else if (textureLocation !== void 0) {
+            texture = AssetKey.parse("textures", textureLocation.replace(/^([^:]+:)?textures\//, "$1"));
+            if (isAssetKey(modelKey)) texture.root = modelKey.root;
+          } else {
+            texture = await this.resolveTexture(modelKey);
+          }
+          const render = pass.render ?? layer.render;
+          return [name, { key: override ?? modelKey, texture, layer, ...render && { render }, ...pass.tint && { tint: pass.tint } }];
+        })));
+        return { ...layers[names[0]], id: model.id, layers, ...model.transform && { transform: model.transform } };
+      }
+      /**
+       * Vanilla's keyframe animations of a model by name, or undefined when the model or the selected version has none.
+       */
+      static async getAnimations(modelKey) {
+        const path = isAssetKey(modelKey) ? modelKey.getFullPath() : modelKey.path;
+        const key = new AssetKey(modelKey.namespace, path, void 0, void 0, "entity-models/animations", ".json");
+        const file = await Caching.entityAnimationCache.get(key.serialize(), () => AssetLoader.get(key, "json" /* JSON */));
+        return file?.animations;
+      }
+      static async resolveTexture(modelKey) {
+        const path = isAssetKey(modelKey) ? modelKey.getFullPath() : modelKey.path;
+        const root = isAssetKey(modelKey) ? modelKey.root : void 0;
+        const key = new AssetKey(modelKey.namespace, path, void 0, void 0, "entity-models", ".json", root);
+        return Caching.entityTextureCache.get(key.serialize(), async () => {
+          const name = path.split("/").pop();
+          for (const candidate of [path, `${path}/${name}`]) {
+            const texture2 = new AssetKey(modelKey.namespace, candidate, "textures", "entity", "assets", ".png", root);
+            if (await ModelTextures.get(texture2)) return texture2;
+          }
+          const listKey = new AssetKey(modelKey.namespace, "_list", `${name}_variant`, void 0, "data", ".json", root);
+          const list = await AssetLoader.get(listKey, "list" /* LIST */);
+          const files = list?.files.filter((file2) => file2.endsWith(".json") && file2 !== "_list.json");
+          const file = files?.find((file2) => file2 === "temperate.json") ?? files?.[0];
+          if (!file) return void 0;
+          const variantKey = new AssetKey(modelKey.namespace, file.slice(0, -5), `${name}_variant`, void 0, "data", ".json", root);
+          const variant = await AssetLoader.get(variantKey, "json" /* JSON */);
+          const assets = variant?.assets;
+          const textureId = variant?.asset_id ?? (typeof assets?.wild === "string" ? assets.wild : Object.values(assets ?? {}).find((value) => typeof value === "string"));
+          if (typeof textureId !== "string") return void 0;
+          const texture = AssetKey.parse("textures", textureId);
+          texture.root = root;
+          return texture;
+        });
+      }
+      /** @deprecated Use getEntityList(); block entities share the entity dataset. */
+      static getBlockList() {
+        return this.getEntityList();
+      }
+      /** @deprecated Use getEntity(); block entities share the entity dataset. */
+      static getBlock(modelKey, textureKey, options) {
+        return this.getEntity(modelKey, textureKey, options);
+      }
+    };
+  }
+});
+
+// src/entity/EntityAnimation.ts
+function catmullRom(delta, p0, p1, p22, p32) {
+  return 0.5 * (2 * p1 + (p22 - p0) * delta + (2 * p0 - 5 * p1 + 4 * p22 - p32) * delta * delta + (3 * p1 - p0 - 3 * p22 + p32) * delta * delta * delta);
+}
+function sampleEntityKeyframes(keyframes, time) {
+  if (keyframes.length === 0) return [0, 0, 0];
+  let low = 0, high = keyframes.length;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    if (time <= keyframes[middle].time) high = middle;
+    else low = middle + 1;
+  }
+  const a = Math.max(0, low - 1);
+  const b = Math.min(keyframes.length - 1, a + 1);
+  const from = keyframes[a];
+  const to = keyframes[b];
+  const delta = a === b ? 0 : Math.min(1, Math.max(0, (time - from.time) / (to.time - from.time)));
+  if (to.interpolation === "catmullrom") {
+    const before = keyframes[Math.max(0, a - 1)].value;
+    const after = keyframes[Math.min(keyframes.length - 1, b + 1)].value;
+    return [0, 1, 2].map((i) => catmullRom(delta, before[i], from.value[i], to.value[i], after[i]));
+  }
+  const target = to.pre ?? to.value;
+  return [0, 1, 2].map((i) => from.value[i] + (target[i] - from.value[i]) * delta);
+}
+function entityAnimationTime(animation, time, loop = animation.loop) {
+  return loop && animation.length > 0 ? time % animation.length : time;
+}
+function sampleEntityAnimation(animation, time, loop = animation.loop) {
+  const elapsed = entityAnimationTime(animation, time, loop);
+  const pose = {};
+  for (const [name, bone] of Object.entries(animation.bones)) {
+    const sampled = pose[name] = {};
+    for (const channel of ENTITY_ANIMATION_CHANNELS) {
+      const keyframes = bone[channel];
+      if (keyframes?.length) sampled[channel] = sampleEntityKeyframes(keyframes, elapsed);
+    }
+  }
+  return pose;
+}
+var ENTITY_ANIMATION_CHANNELS;
+var init_EntityAnimation = __esm({
+  "src/entity/EntityAnimation.ts"() {
+    ENTITY_ANIMATION_CHANNELS = ["position", "rotation", "scale"];
+  }
+});
+
+// src/entity/scene/EntityAnimationPlayer.ts
+var ZERO, EntityAnimationPlayer;
+var init_EntityAnimationPlayer = __esm({
+  "src/entity/scene/EntityAnimationPlayer.ts"() {
+    init_EntityAnimation();
+    ZERO = [0, 0, 0];
+    EntityAnimationPlayer = class {
+      constructor() {
+        this.parts = [];
+        this._time = 0;
+        this.loop = false;
+        this.speed = 1;
+      }
+      get animation() {
+        return this._animation;
+      }
+      get time() {
+        return this._time;
+      }
+      /**
+       * Starts an animation on the named parts below each layer root. The current pose of a part becomes its default;
+       * bones without a matching part are skipped.
+       */
+      play(layers, animation, options = {}) {
+        this.stop();
+        this._animation = animation;
+        this._time = options.time ?? 0;
+        this.loop = options.loop ?? animation.loop;
+        this.speed = options.speed ?? 1;
+        for (const layer of layers) {
+          for (const bone of Object.keys(animation.bones)) {
+            const object = layer.getObjectByName(`group:${bone}`);
+            if (!object) continue;
+            this.parts.push({ bone, object, position: object.position.clone(), rotation: object.rotation.clone(), scale: object.scale.clone() });
+          }
+        }
+        this.apply();
+      }
+      /** Restores the default poses. Returns whether an animation was active. */
+      stop() {
+        if (!this._animation) return false;
+        for (const part of this.parts) {
+          part.object.position.copy(part.position);
+          part.object.rotation.copy(part.rotation);
+          part.object.scale.copy(part.scale);
+        }
+        this.clear();
+        return true;
+      }
+      /** Forgets the animation without touching the parts, for parts that no longer exist. */
+      clear() {
+        this.parts = [];
+        this._animation = void 0;
+        this._time = 0;
+      }
+      setTime(seconds) {
+        if (!this._animation) return false;
+        this._time = seconds;
+        this.apply();
+        return true;
+      }
+      advance(deltaSeconds) {
+        return this.setTime(this._time + deltaSeconds * this.speed);
+      }
+      apply() {
+        const pose = sampleEntityAnimation(this._animation, this._time, this.loop);
+        for (const part of this.parts) {
+          const { position = ZERO, rotation = ZERO, scale = ZERO } = pose[part.bone];
+          part.object.position.set(part.position.x + position[0], part.position.y + position[1], part.position.z + position[2]);
+          part.object.rotation.set(part.rotation.x + rotation[0], part.rotation.y + rotation[1], part.rotation.z + rotation[2], part.rotation.order);
+          part.object.scale.set(part.scale.x + scale[0], part.scale.y + scale[1], part.scale.z + scale[2]);
+        }
+      }
+    };
+  }
+});
+
 // src/instance/InstanceReference.ts
 function isInstanceReference(obj) {
   return obj.isInstanceReference;
@@ -3611,6 +3988,242 @@ var init_SceneObject = __esm({
   }
 });
 
+// src/entity/scene/EntityObject.ts
+import { Color as Color3, Euler as Euler4, Matrix4 as Matrix45, Object3D as Object3D3 } from "three";
+function isEntityObject(obj) {
+  return obj.isEntityObject;
+}
+var import_ts_deepmerge4, EntityObject;
+var init_EntityObject = __esm({
+  "src/entity/scene/EntityObject.ts"() {
+    init_SceneObject();
+    init_Caching();
+    import_ts_deepmerge4 = __toESM(require_dist());
+    init_Ticker();
+    init_model();
+    init_ModelTextures();
+    init_AssetKey();
+    init_Materials();
+    init_MinecraftCubeTexture();
+    init_three();
+    init_EntityAnimationPlayer();
+    EntityObject = class _EntityObject extends SceneObject {
+      constructor(entity, options) {
+        super();
+        this.entity = entity;
+        this.isEntityObject = true;
+        this.meshesCreated = false;
+        this.geometries = /* @__PURE__ */ new Set();
+        this.disposeWireframes = [];
+        /** Scrolling materials are owned: their texture offset follows this entity's age. */
+        this.scrollMaterials = [];
+        /** Entity age in ticks, as vanilla's `ageInTicks`; drives the scrolling render modes. */
+        this.age = 0;
+        this.animationPlayer = new EntityAnimationPlayer();
+        this.options = (0, import_ts_deepmerge4.default)({}, _EntityObject.DEFAULT_OPTIONS, options ?? {});
+        this.addEventListener("added", () => this.updateScrollSubscription());
+        this.addEventListener("removed", () => this.updateScrollSubscription());
+      }
+      static {
+        this.DEFAULT_OPTIONS = (0, import_ts_deepmerge4.default)({}, SceneObject.DEFAULT_OPTIONS);
+      }
+      async init() {
+        this.createMeshes();
+        await this.applyTextures();
+      }
+      dispose() {
+        super.dispose();
+      }
+      disposeAndRemoveAllChildren() {
+        this.clearScrollMaterials();
+        for (const geometry of this.geometries) geometry.dispose();
+        this.geometries.clear();
+        for (const dispose of this.disposeWireframes.splice(0)) dispose();
+        this.animationPlayer.clear();
+        super.disposeAndRemoveAllChildren();
+      }
+      clearScrollMaterials() {
+        Ticker.remove(this.scrollTicker);
+        this.scrollTicker = void 0;
+        for (const { material } of this.scrollMaterials.splice(0)) {
+          material.map?.dispose();
+          material.dispose();
+        }
+      }
+      updateScrollSubscription() {
+        if (this.parent && this.scrollMaterials.length) {
+          if (this.scrollTicker === void 0) {
+            this.scrollTicker = Ticker.add(() => {
+              this.age++;
+              this.updateScroll();
+            });
+          }
+        } else {
+          Ticker.remove(this.scrollTicker);
+          this.scrollTicker = void 0;
+        }
+      }
+      /** Applies the entity age to the scrolling materials; the ticker calls this 20 times per second. */
+      updateScroll() {
+        for (const { offset, speed } of this.scrollMaterials) {
+          offset.set(this.age * speed[0] % 1, 0 - this.age * speed[1] % 1);
+        }
+        this.notifyDirty();
+      }
+      //<editor-fold desc="ANIMATION">
+      /** The animation started by {@link playAnimation}, until {@link stopAnimation} or disposal. */
+      get animation() {
+        return this.animationPlayer.animation;
+      }
+      /** Seconds since the animation started, before looping. */
+      get animationTime() {
+        return this.animationPlayer.time;
+      }
+      /**
+       * Poses the object from a keyframe animation of {@link Entities.getAnimations}, replacing the current one.
+       * Parts of every layer are matched by name and their current pose is the default the offsets add to.
+       * The object owns no clock: call {@link advanceAnimation} per frame, or {@link setAnimationTime}.
+       */
+      playAnimation(animation, options) {
+        this.createMeshes();
+        const layers = Object.keys(this.entityLayers).map((name) => this.getLayerGroup(name)).filter((layer) => !!layer);
+        this.animationPlayer.play(layers, animation, options);
+        this.notifyDirty();
+      }
+      /** Stops the animation and restores the default pose. */
+      stopAnimation() {
+        if (this.animationPlayer.stop()) this.notifyDirty();
+      }
+      /** Poses the object at an explicit time in seconds. Has no effect without an animation. */
+      setAnimationTime(seconds) {
+        if (this.animationPlayer.setTime(seconds)) this.notifyDirty();
+      }
+      /** Advances the animation by a frame delta in seconds, scaled by its speed. Has no effect without an animation. */
+      advanceAnimation(deltaSeconds) {
+        if (this.animationPlayer.advance(deltaSeconds)) this.notifyDirty();
+      }
+      //</editor-fold>
+      getLayerGroup(name) {
+        return super.getGroupByName(`layer:${name}`);
+      }
+      getGroupByName(name, layerName) {
+        return layerName === void 0 ? super.getGroupByName(name) : this.getLayerGroup(layerName)?.getObjectByName(`group:${name}`);
+      }
+      getMeshByName(name, layerName) {
+        return layerName === void 0 ? super.getMeshByName(name) : this.getLayerGroup(layerName)?.getObjectByName(`mesh:${name}`);
+      }
+      get entityLayers() {
+        return this.entity.layers ?? { main: this.entity };
+      }
+      getTextureKey(layer) {
+        if (layer.texture) return layer.texture;
+        const key = layer.key;
+        return new AssetKey(
+          key.namespace,
+          isAssetKey(key) ? key.getFullPath() : key.path,
+          "textures",
+          "entity",
+          "assets",
+          ".png"
+        );
+      }
+      async loadTextures(layer = this.entity) {
+        return ModelTextures.get(this.getTextureKey(layer));
+      }
+      createMeshes(force = false) {
+        if (this.meshesCreated && !force) return;
+        const modelRoot = new Object3D3();
+        const transform = this.options.flip === void 0 ? this.entity.transform : void 0;
+        if (transform) {
+          for (const op of transform) {
+            const matrix = new Matrix45();
+            if ("scale" in op) matrix.makeScale(...op.scale);
+            else if ("translate" in op) matrix.makeTranslation(...op.translate);
+            else matrix.makeRotationFromEuler(new Euler4(...op.rotate, "ZYX"));
+            modelRoot.matrix.multiply(matrix);
+          }
+          modelRoot.matrixAutoUpdate = false;
+        } else if (this.options.flip ?? true) {
+          modelRoot.scale.set(-1, -1, 1);
+        }
+        this.add(modelRoot);
+        Object.entries(this.entityLayers).forEach(([name, layer], index) => {
+          const group = this.createGroup(`layer:${name}`);
+          modelRoot.add(group);
+          const inward = !Materials.entityModeCulls(layer.render ?? layer.layer.render);
+          this.createPart("root", layer.layer.root, group, layer.layer.texture, Materials.MISSING_TEXTURE, index, inward);
+        });
+        this.meshesCreated = true;
+      }
+      createPart(name, part, parent, textureSize, material, renderOrder, inward = true) {
+        const anchor = this.createGroup(name);
+        anchor.position.fromArray(part.pose.offset);
+        anchor.rotation.set(...part.pose.rotation, "ZYX");
+        anchor.scale.fromArray(part.pose.scale ?? [1, 1, 1]);
+        parent.add(anchor);
+        const size = part.texture ?? textureSize;
+        for (const cube of part.cubes) {
+          const [width, height, depth] = cube.size;
+          const [growX, growY, growZ] = cube.grow ?? [0, 0, 0];
+          const texture = new MinecraftCubeTexture(...cube.uv, ...size);
+          const uv = size[0] === 0 || size[1] === 0 ? new Array(48).fill(0) : texture.toUvArray(width, height, depth, cube.mirror);
+          const geometry = this._getBoxGeometryForDimensionsAndUv(
+            width + growX * 2,
+            height + growY * 2,
+            depth + growZ * 2,
+            uv
+          ).clone();
+          this.geometries.add(geometry);
+          geometry.translate(cube.origin[0] + width / 2, cube.origin[1] + height / 2, cube.origin[2] + depth / 2);
+          if (inward && Math.min(width + growX * 2, height + growY * 2, depth + growZ * 2) > 0) {
+            const index = Array.from(geometry.getIndex().array);
+            geometry.setIndex(index.concat(index.slice().reverse()));
+          }
+          const mesh = this.createMesh(name, geometry, material);
+          mesh.renderOrder = renderOrder;
+          anchor.add(mesh);
+          if (this.options.wireframe) this.disposeWireframes.push(addWireframeToMesh(geometry, mesh));
+        }
+        for (const [childName, child] of Object.entries(part.children)) {
+          this.createPart(childName, child, anchor, size, material, renderOrder, inward);
+        }
+      }
+      async applyTextures() {
+        this.clearScrollMaterials();
+        await Promise.all(Object.entries(this.entityLayers).map(async ([name, layer]) => {
+          const mode = layer.render ?? layer.layer.render ?? "cutout";
+          const tint = layer.tint === void 0 ? void 0 : this.options.tints?.[layer.tint];
+          const scroll = Materials.entityModeScroll(mode);
+          const assetKeyStr = this.getTextureKey(layer).serialize();
+          const keyStr = `entity:${mode}:${tint === void 0 ? "" : new Color3(tint).getHexString()}:${assetKeyStr}`;
+          let mat = scroll ? void 0 : Caching.materialCache.getIfPresent(keyStr);
+          if (!mat) {
+            const cachedAsset = Caching.textureAssetCache.getIfPresent(assetKeyStr);
+            const imageData = await this.loadTextures(layer);
+            if (!imageData) return;
+            const canvas = imageData.data.canvas;
+            const createMaterial = () => Materials.createEntityCanvasMaterial(canvas, mode, tint);
+            mat = !scroll && cachedAsset && Caching.textureAssetCache.getIfPresent(assetKeyStr) === cachedAsset ? Caching.materialCache.get(keyStr, createMaterial) : createMaterial();
+            if (scroll) {
+              this.scrollMaterials.push({ material: mat, offset: mat.map.offset, speed: scroll });
+            }
+          }
+          this.getLayerGroup(name)?.traverse((object) => {
+            if (isMesh(object)) object.material = mat;
+          });
+        }));
+        if (!this.children.length) {
+          this.clearScrollMaterials();
+        } else if (this.scrollMaterials.length) {
+          this.updateScroll();
+        }
+        this.updateScrollSubscription();
+        this.notifyDirty();
+      }
+    };
+  }
+});
+
 // src/three/BufferGeometryUtils.js
 import {
   BufferAttribute as BufferAttribute4,
@@ -4199,8 +4812,121 @@ var init_ModelCulling = __esm({
   }
 });
 
+// src/model/SpecialItems.ts
+import { Matrix4 as Matrix48 } from "three";
+var SpecialItems;
+var init_SpecialItems = __esm({
+  "src/model/SpecialItems.ts"() {
+    init_AssetKey();
+    init_Entities();
+    SpecialItems = class {
+      /** Resolves the static entity parts drawn by a special item renderer, in model units. */
+      static async getParts(special, root) {
+        const texture = (id, directory) => {
+          const key = AssetKey.parse("textures", id);
+          return new AssetKey(
+            key.namespace,
+            [directory, key.getFullPath()].filter(Boolean).join("/"),
+            "textures",
+            "entity",
+            "assets",
+            ".png",
+            root
+          );
+        };
+        const load = async (id, textureKey, transform, rotations = {}) => {
+          const key = new AssetKey("minecraft", id, void 0, void 0, "entity-models", ".json", root);
+          const model = await Entities.getEntity(key, textureKey, { layer: "main" });
+          if (!model) throw new Error(`Missing entity model minecraft:${id} for special item ${special.type}`);
+          return { model, transform, rotations };
+        };
+        switch (special.type) {
+          case "minecraft:chest":
+          case "chest": {
+            const angle = -(special.openness ?? 0) * Math.PI / 2;
+            const chest = await load("chest", texture(special.texture, "chest"), new Matrix48(), {
+              lid: [angle, 0, 0],
+              lock: [angle, 0, 0]
+            });
+            chest.model = { ...chest.model, render: "solid", layers: void 0 };
+            return [chest];
+          }
+          case "minecraft:bed":
+          case "bed": {
+            const transform = new Matrix48().makeTranslation(0, 9, 0).multiply(new Matrix48().makeRotationX(Math.PI / 2)).multiply(new Matrix48().makeTranslation(8, 8, 8)).multiply(new Matrix48().makeRotationZ(Math.PI)).multiply(new Matrix48().makeTranslation(-8, -8, -8));
+            const key = texture(special.texture, "bed");
+            return Promise.all([
+              load("bed_head", key, transform),
+              load("bed_foot", key, new Matrix48().makeTranslation(0, 0, -16).multiply(transform))
+            ]);
+          }
+          case "minecraft:head":
+          case "head": {
+            const models = {
+              skeleton: "skeleton_skull",
+              wither_skeleton: "wither_skeleton_skull",
+              zombie: "zombie_head",
+              creeper: "creeper_head",
+              dragon: "dragon_skull",
+              piglin: "piglin_head"
+            };
+            const id = Object.prototype.hasOwnProperty.call(models, special.kind) ? models[special.kind] : void 0;
+            if (!id) throw new Error(`Unsupported special item head kind ${special.kind}`);
+            const animation = (special.animation ?? 0) * Math.PI * 0.2;
+            const rotations = { head: [0, Math.PI, 0] };
+            if (special.kind === "dragon") rotations.jaw = [(Math.sin(animation) + 1) * 0.2, 0, 0];
+            if (special.kind === "piglin") {
+              rotations.left_ear = [0, 0, -(Math.cos(animation * 1.2) + 2.5) * 0.2];
+              rotations.right_ear = [0, 0, (Math.cos(animation) + 2.5) * 0.2];
+            }
+            return [await load(
+              id,
+              special.texture ? texture(special.texture, "") : void 0,
+              new Matrix48().makeTranslation(8, 0, 8).multiply(new Matrix48().makeScale(-1, -1, 1)),
+              rotations
+            )];
+          }
+        }
+      }
+      /** An owned material with model-preview shading; its entity texture remains shared. */
+      static createMaterial(source, shade) {
+        const material = source.clone();
+        if (shade) {
+          material.onBeforeCompile = (shader) => {
+            shader.vertexShader = `varying float itemLight;
+${shader.vertexShader}`.replace("#include <begin_vertex>", `
+                    #include <begin_vertex>
+                    vec3 N = inverseTransformDirection(normalMatrix * normal, viewMatrix);
+                    itemLight = (1.0 + N.y) * 0.25 - N.x * N.x * 0.15 + N.z * N.z * 0.05 + 0.5;
+                `);
+            shader.fragmentShader = `varying float itemLight;
+${shader.fragmentShader}`.replace(
+              "#include <color_fragment>",
+              "#include <color_fragment>\ndiffuseColor.rgb *= itemLight;"
+            );
+          };
+          material.customProgramCacheKey = () => "special-item-side";
+        }
+        return material;
+      }
+    };
+  }
+});
+
+// src/model/GuiLight.ts
+var GuiLight;
+var init_GuiLight = __esm({
+  "src/model/GuiLight.ts"() {
+    GuiLight = /* @__PURE__ */ ((GuiLight2) => {
+      GuiLight2["FRONT"] = "front";
+      GuiLight2["SIDE"] = "side";
+      return GuiLight2;
+    })(GuiLight || {});
+  }
+});
+
 // src/model/scene/ModelObject.ts
-import { BoxGeometry as BoxGeometry5, BufferAttribute as BufferAttribute5, Color as Color8, Euler as Euler6, Matrix4 as Matrix48 } from "three";
+import { BoxGeometry as BoxGeometry5, BufferAttribute as BufferAttribute5, Color as Color8, Euler as Euler6, Matrix4 as Matrix49 } from "three";
 function isModelObject(obj) {
   return obj.isModelObject;
 }
@@ -4215,16 +4941,22 @@ var init_ModelObject = __esm({
     import_ts_deepmerge5 = __toESM(require_dist());
     init_log();
     init_CubeFace();
+    init_DisplayPosition();
     init_DisplayTransforms();
     init_ModelCulling();
+    init_SpecialItems();
+    init_EntityObject();
+    init_GuiLight();
     p7 = prefix("ModelObject");
     ModelObject = class _ModelObject extends SceneObject {
       constructor(originalModel, options) {
         super(options);
         this.originalModel = originalModel;
         this.isModelObject = true;
+        this.specialMaterials = /* @__PURE__ */ new Map();
         this.meshesCreated = false;
         this.options = (0, import_ts_deepmerge5.default)({}, _ModelObject.DEFAULT_OPTIONS, options ?? {});
+        if (originalModel.special) this.options.instanceMeshes = false;
         if (this.options.tints) this.options.tints = { ...this.options.tints };
         this.addEventListener("added", () => this.updateAnimationSubscription());
         this.addEventListener("removed", () => this.updateAnimationSubscription());
@@ -4233,6 +4965,39 @@ var init_ModelObject = __esm({
         this.DEFAULT_OPTIONS = (0, import_ts_deepmerge5.default)({}, SceneObject.DEFAULT_OPTIONS, {});
       }
       async init() {
+        const special = this.originalModel.special;
+        if (special) {
+          const parts = await SpecialItems.getParts(special, this.originalModel.key?.root);
+          const transform = this.options.displayPosition ? DisplayTransforms.getMatrix(this.originalModel.display, this.options.displayPosition) : new Matrix49();
+          transform.multiply(new Matrix49().makeTranslation(-8, -8, -8));
+          try {
+            for (const part of parts) {
+              const object = new EntityObject(part.model, { flip: false, wireframe: this.options.wireframe });
+              object.matrix.copy(transform).multiply(part.transform);
+              object.matrixAutoUpdate = false;
+              this.add(object);
+              await object.init();
+              object.iterateAllMeshes((mesh) => {
+                const source = mesh.material;
+                let material = this.specialMaterials.get(source);
+                if (!material) {
+                  const front = this.options.displayPosition === "gui" /* GUI */ && this.originalModel.gui_light === "front" /* FRONT */;
+                  material = SpecialItems.createMaterial(source, !front);
+                  this.specialMaterials.set(source, material);
+                }
+                mesh.material = material;
+              });
+              for (const [name, rotation] of Object.entries(part.rotations)) {
+                object.getGroupByName(name)?.rotation.set(...rotation, "ZYX");
+              }
+            }
+          } catch (error) {
+            this.disposeAndRemoveAllChildren();
+            throw error;
+          }
+          this.notifyDirty();
+          return;
+        }
         await this.loadTextures();
         this.createMeshes();
         this.applyTextures();
@@ -4282,12 +5047,12 @@ var init_ModelObject = __esm({
                 }
                 elGeo.setAttribute("color", new BufferAttribute5(colors, 3));
               }
-              elGeo.applyMatrix4(new Matrix48().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 Matrix48().makeTranslation(el.from[0], el.from[1], el.from[2]));
+              elGeo.applyMatrix4(new Matrix49().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 Matrix49().makeTranslation(el.from[0], el.from[1], el.from[2]));
               if (el.rotation) {
                 applyElementRotation(el.rotation, elGeo);
               }
-              elGeo.applyMatrix4(new Matrix48().makeTranslation(-8, -8, -8));
+              elGeo.applyMatrix4(new Matrix49().makeTranslation(-8, -8, -8));
               if (displayTransform) DisplayTransforms.apply(elGeo, displayTransform);
               if (this.options.mergeMeshes) {
                 allGeos.push(elGeo);
@@ -4377,6 +5142,8 @@ var init_ModelObject = __esm({
         this.atlasMaterial?.dispose();
         this.atlasTexture = void 0;
         this.atlasMaterial = void 0;
+        for (const material of this.specialMaterials.values()) material.dispose();
+        this.specialMaterials.clear();
         super.disposeAndRemoveAllChildren();
       }
     };
@@ -4727,96 +5494,8 @@ var Meshes = class _Meshes {
   }
 };
 
-// src/MinecraftCubeTexture.ts
-init_UVMapper();
-init_CubeFace();
-var MinecraftCubeTexture = class {
-  constructor(u, v, width, height) {
-    this.u = u;
-    this.v = v;
-    this.width = width;
-    this.height = height;
-  }
-  mapW(x) {
-    return x / this.width;
-  }
-  mapH(x) {
-    return 1 - x / this.height;
-  }
-  getUvEast(w, h, l) {
-    return [
-      [this.mapW(this.u + l + w + l), this.mapH(this.v + l + h)],
-      [this.mapW(this.u + l + w), this.mapH(this.v + l + h)],
-      [this.mapW(this.u + l + w + l), this.mapH(this.v + l)],
-      [this.mapW(this.u + l + w), this.mapH(this.v + l)]
-    ];
-  }
-  getUvWest(w, h, l) {
-    return [
-      [this.mapW(this.u + l), this.mapH(this.v + l + h)],
-      [this.mapW(this.u), this.mapH(this.v + l + h)],
-      [this.mapW(this.u + l), this.mapH(this.v + l)],
-      [this.mapW(this.u), this.mapH(this.v + l)]
-    ];
-  }
-  getUvUp(w, h, l) {
-    return [
-      [this.mapW(this.u + l + w), this.mapH(this.v + l)],
-      [this.mapW(this.u + l + w + w), this.mapH(this.v + l)],
-      [this.mapW(this.u + l + w), this.mapH(this.v)],
-      [this.mapW(this.u + l + w + w), this.mapH(this.v)]
-    ];
-  }
-  getUvDown(w, h, l) {
-    return [
-      [this.mapW(this.u + l), this.mapH(this.v)],
-      [this.mapW(this.u + l + w), this.mapH(this.v)],
-      [this.mapW(this.u + l), this.mapH(this.v + l)],
-      [this.mapW(this.u + l + w), this.mapH(this.v + l)]
-    ];
-  }
-  getUvSouth(w, h, l) {
-    return [
-      [this.mapW(this.u + l + w + l + w), this.mapH(this.v + l + h)],
-      [this.mapW(this.u + l + w + l), this.mapH(this.v + l + h)],
-      [this.mapW(this.u + l + w + l + w), this.mapH(this.v + l)],
-      [this.mapW(this.u + l + w + l), this.mapH(this.v + l)]
-    ];
-  }
-  getUvNorth(w, h, l) {
-    return [
-      [this.mapW(this.u + l + w), this.mapH(this.v + l + h)],
-      [this.mapW(this.u + l), this.mapH(this.v + l + h)],
-      [this.mapW(this.u + l + w), this.mapH(this.v + l)],
-      [this.mapW(this.u + l), this.mapH(this.v + l)]
-    ];
-  }
-  getFaceUv(face, w, h, l) {
-    switch (face) {
-      case "east" /* EAST */:
-        return this.getUvEast(w, h, l);
-      case "west" /* WEST */:
-        return this.getUvWest(w, h, l);
-      case "up" /* UP */:
-        return this.getUvUp(w, h, l);
-      case "down" /* DOWN */:
-        return this.getUvDown(w, h, l);
-      case "south" /* SOUTH */:
-        return this.getUvSouth(w, h, l);
-      case "north" /* NORTH */:
-        return this.getUvNorth(w, h, l);
-    }
-  }
-  toUvArray(w, h, l, mirror = false) {
-    const uv = [];
-    for (let i = 0; i < CUBE_FACES.length; i++) {
-      const face = mirror && i < 2 ? CUBE_FACES[1 - i] : CUBE_FACES[i];
-      const corners = this.getFaceUv(face, w, h, l);
-      UVMapper.setFaceUvInArray(uv, i * 4, mirror ? [corners[1], corners[0], corners[3], corners[2]] : corners);
-    }
-    return uv;
-  }
-};
+// src/index.ts
+init_MinecraftCubeTexture();
 
 // src/SceneStats.ts
 var SceneStats = class {
@@ -4910,116 +5589,7 @@ var BlockEntities = class {
 
 // src/assets/index.ts
 init_BlockStates();
-
-// src/assets/Entities.ts
-init_AssetKey();
-init_AssetLoader();
-init_source();
-init_Caching();
-init_Assets();
-init_MineRenderError();
-init_ModelTextures();
-var Entities = class {
-  static async getEntityList() {
-    const collect = async (path) => {
-      const prefix2 = path ? `${path}/` : "";
-      const key = new AssetKey(DEFAULT_NAMESPACE, `${prefix2}_list`, void 0, void 0, "entity-models", ".json");
-      const list = await Caching.listAssetCache.get(key.serialize(), () => AssetLoader.get(key, "list" /* LIST */));
-      if (!list) return [];
-      const files = list.files.filter((file) => file.endsWith(".json") && file !== "_list.json").map((file) => `${prefix2}${file.slice(0, -5)}`);
-      const children = await Promise.all(list.directories.map((directory) => collect(`${prefix2}${directory}`)));
-      return [...files, ...children.flat()];
-    };
-    return collect("");
-  }
-  static async getModelFile(modelKey) {
-    const path = isAssetKey(modelKey) ? modelKey.getFullPath() : modelKey.path;
-    const key = new AssetKey(modelKey.namespace, path, void 0, void 0, "entity-models", ".json");
-    return Caching.entityModelCache.get(key.serialize(), () => AssetLoader.get(key, "json" /* JSON */));
-  }
-  static async getLayerList(modelKey) {
-    return Object.keys((await this.getModelFile(modelKey))?.layers ?? {});
-  }
-  /** The dataset's extra draws on top of `main`; their `when` labels are the states `EntityModelOptions.when` can enable. */
-  static async getPassList(modelKey) {
-    return (await this.getModelFile(modelKey))?.passes ?? [];
-  }
-  static async getEntity(modelKey, textureKey, options) {
-    const model = await this.getModelFile(modelKey);
-    if (!model) return void 0;
-    const passes = options?.layers || options?.layer !== void 0 ? [] : (model.passes ?? []).filter((pass) => pass.when === void 0 || options?.when?.includes(pass.when));
-    const draws = [...new Set(options?.layers ?? [options?.layer ?? "main"])].map((layer) => ({ layer }));
-    if (draws.length === 0) throw new MineRenderError(`Entity ${model.id} requires at least one layer`);
-    draws.push(...passes);
-    const names = [];
-    const selected = draws.map((pass) => {
-      const layer = model.layers[pass.layer];
-      if (!layer) {
-        throw new MineRenderError(`Entity ${model.id} has no layer "${pass.layer}". Available layers: ${Object.keys(model.layers).join(", ")}`);
-      }
-      let name = pass.layer;
-      for (let n = 2; names.includes(name); n++) name = `${pass.layer}#${n}`;
-      names.push(name);
-      return { name, layer, pass };
-    });
-    const layers = Object.fromEntries(await Promise.all(selected.map(async ({ name, layer, pass }, index) => {
-      const override = options?.textures?.[name] ?? (index === 0 ? textureKey : void 0);
-      const textureLocation = pass.textureLocation ?? layer.textureLocation;
-      let texture;
-      if (override) {
-        const path = isAssetKey(override) ? override.getFullPath() : override.path;
-        texture = isAssetKey(override) && override.assetType === "textures" && path.startsWith("entity/") ? override : new AssetKey(override.namespace, path, "textures", "entity", "assets", ".png", isAssetKey(override) ? override.root : void 0);
-      } else if (textureLocation !== void 0) {
-        texture = AssetKey.parse("textures", textureLocation.replace(/^([^:]+:)?textures\//, "$1"));
-      } else {
-        texture = await this.resolveTexture(modelKey);
-      }
-      const render = pass.render ?? layer.render;
-      return [name, { key: override ?? modelKey, texture, layer, ...render && { render }, ...pass.tint && { tint: pass.tint } }];
-    })));
-    return { ...layers[names[0]], id: model.id, layers, ...model.transform && { transform: model.transform } };
-  }
-  /**
-   * Vanilla's keyframe animations of a model by name, or undefined when the model or the selected version has none.
-   */
-  static async getAnimations(modelKey) {
-    const path = isAssetKey(modelKey) ? modelKey.getFullPath() : modelKey.path;
-    const key = new AssetKey(modelKey.namespace, path, void 0, void 0, "entity-models/animations", ".json");
-    const file = await Caching.entityAnimationCache.get(key.serialize(), () => AssetLoader.get(key, "json" /* JSON */));
-    return file?.animations;
-  }
-  static async resolveTexture(modelKey) {
-    const path = isAssetKey(modelKey) ? modelKey.getFullPath() : modelKey.path;
-    const key = new AssetKey(modelKey.namespace, path, void 0, void 0, "entity-models", ".json");
-    return Caching.entityTextureCache.get(key.serialize(), async () => {
-      const name = path.split("/").pop();
-      for (const candidate of [path, `${path}/${name}`]) {
-        const texture = new AssetKey(modelKey.namespace, candidate, "textures", "entity", "assets", ".png");
-        if (await ModelTextures.get(texture)) return texture;
-      }
-      const listKey = new AssetKey(modelKey.namespace, "_list", `${name}_variant`, void 0, "data", ".json");
-      const list = await AssetLoader.get(listKey, "list" /* LIST */);
-      const files = list?.files.filter((file2) => file2.endsWith(".json") && file2 !== "_list.json");
-      const file = files?.find((file2) => file2 === "temperate.json") ?? files?.[0];
-      if (!file) return void 0;
-      const variantKey = new AssetKey(modelKey.namespace, file.slice(0, -5), `${name}_variant`, void 0, "data", ".json");
-      const variant = await AssetLoader.get(variantKey, "json" /* JSON */);
-      const assets = variant?.assets;
-      const textureId = variant?.asset_id ?? (typeof assets?.wild === "string" ? assets.wild : Object.values(assets ?? {}).find((value) => typeof value === "string"));
-      return typeof textureId === "string" ? AssetKey.parse("textures", textureId) : void 0;
-    });
-  }
-  /** @deprecated Use getEntityList(); block entities share the entity dataset. */
-  static getBlockList() {
-    return this.getEntityList();
-  }
-  /** @deprecated Use getEntity(); block entities share the entity dataset. */
-  static getBlock(modelKey, textureKey, options) {
-    return this.getEntity(modelKey, textureKey, options);
-  }
-};
-
-// src/assets/index.ts
+init_Entities();
 init_ModelTextures();
 init_Models();
 init_source();
@@ -5064,347 +5634,12 @@ function trimCanvas(source) {
   return canvas;
 }
 
-// src/entity/EntityAnimation.ts
-var ENTITY_ANIMATION_CHANNELS = ["position", "rotation", "scale"];
-function catmullRom(delta, p0, p1, p22, p32) {
-  return 0.5 * (2 * p1 + (p22 - p0) * delta + (2 * p0 - 5 * p1 + 4 * p22 - p32) * delta * delta + (3 * p1 - p0 - 3 * p22 + p32) * delta * delta * delta);
-}
-function sampleEntityKeyframes(keyframes, time) {
-  if (keyframes.length === 0) return [0, 0, 0];
-  let low = 0, high = keyframes.length;
-  while (low < high) {
-    const middle = low + high >>> 1;
-    if (time <= keyframes[middle].time) high = middle;
-    else low = middle + 1;
-  }
-  const a = Math.max(0, low - 1);
-  const b = Math.min(keyframes.length - 1, a + 1);
-  const from = keyframes[a];
-  const to = keyframes[b];
-  const delta = a === b ? 0 : Math.min(1, Math.max(0, (time - from.time) / (to.time - from.time)));
-  if (to.interpolation === "catmullrom") {
-    const before = keyframes[Math.max(0, a - 1)].value;
-    const after = keyframes[Math.min(keyframes.length - 1, b + 1)].value;
-    return [0, 1, 2].map((i) => catmullRom(delta, before[i], from.value[i], to.value[i], after[i]));
-  }
-  const target = to.pre ?? to.value;
-  return [0, 1, 2].map((i) => from.value[i] + (target[i] - from.value[i]) * delta);
-}
-function entityAnimationTime(animation, time, loop = animation.loop) {
-  return loop && animation.length > 0 ? time % animation.length : time;
-}
-function sampleEntityAnimation(animation, time, loop = animation.loop) {
-  const elapsed = entityAnimationTime(animation, time, loop);
-  const pose = {};
-  for (const [name, bone] of Object.entries(animation.bones)) {
-    const sampled = pose[name] = {};
-    for (const channel of ENTITY_ANIMATION_CHANNELS) {
-      const keyframes = bone[channel];
-      if (keyframes?.length) sampled[channel] = sampleEntityKeyframes(keyframes, elapsed);
-    }
-  }
-  return pose;
-}
-
-// src/entity/scene/EntityAnimationPlayer.ts
-var ZERO = [0, 0, 0];
-var EntityAnimationPlayer = class {
-  constructor() {
-    this.parts = [];
-    this._time = 0;
-    this.loop = false;
-    this.speed = 1;
-  }
-  get animation() {
-    return this._animation;
-  }
-  get time() {
-    return this._time;
-  }
-  /**
-   * Starts an animation on the named parts below each layer root. The current pose of a part becomes its default;
-   * bones without a matching part are skipped.
-   */
-  play(layers, animation, options = {}) {
-    this.stop();
-    this._animation = animation;
-    this._time = options.time ?? 0;
-    this.loop = options.loop ?? animation.loop;
-    this.speed = options.speed ?? 1;
-    for (const layer of layers) {
-      for (const bone of Object.keys(animation.bones)) {
-        const object = layer.getObjectByName(`group:${bone}`);
-        if (!object) continue;
-        this.parts.push({ bone, object, position: object.position.clone(), rotation: object.rotation.clone(), scale: object.scale.clone() });
-      }
-    }
-    this.apply();
-  }
-  /** Restores the default poses. Returns whether an animation was active. */
-  stop() {
-    if (!this._animation) return false;
-    for (const part of this.parts) {
-      part.object.position.copy(part.position);
-      part.object.rotation.copy(part.rotation);
-      part.object.scale.copy(part.scale);
-    }
-    this.clear();
-    return true;
-  }
-  /** Forgets the animation without touching the parts, for parts that no longer exist. */
-  clear() {
-    this.parts = [];
-    this._animation = void 0;
-    this._time = 0;
-  }
-  setTime(seconds) {
-    if (!this._animation) return false;
-    this._time = seconds;
-    this.apply();
-    return true;
-  }
-  advance(deltaSeconds) {
-    return this.setTime(this._time + deltaSeconds * this.speed);
-  }
-  apply() {
-    const pose = sampleEntityAnimation(this._animation, this._time, this.loop);
-    for (const part of this.parts) {
-      const { position = ZERO, rotation = ZERO, scale = ZERO } = pose[part.bone];
-      part.object.position.set(part.position.x + position[0], part.position.y + position[1], part.position.z + position[2]);
-      part.object.rotation.set(part.rotation.x + rotation[0], part.rotation.y + rotation[1], part.rotation.z + rotation[2], part.rotation.order);
-      part.object.scale.set(part.scale.x + scale[0], part.scale.y + scale[1], part.scale.z + scale[2]);
-    }
-  }
-};
+// src/entity/index.ts
+init_EntityAnimation();
 
-// src/entity/scene/EntityObject.ts
-init_SceneObject();
-init_Caching();
-var import_ts_deepmerge4 = __toESM(require_dist());
-init_Ticker();
-init_model();
-init_ModelTextures();
-init_AssetKey();
-init_Materials();
-import { Color as Color3, Euler as Euler4, Matrix4 as Matrix45, Object3D as Object3D3 } from "three";
-init_three();
-var EntityObject = class _EntityObject extends SceneObject {
-  constructor(entity, options) {
-    super();
-    this.entity = entity;
-    this.isEntityObject = true;
-    this.meshesCreated = false;
-    this.geometries = /* @__PURE__ */ new Set();
-    this.disposeWireframes = [];
-    /** Scrolling materials are owned: their texture offset follows this entity's age. */
-    this.scrollMaterials = [];
-    /** Entity age in ticks, as vanilla's `ageInTicks`; drives the scrolling render modes. */
-    this.age = 0;
-    this.animationPlayer = new EntityAnimationPlayer();
-    this.options = (0, import_ts_deepmerge4.default)({}, _EntityObject.DEFAULT_OPTIONS, options ?? {});
-    this.addEventListener("added", () => this.updateScrollSubscription());
-    this.addEventListener("removed", () => this.updateScrollSubscription());
-  }
-  static {
-    this.DEFAULT_OPTIONS = (0, import_ts_deepmerge4.default)({}, SceneObject.DEFAULT_OPTIONS);
-  }
-  async init() {
-    this.createMeshes();
-    await this.applyTextures();
-  }
-  dispose() {
-    super.dispose();
-  }
-  disposeAndRemoveAllChildren() {
-    this.clearScrollMaterials();
-    for (const geometry of this.geometries) geometry.dispose();
-    this.geometries.clear();
-    for (const dispose of this.disposeWireframes.splice(0)) dispose();
-    this.animationPlayer.clear();
-    super.disposeAndRemoveAllChildren();
-  }
-  clearScrollMaterials() {
-    Ticker.remove(this.scrollTicker);
-    this.scrollTicker = void 0;
-    for (const { material } of this.scrollMaterials.splice(0)) {
-      material.map?.dispose();
-      material.dispose();
-    }
-  }
-  updateScrollSubscription() {
-    if (this.parent && this.scrollMaterials.length) {
-      if (this.scrollTicker === void 0) {
-        this.scrollTicker = Ticker.add(() => {
-          this.age++;
-          this.updateScroll();
-        });
-      }
-    } else {
-      Ticker.remove(this.scrollTicker);
-      this.scrollTicker = void 0;
-    }
-  }
-  /** Applies the entity age to the scrolling materials; the ticker calls this 20 times per second. */
-  updateScroll() {
-    for (const { offset, speed } of this.scrollMaterials) {
-      offset.set(this.age * speed[0] % 1, 0 - this.age * speed[1] % 1);
-    }
-    this.notifyDirty();
-  }
-  //<editor-fold desc="ANIMATION">
-  /** The animation started by {@link playAnimation}, until {@link stopAnimation} or disposal. */
-  get animation() {
-    return this.animationPlayer.animation;
-  }
-  /** Seconds since the animation started, before looping. */
-  get animationTime() {
-    return this.animationPlayer.time;
-  }
-  /**
-   * Poses the object from a keyframe animation of {@link Entities.getAnimations}, replacing the current one.
-   * Parts of every layer are matched by name and their current pose is the default the offsets add to.
-   * The object owns no clock: call {@link advanceAnimation} per frame, or {@link setAnimationTime}.
-   */
-  playAnimation(animation, options) {
-    this.createMeshes();
-    const layers = Object.keys(this.entityLayers).map((name) => this.getLayerGroup(name)).filter((layer) => !!layer);
-    this.animationPlayer.play(layers, animation, options);
-    this.notifyDirty();
-  }
-  /** Stops the animation and restores the default pose. */
-  stopAnimation() {
-    if (this.animationPlayer.stop()) this.notifyDirty();
-  }
-  /** Poses the object at an explicit time in seconds. Has no effect without an animation. */
-  setAnimationTime(seconds) {
-    if (this.animationPlayer.setTime(seconds)) this.notifyDirty();
-  }
-  /** Advances the animation by a frame delta in seconds, scaled by its speed. Has no effect without an animation. */
-  advanceAnimation(deltaSeconds) {
-    if (this.animationPlayer.advance(deltaSeconds)) this.notifyDirty();
-  }
-  //</editor-fold>
-  getLayerGroup(name) {
-    return super.getGroupByName(`layer:${name}`);
-  }
-  getGroupByName(name, layerName) {
-    return layerName === void 0 ? super.getGroupByName(name) : this.getLayerGroup(layerName)?.getObjectByName(`group:${name}`);
-  }
-  getMeshByName(name, layerName) {
-    return layerName === void 0 ? super.getMeshByName(name) : this.getLayerGroup(layerName)?.getObjectByName(`mesh:${name}`);
-  }
-  get entityLayers() {
-    return this.entity.layers ?? { main: this.entity };
-  }
-  getTextureKey(layer) {
-    if (layer.texture) return layer.texture;
-    const key = layer.key;
-    return new AssetKey(
-      key.namespace,
-      isAssetKey(key) ? key.getFullPath() : key.path,
-      "textures",
-      "entity",
-      "assets",
-      ".png"
-    );
-  }
-  async loadTextures(layer = this.entity) {
-    return ModelTextures.get(this.getTextureKey(layer));
-  }
-  createMeshes(force = false) {
-    if (this.meshesCreated && !force) return;
-    const modelRoot = new Object3D3();
-    const transform = this.options.flip === void 0 ? this.entity.transform : void 0;
-    if (transform) {
-      for (const op of transform) {
-        const matrix = new Matrix45();
-        if ("scale" in op) matrix.makeScale(...op.scale);
-        else if ("translate" in op) matrix.makeTranslation(...op.translate);
-        else matrix.makeRotationFromEuler(new Euler4(...op.rotate, "ZYX"));
-        modelRoot.matrix.multiply(matrix);
-      }
-      modelRoot.matrixAutoUpdate = false;
-    } else if (this.options.flip ?? true) {
-      modelRoot.scale.set(-1, -1, 1);
-    }
-    this.add(modelRoot);
-    Object.entries(this.entityLayers).forEach(([name, layer], index) => {
-      const group = this.createGroup(`layer:${name}`);
-      modelRoot.add(group);
-      const inward = !Materials.entityModeCulls(layer.render ?? layer.layer.render);
-      this.createPart("root", layer.layer.root, group, layer.layer.texture, Materials.MISSING_TEXTURE, index, inward);
-    });
-    this.meshesCreated = true;
-  }
-  createPart(name, part, parent, textureSize, material, renderOrder, inward = true) {
-    const anchor = this.createGroup(name);
-    anchor.position.fromArray(part.pose.offset);
-    anchor.rotation.set(...part.pose.rotation, "ZYX");
-    anchor.scale.fromArray(part.pose.scale ?? [1, 1, 1]);
-    parent.add(anchor);
-    const size = part.texture ?? textureSize;
-    for (const cube of part.cubes) {
-      const [width, height, depth] = cube.size;
-      const [growX, growY, growZ] = cube.grow ?? [0, 0, 0];
-      const texture = new MinecraftCubeTexture(...cube.uv, ...size);
-      const uv = size[0] === 0 || size[1] === 0 ? new Array(48).fill(0) : texture.toUvArray(width, height, depth, cube.mirror);
-      const geometry = this._getBoxGeometryForDimensionsAndUv(
-        width + growX * 2,
-        height + growY * 2,
-        depth + growZ * 2,
-        uv
-      ).clone();
-      this.geometries.add(geometry);
-      geometry.translate(cube.origin[0] + width / 2, cube.origin[1] + height / 2, cube.origin[2] + depth / 2);
-      if (inward && Math.min(width + growX * 2, height + growY * 2, depth + growZ * 2) > 0) {
-        const index = Array.from(geometry.getIndex().array);
-        geometry.setIndex(index.concat(index.slice().reverse()));
-      }
-      const mesh = this.createMesh(name, geometry, material);
-      mesh.renderOrder = renderOrder;
-      anchor.add(mesh);
-      if (this.options.wireframe) this.disposeWireframes.push(addWireframeToMesh(geometry, mesh));
-    }
-    for (const [childName, child] of Object.entries(part.children)) {
-      this.createPart(childName, child, anchor, size, material, renderOrder, inward);
-    }
-  }
-  async applyTextures() {
-    this.clearScrollMaterials();
-    await Promise.all(Object.entries(this.entityLayers).map(async ([name, layer]) => {
-      const mode = layer.render ?? layer.layer.render ?? "cutout";
-      const tint = layer.tint === void 0 ? void 0 : this.options.tints?.[layer.tint];
-      const scroll = Materials.entityModeScroll(mode);
-      const assetKeyStr = this.getTextureKey(layer).serialize();
-      const keyStr = `entity:${mode}:${tint === void 0 ? "" : new Color3(tint).getHexString()}:${assetKeyStr}`;
-      let mat = scroll ? void 0 : Caching.materialCache.getIfPresent(keyStr);
-      if (!mat) {
-        const cachedAsset = Caching.textureAssetCache.getIfPresent(assetKeyStr);
-        const imageData = await this.loadTextures(layer);
-        if (!imageData) return;
-        const canvas = imageData.data.canvas;
-        const createMaterial = () => Materials.createEntityCanvasMaterial(canvas, mode, tint);
-        mat = !scroll && cachedAsset && Caching.textureAssetCache.getIfPresent(assetKeyStr) === cachedAsset ? Caching.materialCache.get(keyStr, createMaterial) : createMaterial();
-        if (scroll) {
-          this.scrollMaterials.push({ material: mat, offset: mat.map.offset, speed: scroll });
-        }
-      }
-      this.getLayerGroup(name)?.traverse((object) => {
-        if (isMesh(object)) object.material = mat;
-      });
-    }));
-    if (!this.children.length) {
-      this.clearScrollMaterials();
-    } else if (this.scrollMaterials.length) {
-      this.updateScroll();
-    }
-    this.updateScrollSubscription();
-    this.notifyDirty();
-  }
-};
-function isEntityObject(obj) {
-  return obj.isEntityObject;
-}
+// src/entity/scene/index.ts
+init_EntityAnimationPlayer();
+init_EntityObject();
 
 // src/error/index.ts
 init_MineRenderError();
@@ -8033,16 +8268,8 @@ init_SceneObject();
 init_Materials();
 init_ModelObject();
 init_DisplayPosition();
-import { Box2, Box3 as Box32, Mesh as Mesh7, PlaneGeometry as PlaneGeometry2, Vector2 as Vector23 } from "three";
-
-// src/model/GuiLight.ts
-var GuiLight = /* @__PURE__ */ ((GuiLight2) => {
-  GuiLight2["FRONT"] = "front";
-  GuiLight2["SIDE"] = "side";
-  return GuiLight2;
-})(GuiLight || {});
-
-// src/gui/scene/GuiObject.ts
+init_GuiLight();
+import { Box2, Box3 as Box32, Matrix4 as Matrix410, Mesh as Mesh7, PlaneGeometry as PlaneGeometry2, Vector2 as Vector23 } from "three";
 var GuiObject = class extends SceneObject {
   constructor(textureLayers, options) {
     super({ ...options, instanceMeshes: false, mergeMeshes: false });
@@ -8065,13 +8292,13 @@ var GuiObject = class extends SceneObject {
           const item = await this.createItem(layer, index);
           item.position.set(x + width2 / 2, -y - height2 / 2, 0);
           item.scale.set(width2 / 16, height2 / 16, width2 / 16);
-          item.updateMatrix();
+          item.updateWorldMatrix(true, true);
+          const inverse = this.matrixWorld.clone().invert();
           const bounds = new Box32();
           item.iterateAllMeshes((mesh2) => {
             mesh2.geometry.computeBoundingBox();
-            bounds.union(mesh2.geometry.boundingBox);
+            bounds.union(mesh2.geometry.boundingBox.clone().applyMatrix4(new Matrix410().multiplyMatrices(inverse, mesh2.matrixWorld)));
           });
-          bounds.applyMatrix4(item.matrix);
           item.position.z = depth - bounds.min.z;
           depth += bounds.max.z - bounds.min.z + 0.01;
           this.bounds.expandByPoint(new Vector23(x, y));
@@ -8126,7 +8353,7 @@ var GuiObject = class extends SceneObject {
     this.add(item);
     await item.init();
     item.iterateAllMeshes((mesh) => {
-      this.geometries.add(mesh.geometry);
+      if (!model.special) this.geometries.add(mesh.geometry);
       mesh.name = `mesh:${layer.name ?? index}`;
       mesh.renderOrder = index;
       for (const material of Array.isArray(mesh.material) ? mesh.material : [mesh.material]) {
@@ -8584,26 +8811,12 @@ function isInstanceable(obj) {
 // src/model/index.ts
 init_DisplayPosition();
 init_DisplayTransforms();
-
-// src/model/Model.ts
-var ITEM_GENERATED = "item/generated";
-var BUILTIN_GENERATED = "builtin/generated";
-var BUILTIN_ENTITY = "builtin/entity";
-var DEFAULT_ELEMENTS = [];
-function isDoubleArray(obj) {
-  return Array.isArray(obj) && obj.length === 2;
-}
-function isTripleArray(obj) {
-  return Array.isArray(obj) && obj.length === 3;
-}
-function isQuadArray(obj) {
-  return Array.isArray(obj) && obj.length === 4;
-}
-
-// src/model/index.ts
+init_GuiLight();
+init_Model();
 init_ModelCulling();
 init_ModelGenerator();
 init_ModelMerger();
+init_SpecialItems();
 
 // src/model/block/BlockStateResolver.ts
 init_BlockStates();
@@ -8794,9 +9007,10 @@ var import_ts_deepmerge6 = __toESM(require_dist());
 init_MineRenderError();
 init_InstanceReference();
 init_AssetKey();
-import { Euler as Euler8, Matrix4 as Matrix49, Quaternion as Quaternion5, Vector3 as Vector311 } from "three";
+import { Euler as Euler8, Matrix4 as Matrix411, Quaternion as Quaternion5, Vector3 as Vector311 } from "three";
 init_ModelCulling();
 init_FluidGeometry();
+init_Entities();
 var BlockObject = class _BlockObject extends SceneObject {
   constructor(blockState, options) {
     super(options);
@@ -8812,7 +9026,7 @@ var BlockObject = class _BlockObject extends SceneObject {
     this._models = [];
     this._cullMask = 0;
     this._entities = [];
-    this._entityPlacement = new Matrix49();
+    this._entityPlacement = new Matrix411();
     this._entityGeneration = 0;
     this.options = (0, import_ts_deepmerge6.default)({}, _BlockObject.DEFAULT_OPTIONS, options ?? {});
   }
@@ -8897,7 +9111,7 @@ var BlockObject = class _BlockObject extends SceneObject {
     return true;
   }
   placeEntities() {
-    const matrix = new Matrix49().makeTranslation(this.position.x - 8, this.position.y - 8, this.position.z - 8).multiply(this._entityPlacement);
+    const matrix = new Matrix411().makeTranslation(this.position.x - 8, this.position.y - 8, this.position.z - 8).multiply(this._entityPlacement);
     for (const entity of this._entities) {
       matrix.decompose(entity.position, entity.quaternion, entity.scale);
     }
@@ -8983,7 +9197,7 @@ var BlockObject = class _BlockObject extends SceneObject {
       () => new FluidModelObject2(kind, surface.sample, this.blockState.key, this.options)
     );
     const previous = this._fluidModel;
-    const matrix = previous ? this.getModelMatrix(previous) : new Matrix49().makeTranslation(...this.position.toArray());
+    const matrix = previous ? this.getModelMatrix(previous) : new Matrix411().makeTranslation(...this.position.toArray());
     if (isInstanceReference(replacement)) replacement.setMatrix(matrix);
     else matrix.decompose(replacement.position, replacement.quaternion, replacement.scale);
     this._models = this._models.filter((model) => model !== previous);
@@ -9121,7 +9335,7 @@ var BlockObject = class _BlockObject extends SceneObject {
   setPositionRotationScaleAt(index, position, rotation, scale) {
     super.setPositionRotationScaleAt(index, position, rotation, scale);
   }
-  getMatrixAt(index, matrix = new Matrix49()) {
+  getMatrixAt(index, matrix = new Matrix411()) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const child = this._models[0];
     if (child && isModelObject(child)) {
@@ -11724,7 +11938,7 @@ init_util();
 init_Caching();
 init_CacheKey();
 init_MineRenderError();
-import { DataTexture as DataTexture2, DoubleSide as DoubleSide4, FrontSide as FrontSide2, MeshBasicMaterial as MeshBasicMaterial5, SRGBColorSpace as SRGBColorSpace5 } from "three";
+import { DataTexture as DataTexture2, DoubleSide as DoubleSide4, FrontSide as FrontSide2, MeshBasicMaterial as MeshBasicMaterial6, SRGBColorSpace as SRGBColorSpace5 } from "three";
 
 // src/skin/SkinImage.ts
 init_Caching();
@@ -11809,7 +12023,7 @@ var SkinTextures = class {
     texture.colorSpace = SRGBColorSpace5;
     texture.flipY = true;
     texture.needsUpdate = true;
-    return new MeshBasicMaterial5({ map: texture, transparent, side: transparent ? DoubleSide4 : FrontSide2, alphaTest: transparent ? 0.1 : 0 });
+    return new MeshBasicMaterial6({ map: texture, transparent, side: transparent ? DoubleSide4 : FrontSide2, alphaTest: transparent ? 0.1 : 0 });
   }
   static isSlim(image, scale) {
     for (const [x, y] of [[46, 52], [54, 20]]) {
@@ -12037,6 +12251,7 @@ var SkinObject = class extends SceneObject {
 };
 
 // src/renderer/MineRenderScene.ts
+init_EntityObject();
 var MineRenderScene = class _MineRenderScene extends Scene5 {
   constructor(options) {
     super();
@@ -12168,9 +12383,10 @@ function isMineRenderScene(obj) {
 import { AxesHelper as AxesHelper2, GridHelper, OrthographicCamera, PCFSoftShadowMap, PerspectiveCamera as PerspectiveCamera2, SRGBColorSpace as SRGBColorSpace6, Vector3 as Vector313, WebGLRenderer as WebGLRenderer2 } from "three";
 var import_ts_deepmerge9 = __toESM(require_dist());
 init_util();
+init_Model();
+init_three();
 import Stats from "stats.js";
 import { EffectComposer, RenderPass } from "postprocessing";
-init_three();
 
 // src/three/OrbitControls.js
 import {
@@ -13674,6 +13890,7 @@ init_BlockStates();
 init_AssetKey();
 
 // src/world/MineRenderWorld.ts
+init_Model();
 import { Vector3 as Vector315 } from "three";
 init_BatchedExecutor();
 init_AssetKey();
@@ -13684,7 +13901,7 @@ init_CubeFace();
 init_AssetKey();
 init_Models();
 init_CubeFace();
-import { Matrix4 as Matrix410, Vector3 as Vector314 } from "three";
+import { Matrix4 as Matrix412, Vector3 as Vector314 } from "three";
 init_ModelCulling();
 init_ModelObject();
 init_UVMapper();
@@ -13747,7 +13964,7 @@ var SectionModels = class {
         });
         await object.init();
         const geometry = object.children[0].geometry;
-        geometry.applyMatrix4(new Matrix410().makeRotationFromEuler(rotation));
+        geometry.applyMatrix4(new Matrix412().makeRotationFromEuler(rotation));
         object.clear();
         const cullFaces = CUBE_FACES.map((face) => {
           const local = CUBE_FACES.findIndex((name) => name === atlas.model.elements[0].faces[face]?.cullface);
@@ -13994,6 +14211,9 @@ var MineRenderWorld = class {
   }
 };
 
+// src/world/Chunk.ts
+init_Model();
+
 // src/world/SectionMesh.ts
 init_CanvasCompat();
 init_Materials();
@@ -14342,6 +14562,7 @@ export {
   SkinPart,
   SkinTextures,
   Skins,
+  SpecialItems,
   StructureParser,
   TextureAtlas,
   TextureLoader,