minerender 2.1.0-alpha.60 → 2.1.0-alpha.61

package/dist/bundle.js

@@ -33790,7 +33790,7 @@ var MineRender = (() => {
         }
         static async getItemModel(key) {
           const itemKey = new AssetKey(key.namespace, key.path, "items", void 0, key.rootType, ".json", key.root);
-          const model = await this.PERSISTENT_CACHE.getOrLoad(AssetLoader.persistentKey(itemKey.serialize()), async () => {
+          const model = await this.PERSISTENT_CACHE.getOrLoad(`item-v2:${AssetLoader.persistentKey(itemKey.serialize())}`, async () => {
             const result = await AssetLoader.getFirst([itemKey, key], "json" /* JSON */);
             if (!result) return void 0;
             if (result.key.assetType !== "items") return { ...result.asset, key };
@@ -33799,7 +33799,7 @@ var MineRender = (() => {
             modelKey.root = key.root;
             const model2 = await this.getRaw(modelKey);
             if (!model2) throw new Error(`Item ${key.toNamespacedString()} references missing model ${selected.model}`);
-            return selected.special ? { ...model2, special: selected.special } : model2;
+            return { ...model2, ...selected.special && { special: selected.special }, ...selected.tints && { tints: selected.tints } };
           });
           return model ? { ...model, key: Object.assign(new AssetKey("", ""), model.key) } : void 0;
         }
@@ -33810,7 +33810,7 @@ var MineRender = (() => {
           }
           switch (node.type.replace(/^minecraft:/, "")) {
             case "model":
-              if (typeof node.model === "string" && node.model) return { model: node.model };
+              if (typeof node.model === "string" && node.model) return { model: node.model, tints: node.tints };
               break;
             case "special": {
               if (!node.base || !node.model || typeof node.model !== "object") break;
@@ -80541,6 +80541,93 @@ ${shader.fragmentShader}`.replace(
     }
   });
 
+  // src/texture/Colormaps.ts
+  var Colormaps;
+  var init_Colormaps = __esm({
+    "src/texture/Colormaps.ts"() {
+      init_dirname();
+      init_buffer2();
+      init_process2();
+      init_AssetKey();
+      init_ModelTextures();
+      init_Caching();
+      init_MineRenderError();
+      Colormaps = class {
+        /** Samples the selected resource pack's grass colormap using Minecraft's climate coordinates. */
+        static async grassColor(origin, temperature = 0.5, downfall = 1) {
+          const key = AssetKey.parse("textures", "minecraft:colormap/grass", origin);
+          const temp = Math.fround(temperature);
+          const rain = Math.fround(downfall) * temp;
+          const x4 = Math.floor((1 - temp) * 255), y5 = Math.floor((1 - rain) * 255);
+          return await Caching.blockTintCache.get(`${key.serialize()}|${x4},${y5}`, async () => {
+            const image = await ModelTextures.get(key);
+            if (!image) throw new MineRenderError(`Missing grass colormap: ${key.toNamespacedString()}`);
+            if (image.width !== 256 || image.height !== 256) {
+              throw new MineRenderError("Grass colormaps must be 256 \xD7 256 pixels");
+            }
+            const [red, green, blue] = image.data.getImageData(x4, y5, 1, 1).data;
+            return red << 16 | green << 8 | blue;
+          });
+        }
+      };
+    }
+  });
+
+  // src/model/ItemTints.ts
+  var ItemTints;
+  var init_ItemTints = __esm({
+    "src/model/ItemTints.ts"() {
+      init_dirname();
+      init_buffer2();
+      init_process2();
+      init_MineRenderError();
+      init_Colormaps();
+      ItemTints = class {
+        /** Resolves preview colors from item definitions; explicit per-index colors take precedence. */
+        static async get(model, tints) {
+          const sources = model.tints;
+          if (!sources?.length) return tints;
+          const colors = { ...tints };
+          await Promise.all(sources.map(async (source, index) => {
+            if (colors[index] !== void 0) return;
+            switch (source.type) {
+              case "constant":
+              case "minecraft:constant":
+                colors[index] = this.rgb(source.value);
+                break;
+              case "grass":
+              case "minecraft:grass":
+                colors[index] = await Colormaps.grassColor(model.key, source.temperature, source.downfall);
+                break;
+              case "dye":
+              case "minecraft:dye":
+              case "potion":
+              case "minecraft:potion":
+              case "map_color":
+              case "minecraft:map_color":
+              case "firework":
+              case "minecraft:firework":
+              case "team":
+              case "minecraft:team":
+              case "custom_model_data":
+              case "minecraft:custom_model_data":
+                colors[index] = this.rgb(source.default);
+                break;
+              default:
+                throw new MineRenderError(`Unsupported item tint source ${source.type}`);
+            }
+          }));
+          return colors;
+        }
+        static rgb(color2) {
+          if (!Array.isArray(color2)) return color2 & 16777215;
+          const [red, green, blue] = color2.map((channel) => Math.floor(Math.fround(Math.fround(channel) * 255)));
+          return red << 16 | green << 8 | blue;
+        }
+      };
+    }
+  });
+
   // src/model/scene/ModelObject.ts
   function isModelObject(obj) {
     return obj.isModelObject;
@@ -80566,6 +80653,7 @@ ${shader.fragmentShader}`.replace(
       init_SpecialItems();
       init_EntityObject();
       init_GuiLight();
+      init_ItemTints();
       p10 = prefix("ModelObject");
       _ModelObject = class _ModelObject extends SceneObject {
         constructor(originalModel, options) {
@@ -80581,6 +80669,7 @@ ${shader.fragmentShader}`.replace(
           this.addEventListener("removed", () => this.updateAnimationSubscription());
         }
         async init() {
+          this.options.tints = await ItemTints.get(this.originalModel, this.options.tints);
           const special = this.originalModel.special;
           if (special) {
             const parts = await SpecialItems.getParts(special, this.originalModel.key?.root);
@@ -83855,6 +83944,7 @@ ${shader.fragmentShader}`.replace(
     CanvasImage: () => CanvasImage,
     Chunk: () => Chunk,
     ChunkData: () => ChunkData,
+    Colormaps: () => Colormaps,
     CubeFace: () => CubeFace,
     CubeFaceIndex: () => CubeFaceIndex,
     DEFAULT_ELEMENTS: () => DEFAULT_ELEMENTS,
@@ -83880,6 +83970,7 @@ ${shader.fragmentShader}`.replace(
     ImageLoader: () => ImageLoader,
     InstanceManager: () => InstanceManager,
     InstanceReference: () => InstanceReference,
+    ItemTints: () => ItemTints,
     MapControls: () => MapControls,
     Materials: () => Materials,
     Meshes: () => Meshes,
@@ -87614,6 +87705,7 @@ property list uchar int vertex_index
 
   // src/model/index.ts
   init_GuiLight();
+  init_ItemTints();
   init_Model();
   init_ModelCulling();
 
@@ -87744,10 +87836,7 @@ property list uchar int vertex_index
   init_dirname();
   init_buffer2();
   init_process2();
-  init_AssetKey();
-  init_ModelTextures();
-  init_Caching();
-  init_MineRenderError();
+  init_Colormaps();
 
   // src/model/block/blockTints.json
   var blockTints_default = {
@@ -87802,7 +87891,7 @@ property list uchar int vertex_index
           color2 = rule.color;
           break;
         case "grass":
-          color2 = await this.grassColor(key);
+          color2 = await Colormaps.grassColor(key);
           break;
         case "redstone": {
           const power = Number(state.power ?? 0) / 15;
@@ -87820,18 +87909,6 @@ property list uchar int vertex_index
       }
       return { ...Object.fromEntries([...indices].map((index) => [index, color2])), ...tints };
     }
-    static async grassColor(origin) {
-      const key = AssetKey.parse("textures", "minecraft:colormap/grass", origin);
-      return await Caching.blockTintCache.get(key.serialize(), async () => {
-        const image = await ModelTextures.get(key);
-        if (!image) throw new MineRenderError(`Missing grass colormap: ${key.toNamespacedString()}`);
-        if (image.width !== 256 || image.height !== 256) {
-          throw new MineRenderError("Grass colormaps must be 256 \xD7 256 pixels");
-        }
-        const [red, green, blue] = image.data.getImageData(127, 127, 1, 1).data;
-        return red << 16 | green << 8 | blue;
-      });
-    }
   };
 
   // src/model/block/scene/index.ts
@@ -91145,6 +91222,7 @@ property list uchar int vertex_index
 
   // src/renderer/MineRenderScene.ts
   init_EntityObject();
+  init_ItemTints();
   var _MineRenderScene = class _MineRenderScene extends Scene {
     constructor(options) {
       super();
@@ -91237,6 +91315,7 @@ property list uchar int vertex_index
       }
     }
     async addModel(model, options, parent = this) {
+      options = { ...options, tints: await ItemTints.get(model, options?.tints) };
       return this.addSceneObject(model, () => new ModelObject(model, options), options, parent);
     }
     async addBlock(blockState, options, parent = this) {
@@ -94298,6 +94377,7 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
   init_dirname();
   init_buffer2();
   init_process2();
+  init_Colormaps();
   init_TextureAtlas();
   init_TextureLoader();
   init_Textures();