minerender 2.1.0-alpha.60 → 2.1.0-alpha.62

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;
@@ -78923,11 +78923,11 @@ ${key}` : key;
           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.
+         * Native and sampled vanilla clips by name, or undefined when the model or 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 key = new AssetKey(modelKey.namespace, path, void 0, void 0, "entity-models/animations", ".json", isAssetKey(modelKey) ? modelKey.root : void 0);
           const file = await Caching.entityAnimationCache.get(key.serialize(), () => AssetLoader.get(key, "json" /* JSON */));
           return file?.animations;
         }
@@ -78977,7 +78977,7 @@ ${key}` : key;
     let low = 0, high = keyframes.length;
     while (low < high) {
       const middle = low + high >>> 1;
-      if (time <= keyframes[middle].time) high = middle;
+      if (time < keyframes[middle].time) high = middle;
       else low = middle + 1;
     }
     const a4 = Math.max(0, low - 1);
@@ -79025,6 +79025,7 @@ ${key}` : key;
       init_dirname();
       init_buffer2();
       init_process2();
+      init_three_module();
       init_EntityAnimation();
       ZERO = [0, 0, 0];
       EntityAnimationPlayer = class {
@@ -79041,25 +79042,45 @@ ${key}` : key;
           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.
+         * Starts an animation on matching named parts. Supplied baked poses are the baseline for offsets;
+         * without them, the current pose is used. Stopping restores the pose from before playback.
          */
-        play(layers, animation, options = {}) {
+        play(layers, animation, options = {}, poses) {
           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() });
+            const objects = [];
+            if (poses) {
+              layer.traverse((object) => {
+                if (poses.has(object)) objects.push(object);
+              });
+            } else {
+              for (const bone of Object.keys(animation.bones)) {
+                const object = layer.getObjectByName(`group:${bone}`);
+                if (object) objects.push(object);
+              }
+            }
+            for (const object of objects) {
+              const bone = object.name.slice("group:".length);
+              const pose = poses?.get(object);
+              this.parts.push({
+                bone,
+                object,
+                position: object.position.clone(),
+                rotation: object.rotation.clone(),
+                scale: object.scale.clone(),
+                basePosition: pose ? new Vector3(...pose.offset) : object.position.clone(),
+                baseRotation: pose ? new Euler(...pose.rotation, "ZYX") : object.rotation.clone(),
+                baseScale: pose ? new Vector3(...pose.scale ?? [1, 1, 1]) : object.scale.clone()
+              });
             }
           }
           this.apply();
         }
-        /** Restores the default poses. Returns whether an animation was active. */
+        /** Restores the poses from before playback. Returns whether an animation was active. */
         stop() {
           if (!this._animation) return false;
           for (const part of this.parts) {
@@ -79088,10 +79109,10 @@ ${key}` : key;
         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]);
+            const { position = ZERO, rotation = ZERO, scale = ZERO } = pose[part.bone] ?? {};
+            part.object.position.set(part.basePosition.x + position[0], part.basePosition.y + position[1], part.basePosition.z + position[2]);
+            part.object.rotation.set(part.baseRotation.x + rotation[0], part.baseRotation.y + rotation[1], part.baseRotation.z + rotation[2], part.baseRotation.order);
+            part.object.scale.set(part.baseScale.x + scale[0], part.baseScale.y + scale[1], part.baseScale.z + scale[2]);
           }
         }
       };
@@ -79634,7 +79655,8 @@ ${key}` : key;
           this.scrollMaterials = [];
           /** Entity age in ticks, as vanilla's `ageInTicks`; drives the scrolling render modes. */
           this.age = 0;
-          this.animationPlayer = new EntityAnimationPlayer();
+          this.animationPlayers = [];
+          this.partPoses = /* @__PURE__ */ new Map();
           this.options = (0, import_ts_deepmerge4.default)({}, _EntityObject.DEFAULT_OPTIONS, options ?? {});
           this.addEventListener("added", () => this.updateScrollSubscription());
           this.addEventListener("removed", () => this.updateScrollSubscription());
@@ -79651,7 +79673,8 @@ ${key}` : key;
           for (const geometry of this.geometries) geometry.dispose();
           this.geometries.clear();
           for (const dispose of this.disposeWireframes.splice(0)) dispose();
-          this.animationPlayer.clear();
+          for (const player of this.animationPlayers.splice(0)) player.clear();
+          this.partPoses.clear();
           super.disposeAndRemoveAllChildren();
         }
         clearScrollMaterials() {
@@ -79683,36 +79706,61 @@ ${key}` : key;
           this.notifyDirty();
         }
         //<editor-fold desc="ANIMATION">
-        /** The animation started by {@link playAnimation}, until {@link stopAnimation} or disposal. */
+        /** The first active clip, until playback is stopped or the object is disposed. */
         get animation() {
-          return this.animationPlayer.animation;
+          return this.animationPlayers[0]?.animation;
+        }
+        /** Clips playing together, each targeting a separate geometry layer. */
+        get activeAnimations() {
+          return this.animationPlayers.map((player) => player.animation);
         }
         /** Seconds since the animation started, before looping. */
         get animationTime() {
-          return this.animationPlayer.time;
+          return this.animationPlayers[0]?.time ?? 0;
         }
         /**
-         * 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.
+         * Plays a clip from {@link Entities.getAnimations}, replacing all active clips.
+         * Offsets apply to the baked pose in the clip's layer (`main` by default), including repeated draws of that layer.
          * The object owns no clock: call {@link advanceAnimation} per frame, or {@link setAnimationTime}.
          */
         playAnimation(animation, options) {
+          this.playAnimations([animation], options);
+        }
+        /** Plays one clip per selected geometry layer, with a shared clock and no blending between clips. */
+        playAnimations(animations, options) {
+          const targets = /* @__PURE__ */ new Set();
+          const selections = animations.map((animation) => {
+            const layer = animation.layer ?? "main";
+            if (targets.has(layer)) throw new Error(`Multiple animations target layer "${layer}"`);
+            targets.add(layer);
+            const names = Object.keys(this.entityLayers).filter((name2) => name2.split("#")[0] === layer);
+            if (!names.length) throw new Error(`Entity ${this.entity.id} has no selected animation layer "${layer}"`);
+            return { animation, names };
+          });
           this.createMeshes();
-          const layers = Object.keys(this.entityLayers).map((name2) => this.getLayerGroup(name2)).filter((layer) => !!layer);
-          this.animationPlayer.play(layers, animation, options);
+          this.stopAnimation();
+          for (const { animation, names } of selections) {
+            const player = new EntityAnimationPlayer();
+            player.play(names.map((name2) => this.getLayerGroup(name2)), animation, options, this.partPoses);
+            this.animationPlayers.push(player);
+          }
           this.notifyDirty();
         }
-        /** Stops the animation and restores the default pose. */
+        /** Stops all clips and restores the poses from before playback. */
         stopAnimation() {
-          if (this.animationPlayer.stop()) this.notifyDirty();
+          const players = this.animationPlayers.splice(0);
+          for (const player of players) player.stop();
+          if (players.length) 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();
+          for (const player of this.animationPlayers) player.setTime(seconds);
+          if (this.animationPlayers.length) 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();
+          for (const player of this.animationPlayers) player.advance(deltaSeconds);
+          if (this.animationPlayers.length) this.notifyDirty();
         }
         //</editor-fold>
         getLayerGroup(name2) {
@@ -79772,6 +79820,7 @@ ${key}` : key;
           anchor.position.fromArray(part.pose.offset);
           anchor.rotation.set(...part.pose.rotation, "ZYX");
           anchor.scale.fromArray(part.pose.scale ?? [1, 1, 1]);
+          this.partPoses.set(anchor, part.pose);
           parent.add(anchor);
           const size = part.texture ?? textureSize;
           for (const cube of part.cubes) {
@@ -80541,6 +80590,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 +80702,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 +80718,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 +83993,7 @@ ${shader.fragmentShader}`.replace(
     CanvasImage: () => CanvasImage,
     Chunk: () => Chunk,
     ChunkData: () => ChunkData,
+    Colormaps: () => Colormaps,
     CubeFace: () => CubeFace,
     CubeFaceIndex: () => CubeFaceIndex,
     DEFAULT_ELEMENTS: () => DEFAULT_ELEMENTS,
@@ -83880,6 +84019,7 @@ ${shader.fragmentShader}`.replace(
     ImageLoader: () => ImageLoader,
     InstanceManager: () => InstanceManager,
     InstanceReference: () => InstanceReference,
+    ItemTints: () => ItemTints,
     MapControls: () => MapControls,
     Materials: () => Materials,
     Meshes: () => Meshes,
@@ -87614,6 +87754,7 @@ property list uchar int vertex_index
 
   // src/model/index.ts
   init_GuiLight();
+  init_ItemTints();
   init_Model();
   init_ModelCulling();
 
@@ -87744,10 +87885,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 +87940,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 +87958,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 +91271,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 +91364,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 +94426,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();