minerender 2.1.0-alpha.130 → 2.1.0-alpha.132

package/dist/bundle.js

@@ -38432,13 +38432,13 @@ ${key}` : key, async () => {
         break;
     }
     if (rotation.rescale) {
-      if (Math.abs(rotation.angle) === 22.5) {
-        const s4 = 1 / Math.cos(0.39269909262657166);
-        geometry.scale(s4, 1, s4);
-      } else {
-        const s4 = 1 / Math.cos(0.7853981852531433);
-        geometry.scale(s4, 1, s4);
-      }
+      const angle = toRadians(rotation.angle);
+      const s4 = 1 / Math.max(Math.abs(Math.cos(angle)), Math.abs(Math.sin(angle)));
+      geometry.scale(
+        rotation.axis === "x" /* X */ ? 1 : s4,
+        rotation.axis === "y" /* Y */ ? 1 : s4,
+        rotation.axis === "z" /* Z */ ? 1 : s4
+      );
     }
     geometry.translate(origin.x, origin.y, origin.z);
   }
@@ -84835,6 +84835,13 @@ ${key}` : key;
   });
 
   // src/entity/scene/EntityAnimationPlayer.ts
+  function validateAnimationWeights(weights, count) {
+    const values = Array.from(weights);
+    if (values.length !== count || values.some((weight) => !Number.isFinite(weight) || weight < 0)) {
+      throw new Error("Animation weights must match the clip count and contain only finite nonnegative numbers");
+    }
+    return values;
+  }
   var ZERO, EntityAnimationPlayer;
   var init_EntityAnimationPlayer = __esm({
     "src/entity/scene/EntityAnimationPlayer.ts"() {
@@ -84847,12 +84854,20 @@ ${key}` : key;
       EntityAnimationPlayer = class {
         constructor() {
           this.parts = [];
+          this._animations = [];
+          this._weights = [];
+          this.loops = [];
           this._time = 0;
-          this.loop = false;
           this.speed = 1;
         }
         get animation() {
-          return this._animation;
+          return this._animations[0];
+        }
+        get animations() {
+          return this._animations.slice();
+        }
+        get weights() {
+          return this._weights.slice();
         }
         get time() {
           return this._time;
@@ -84862,10 +84877,20 @@ ${key}` : key;
          * without them, the current pose is used. Stopping restores the pose from before playback.
          */
         play(layers, animation, options = {}, poses) {
+          this.playAnimations(layers, [animation], options, poses);
+        }
+        /**
+         * Starts clips on matching parts with a shared clock. Weighted offsets add to the supplied baked poses
+         * or, without poses, to each animated part's pose when playback starts.
+         */
+        playAnimations(layers, animations, options = {}, poses) {
+          const weights = validateAnimationWeights(options.weights ?? animations.map(() => 1), animations.length);
           this.stop();
-          this._animation = animation;
+          this._animations = animations.slice();
+          this._weights = weights;
+          if (!animations.length) return;
           this._time = options.time ?? 0;
-          this.loop = options.loop ?? animation.loop;
+          this.loops = animations.map((animation) => options.loop ?? animation.loop);
           this.speed = options.speed ?? 1;
           for (const layer of layers) {
             const objects = [];
@@ -84874,7 +84899,8 @@ ${key}` : key;
                 if (poses.has(object4)) objects.push(object4);
               });
             } else {
-              for (const bone of Object.keys(animation.bones)) {
+              const bones = new Set(animations.flatMap((animation) => Object.keys(animation.bones)));
+              for (const bone of bones) {
                 const object4 = layer.getObjectByName(`group:${bone}`);
                 if (object4) objects.push(object4);
               }
@@ -84898,7 +84924,7 @@ ${key}` : key;
         }
         /** Restores the poses from before playback. Returns whether an animation was active. */
         stop() {
-          if (!this._animation) return false;
+          if (!this._animations.length) return false;
           for (const part of this.parts) {
             part.object.position.copy(part.position);
             part.object.rotation.copy(part.rotation);
@@ -84910,12 +84936,14 @@ ${key}` : key;
         /** Forgets the animation without touching the parts, for parts that no longer exist. */
         clear() {
           this.parts = [];
-          this._animation = void 0;
+          this._animations = [];
+          this._weights = [];
+          this.loops = [];
           this._time = 0;
         }
         /** Applies the pose at an absolute playback time. Returns `false` when no clip is active. */
         setTime(seconds) {
-          if (!this._animation) return false;
+          if (!this._animations.length) return false;
           this._time = seconds;
           this.apply();
           return true;
@@ -84924,8 +84952,30 @@ ${key}` : key;
         advance(deltaSeconds) {
           return this.setTime(this._time + deltaSeconds * this.speed);
         }
+        /** Changes weights in clip order and reapplies the current time without restarting playback. */
+        setWeights(weights) {
+          if (!this._animations.length) return false;
+          const validated = validateAnimationWeights(weights, this._animations.length);
+          this._weights = validated;
+          this.apply();
+          return true;
+        }
         apply() {
-          const pose = sampleEntityAnimation(this._animation, this._time, this.loop);
+          const pose = /* @__PURE__ */ Object.create(null);
+          for (let i4 = 0; i4 < this._animations.length; i4++) {
+            const weight = this._weights[i4];
+            if (weight === 0) continue;
+            const sampled = sampleEntityAnimation(this._animations[i4], this._time, this.loops[i4]);
+            for (const [bone, channels] of Object.entries(sampled)) {
+              const blended = pose[bone] ?? (pose[bone] = {});
+              for (const channel of ENTITY_ANIMATION_CHANNELS) {
+                const value = channels[channel];
+                if (!value) continue;
+                const target = blended[channel] ?? (blended[channel] = [0, 0, 0]);
+                for (let axis = 0; axis < 3; axis++) target[axis] += value[axis] * weight;
+              }
+            }
+          }
           for (const part of this.parts) {
             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]);
@@ -85554,7 +85604,7 @@ ${key}` : key;
           for (const geometry of this.geometries) geometry.dispose();
           this.geometries.clear();
           for (const dispose of this.disposeWireframes.splice(0)) dispose();
-          for (const player of this.animationPlayers.splice(0)) player.clear();
+          for (const { player } of this.animationPlayers.splice(0)) player.clear();
           this.partPoses.clear();
           super.disposeAndRemoveAllChildren();
         }
@@ -85589,15 +85639,31 @@ ${key}` : key;
         //<editor-fold desc="ANIMATION">
         /** The first active clip, until playback is stopped or the object is disposed. */
         get animation() {
-          return this.animationPlayers[0]?.animation;
+          return this.animationPlayers[0]?.player.animation;
         }
-        /** Clips playing together, each targeting a separate geometry layer. */
+        /** Clips playing together, in the order passed to {@link playAnimations}. */
         get activeAnimations() {
-          return this.animationPlayers.map((player) => player.animation);
+          const animations = [];
+          for (const { player, indices } of this.animationPlayers) {
+            player.animations.forEach((animation, i4) => {
+              animations[indices[i4]] = animation;
+            });
+          }
+          return animations;
+        }
+        /** Weights of the active clips, in the same order as {@link activeAnimations}. */
+        get animationWeights() {
+          const weights = [];
+          for (const { player, indices } of this.animationPlayers) {
+            player.weights.forEach((weight, i4) => {
+              weights[indices[i4]] = weight;
+            });
+          }
+          return weights;
         }
         /** Seconds since the animation started, before looping. */
         get animationTime() {
-          return this.animationPlayers[0]?.time ?? 0;
+          return this.animationPlayers[0]?.player.time ?? 0;
         }
         /**
          * Plays a clip from {@link Entities.getAnimations}, replacing all active clips.
@@ -85608,42 +85674,59 @@ ${key}` : key;
         playAnimation(animation, options) {
           this.playAnimations([animation], options);
         }
-        /** Plays clips with a shared clock and no blending. Selected layers without their own clip follow `main`. */
+        /**
+         * Plays clips with a shared clock, adding their weighted offsets within each geometry layer.
+         * Weights default to 1 and are not normalized. Selected layers without their own clip follow `main`.
+         */
         playAnimations(animations, options) {
-          const targets = /* @__PURE__ */ new Set();
-          const selections = animations.map((animation) => {
+          const weights = validateAnimationWeights(options?.weights ?? animations.map(() => 1), animations.length);
+          const selections = /* @__PURE__ */ new Map();
+          animations.forEach((animation, index) => {
             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 };
+            let selection = selections.get(layer);
+            if (!selection) selections.set(layer, selection = { animations: [], names, indices: [] });
+            selection.animations.push(animation);
+            selection.indices.push(index);
           });
-          const main = selections.find(({ animation }) => (animation.layer ?? "main") === "main");
-          if (main) main.names.push(...Object.keys(this.entityLayers).filter((name2) => !targets.has(name2.split("#")[0])));
+          const main = selections.get("main");
+          if (main) main.names.push(...Object.keys(this.entityLayers).filter((name2) => !selections.has(name2.split("#")[0])));
           this.createMeshes();
           this.stopAnimation();
-          for (const { animation, names } of selections) {
+          for (const { animations: clips, names, indices } of selections.values()) {
             const player = new EntityAnimationPlayer();
-            player.play(names.map((name2) => this.getLayerGroup(name2)), animation, options, this.partPoses);
-            this.animationPlayers.push(player);
+            player.playAnimations(
+              names.map((name2) => this.getLayerGroup(name2)),
+              clips,
+              { ...options, weights: indices.map((index) => weights[index]) },
+              this.partPoses
+            );
+            this.animationPlayers.push({ player, indices });
           }
           this.notifyDirty();
         }
+        /** Changes weights in active clip order, notifying the scene without restarting the shared clock. Has no effect without an animation. */
+        setAnimationWeights(weights) {
+          if (!this.animationPlayers.length) return;
+          const values = validateAnimationWeights(weights, this.activeAnimations.length);
+          for (const { player, indices } of this.animationPlayers) player.setWeights(indices.map((index) => values[index]));
+          this.notifyDirty();
+        }
         /** Stops all clips and restores the poses from before playback. */
         stopAnimation() {
           const players = this.animationPlayers.splice(0);
-          for (const player of players) player.stop();
+          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) {
-          for (const player of this.animationPlayers) player.setTime(seconds);
+          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) {
-          for (const player of this.animationPlayers) player.advance(deltaSeconds);
+          for (const { player } of this.animationPlayers) player.advance(deltaSeconds);
           if (this.animationPlayers.length) this.notifyDirty();
         }
         //</editor-fold>
@@ -94105,6 +94188,7 @@ ${shader.fragmentShader}`.replace(
     toRadians: () => toRadians,
     toTrianglesDrawMode: () => toTrianglesDrawMode,
     trimCanvas: () => trimCanvas,
+    validateAnimationWeights: () => validateAnimationWeights,
     yieldToEventLoop: () => yieldToEventLoop
   });
   init_dirname();