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

package/dist/bundle.js

@@ -33399,6 +33399,29 @@ var MineRender = (() => {
     }
   });
 
+  // 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"() {
+      init_dirname();
+      init_buffer2();
+      init_process2();
+      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"(exports13) {
@@ -33672,6 +33695,7 @@ var MineRender = (() => {
       init_dirname();
       init_buffer2();
       init_process2();
+      init_Model();
       init_Models();
       import_ts_deepmerge = __toESM(require_dist());
       init_AssetKey();
@@ -33697,6 +33721,7 @@ var MineRender = (() => {
           }
           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) {
@@ -33769,12 +33794,12 @@ var MineRender = (() => {
             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;
         }
@@ -33785,8 +33810,25 @@ var MineRender = (() => {
           }
           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": {
@@ -78687,6 +78729,105 @@ ${key}` : key;
     }
   });
 
+  // src/MinecraftCubeTexture.ts
+  var MinecraftCubeTexture;
+  var init_MinecraftCubeTexture = __esm({
+    "src/MinecraftCubeTexture.ts"() {
+      init_dirname();
+      init_buffer2();
+      init_process2();
+      init_UVMapper();
+      init_CubeFace();
+      MinecraftCubeTexture = class {
+        constructor(u4, v5, width, height) {
+          this.u = u4;
+          this.v = v5;
+          this.width = width;
+          this.height = height;
+        }
+        mapW(x4) {
+          return x4 / this.width;
+        }
+        mapH(x4) {
+          return 1 - x4 / this.height;
+        }
+        getUvEast(w4, h5, l4) {
+          return [
+            [this.mapW(this.u + l4 + w4 + l4), this.mapH(this.v + l4 + h5)],
+            [this.mapW(this.u + l4 + w4), this.mapH(this.v + l4 + h5)],
+            [this.mapW(this.u + l4 + w4 + l4), this.mapH(this.v + l4)],
+            [this.mapW(this.u + l4 + w4), this.mapH(this.v + l4)]
+          ];
+        }
+        getUvWest(w4, h5, l4) {
+          return [
+            [this.mapW(this.u + l4), this.mapH(this.v + l4 + h5)],
+            [this.mapW(this.u), this.mapH(this.v + l4 + h5)],
+            [this.mapW(this.u + l4), this.mapH(this.v + l4)],
+            [this.mapW(this.u), this.mapH(this.v + l4)]
+          ];
+        }
+        getUvUp(w4, h5, l4) {
+          return [
+            [this.mapW(this.u + l4 + w4), this.mapH(this.v + l4)],
+            [this.mapW(this.u + l4 + w4 + w4), this.mapH(this.v + l4)],
+            [this.mapW(this.u + l4 + w4), this.mapH(this.v)],
+            [this.mapW(this.u + l4 + w4 + w4), this.mapH(this.v)]
+          ];
+        }
+        getUvDown(w4, h5, l4) {
+          return [
+            [this.mapW(this.u + l4), this.mapH(this.v)],
+            [this.mapW(this.u + l4 + w4), this.mapH(this.v)],
+            [this.mapW(this.u + l4), this.mapH(this.v + l4)],
+            [this.mapW(this.u + l4 + w4), this.mapH(this.v + l4)]
+          ];
+        }
+        getUvSouth(w4, h5, l4) {
+          return [
+            [this.mapW(this.u + l4 + w4 + l4 + w4), this.mapH(this.v + l4 + h5)],
+            [this.mapW(this.u + l4 + w4 + l4), this.mapH(this.v + l4 + h5)],
+            [this.mapW(this.u + l4 + w4 + l4 + w4), this.mapH(this.v + l4)],
+            [this.mapW(this.u + l4 + w4 + l4), this.mapH(this.v + l4)]
+          ];
+        }
+        getUvNorth(w4, h5, l4) {
+          return [
+            [this.mapW(this.u + l4 + w4), this.mapH(this.v + l4 + h5)],
+            [this.mapW(this.u + l4), this.mapH(this.v + l4 + h5)],
+            [this.mapW(this.u + l4 + w4), this.mapH(this.v + l4)],
+            [this.mapW(this.u + l4), this.mapH(this.v + l4)]
+          ];
+        }
+        getFaceUv(face, w4, h5, l4) {
+          switch (face) {
+            case "east" /* EAST */:
+              return this.getUvEast(w4, h5, l4);
+            case "west" /* WEST */:
+              return this.getUvWest(w4, h5, l4);
+            case "up" /* UP */:
+              return this.getUvUp(w4, h5, l4);
+            case "down" /* DOWN */:
+              return this.getUvDown(w4, h5, l4);
+            case "south" /* SOUTH */:
+              return this.getUvSouth(w4, h5, l4);
+            case "north" /* NORTH */:
+              return this.getUvNorth(w4, h5, l4);
+          }
+        }
+        toUvArray(w4, h5, l4, mirror = false) {
+          const uv = [];
+          for (let i4 = 0; i4 < CUBE_FACES.length; i4++) {
+            const face = mirror && i4 < 2 ? CUBE_FACES[1 - i4] : CUBE_FACES[i4];
+            const corners = this.getFaceUv(face, w4, h5, l4);
+            UVMapper.setFaceUvInArray(uv, i4 * 4, mirror ? [corners[1], corners[0], corners[3], corners[2]] : corners);
+          }
+          return uv;
+        }
+      };
+    }
+  });
+
   // src/error/MineRenderError.ts
   var MineRenderError;
   var init_MineRenderError = __esm({
@@ -78706,6 +78847,257 @@ ${key}` : key;
     }
   });
 
+  // src/assets/Entities.ts
+  var Entities;
+  var init_Entities = __esm({
+    "src/assets/Entities.ts"() {
+      init_dirname();
+      init_buffer2();
+      init_process2();
+      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 name2 = pass.layer;
+            for (let n4 = 2; names.includes(name2); n4++) name2 = `${pass.layer}#${n4}`;
+            names.push(name2);
+            return { name: name2, layer, pass };
+          });
+          const layers = Object.fromEntries(await Promise.all(selected.map(async ({ name: name2, layer, pass }, index) => {
+            const override = options?.textures?.[name2] ?? (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 [name2, { 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 name2 = path.split("/").pop();
+            for (const candidate of [path, `${path}/${name2}`]) {
+              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", `${name2}_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), `${name2}_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 a4 = Math.max(0, low - 1);
+    const b4 = Math.min(keyframes.length - 1, a4 + 1);
+    const from = keyframes[a4];
+    const to = keyframes[b4];
+    const delta = a4 === b4 ? 0 : Math.min(1, Math.max(0, (time - from.time) / (to.time - from.time)));
+    if (to.interpolation === "catmullrom") {
+      const before = keyframes[Math.max(0, a4 - 1)].value;
+      const after = keyframes[Math.min(keyframes.length - 1, b4 + 1)].value;
+      return [0, 1, 2].map((i4) => catmullRom(delta, before[i4], from.value[i4], to.value[i4], after[i4]));
+    }
+    const target = to.pre ?? to.value;
+    return [0, 1, 2].map((i4) => from.value[i4] + (target[i4] - from.value[i4]) * 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 [name2, bone] of Object.entries(animation.bones)) {
+      const sampled = pose[name2] = {};
+      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"() {
+      init_dirname();
+      init_buffer2();
+      init_process2();
+      ENTITY_ANIMATION_CHANNELS = ["position", "rotation", "scale"];
+    }
+  });
+
+  // src/entity/scene/EntityAnimationPlayer.ts
+  var ZERO, EntityAnimationPlayer;
+  var init_EntityAnimationPlayer = __esm({
+    "src/entity/scene/EntityAnimationPlayer.ts"() {
+      init_dirname();
+      init_buffer2();
+      init_process2();
+      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;
@@ -79208,6 +79600,244 @@ ${key}` : key;
     }
   });
 
+  // src/entity/scene/EntityObject.ts
+  function isEntityObject(obj) {
+    return obj.isEntityObject;
+  }
+  var import_ts_deepmerge4, _EntityObject, EntityObject;
+  var init_EntityObject = __esm({
+    "src/entity/scene/EntityObject.ts"() {
+      init_dirname();
+      init_buffer2();
+      init_process2();
+      init_SceneObject();
+      init_Caching();
+      import_ts_deepmerge4 = __toESM(require_dist());
+      init_three_module();
+      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());
+        }
+        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((name2) => this.getLayerGroup(name2)).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(name2) {
+          return super.getGroupByName(`layer:${name2}`);
+        }
+        getGroupByName(name2, layerName) {
+          return layerName === void 0 ? super.getGroupByName(name2) : this.getLayerGroup(layerName)?.getObjectByName(`group:${name2}`);
+        }
+        getMeshByName(name2, layerName) {
+          return layerName === void 0 ? super.getMeshByName(name2) : this.getLayerGroup(layerName)?.getObjectByName(`mesh:${name2}`);
+        }
+        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 Object3D();
+          const transform = this.options.flip === void 0 ? this.entity.transform : void 0;
+          if (transform) {
+            for (const op of transform) {
+              const matrix = new Matrix4();
+              if ("scale" in op) matrix.makeScale(...op.scale);
+              else if ("translate" in op) matrix.makeTranslation(...op.translate);
+              else matrix.makeRotationFromEuler(new Euler(...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(([name2, layer], index) => {
+            const group = this.createGroup(`layer:${name2}`);
+            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(name2, part, parent, textureSize, material, renderOrder, inward = true) {
+          const anchor = this.createGroup(name2);
+          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(name2, 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 ([name2, layer]) => {
+            const mode2 = layer.render ?? layer.layer.render ?? "cutout";
+            const tint = layer.tint === void 0 ? void 0 : this.options.tints?.[layer.tint];
+            const scroll = Materials.entityModeScroll(mode2);
+            const assetKeyStr = this.getTextureKey(layer).serialize();
+            const keyStr = `entity:${mode2}:${tint === void 0 ? "" : new Color(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, mode2, 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(name2)?.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();
+        }
+      };
+      _EntityObject.DEFAULT_OPTIONS = (0, import_ts_deepmerge4.default)({}, SceneObject.DEFAULT_OPTIONS);
+      EntityObject = _EntityObject;
+    }
+  });
+
   // src/three/BufferGeometryUtils.js
   function computeTangents(geometry) {
     geometry.computeTangents();
@@ -79792,6 +80422,125 @@ ${key}` : key;
     }
   });
 
+  // src/model/SpecialItems.ts
+  var SpecialItems;
+  var init_SpecialItems = __esm({
+    "src/model/SpecialItems.ts"() {
+      init_dirname();
+      init_buffer2();
+      init_process2();
+      init_three_module();
+      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 Matrix4(), {
+                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 Matrix4().makeTranslation(0, 9, 0).multiply(new Matrix4().makeRotationX(Math.PI / 2)).multiply(new Matrix4().makeTranslation(8, 8, 8)).multiply(new Matrix4().makeRotationZ(Math.PI)).multiply(new Matrix4().makeTranslation(-8, -8, -8));
+              const key = texture(special.texture, "bed");
+              return Promise.all([
+                load("bed_head", key, transform),
+                load("bed_foot", key, new Matrix4().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 Matrix4().makeTranslation(8, 0, 8).multiply(new Matrix4().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"() {
+      init_dirname();
+      init_buffer2();
+      init_process2();
+      GuiLight = /* @__PURE__ */ ((GuiLight2) => {
+        GuiLight2["FRONT"] = "front";
+        GuiLight2["SIDE"] = "side";
+        return GuiLight2;
+      })(GuiLight || {});
+    }
+  });
+
   // src/model/scene/ModelObject.ts
   function isModelObject(obj) {
     return obj.isModelObject;
@@ -79811,21 +80560,60 @@ ${key}` : key;
       import_ts_deepmerge5 = __toESM(require_dist());
       init_log();
       init_CubeFace();
+      init_DisplayPosition();
       init_DisplayTransforms();
       init_ModelCulling();
+      init_SpecialItems();
+      init_EntityObject();
+      init_GuiLight();
       p10 = 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());
         }
         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 Matrix4();
+            transform.multiply(new Matrix4().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 [name2, rotation] of Object.entries(part.rotations)) {
+                  object.getGroupByName(name2)?.rotation.set(...rotation, "ZYX");
+                }
+              }
+            } catch (error) {
+              this.disposeAndRemoveAllChildren();
+              throw error;
+            }
+            this.notifyDirty();
+            return;
+          }
           await this.loadTextures();
           this.createMeshes();
           this.applyTextures();
@@ -79970,6 +80758,8 @@ ${key}` : key;
           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();
         }
       };
@@ -83124,6 +83914,7 @@ ${key}` : key;
     SkinPart: () => SkinPart,
     SkinTextures: () => SkinTextures,
     Skins: () => Skins,
+    SpecialItems: () => SpecialItems,
     StructureParser: () => StructureParser,
     TextureAtlas: () => TextureAtlas,
     TextureLoader: () => TextureLoader,
@@ -83401,99 +84192,8 @@ ${key}` : key;
   init_buffer2();
   init_process2();
 
-  // src/MinecraftCubeTexture.ts
-  init_dirname();
-  init_buffer2();
-  init_process2();
-  init_UVMapper();
-  init_CubeFace();
-  var MinecraftCubeTexture = class {
-    constructor(u4, v5, width, height) {
-      this.u = u4;
-      this.v = v5;
-      this.width = width;
-      this.height = height;
-    }
-    mapW(x4) {
-      return x4 / this.width;
-    }
-    mapH(x4) {
-      return 1 - x4 / this.height;
-    }
-    getUvEast(w4, h5, l4) {
-      return [
-        [this.mapW(this.u + l4 + w4 + l4), this.mapH(this.v + l4 + h5)],
-        [this.mapW(this.u + l4 + w4), this.mapH(this.v + l4 + h5)],
-        [this.mapW(this.u + l4 + w4 + l4), this.mapH(this.v + l4)],
-        [this.mapW(this.u + l4 + w4), this.mapH(this.v + l4)]
-      ];
-    }
-    getUvWest(w4, h5, l4) {
-      return [
-        [this.mapW(this.u + l4), this.mapH(this.v + l4 + h5)],
-        [this.mapW(this.u), this.mapH(this.v + l4 + h5)],
-        [this.mapW(this.u + l4), this.mapH(this.v + l4)],
-        [this.mapW(this.u), this.mapH(this.v + l4)]
-      ];
-    }
-    getUvUp(w4, h5, l4) {
-      return [
-        [this.mapW(this.u + l4 + w4), this.mapH(this.v + l4)],
-        [this.mapW(this.u + l4 + w4 + w4), this.mapH(this.v + l4)],
-        [this.mapW(this.u + l4 + w4), this.mapH(this.v)],
-        [this.mapW(this.u + l4 + w4 + w4), this.mapH(this.v)]
-      ];
-    }
-    getUvDown(w4, h5, l4) {
-      return [
-        [this.mapW(this.u + l4), this.mapH(this.v)],
-        [this.mapW(this.u + l4 + w4), this.mapH(this.v)],
-        [this.mapW(this.u + l4), this.mapH(this.v + l4)],
-        [this.mapW(this.u + l4 + w4), this.mapH(this.v + l4)]
-      ];
-    }
-    getUvSouth(w4, h5, l4) {
-      return [
-        [this.mapW(this.u + l4 + w4 + l4 + w4), this.mapH(this.v + l4 + h5)],
-        [this.mapW(this.u + l4 + w4 + l4), this.mapH(this.v + l4 + h5)],
-        [this.mapW(this.u + l4 + w4 + l4 + w4), this.mapH(this.v + l4)],
-        [this.mapW(this.u + l4 + w4 + l4), this.mapH(this.v + l4)]
-      ];
-    }
-    getUvNorth(w4, h5, l4) {
-      return [
-        [this.mapW(this.u + l4 + w4), this.mapH(this.v + l4 + h5)],
-        [this.mapW(this.u + l4), this.mapH(this.v + l4 + h5)],
-        [this.mapW(this.u + l4 + w4), this.mapH(this.v + l4)],
-        [this.mapW(this.u + l4), this.mapH(this.v + l4)]
-      ];
-    }
-    getFaceUv(face, w4, h5, l4) {
-      switch (face) {
-        case "east" /* EAST */:
-          return this.getUvEast(w4, h5, l4);
-        case "west" /* WEST */:
-          return this.getUvWest(w4, h5, l4);
-        case "up" /* UP */:
-          return this.getUvUp(w4, h5, l4);
-        case "down" /* DOWN */:
-          return this.getUvDown(w4, h5, l4);
-        case "south" /* SOUTH */:
-          return this.getUvSouth(w4, h5, l4);
-        case "north" /* NORTH */:
-          return this.getUvNorth(w4, h5, l4);
-      }
-    }
-    toUvArray(w4, h5, l4, mirror = false) {
-      const uv = [];
-      for (let i4 = 0; i4 < CUBE_FACES.length; i4++) {
-        const face = mirror && i4 < 2 ? CUBE_FACES[1 - i4] : CUBE_FACES[i4];
-        const corners = this.getFaceUv(face, w4, h5, l4);
-        UVMapper.setFaceUvInArray(uv, i4 * 4, mirror ? [corners[1], corners[0], corners[3], corners[2]] : corners);
-      }
-      return uv;
-    }
-  };
+  // src/index.ts
+  init_MinecraftCubeTexture();
 
   // src/MinecraftTextureMeta.ts
   init_dirname();
@@ -83615,119 +84315,7 @@ ${key}` : key;
 
   // src/assets/index.ts
   init_BlockStates();
-
-  // src/assets/Entities.ts
-  init_dirname();
-  init_buffer2();
-  init_process2();
-  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 name2 = pass.layer;
-        for (let n4 = 2; names.includes(name2); n4++) name2 = `${pass.layer}#${n4}`;
-        names.push(name2);
-        return { name: name2, layer, pass };
-      });
-      const layers = Object.fromEntries(await Promise.all(selected.map(async ({ name: name2, layer, pass }, index) => {
-        const override = options?.textures?.[name2] ?? (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 [name2, { 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 name2 = path.split("/").pop();
-        for (const candidate of [path, `${path}/${name2}`]) {
-          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", `${name2}_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), `${name2}_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();
@@ -83810,51 +84398,7 @@ ${key}` : key;
   init_dirname();
   init_buffer2();
   init_process2();
-
-  // src/entity/EntityAnimation.ts
-  init_dirname();
-  init_buffer2();
-  init_process2();
-  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 a4 = Math.max(0, low - 1);
-    const b4 = Math.min(keyframes.length - 1, a4 + 1);
-    const from = keyframes[a4];
-    const to = keyframes[b4];
-    const delta = a4 === b4 ? 0 : Math.min(1, Math.max(0, (time - from.time) / (to.time - from.time)));
-    if (to.interpolation === "catmullrom") {
-      const before = keyframes[Math.max(0, a4 - 1)].value;
-      const after = keyframes[Math.min(keyframes.length - 1, b4 + 1)].value;
-      return [0, 1, 2].map((i4) => catmullRom(delta, before[i4], from.value[i4], to.value[i4], after[i4]));
-    }
-    const target = to.pre ?? to.value;
-    return [0, 1, 2].map((i4) => from.value[i4] + (target[i4] - from.value[i4]) * 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 [name2, bone] of Object.entries(animation.bones)) {
-      const sampled = pose[name2] = {};
-      for (const channel of ENTITY_ANIMATION_CHANNELS) {
-        const keyframes = bone[channel];
-        if (keyframes?.length) sampled[channel] = sampleEntityKeyframes(keyframes, elapsed);
-      }
-    }
-    return pose;
-  }
+  init_EntityAnimation();
 
   // src/entity/EntityModel.ts
   init_dirname();
@@ -83865,311 +84409,8 @@ ${key}` : key;
   init_dirname();
   init_buffer2();
   init_process2();
-
-  // src/entity/scene/EntityAnimationPlayer.ts
-  init_dirname();
-  init_buffer2();
-  init_process2();
-  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/scene/EntityObject.ts
-  init_dirname();
-  init_buffer2();
-  init_process2();
-  init_SceneObject();
-  init_Caching();
-  var import_ts_deepmerge4 = __toESM(require_dist());
-  init_three_module();
-  init_Ticker();
-  init_model();
-  init_ModelTextures();
-  init_AssetKey();
-  init_Materials();
-  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());
-    }
-    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((name2) => this.getLayerGroup(name2)).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(name2) {
-      return super.getGroupByName(`layer:${name2}`);
-    }
-    getGroupByName(name2, layerName) {
-      return layerName === void 0 ? super.getGroupByName(name2) : this.getLayerGroup(layerName)?.getObjectByName(`group:${name2}`);
-    }
-    getMeshByName(name2, layerName) {
-      return layerName === void 0 ? super.getMeshByName(name2) : this.getLayerGroup(layerName)?.getObjectByName(`mesh:${name2}`);
-    }
-    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 Object3D();
-      const transform = this.options.flip === void 0 ? this.entity.transform : void 0;
-      if (transform) {
-        for (const op of transform) {
-          const matrix = new Matrix4();
-          if ("scale" in op) matrix.makeScale(...op.scale);
-          else if ("translate" in op) matrix.makeTranslation(...op.translate);
-          else matrix.makeRotationFromEuler(new Euler(...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(([name2, layer], index) => {
-        const group = this.createGroup(`layer:${name2}`);
-        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(name2, part, parent, textureSize, material, renderOrder, inward = true) {
-      const anchor = this.createGroup(name2);
-      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(name2, 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 ([name2, layer]) => {
-        const mode2 = layer.render ?? layer.layer.render ?? "cutout";
-        const tint = layer.tint === void 0 ? void 0 : this.options.tints?.[layer.tint];
-        const scroll = Materials.entityModeScroll(mode2);
-        const assetKeyStr = this.getTextureKey(layer).serialize();
-        const keyStr = `entity:${mode2}:${tint === void 0 ? "" : new Color(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, mode2, 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(name2)?.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();
-    }
-  };
-  _EntityObject.DEFAULT_OPTIONS = (0, import_ts_deepmerge4.default)({}, SceneObject.DEFAULT_OPTIONS);
-  var EntityObject = _EntityObject;
-  function isEntityObject(obj) {
-    return obj.isEntityObject;
-  }
+  init_EntityAnimationPlayer();
+  init_EntityObject();
 
   // src/error/index.ts
   init_dirname();
@@ -86798,18 +87039,7 @@ property list uchar int vertex_index
   init_Materials();
   init_ModelObject();
   init_DisplayPosition();
-
-  // src/model/GuiLight.ts
-  init_dirname();
-  init_buffer2();
-  init_process2();
-  var GuiLight = /* @__PURE__ */ ((GuiLight2) => {
-    GuiLight2["FRONT"] = "front";
-    GuiLight2["SIDE"] = "side";
-    return GuiLight2;
-  })(GuiLight || {});
-
-  // src/gui/scene/GuiObject.ts
+  init_GuiLight();
   var GuiObject = class extends SceneObject {
     constructor(textureLayers, options) {
       super({ ...options, instanceMeshes: false, mergeMeshes: false });
@@ -86832,13 +87062,13 @@ property list uchar int vertex_index
             const item = await this.createItem(layer, index);
             item.position.set(x4 + width2 / 2, -y5 - 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 Box3();
             item.iterateAllMeshes((mesh2) => {
               mesh2.geometry.computeBoundingBox();
-              bounds.union(mesh2.geometry.boundingBox);
+              bounds.union(mesh2.geometry.boundingBox.clone().applyMatrix4(new Matrix4().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 Vector2(x4, y5));
@@ -86893,7 +87123,7 @@ property list uchar int vertex_index
       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]) {
@@ -87382,25 +87612,9 @@ property list uchar int vertex_index
   init_buffer2();
   init_process2();
 
-  // src/model/Model.ts
-  init_dirname();
-  init_buffer2();
-  init_process2();
-  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();
 
   // src/model/ModelElement.ts
@@ -87411,6 +87625,7 @@ property list uchar int vertex_index
   // src/model/index.ts
   init_ModelGenerator();
   init_ModelMerger();
+  init_SpecialItems();
 
   // src/model/block/index.ts
   init_dirname();
@@ -87638,6 +87853,7 @@ property list uchar int vertex_index
   init_AssetKey();
   init_ModelCulling();
   init_FluidGeometry();
+  init_Entities();
   var _BlockObject = class _BlockObject extends SceneObject {
     constructor(blockState, options) {
       super(options);
@@ -90928,6 +91144,7 @@ property list uchar int vertex_index
   };
 
   // src/renderer/MineRenderScene.ts
+  init_EntityObject();
   var _MineRenderScene = class _MineRenderScene extends Scene {
     constructor(options) {
       super();
@@ -92834,6 +93051,7 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
 
   // src/renderer/Renderer.ts
   init_util();
+  init_Model();
   init_three();
 
   // src/three/OrbitControls.js
@@ -94379,6 +94597,7 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
   init_buffer2();
   init_process2();
   init_three_module();
+  init_Model();
   init_BatchedExecutor();
   init_AssetKey();
   init_BlockStates();
@@ -94701,6 +94920,9 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
     }
   };
 
+  // src/world/Chunk.ts
+  init_Model();
+
   // src/world/SectionMesh.ts
   init_dirname();
   init_buffer2();