minerender 2.1.0-alpha.53 → 2.1.0-alpha.54

package/dist/bundle.js

@@ -33153,6 +33153,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),
@@ -83512,32 +83577,44 @@ ${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 } };
     }
     static async resolveTexture(modelKey) {
       const path = isAssetKey(modelKey) ? modelKey.getFullPath() : modelKey.path;
@@ -83672,6 +83749,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 +83761,10 @@ ${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.options = (0, import_ts_deepmerge4.default)({}, _EntityObject.DEFAULT_OPTIONS, options ?? {});
     }
     async init() {
@@ -83692,6 +83774,25 @@ ${key}` : key;
     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(name2) {
       return super.getGroupByName(`layer:${name2}`);
     }
@@ -83722,16 +83823,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 +83864,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 +83874,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 +86458,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