minerender 2.1.0-alpha.61 → 2.1.0-alpha.62

package/dist/bundle.js

@@ -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) {