minerender 2.1.0-alpha.53 → 2.1.0-alpha.55

package/dist/bundle.js

@@ -32176,7 +32176,9 @@ var MineRender = (() => {
             this.defaultBlockStatesCache,
             this.blockTintCache,
             this.entityModelCache,
-            this.entityTextureCache
+            this.entityTextureCache,
+            this.entityAnimationCache,
+            this.blockEntityIndexCache
           ];
         }
         static clear() {
@@ -32221,6 +32223,8 @@ var MineRender = (() => {
       _Caching.blockTintCache = _Caching.createAssetCache();
       _Caching.entityModelCache = _Caching.createAssetCache();
       _Caching.entityTextureCache = _Caching.createAssetCache();
+      _Caching.entityAnimationCache = _Caching.createAssetCache();
+      _Caching.blockEntityIndexCache = _Caching.createAssetCache();
       Caching = _Caching;
     }
   });
@@ -33153,6 +33157,71 @@ var MineRender = (() => {
             alphaTest: 0.5
           });
         }
+        /** Whether vanilla's render type for the mode culls back faces. */
+        static entityModeCulls(mode2 = "cutout") {
+          return mode2 === "cutout_cull" || mode2 === "solid" || mode2 === "eyes" || mode2 === "water_mask";
+        }
+        /** UV offset per tick of entity age for the scrolling modes, as vanilla's texture matrix applies it. */
+        static entityModeScroll(mode2 = "cutout") {
+          if (mode2 === "energy_swirl") return [0.01, 0.01];
+          if (mode2 === "breeze_wind") return [0.02, 0];
+          return void 0;
+        }
+        /**
+         * Entity material for one of vanilla's render types. Entities are unlit here, so the lit and full-bright modes
+         * differ only in blending and depth state. Culling is not a material property: {@link entityModeCulls} decides
+         * whether the geometry gets inward faces.
+         */
+        static createEntityCanvasMaterial(canvas, mode2 = "cutout", tint) {
+          const material = _Materials.createBasicCanvasMaterial(canvas);
+          switch (mode2) {
+            case "cutout":
+            case "cutout_cull":
+              break;
+            case "cutout_z_offset":
+              material.polygonOffset = true;
+              material.polygonOffsetFactor = -1;
+              material.polygonOffsetUnits = -10;
+              break;
+            case "solid":
+              material.alphaTest = 0;
+              break;
+            case "translucent":
+            case "breeze_wind":
+              material.transparent = true;
+              material.alphaTest = 0.1;
+              break;
+            case "translucent_emissive":
+              material.transparent = true;
+              material.alphaTest = 0.1;
+              material.depthWrite = false;
+              break;
+            case "eyes":
+              material.transparent = true;
+              material.alphaTest = 0;
+              material.depthWrite = false;
+              break;
+            case "energy_swirl":
+              material.transparent = true;
+              material.alphaTest = 0.1;
+              material.blending = CustomBlending;
+              material.blendSrc = OneFactor;
+              material.blendDst = OneFactor;
+              material.blendSrcAlpha = ZeroFactor;
+              material.blendDstAlpha = OneFactor;
+              material.color.set(8421504);
+              break;
+            case "water_mask":
+              material.alphaTest = 0;
+              material.colorWrite = false;
+              break;
+          }
+          if (_Materials.entityModeScroll(mode2)) {
+            material.map.wrapS = material.map.wrapT = RepeatWrapping;
+          }
+          if (tint !== void 0) material.color.multiply(new Color(tint));
+          return material;
+        }
         static createGuiCanvasMaterial(canvas) {
           const material = new MeshBasicMaterial({
             map: Textures.createCanvasTexture(canvas),
@@ -82977,6 +83046,7 @@ ${key}` : key;
     BUILTIN_GENERATED: () => BUILTIN_GENERATED,
     BasicAssetKey: () => BasicAssetKey,
     BatchedExecutor: () => BatchedExecutor,
+    BlockEntities: () => BlockEntities,
     BlockObject: () => BlockObject,
     BlockStateResolver: () => BlockStateResolver,
     BlockStates: () => BlockStates,
@@ -83000,7 +83070,9 @@ ${key}` : key;
     DefaultBlockStates: () => DefaultBlockStates,
     DisplayPosition: () => DisplayPosition,
     DisplayTransforms: () => DisplayTransforms,
+    ENTITY_ANIMATION_CHANNELS: () => ENTITY_ANIMATION_CHANNELS,
     Entities: () => Entities,
+    EntityAnimationPlayer: () => EntityAnimationPlayer,
     EntityObject: () => EntityObject,
     Env: () => Env,
     FluidModelObject: () => FluidModelObject,
@@ -83074,6 +83146,7 @@ ${key}` : key;
     createCanvas: () => createCanvas,
     createFluidGeometry: () => createFluidGeometry,
     createImage: () => createImage,
+    entityAnimationTime: () => entityAnimationTime,
     estimateBytesUsed: () => estimateBytesUsed,
     getBlockFluidState: () => getBlockFluidState,
     getFluidKind: () => getFluidKind,
@@ -83107,6 +83180,8 @@ ${key}` : key;
     prefix: () => prefix,
     probeImageSize: () => probeImageSize,
     registerBrowserEnv: () => registerBrowserEnv,
+    sampleEntityAnimation: () => sampleEntityAnimation,
+    sampleEntityKeyframes: () => sampleEntityKeyframes,
     sampleFluid: () => sampleFluid,
     serializeBoxGeometryKey: () => serializeBoxGeometryKey,
     serializeImageKey: () => serializeImageKey,
@@ -83478,6 +83553,62 @@ ${key}` : key;
   init_AssetKey();
   init_AssetLoader();
   init_Assets();
+
+  // src/assets/BlockEntities.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  init_three_module();
+  init_AssetKey();
+  init_AssetLoader();
+  init_source();
+  init_Caching();
+  var BlockEntities = class {
+    /**
+     * Loads the block index of a version. Versions and sources without one yield an empty index, and so does
+     * a failed load: the index is optional, and blocks must not retry or fail with it one by one. The empty
+     * result is cached like any other; `Caching.clear()` or `AssetLoader.setVersion()` forces a new attempt.
+     */
+    static async getIndex(root) {
+      const key = new AssetKey("entity-models", "blocks", void 0, void 0, void 0, ".json", root);
+      key.rootType = void 0;
+      const index = await Caching.blockEntityIndexCache.get(key.serialize(), async () => {
+        try {
+          return await AssetLoader.get(key, "json" /* JSON */) ?? {};
+        } catch (error) {
+          console.warn("Could not load the block entity index; block entities are drawn as plain block models", error);
+          return {};
+        }
+      });
+      return index ?? {};
+    }
+    /** The index entry of a block ID such as `minecraft:chest`. */
+    static entry(index, block) {
+      const entry = Object.prototype.hasOwnProperty.call(index, block) ? index[block] : void 0;
+      return Array.isArray(entry?.parts) ? entry : void 0;
+    }
+    /** Selects the parts and placement for a block ID such as `minecraft:chest`; undefined when nothing is drawn. */
+    static resolve(index, block, state = {}) {
+      const entry = this.entry(index, block);
+      if (!entry) return void 0;
+      const value = (property) => String(state[property]).toLowerCase();
+      const parts = entry.parts.filter((part) => Object.entries(part.when ?? {}).every(([property, values]) => String(values).split("|").includes(value(property))));
+      if (!parts.length) return void 0;
+      let rotation = 0;
+      if (entry.rotation) {
+        const selected = value(entry.rotation.property);
+        rotation = "degrees" in entry.rotation ? entry.rotation.degrees[selected] : Number(selected) * entry.rotation.step;
+        if (!Number.isFinite(rotation)) rotation = 0;
+      }
+      return { parts, rotation, translation: entry.translation ?? [0, 0, 0] };
+    }
+    /** Placement in block space (0..16 per axis), applied on top of the model's own transform. */
+    static matrix(resolved, matrix = new Matrix4()) {
+      return matrix.makeTranslation(8, 0, 8).multiply(new Matrix4().makeRotationY(resolved.rotation * Math.PI / 180)).multiply(new Matrix4().makeTranslation(resolved.translation[0] - 8, resolved.translation[1], resolved.translation[2] - 8));
+    }
+  };
+
+  // src/assets/index.ts
   init_BlockStates();
 
   // src/assets/Entities.ts
@@ -83512,32 +83643,53 @@ ${key}` : key;
     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 names = [...new Set(options?.layers ?? [options?.layer ?? "main"])];
-      if (names.length === 0) throw new MineRenderError(`Entity ${model.id} requires at least one layer`);
-      const selected = names.map((name2) => {
-        const layer = model.layers[name2];
+      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 "${name2}". Available layers: ${Object.keys(model.layers).join(", ")}`);
+          throw new MineRenderError(`Entity ${model.id} has no layer "${pass.layer}". Available layers: ${Object.keys(model.layers).join(", ")}`);
         }
-        return { name: name2, layer };
+        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 }, index) => {
+      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 (layer.textureLocation !== void 0) {
-          texture = AssetKey.parse("textures", layer.textureLocation.replace(/^([^:]+:)?textures\//, "$1"));
+        } else if (textureLocation !== void 0) {
+          texture = AssetKey.parse("textures", textureLocation.replace(/^([^:]+:)?textures\//, "$1"));
         } else {
           texture = await this.resolveTexture(modelKey);
         }
-        return [name2, { key: override ?? modelKey, texture, layer }];
+        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 };
+      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;
@@ -83654,6 +83806,51 @@ ${key}` : key;
   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;
+  }
+
   // src/entity/EntityModel.ts
   init_dirname();
   init_buffer2();
@@ -83664,6 +83861,80 @@ ${key}` : key;
   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();
@@ -83672,6 +83943,7 @@ ${key}` : key;
   init_Caching();
   var import_ts_deepmerge4 = __toESM(require_dist());
   init_three_module();
+  init_Ticker();
   init_model();
   init_ModelTextures();
   init_AssetKey();
@@ -83683,6 +83955,11 @@ ${key}` : key;
       this.entity = entity;
       this.isEntityObject = true;
       this.meshesCreated = false;
+      /** 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 ?? {});
     }
     async init() {
@@ -83692,6 +83969,59 @@ ${key}` : key;
     dispose() {
       super.dispose();
     }
+    disposeAndRemoveAllChildren() {
+      this.clearScrollMaterials();
+      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();
+      }
+    }
+    /** 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}`);
     }
@@ -83722,16 +84052,29 @@ ${key}` : key;
     createMeshes(force = false) {
       if (this.meshesCreated && !force) return;
       const modelRoot = new Object3D();
-      if (this.options.flip) modelRoot.scale.set(-1, -1, 1);
+      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);
-        this.createPart("root", layer.layer.root, group, layer.layer.texture, Materials.MISSING_TEXTURE, index);
+        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) {
+    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");
@@ -83750,7 +84093,7 @@ ${key}` : key;
           uv
         ).clone();
         geometry.translate(cube.origin[0] + width / 2, cube.origin[1] + height / 2, cube.origin[2] + depth / 2);
-        if (Math.min(width + growX * 2, height + growY * 2, depth + growZ * 2) > 0) {
+        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()));
         }
@@ -83760,30 +84103,46 @@ ${key}` : key;
         if (this.options.wireframe) addWireframeToMesh(geometry, mesh);
       }
       for (const [childName, child] of Object.entries(part.children)) {
-        this.createPart(childName, child, anchor, size, material, renderOrder);
+        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:${assetKeyStr}`;
-        let mat = Caching.materialCache.getIfPresent(keyStr);
+        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.createBasicCanvasMaterial(canvas);
-          mat = cachedAsset && Caching.textureAssetCache.getIfPresent(assetKeyStr) === cachedAsset ? Caching.materialCache.get(keyStr, createMaterial) : createMaterial();
+          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.scrollTicker = Ticker.add(() => {
+          this.age++;
+          this.updateScroll();
+        });
+      }
       this.notifyDirty();
     }
   };
-  _EntityObject.DEFAULT_OPTIONS = (0, import_ts_deepmerge4.default)({}, SceneObject.DEFAULT_OPTIONS, { flip: true });
+  _EntityObject.DEFAULT_OPTIONS = (0, import_ts_deepmerge4.default)({}, SceneObject.DEFAULT_OPTIONS);
   var EntityObject = _EntityObject;
   function isEntityObject(obj) {
     return obj.isEntityObject;
@@ -86328,11 +86687,69 @@ property list uchar int vertex_index
   init_dirname();
   init_buffer2();
   init_process2();
+  init_AssetKey();
   var GuiHelper = class {
     static inventorySlot(slot, origin = [0, 0], offset = [18, 18], rowSize = 9) {
       const [column, row] = typeof slot === "number" ? [slot % rowSize, Math.floor(slot / rowSize)] : slot;
       return [origin[0] + column * offset[0], origin[1] + row * offset[1]];
     }
+    /** Creates crafting-table layers for ingredients and the result; stack counts are not drawn. */
+    static recipe(recipe, options = {}) {
+      const layers = [
+        { name: "background", texture: "minecraft:gui/container/crafting_table", crop: [0, 0, 176, 166] }
+      ];
+      const itemKey = (ingredient) => {
+        const item = typeof ingredient === "string" && !ingredient.startsWith("#") ? ingredient : typeof ingredient === "object" && "item" in ingredient ? ingredient.item : options.resolveIngredient?.(ingredient);
+        if (isAssetKey(item)) return item;
+        if (!item || item.startsWith("#")) {
+          throw new Error(`Select a concrete item for recipe ingredient ${JSON.stringify(ingredient)}`);
+        }
+        const key = AssetKey.parse("models", item);
+        return new AssetKey(key.namespace, key.getFullPath(), "models", "item");
+      };
+      const addIngredient = (ingredient, slot) => {
+        layers.push({
+          name: `ingredient-${slot}`,
+          item: itemKey(ingredient),
+          position: this.inventorySlot(slot, [30, 17], [18, 18], 3)
+        });
+      };
+      switch (recipe.type) {
+        case "minecraft:crafting_shaped":
+        case "crafting_shaped": {
+          const pattern = recipe.pattern;
+          if (!pattern.length || pattern.length > 3 || !pattern[0].length || pattern[0].length > 3 || pattern.some((row) => row.length !== pattern[0].length)) {
+            throw new Error("Crafting patterns must be rectangular, with 1\u20133 rows and columns");
+          }
+          const cells = pattern.flatMap((row, y5) => row.split("").map((symbol, x4) => ({ symbol, x: x4, y: y5 }))).filter((cell) => cell.symbol !== " ");
+          if (!cells.length) throw new Error("Crafting patterns must contain an ingredient");
+          const minX = Math.min(...cells.map((cell) => cell.x)), maxX = Math.max(...cells.map((cell) => cell.x));
+          const minY = Math.min(...cells.map((cell) => cell.y)), maxY = Math.max(...cells.map((cell) => cell.y));
+          const offsetX = minX === maxX ? 1 : 0, offsetY = minY === maxY ? 1 : 0;
+          for (const { symbol, x: x4, y: y5 } of cells) {
+            const ingredient = recipe.key[symbol];
+            if (!ingredient) throw new Error(`Missing recipe ingredient for symbol ${JSON.stringify(symbol)}`);
+            addIngredient(ingredient, (y5 - minY + offsetY) * 3 + x4 - minX + offsetX);
+          }
+          break;
+        }
+        case "minecraft:crafting_shapeless":
+        case "crafting_shapeless":
+          if (!recipe.ingredients.length || recipe.ingredients.length > 9) {
+            throw new Error("Shapeless crafting recipes require 1\u20139 ingredients");
+          }
+          recipe.ingredients.forEach(addIngredient);
+          break;
+        default:
+          throw new Error(`Unsupported crafting recipe type: ${recipe.type}`);
+      }
+      layers.push({
+        name: "result",
+        item: itemKey("id" in recipe.result ? recipe.result.id : recipe.result.item),
+        position: [124, 35]
+      });
+      return layers;
+    }
   };
 
   // src/gui/GuiLayer.ts
@@ -87212,6 +87629,9 @@ property list uchar int vertex_index
       this._variants = [];
       this._models = [];
       this._cullMask = 0;
+      this._entities = [];
+      this._entityPlacement = new Matrix4();
+      this._entityGeneration = 0;
       this.options = (0, import_ts_deepmerge6.default)({}, _BlockObject.DEFAULT_OPTIONS, options ?? {});
     }
     async init() {
@@ -87231,6 +87651,8 @@ property list uchar int vertex_index
     }
     clearModels() {
       this.removeModels(this._models.splice(0));
+      this._entityGeneration++;
+      this.removeEntities(this._entities.splice(0));
       this._fluidKey = void 0;
       this._fluidModel = void 0;
       this._isInstanced = false;
@@ -87242,6 +87664,57 @@ property list uchar int vertex_index
         if (!isInstanceReference(model)) model.dispose();
       }
     }
+    removeEntities(entities) {
+      for (const entity of entities) {
+        entity.removeFromScene();
+        entity.dispose();
+      }
+    }
+    /** Entity models drawn for this block instead of its block model; they are scene children, unlike the block. */
+    get blockEntities() {
+      return this._entities;
+    }
+    /**
+     * Draws the block through the dataset's block-entity index. Returns false, leaving nothing behind,
+     * when the block is not listed or one of its models cannot be loaded.
+     */
+    async createBlockEntities() {
+      const key = this.blockState.key;
+      if (!key || this.options.displayPosition) return false;
+      const generation = this._entityGeneration;
+      const created = [];
+      let resolved;
+      try {
+        resolved = BlockEntities.resolve(await BlockEntities.getIndex(key.root), key.toNamespacedString(), this.state);
+        if (!resolved) return false;
+        for (const part of resolved.parts) {
+          const [namespace, path] = part.model.includes(":") ? part.model.split(":") : [key.namespace, part.model];
+          const texture = part.textureLocation === void 0 ? void 0 : AssetKey.parse("textures", part.textureLocation.replace(/^([^:]+:)?textures\//, "$1"));
+          if (texture) texture.root = key.root;
+          const entity = await Entities.getEntity(new BasicAssetKey(namespace, path), texture, { layer: part.layer });
+          if (!entity) throw new MineRenderError(`Missing entity model ${part.model}`);
+          created.push(await this.scene.addEntity(entity, { wireframe: this.options.wireframe }));
+        }
+      } catch (error) {
+        console.warn(`Could not draw block entity ${key.toNamespacedString()}, using its block model`, error);
+        this.removeEntities(created);
+        return false;
+      }
+      if (generation !== this._entityGeneration) {
+        this.removeEntities(created);
+        return true;
+      }
+      BlockEntities.matrix(resolved, this._entityPlacement);
+      this._entities = created;
+      this.placeEntities();
+      return true;
+    }
+    placeEntities() {
+      const matrix = new Matrix4().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);
+      }
+    }
     get isOccluding() {
       return this._models.some((model) => {
         const object = isInstanceReference(model) ? model.instanceable : model;
@@ -87353,13 +87826,20 @@ property list uchar int vertex_index
         await this.updateFluid(this._fluidSampler);
         return;
       }
+      const hasEntities = await this.createBlockEntities();
       const variantsToCreate = await this.mapStateToVariant(this.state);
       this._variants = variantsToCreate;
       for (let blockStateVariant of variantsToCreate) {
+        if (hasEntities && !await this.hasGeometry(blockStateVariant)) continue;
         this._models.push(await this.createVariant(blockStateVariant));
       }
       await this.updateFluid(this._fluidSampler);
     }
+    async hasGeometry(variant) {
+      const modelKey = AssetKey.parse("models", variant.model);
+      modelKey.root = this.blockState.key?.root;
+      return !!(await Models.getMerged(modelKey))?.elements?.length;
+    }
     getSingleVariant(variants) {
       return BlockStateResolver.choose(variants);
     }
@@ -87479,6 +87959,7 @@ property list uchar int vertex_index
       for (let model of this._models) {
         model.setPosition(position);
       }
+      this.placeEntities();
       this.notifyDirty();
     }
     //TODO: should override rotation + scale methods
@@ -94365,7 +94846,8 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
           this.data.set(index, void 0);
           return void 0;
         }
-        const template = getFluidKind(blockState.key, stored.properties) ? void 0 : await this.sectionModels?.get(blockState, stored.properties);
+        const perBlock = !this.sectionModels || getFluidKind(blockState.key, stored.properties) || blockState.key && BlockEntities.entry(await BlockEntities.getIndex(blockState.key.root), blockState.key.toNamespacedString());
+        const template = perBlock ? void 0 : await this.sectionModels.get(blockState, stored.properties);
         if (template) {
           this.sectionBlocks.set(index, { index, template, cullMask: 0 });
           this.meshDirty = true;