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

package/dist/browser/index.js

@@ -839,6 +839,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),
@@ -4925,32 +4990,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;
@@ -5033,6 +5110,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();
@@ -5044,6 +5122,10 @@ 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 ?? {});
   }
   async init() {
@@ -5053,6 +5135,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}`);
   }
@@ -5083,16 +5184,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");
@@ -5111,7 +5225,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()));
       }
@@ -5121,30 +5235,46 @@ 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();
   }
 };
-_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;
@@ -7658,11 +7788,69 @@ 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