minerender 2.1.0-alpha.52 → 2.1.0-alpha.54

package/dist/node/index.js

@@ -886,6 +886,71 @@ var init_Materials = __esm({
           alphaTest: 0.5
         });
       }
+      /** Whether vanilla's render type for the mode culls back faces. */
+      static entityModeCulls(mode = "cutout") {
+        return mode === "cutout_cull" || mode === "solid" || mode === "eyes" || mode === "water_mask";
+      }
+      /** UV offset per tick of entity age for the scrolling modes, as vanilla's texture matrix applies it. */
+      static entityModeScroll(mode = "cutout") {
+        if (mode === "energy_swirl") return [0.01, 0.01];
+        if (mode === "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, mode = "cutout", tint) {
+        const material = _Materials.createBasicCanvasMaterial(canvas);
+        switch (mode) {
+          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 = import_three5.CustomBlending;
+            material.blendSrc = import_three5.OneFactor;
+            material.blendDst = import_three5.OneFactor;
+            material.blendSrcAlpha = import_three5.ZeroFactor;
+            material.blendDstAlpha = import_three5.OneFactor;
+            material.color.set(8421504);
+            break;
+          case "water_mask":
+            material.alphaTest = 0;
+            material.colorWrite = false;
+            break;
+        }
+        if (_Materials.entityModeScroll(mode)) {
+          material.map.wrapS = material.map.wrapT = import_three5.RepeatWrapping;
+        }
+        if (tint !== void 0) material.color.multiply(new import_three5.Color(tint));
+        return material;
+      }
       static createGuiCanvasMaterial(canvas) {
         const material = new import_three5.MeshBasicMaterial({
           map: Textures.createCanvasTexture(canvas),
@@ -3535,48 +3600,6 @@ var init_SceneObject = __esm({
   }
 });
 
-// src/model/ModelCulling.ts
-var import_three22, ModelCulling;
-var init_ModelCulling = __esm({
-  "src/model/ModelCulling.ts"() {
-    import_three22 = require("three");
-    init_CubeFace();
-    ModelCulling = class {
-      static toLocalMask(worldMask, rotation) {
-        let localMask = 0;
-        for (const [localFace, offset] of CUBE_FACE_OFFSETS.entries()) {
-          const normal = new import_three22.Vector3(...offset).applyEuler(rotation);
-          const worldFace = CUBE_FACE_OFFSETS.findIndex(([x, y, z]) => Math.abs(normal.x - x) < 1e-6 && Math.abs(normal.y - y) < 1e-6 && Math.abs(normal.z - z) < 1e-6);
-          if (worldFace < 0) return 0;
-          if (worldMask & 1 << worldFace) localMask |= 1 << localFace;
-        }
-        return localMask;
-      }
-      static isOpaqueFullCube(atlas) {
-        if (!atlas || atlas.hasTransparency !== false || atlas.model.elements?.length !== 1) return false;
-        const element = atlas.model.elements[0];
-        if (element.from.length !== 3 || !element.from.every((value) => value === 0) || element.to.length !== 3 || !element.to.every((value) => value === 16) || element.rotation && element.rotation.angle !== 0 || element.mappedUv?.length !== 48 || !element.mappedUv.every(Number.isFinite)) return false;
-        if (!(atlas.image.width > 0 && atlas.image.height > 0)) return false;
-        return CUBE_FACES.every((face, faceIndex) => {
-          const texture = element.faces[face]?.texture;
-          if (!texture?.startsWith("#")) return false;
-          const key = texture.slice(1);
-          const position = atlas.positions[key];
-          const size = atlas.sizes[key];
-          if (position?.length !== 2 || !position.every(Number.isFinite) || size?.length !== 2 || !size.every((value) => value > 0 && Number.isFinite(value))) return false;
-          for (let vertex = 0; vertex < 4; vertex++) {
-            const uvIndex = (faceIndex * 4 + vertex) * 2;
-            const x = element.mappedUv[uvIndex] * atlas.image.width;
-            const y = (1 - element.mappedUv[uvIndex + 1]) * atlas.image.height;
-            if (x < position[0] - 1e-6 || x > position[0] + size[0] + 1e-6 || y < position[1] - 1e-6 || y > position[1] + size[1] + 1e-6) return false;
-          }
-          return true;
-        });
-      }
-    };
-  }
-});
-
 // src/three/BufferGeometryUtils.js
 function computeTangents(geometry) {
   geometry.computeTangents();
@@ -3589,7 +3612,7 @@ function mergeBufferGeometries(geometries, useGroups = false) {
   const attributes = {};
   const morphAttributes = {};
   const morphTargetsRelative = geometries[0].morphTargetsRelative;
-  const mergedGeometry = new import_three24.BufferGeometry();
+  const mergedGeometry = new import_three19.BufferGeometry();
   let offset = 0;
   for (let i = 0; i < geometries.length; ++i) {
     const geometry = geometries[i];
@@ -3713,7 +3736,7 @@ function mergeBufferAttributes(attributes) {
     array.set(attributes[i].array, offset);
     offset += attributes[i].array.length;
   }
-  return new import_three24.BufferAttribute(array, itemSize, normalized);
+  return new import_three19.BufferAttribute(array, itemSize, normalized);
 }
 function interleaveAttributes(attributes) {
   let TypedArray;
@@ -3729,7 +3752,7 @@ function interleaveAttributes(attributes) {
     arrayLength += attribute.array.length;
     stride += attribute.itemSize;
   }
-  const interleavedBuffer = new import_three24.InterleavedBuffer(new TypedArray(arrayLength), stride);
+  const interleavedBuffer = new import_three19.InterleavedBuffer(new TypedArray(arrayLength), stride);
   let offset = 0;
   const res = [];
   const getters = ["getX", "getY", "getZ", "getW"];
@@ -3738,7 +3761,7 @@ function interleaveAttributes(attributes) {
     const attribute = attributes[j];
     const itemSize = attribute.itemSize;
     const count = attribute.count;
-    const iba = new import_three24.InterleavedBufferAttribute(interleavedBuffer, itemSize, offset, attribute.normalized);
+    const iba = new import_three19.InterleavedBufferAttribute(interleavedBuffer, itemSize, offset, attribute.normalized);
     res.push(iba);
     offset += itemSize;
     for (let c = 0; c < count; c++) {
@@ -3822,13 +3845,13 @@ function mergeVertices(geometry, tolerance = 1e-4) {
     const name = attributeNames[i];
     const oldAttribute = geometry.getAttribute(name);
     const buffer = new oldAttribute.array.constructor(attrArrays[name]);
-    const attribute = new import_three24.BufferAttribute(buffer, oldAttribute.itemSize, oldAttribute.normalized);
+    const attribute = new import_three19.BufferAttribute(buffer, oldAttribute.itemSize, oldAttribute.normalized);
     result.setAttribute(name, attribute);
     if (name in morphAttrsArrays) {
       for (let j = 0; j < morphAttrsArrays[name].length; j++) {
         const oldMorphAttribute = geometry.morphAttributes[name][j];
         const buffer2 = new oldMorphAttribute.array.constructor(morphAttrsArrays[name][j]);
-        const morphAttribute = new import_three24.BufferAttribute(buffer2, oldMorphAttribute.itemSize, oldMorphAttribute.normalized);
+        const morphAttribute = new import_three19.BufferAttribute(buffer2, oldMorphAttribute.itemSize, oldMorphAttribute.normalized);
         result.morphAttributes[name][j] = morphAttribute;
       }
     }
@@ -3837,11 +3860,11 @@ function mergeVertices(geometry, tolerance = 1e-4) {
   return result;
 }
 function toTrianglesDrawMode(geometry, drawMode) {
-  if (drawMode === import_three24.TrianglesDrawMode) {
+  if (drawMode === import_three19.TrianglesDrawMode) {
     console.warn("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles.");
     return geometry;
   }
-  if (drawMode === import_three24.TriangleFanDrawMode || drawMode === import_three24.TriangleStripDrawMode) {
+  if (drawMode === import_three19.TriangleFanDrawMode || drawMode === import_three19.TriangleStripDrawMode) {
     let index = geometry.getIndex();
     if (index === null) {
       const indices = [];
@@ -3859,7 +3882,7 @@ function toTrianglesDrawMode(geometry, drawMode) {
     }
     const numberOfTriangles = index.count - 2;
     const newIndices = [];
-    if (drawMode === import_three24.TriangleFanDrawMode) {
+    if (drawMode === import_three19.TriangleFanDrawMode) {
       for (let i = 1; i <= numberOfTriangles; i++) {
         newIndices.push(index.getX(0));
         newIndices.push(index.getX(i));
@@ -3895,15 +3918,15 @@ function computeMorphedAttributes(object) {
     console.error("THREE.BufferGeometryUtils: Geometry is not of type BufferGeometry.");
     return null;
   }
-  const _vA = new import_three24.Vector3();
-  const _vB = new import_three24.Vector3();
-  const _vC = new import_three24.Vector3();
-  const _tempA = new import_three24.Vector3();
-  const _tempB = new import_three24.Vector3();
-  const _tempC = new import_three24.Vector3();
-  const _morphA = new import_three24.Vector3();
-  const _morphB = new import_three24.Vector3();
-  const _morphC = new import_three24.Vector3();
+  const _vA = new import_three19.Vector3();
+  const _vB = new import_three19.Vector3();
+  const _vC = new import_three19.Vector3();
+  const _tempA = new import_three19.Vector3();
+  const _tempB = new import_three19.Vector3();
+  const _tempC = new import_three19.Vector3();
+  const _morphA = new import_three19.Vector3();
+  const _morphB = new import_three19.Vector3();
+  const _morphC = new import_three19.Vector3();
   function _calculateMorphedAttributeData(object2, material2, attribute, morphAttribute, morphTargetsRelative2, a2, b2, c2, modifiedAttributeArray) {
     _vA.fromBufferAttribute(attribute, a2);
     _vB.fromBufferAttribute(attribute, b2);
@@ -4098,8 +4121,8 @@ function computeMorphedAttributes(object) {
       }
     }
   }
-  const morphedPositionAttribute = new import_three24.Float32BufferAttribute(modifiedPosition, 3);
-  const morphedNormalAttribute = new import_three24.Float32BufferAttribute(modifiedNormal, 3);
+  const morphedPositionAttribute = new import_three19.Float32BufferAttribute(modifiedPosition, 3);
+  const morphedNormalAttribute = new import_three19.Float32BufferAttribute(modifiedNormal, 3);
   return {
     positionAttribute,
     normalAttribute,
@@ -4107,10 +4130,52 @@ function computeMorphedAttributes(object) {
     morphedNormalAttribute
   };
 }
-var import_three24;
+var import_three19;
 var init_BufferGeometryUtils = __esm({
   "src/three/BufferGeometryUtils.js"() {
-    import_three24 = require("three");
+    import_three19 = require("three");
+  }
+});
+
+// src/model/ModelCulling.ts
+var import_three20, ModelCulling;
+var init_ModelCulling = __esm({
+  "src/model/ModelCulling.ts"() {
+    import_three20 = require("three");
+    init_CubeFace();
+    ModelCulling = class {
+      static toLocalMask(worldMask, rotation) {
+        let localMask = 0;
+        for (const [localFace, offset] of CUBE_FACE_OFFSETS.entries()) {
+          const normal = new import_three20.Vector3(...offset).applyEuler(rotation);
+          const worldFace = CUBE_FACE_OFFSETS.findIndex(([x, y, z]) => Math.abs(normal.x - x) < 1e-6 && Math.abs(normal.y - y) < 1e-6 && Math.abs(normal.z - z) < 1e-6);
+          if (worldFace < 0) return 0;
+          if (worldMask & 1 << worldFace) localMask |= 1 << localFace;
+        }
+        return localMask;
+      }
+      static isOpaqueFullCube(atlas) {
+        if (!atlas || atlas.hasTransparency !== false || atlas.model.elements?.length !== 1) return false;
+        const element = atlas.model.elements[0];
+        if (element.from.length !== 3 || !element.from.every((value) => value === 0) || element.to.length !== 3 || !element.to.every((value) => value === 16) || element.rotation && element.rotation.angle !== 0 || element.mappedUv?.length !== 48 || !element.mappedUv.every(Number.isFinite)) return false;
+        if (!(atlas.image.width > 0 && atlas.image.height > 0)) return false;
+        return CUBE_FACES.every((face, faceIndex) => {
+          const texture = element.faces[face]?.texture;
+          if (!texture?.startsWith("#")) return false;
+          const key = texture.slice(1);
+          const position = atlas.positions[key];
+          const size = atlas.sizes[key];
+          if (position?.length !== 2 || !position.every(Number.isFinite) || size?.length !== 2 || !size.every((value) => value > 0 && Number.isFinite(value))) return false;
+          for (let vertex = 0; vertex < 4; vertex++) {
+            const uvIndex = (faceIndex * 4 + vertex) * 2;
+            const x = element.mappedUv[uvIndex] * atlas.image.width;
+            const y = (1 - element.mappedUv[uvIndex + 1]) * atlas.image.height;
+            if (x < position[0] - 1e-6 || x > position[0] + size[0] + 1e-6 || y < position[1] - 1e-6 || y > position[1] + size[1] + 1e-6) return false;
+          }
+          return true;
+        });
+      }
+    };
   }
 });
 
@@ -4118,13 +4183,13 @@ var init_BufferGeometryUtils = __esm({
 function isModelObject(obj) {
   return obj.isModelObject;
 }
-var import_three25, import_ts_deepmerge5, p9, ModelObject;
+var import_three21, import_ts_deepmerge5, p7, ModelObject;
 var init_ModelObject = __esm({
   "src/model/scene/ModelObject.ts"() {
     init_SceneObject();
     init_Materials();
     init_UVMapper();
-    import_three25 = require("three");
+    import_three21 = require("three");
     init_BufferGeometryUtils();
     init_model();
     import_ts_deepmerge5 = __toESM(require_dist());
@@ -4132,7 +4197,7 @@ var init_ModelObject = __esm({
     init_CubeFace();
     init_DisplayTransforms();
     init_ModelCulling();
-    p9 = prefix("ModelObject");
+    p7 = prefix("ModelObject");
     ModelObject = class _ModelObject extends SceneObject {
       constructor(originalModel, options) {
         super(options);
@@ -4181,7 +4246,7 @@ var init_ModelObject = __esm({
                 elGeo.clearGroups();
               }
               if (this.options.uvLockRotation) {
-                UVMapper.lockUvs(elGeo, el.faces, this.atlas, new import_three25.Euler(...this.options.uvLockRotation));
+                UVMapper.lockUvs(elGeo, el.faces, this.atlas, new import_three21.Euler(...this.options.uvLockRotation));
               }
               if (this.options.tints) {
                 const colors = new Float32Array(elGeo.getAttribute("position").count * 3).fill(1);
@@ -4190,19 +4255,19 @@ var init_ModelObject = __esm({
                   if (tintIndex === void 0 || tintIndex < 0) continue;
                   const tint = this.options.tints[tintIndex];
                   if (tint === void 0) continue;
-                  const color = new import_three25.Color(tint);
+                  const color = new import_three21.Color(tint);
                   for (let vertex = 0; vertex < 4; vertex++) {
                     color.toArray(colors, (faceIndex * 4 + vertex) * 3);
                   }
                 }
-                elGeo.setAttribute("color", new import_three25.BufferAttribute(colors, 3));
+                elGeo.setAttribute("color", new import_three21.BufferAttribute(colors, 3));
               }
-              elGeo.applyMatrix4(new import_three25.Matrix4().makeTranslation((el.to[0] - el.from[0]) / 2, (el.to[1] - el.from[1]) / 2, (el.to[2] - el.from[2]) / 2));
-              elGeo.applyMatrix4(new import_three25.Matrix4().makeTranslation(el.from[0], el.from[1], el.from[2]));
+              elGeo.applyMatrix4(new import_three21.Matrix4().makeTranslation((el.to[0] - el.from[0]) / 2, (el.to[1] - el.from[1]) / 2, (el.to[2] - el.from[2]) / 2));
+              elGeo.applyMatrix4(new import_three21.Matrix4().makeTranslation(el.from[0], el.from[1], el.from[2]));
               if (el.rotation) {
                 applyElementRotation(el.rotation, elGeo);
               }
-              elGeo.applyMatrix4(new import_three25.Matrix4().makeTranslation(-8, -8, -8));
+              elGeo.applyMatrix4(new import_three21.Matrix4().makeTranslation(-8, -8, -8));
               if (displayTransform) DisplayTransforms.apply(elGeo, displayTransform);
               if (this.options.mergeMeshes) {
                 allGeos.push(elGeo);
@@ -4214,17 +4279,17 @@ var init_ModelObject = __esm({
               }
             });
           } else {
-            console.debug(p9, this.atlas.model, "has no elements");
+            console.debug(p7, this.atlas.model, "has no elements");
           }
         } else {
-          console.debug(p9, "Missing atlas for", this);
+          console.debug(p7, "Missing atlas for", this);
         }
         if (this.options.mergeMeshes) {
           let combinedGeo;
           if (allGeos.length > 0) {
             combinedGeo = mergeBufferGeometries(allGeos);
           } else {
-            combinedGeo = new import_three25.BoxGeometry(16, 16, 16);
+            combinedGeo = new import_three21.BoxGeometry(16, 16, 16);
             if (displayTransform) DisplayTransforms.apply(combinedGeo, displayTransform);
           }
           combinedGeo.computeBoundingBox();
@@ -4970,32 +5035,44 @@ var Entities = class {
   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((name) => {
-      const layer = model.layers[name];
+    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 "${name}". 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, layer };
+      let name = pass.layer;
+      for (let n = 2; names.includes(name); n++) name = `${pass.layer}#${n}`;
+      names.push(name);
+      return { name, layer, pass };
     });
-    const layers = Object.fromEntries(await Promise.all(selected.map(async ({ name, layer }, index) => {
+    const layers = Object.fromEntries(await Promise.all(selected.map(async ({ name, layer, pass }, index) => {
       const override = options?.textures?.[name] ?? (index === 0 ? textureKey : void 0);
+      const textureLocation = pass.textureLocation ?? layer.textureLocation;
       let texture;
       if (override) {
         const path = isAssetKey(override) ? override.getFullPath() : override.path;
         texture = isAssetKey(override) && override.assetType === "textures" && path.startsWith("entity/") ? override : new AssetKey(override.namespace, path, "textures", "entity", "assets", ".png", isAssetKey(override) ? override.root : void 0);
-      } else if (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 [name, { key: override ?? modelKey, texture, layer }];
+      const render = pass.render ?? layer.render;
+      return [name, { key: override ?? modelKey, texture, layer, ...render && { render }, ...pass.tint && { tint: pass.tint } }];
     })));
-    return { ...layers[names[0]], id: model.id, layers };
+    return { ...layers[names[0]], id: model.id, layers, ...model.transform && { transform: model.transform } };
   }
   static async resolveTexture(modelKey) {
     const path = isAssetKey(modelKey) ? modelKey.getFullPath() : modelKey.path;
@@ -5078,6 +5155,7 @@ init_SceneObject();
 init_Caching();
 var import_ts_deepmerge4 = __toESM(require_dist());
 var import_three12 = require("three");
+init_Ticker();
 init_model();
 init_ModelTextures();
 init_AssetKey();
@@ -5089,10 +5167,14 @@ var EntityObject = class _EntityObject extends SceneObject {
     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.options = (0, import_ts_deepmerge4.default)({}, _EntityObject.DEFAULT_OPTIONS, options ?? {});
   }
   static {
-    this.DEFAULT_OPTIONS = (0, import_ts_deepmerge4.default)({}, SceneObject.DEFAULT_OPTIONS, { flip: true });
+    this.DEFAULT_OPTIONS = (0, import_ts_deepmerge4.default)({}, SceneObject.DEFAULT_OPTIONS);
   }
   async init() {
     this.createMeshes();
@@ -5101,6 +5183,25 @@ var EntityObject = class _EntityObject extends SceneObject {
   dispose() {
     super.dispose();
   }
+  disposeAndRemoveAllChildren() {
+    this.clearScrollMaterials();
+    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();
+  }
   getLayerGroup(name) {
     return super.getGroupByName(`layer:${name}`);
   }
@@ -5131,16 +5232,29 @@ var EntityObject = class _EntityObject extends SceneObject {
   createMeshes(force = false) {
     if (this.meshesCreated && !force) return;
     const modelRoot = new import_three12.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 import_three12.Matrix4();
+        if ("scale" in op) matrix.makeScale(...op.scale);
+        else if ("translate" in op) matrix.makeTranslation(...op.translate);
+        else matrix.makeRotationFromEuler(new import_three12.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(([name, layer], index) => {
       const group = this.createGroup(`layer:${name}`);
       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(name, part, parent, textureSize, material, renderOrder) {
+  createPart(name, part, parent, textureSize, material, renderOrder, inward = true) {
     const anchor = this.createGroup(name);
     anchor.position.fromArray(part.pose.offset);
     anchor.rotation.set(...part.pose.rotation, "ZYX");
@@ -5159,7 +5273,7 @@ var EntityObject = class _EntityObject extends SceneObject {
         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()));
       }
@@ -5169,26 +5283,42 @@ var EntityObject = class _EntityObject extends SceneObject {
       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 ([name, layer]) => {
+      const mode = layer.render ?? layer.layer.render ?? "cutout";
+      const tint = layer.tint === void 0 ? void 0 : this.options.tints?.[layer.tint];
+      const scroll = Materials.entityModeScroll(mode);
       const assetKeyStr = this.getTextureKey(layer).serialize();
-      const keyStr = `entity:${assetKeyStr}`;
-      let mat = Caching.materialCache.getIfPresent(keyStr);
+      const keyStr = `entity:${mode}:${tint === void 0 ? "" : new import_three12.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, mode, tint);
+        mat = !scroll && cachedAsset && Caching.textureAssetCache.getIfPresent(assetKeyStr) === cachedAsset ? Caching.materialCache.get(keyStr, createMaterial) : createMaterial();
+        if (scroll) {
+          this.scrollMaterials.push({ material: mat, offset: mat.map.offset, speed: scroll });
+        }
       }
       this.getLayerGroup(name)?.traverse((object) => {
         if (isMesh(object)) object.material = mat;
       });
     }));
+    if (!this.children.length) {
+      this.clearScrollMaterials();
+    } else if (this.scrollMaterials.length) {
+      this.updateScroll();
+      this.scrollTicker = Ticker.add(() => {
+        this.age++;
+        this.updateScroll();
+      });
+    }
     this.notifyDirty();
   }
 };
@@ -7704,27 +7834,97 @@ function copyDataTexture(source) {
 }
 
 // src/gui/GuiHelper.ts
+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, y) => row.split("").map((symbol, x) => ({ symbol, x, y }))).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, y } of cells) {
+          const ingredient = recipe.key[symbol];
+          if (!ingredient) throw new Error(`Missing recipe ingredient for symbol ${JSON.stringify(symbol)}`);
+          addIngredient(ingredient, (y - minY + offsetY) * 3 + x - 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/scene/GuiObject.ts
-var import_three19 = require("three");
+var import_three22 = require("three");
 init_AssetKey();
 init_ModelTextures();
+init_Models();
 init_Caching();
 init_SceneObject();
 init_Materials();
+init_ModelObject();
+init_DisplayPosition();
+
+// src/model/GuiLight.ts
+var GuiLight = /* @__PURE__ */ ((GuiLight2) => {
+  GuiLight2["FRONT"] = "front";
+  GuiLight2["SIDE"] = "side";
+  return GuiLight2;
+})(GuiLight || {});
+
+// src/gui/scene/GuiObject.ts
 var GuiObject = class extends SceneObject {
   constructor(textureLayers, options) {
     super({ ...options, instanceMeshes: false, mergeMeshes: false });
     this.textureLayers = textureLayers;
     this.isGuiObject = true;
     /** Local bounds in GUI pixels, with y growing down from the origin. */
-    this.bounds = new import_three19.Box2();
+    this.bounds = new import_three22.Box2();
     this.geometries = /* @__PURE__ */ new Set();
     this.ownedMaterials = /* @__PURE__ */ new Set();
     this.initialized = false;
@@ -7732,14 +7932,35 @@ var GuiObject = class extends SceneObject {
   async init() {
     if (this.initialized) return;
     try {
+      let depth = 0;
       for (const [index, layer] of this.textureLayers.entries()) {
+        const [x, y] = layer.position ?? [0, 0];
+        if ("item" in layer) {
+          const [width2, height2] = layer.size ?? [16, 16];
+          const item = await this.createItem(layer, index);
+          item.position.set(x + width2 / 2, -y - height2 / 2, 0);
+          item.scale.set(width2 / 16, height2 / 16, width2 / 16);
+          item.updateMatrix();
+          const bounds = new import_three22.Box3();
+          item.iterateAllMeshes((mesh2) => {
+            mesh2.geometry.computeBoundingBox();
+            bounds.union(mesh2.geometry.boundingBox);
+          });
+          bounds.applyMatrix4(item.matrix);
+          item.position.z = depth - bounds.min.z;
+          depth += bounds.max.z - bounds.min.z + 0.01;
+          this.bounds.expandByPoint(new import_three22.Vector2(x, y));
+          this.bounds.expandByPoint(new import_three22.Vector2(x + width2, y + height2));
+          this.bounds.expandByPoint(new import_three22.Vector2(bounds.min.x, -bounds.max.y));
+          this.bounds.expandByPoint(new import_three22.Vector2(bounds.max.x, -bounds.min.y));
+          continue;
+        }
         const key = typeof layer.texture === "string" ? AssetKey.parse("textures", layer.texture) : layer.texture;
         const material = await this.loadMaterial(key);
         const image = material.map.image;
         const [cropX, cropY, cropWidth, cropHeight] = layer.crop ?? [0, 0, image.width, image.height];
         const [width, height] = layer.size ?? [cropWidth, cropHeight];
-        const [x, y] = layer.position ?? [0, 0];
-        const geometry = new import_three19.PlaneGeometry(width, height);
+        const geometry = new import_three22.PlaneGeometry(width, height);
         this.geometries.add(geometry);
         const uv = geometry.getAttribute("uv");
         for (let i = 0; i < uv.count; i++) {
@@ -7749,14 +7970,16 @@ var GuiObject = class extends SceneObject {
             1 - (cropY + (1 - uv.getY(i)) * cropHeight) / image.height
           );
         }
-        const mesh = new import_three19.Mesh(geometry, material);
+        const mesh = new import_three22.Mesh(geometry, material);
         mesh.name = `mesh:${layer.name ?? index}`;
-        mesh.position.set(x + width / 2, -y - height / 2, 0);
+        mesh.position.set(x + width / 2, -y - height / 2, depth);
         mesh.renderOrder = index;
         this.add(mesh);
-        this.bounds.expandByPoint(new import_three19.Vector2(x, y));
-        this.bounds.expandByPoint(new import_three19.Vector2(x + width, y + height));
+        this.bounds.expandByPoint(new import_three22.Vector2(x, y));
+        this.bounds.expandByPoint(new import_three22.Vector2(x + width, y + height));
+        depth += 0.01;
       }
+      for (const child of this.children) child.position.z -= depth - 0.01;
       this.initialized = true;
       this.notifyDirty();
     } catch (error) {
@@ -7764,6 +7987,32 @@ var GuiObject = class extends SceneObject {
       throw error;
     }
   }
+  async createItem(layer, index) {
+    const key = typeof layer.item === "string" ? AssetKey.parse("models", layer.item) : layer.item;
+    const model = await Models.getMerged(key);
+    if (!model) throw new Error(`Could not load GUI item ${key.toNamespacedString()}`);
+    const item = new ModelObject(model, {
+      displayPosition: "gui" /* GUI */,
+      tints: layer.tints,
+      instanceMeshes: false,
+      mergeMeshes: true
+    });
+    item.name = `group:${layer.name ?? index}`;
+    this.add(item);
+    await item.init();
+    item.iterateAllMeshes((mesh) => {
+      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]) {
+        material.transparent = true;
+        if (model.gui_light === "front" /* FRONT */ && material.uniforms?.SHADE) {
+          material.uniforms.SHADE.value = false;
+        }
+      }
+    });
+    return item;
+  }
   async loadMaterial(key) {
     const assetKey = key.serialize();
     const materialKey = `gui:${assetKey}`;
@@ -7802,21 +8051,21 @@ function isGuiObject(obj) {
 init_image();
 
 // src/inspector/SceneInspector.ts
-var import_three20 = require("three");
+var import_three23 = require("three");
 init_SceneObject();
 init_util();
 init_log();
 init_three();
-var p7 = prefix("SceneInspector");
+var p8 = prefix("SceneInspector");
 var help = "<span>Ctrl/Cmd+Click to Select<br/></span><br/>";
 var SceneInspector = class {
   constructor(renderer) {
     this.renderer = renderer;
-    this.mouse = new import_three20.Vector2();
+    this.mouse = new import_three23.Vector2();
     this.listeners = new AbortController();
     this.objectInfoContainer = document.createElement("div");
     this.objectControlsContainer = document.createElement("div");
-    this.raycaster = new import_three20.Raycaster();
+    this.raycaster = new import_three23.Raycaster();
     this.init();
   }
   init() {
@@ -7901,7 +8150,7 @@ var SceneInspector = class {
   }
   selectObject(targetObject, targetIntersection, instance = this.getIntersectionInstance(targetIntersection)) {
     this.selectedObject = targetObject;
-    console.log(p7, "selected", targetObject);
+    console.log(p8, "selected", targetObject);
     this.redraw(targetObject, targetIntersection, instance);
   }
   redraw(targetObject, targetIntersection, instance) {
@@ -8160,7 +8409,7 @@ var SceneStatsDisplay = class {
 
 // src/instance/InstanceManager.ts
 init_log();
-var p8 = prefix("InstanceManager");
+var p9 = prefix("InstanceManager");
 var InstanceManager = class {
   constructor() {
     this.isInstanceManager = true;
@@ -8168,7 +8417,7 @@ var InstanceManager = class {
   }
   async get(key) {
     if (key in this.instanceCache) {
-      console.debug(p8, "key in cache", key);
+      console.debug(p9, "key in cache", key);
       return (await this.instanceCache[key]).nextInstance();
     }
     return void 0;
@@ -8177,7 +8426,7 @@ var InstanceManager = class {
     if (key in this.instanceCache) {
       return await this.get(key);
     }
-    console.debug(p8, "key not in cache", key);
+    console.debug(p9, "key not in cache", key);
     const pending = Promise.resolve().then(supplier).then((obj) => obj.nextInstance());
     this.instanceCache[key] = pending;
     try {
@@ -8211,13 +8460,6 @@ function isInstanceable(obj) {
 init_DisplayPosition();
 init_DisplayTransforms();
 
-// src/model/GuiLight.ts
-var GuiLight = /* @__PURE__ */ ((GuiLight2) => {
-  GuiLight2["FRONT"] = "front";
-  GuiLight2["SIDE"] = "side";
-  return GuiLight2;
-})(GuiLight || {});
-
 // src/model/Model.ts
 var ITEM_GENERATED = "item/generated";
 var BUILTIN_GENERATED = "builtin/generated";
@@ -8239,7 +8481,7 @@ init_ModelGenerator();
 init_ModelMerger();
 
 // src/model/block/BlockStateResolver.ts
-var import_three23 = require("three");
+var import_three25 = require("three");
 init_BlockStates();
 init_MineRenderError();
 init_util();
@@ -8317,7 +8559,7 @@ var BlockStateResolver = class {
     return variants[variants.length - 1];
   }
   static rotation(variant) {
-    const rotation = new import_three23.Euler();
+    const rotation = new import_three25.Euler();
     if (typeof variant.x !== "undefined") {
       rotation.x = toRadians(clampRotationDegrees(variant.x));
     }