@aura3d/animation 1.4.0 → 1.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aura3d/animation",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -12,6 +12,39 @@
     }
   },
   "dependencies": {
-    "@aura3d/math": "1.4.0"
-  }
+    "@aura3d/math": "1.4.1"
+  },
+  "description": "Deterministic animation clips, mixers, root motion, skeleton palettes, blend trees, state machines, and scene/ECS animation bridges for Aura3D.",
+  "keywords": [
+    "aura3d",
+    "3d",
+    "browser-3d",
+    "web-3d",
+    "typescript",
+    "animation",
+    "animation-engine",
+    "skeletal-animation",
+    "blend-trees",
+    "state-machine",
+    "root-motion",
+    "skinning",
+    "game-animation"
+  ],
+  "homepage": "https://aura3d.auraone.ai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/auraoneai/aura3d.git",
+    "directory": "packages/animation"
+  },
+  "bugs": {
+    "url": "https://github.com/auraoneai/aura3d/issues"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "README.md",
+    "dist"
+  ]
 }

package/src/AnimationAction.ts

@@ -1,166 +0,0 @@
-import type { AnimationClip } from "./AnimationClip.js";
-import { eventsBetween, type AnimationEvent } from "./AnimationEvents.js";
-
-export type LoopMode = "once" | "repeat" | "pingpong";
-
-export type AnimationActionSnapshot = {
-  readonly clipName: string;
-  readonly duration: number;
-  readonly time: number;
-  readonly weight: number;
-  readonly timeScale: number;
-  readonly playing: boolean;
-  readonly paused: boolean;
-  readonly loopMode: LoopMode;
-};
-
-export class AnimationAction {
-  readonly clip: AnimationClip;
-  time = 0;
-  weight = 1;
-  timeScale = 1;
-  loopMode: LoopMode = "repeat";
-  playing = false;
-  paused = false;
-  private pingPongForward = true;
-  private fadeDuration = 0;
-  private fadeElapsed = 0;
-  private fadeStartWeight = 1;
-  private fadeTargetWeight = 1;
-
-  constructor(clip: AnimationClip) {
-    this.clip = clip;
-  }
-
-  play(): this {
-    this.playing = true;
-    this.paused = false;
-    return this;
-  }
-
-  pause(): this {
-    this.paused = true;
-    return this;
-  }
-
-  stop(): this {
-    this.playing = false;
-    this.paused = false;
-    this.time = 0;
-    return this;
-  }
-
-  setWeight(weight: number): this {
-    if (!Number.isFinite(weight) || weight < 0) {
-      throw new Error("AnimationAction weight must be finite and non-negative.");
-    }
-    this.weight = weight;
-    return this;
-  }
-
-  setTimeScale(timeScale: number): this {
-    if (!Number.isFinite(timeScale) || timeScale < 0) {
-      throw new Error("AnimationAction timeScale must be finite and non-negative.");
-    }
-    this.timeScale = timeScale;
-    return this;
-  }
-
-  setLoop(loopMode: LoopMode): this {
-    this.loopMode = loopMode;
-    return this;
-  }
-
-  reset(): this {
-    this.time = 0;
-    this.pingPongForward = true;
-    return this;
-  }
-
-  seek(time: number): this {
-    if (!Number.isFinite(time) || time < 0) {
-      throw new Error("AnimationAction seek time must be finite and non-negative.");
-    }
-    this.time = this.clip.duration > 0 ? Math.min(time, this.clip.duration) : 0;
-    return this;
-  }
-
-  fadeTo(weight: number, duration: number): this {
-    if (!Number.isFinite(duration) || duration < 0 || !Number.isFinite(weight) || weight < 0) {
-      throw new Error("AnimationAction fade target and duration must be valid.");
-    }
-    this.fadeStartWeight = this.weight;
-    this.fadeTargetWeight = weight;
-    this.fadeDuration = duration;
-    this.fadeElapsed = 0;
-    if (duration === 0) {
-      this.weight = weight;
-    }
-    return this;
-  }
-
-  update(delta: number): readonly AnimationEvent[] {
-    if (!Number.isFinite(delta) || delta < 0) {
-      throw new Error("AnimationAction delta must be finite and non-negative.");
-    }
-    if (this.fadeDuration > 0) {
-      this.fadeElapsed = Math.min(this.fadeDuration, this.fadeElapsed + delta);
-      const t = this.fadeElapsed / this.fadeDuration;
-      this.weight = this.fadeStartWeight + (this.fadeTargetWeight - this.fadeStartWeight) * t;
-      if (this.fadeElapsed === this.fadeDuration) {
-        this.fadeDuration = 0;
-      }
-    }
-    if (!this.playing || this.paused || this.clip.duration === 0) {
-      return [];
-    }
-    const previous = this.time;
-    const scaledDelta = delta * this.timeScale;
-    let next = previous + scaledDelta;
-    let looped = false;
-    if (this.loopMode === "repeat") {
-      while (next > this.clip.duration) {
-        next -= this.clip.duration;
-        looped = true;
-      }
-    } else if (this.loopMode === "once") {
-      next = Math.min(next, this.clip.duration);
-      if (next === this.clip.duration) {
-        this.playing = false;
-      }
-    } else {
-      if (this.pingPongForward) {
-        while (next > this.clip.duration) {
-          next = this.clip.duration - (next - this.clip.duration);
-          this.pingPongForward = false;
-          looped = true;
-        }
-      } else {
-        next = previous - scaledDelta;
-        while (next < 0) {
-          next = -next;
-          this.pingPongForward = true;
-          looped = true;
-        }
-      }
-    }
-    this.time = next;
-    if (this.clip.events.length === 0) {
-      return [];
-    }
-    return eventsBetween(this.clip.events, this.clip.name, previous, next, this.clip.duration, looped);
-  }
-
-  snapshot(): AnimationActionSnapshot {
-    return {
-      clipName: this.clip.name,
-      duration: this.clip.duration,
-      time: this.time,
-      weight: this.weight,
-      timeScale: this.timeScale,
-      playing: this.playing,
-      paused: this.paused,
-      loopMode: this.loopMode
-    };
-  }
-}

package/src/AnimationClip.ts

@@ -1,63 +0,0 @@
-import type { AnimationEventMarker } from "./AnimationEvents.js";
-import { AnimationTrack, type SerializedAnimationTrack } from "./AnimationTrack.js";
-
-export type AnimationClipDescriptor = {
-  readonly name: string;
-  readonly duration?: number;
-  readonly tracks: readonly AnimationTrack[];
-  readonly events?: readonly AnimationEventMarker[];
-};
-
-export type SerializedAnimationClip = {
-  readonly name: string;
-  readonly duration: number;
-  readonly tracks: readonly SerializedAnimationTrack[];
-  readonly events: readonly AnimationEventMarker[];
-};
-
-export class AnimationClip {
-  readonly name: string;
-  readonly tracks: readonly AnimationTrack[];
-  readonly events: readonly AnimationEventMarker[];
-  readonly duration: number;
-
-  constructor(descriptor: AnimationClipDescriptor) {
-    if (descriptor.name.trim().length === 0) {
-      throw new Error("AnimationClip name cannot be empty.");
-    }
-    this.name = descriptor.name;
-    this.tracks = [...descriptor.tracks];
-    this.events = [...(descriptor.events ?? [])].sort((a, b) => a.time - b.time || a.name.localeCompare(b.name));
-    const trackDuration = this.tracks.reduce((duration, track) => Math.max(duration, track.duration), 0);
-    this.duration = descriptor.duration ?? trackDuration;
-    if (!Number.isFinite(this.duration) || this.duration < 0) {
-      throw new Error("AnimationClip duration must be finite and non-negative.");
-    }
-    if (this.duration < trackDuration) {
-      throw new Error("AnimationClip duration cannot be shorter than its tracks.");
-    }
-    for (const event of this.events) {
-      if (!Number.isFinite(event.time) || event.time < 0 || event.time > this.duration) {
-        throw new Error(`Animation event ${event.name} is outside clip duration.`);
-      }
-    }
-  }
-
-  toJSON(): SerializedAnimationClip {
-    return {
-      name: this.name,
-      duration: this.duration,
-      tracks: this.tracks.map((track) => track.toJSON()),
-      events: this.events.map((event) => ({ ...event }))
-    };
-  }
-
-  static fromJSON(serialized: SerializedAnimationClip): AnimationClip {
-    return new AnimationClip({
-      name: serialized.name,
-      duration: serialized.duration,
-      tracks: serialized.tracks.map((track) => AnimationTrack.fromJSON(track)),
-      events: serialized.events
-    });
-  }
-}