@zephyr3d/editor 0.3.5 → 0.3.7

package/dist/vendor/zephyr3d/scene/dist/animation/animation.js

@@ -24,6 +24,8 @@ import { Disposable } from '@zephyr3d/base';
     /** @internal */ _tracks;
     _weight;
     /** @internal */ _skeletons;
+    /** @internal */ _frameRate;
+    /** @internal */ _markers;
     /**
    * Creates an animation instance
    * @param name - Name of the animation
@@ -38,6 +40,8 @@ import { Disposable } from '@zephyr3d/base';
         this._weight = 1;
         this._autoPlay = false;
         this._skeletons = new Set();
+        this._frameRate = 30;
+        this._markers = [];
     }
     /**
    * Whether this clip is embedded (owned inline by its container/resource).
@@ -88,6 +92,21 @@ import { Disposable } from '@zephyr3d/base';
         this._skeletons = val;
     }
     /**
+   * Default frame rate used to convert frame-based marker references.
+   */ get frameRate() {
+        return this._frameRate;
+    }
+    set frameRate(val) {
+        if (Number.isFinite(val) && val > 0) {
+            this._frameRate = val;
+        }
+    }
+    /**
+   * Timeline markers stored on this clip.
+   */ get markers() {
+        return this._markers;
+    }
+    /**
    * Total time span of the clip in seconds.
    *
    * Automatically extended when adding tracks with longer duration.
@@ -98,6 +117,74 @@ import { Disposable } from '@zephyr3d/base';
         this._duration = val;
     }
     /**
+   * Add a serializable marker to this clip.
+   *
+   * @param marker - Marker metadata. If `id` is omitted, `name` is used as the id.
+   * @returns The normalized marker.
+   */ addMarker(marker) {
+        if (!marker?.name) {
+            console.error('Animation marker must have a name');
+            return null;
+        }
+        const normalized = {
+            ...marker,
+            id: marker.id || marker.name
+        };
+        if (this.resolveMarkerTime(normalized) === null) {
+            console.error('Animation marker must have either time or frame');
+            return null;
+        }
+        this._markers.push(normalized);
+        this._markers.sort((a, b)=>(this.resolveMarkerTime(a) ?? 0) - (this.resolveMarkerTime(b) ?? 0));
+        return normalized;
+    }
+    /**
+   * Remove markers matching the marker id or name.
+   */ removeMarker(idOrName) {
+        const oldLength = this._markers.length;
+        this._markers = this._markers.filter((marker)=>marker.id !== idOrName && marker.name !== idOrName);
+        return this._markers.length !== oldLength;
+    }
+    /**
+   * Get the first marker matching the marker id or name.
+   */ getMarker(idOrName) {
+        return this._markers.find((marker)=>marker.id === idOrName || marker.name === idOrName) ?? null;
+    }
+    /**
+   * Resolve a marker to seconds on this clip's timeline.
+   */ resolveMarkerTime(marker) {
+        if (typeof marker.time === 'number' && Number.isFinite(marker.time)) {
+            return marker.time;
+        }
+        if (typeof marker.frame === 'number' && Number.isFinite(marker.frame)) {
+            const fps = marker.fps ?? this._frameRate;
+            return fps > 0 ? marker.frame / fps : null;
+        }
+        return null;
+    }
+    /**
+   * Resolve a time reference to seconds on this clip's timeline.
+   */ resolveTimeRef(ref) {
+        if (ref === null || ref === undefined) {
+            return null;
+        }
+        if (typeof ref === 'number') {
+            return Number.isFinite(ref) ? ref : null;
+        }
+        if ('time' in ref) {
+            return Number.isFinite(ref.time) ? ref.time : null;
+        }
+        if ('frame' in ref) {
+            const fps = ref.fps ?? this._frameRate;
+            return Number.isFinite(ref.frame) && fps > 0 ? ref.frame / fps : null;
+        }
+        if ('marker' in ref) {
+            const marker = this.getMarker(ref.marker);
+            return marker ? this.resolveMarkerTime(marker) : null;
+        }
+        return null;
+    }
+    /**
    * Add a skeleton used by this clip.
    *
    * @param skeletonId - Persistent ID of Skeleton to register for this clip.

package/dist/vendor/zephyr3d/scene/dist/animation/animation.js.map

@@ -1 +1 @@
-{"version":3,"file":"animation.js","sources":["../../src/animation/animation.ts"],"sourcesContent":["import { Disposable } from '@zephyr3d/base';\r\nimport type { AnimationSet } from './animationset';\r\nimport type { AnimationTrack } from './animationtrack';\r\n\r\n/**\r\n * Animation clip\r\n *\r\n * Represents a named animation composed of multiple tracks targeting various objects/properties,\r\n * with an overall duration, weight, and optional auto-play behavior. Tracks may target different\r\n * objects and are grouped by a per-target array. Skeletons used by this clip are tracked for\r\n * lifecycle and application during playback.\r\n *\r\n * Typical workflow:\r\n * - Create a clip via `AnimationSet.createAnimation(name)`.\r\n * - Add one or more `AnimationTrack`s via `addTrack(target, track)`.\r\n * - Optionally register skeletons via `addSkeleton(...)`.\r\n * - Start playback through the owning `AnimationSet.playAnimation(name, options)`.\r\n *\r\n * @public\r\n */\r\nexport class AnimationClip extends Disposable {\r\n  /** @internal */\r\n  protected _name: string;\r\n  /** @internal */\r\n  protected _animationSet: AnimationSet;\r\n  /** @internal */\r\n  protected _embedded: boolean;\r\n  /** @internal */\r\n  protected _duration: number;\r\n  /** @internal */\r\n  protected _autoPlay: boolean;\r\n  /** @internal */\r\n  protected _tracks: Map<object, AnimationTrack[]>;\r\n  protected _weight: number;\r\n  /** @internal */\r\n  protected _skeletons: Set<string>;\r\n  /**\r\n   * Creates an animation instance\r\n   * @param name - Name of the animation\r\n   * @param model - Parent node if this is a skeleton animation\r\n   */\r\n  constructor(name: string, animationSet: AnimationSet, embedded = false) {\r\n    super();\r\n    this._name = name;\r\n    this._animationSet = animationSet;\r\n    this._embedded = embedded;\r\n    this._tracks = new Map();\r\n    this._duration = 0;\r\n    this._weight = 1;\r\n    this._autoPlay = false;\r\n    this._skeletons = new Set();\r\n  }\r\n  /**\r\n   * Whether this clip is embedded (owned inline by its container/resource).\r\n   */\r\n  get embedded() {\r\n    return this._embedded;\r\n  }\r\n  /**\r\n   * The `AnimationSet` that owns this clip.\r\n   */\r\n  get animationSet() {\r\n    return this._animationSet;\r\n  }\r\n  /**\r\n   * Global blend weight for the clip.\r\n   *\r\n   * Used by the animation system when combining multiple active clips.\r\n   */\r\n  get weight() {\r\n    return this._weight;\r\n  }\r\n  set weight(val: number) {\r\n    this._weight = val;\r\n  }\r\n  /**\r\n   * Whether this clip should start playing automatically when loaded/instantiated.\r\n   */\r\n  get autoPlay() {\r\n    return this._autoPlay;\r\n  }\r\n  set autoPlay(val: boolean) {\r\n    this._autoPlay = val;\r\n  }\r\n  /**\r\n   * The unique name of this clip.\r\n   */\r\n  get name() {\r\n    return this._name;\r\n  }\r\n  /**\r\n   * All animation tracks grouped by target object.\r\n   *\r\n   * Key: target object; Value: list of `AnimationTrack`s affecting that target.\r\n   */\r\n  get tracks() {\r\n    return this._tracks;\r\n  }\r\n  /**\r\n   * All skeletons referenced by this clip.\r\n   */\r\n  get skeletons() {\r\n    return this._skeletons;\r\n  }\r\n  set skeletons(val: Set<string>) {\r\n    this._skeletons = val;\r\n  }\r\n  /**\r\n   * Total time span of the clip in seconds.\r\n   *\r\n   * Automatically extended when adding tracks with longer duration.\r\n   */\r\n  get timeDuration() {\r\n    return this._duration;\r\n  }\r\n  set timeDuration(val) {\r\n    this._duration = val;\r\n  }\r\n  /**\r\n   * Add a skeleton used by this clip.\r\n   *\r\n   * @param skeletonId - Persistent ID of Skeleton to register for this clip.\r\n   */\r\n  addSkeleton(skeletonId: string) {\r\n    this._skeletons.add(skeletonId);\r\n  }\r\n  /**\r\n   * Remove a specific track from this clip.\r\n   *\r\n   * Errors if the track does not belong to this clip. Does nothing if not found.\r\n   *\r\n   * @param track - The track instance to remove.\r\n   * @returns This clip (for chaining).\r\n   */\r\n  deleteTrack(track: AnimationTrack) {\r\n    if (track?.animation !== this) {\r\n      console.error('Cannot delete animation track which is not belongs to THIS animation');\r\n    }\r\n    for (const k of this._tracks.keys()) {\r\n      const tracks = this._tracks.get(k)!;\r\n      const index = tracks.indexOf(track);\r\n      if (index >= 0) {\r\n        tracks.splice(index, 1);\r\n      }\r\n    }\r\n    return this;\r\n  }\r\n  /**\r\n   * Add a track to this clip for a specific target object.\r\n   *\r\n   * Constraints:\r\n   * - The track must not already belong to another clip.\r\n   * - Only one track with the same blendId may exist per target in a single clip.\r\n   *\r\n   * Side effects:\r\n   * - Assigns this clip to `track.animation`.\r\n   * - Extends `timeDuration` to cover the track duration if longer.\r\n   * - Calls `track.reset(target)` to initialize the target state if needed.\r\n   *\r\n   * @param target - Target object controlled by the track.\r\n   * @param track - Track to add.\r\n   * @returns This clip (for chaining).\r\n   */\r\n  addTrack(target: object, track: AnimationTrack) {\r\n    if (!track) {\r\n      return this;\r\n    }\r\n    if (track.animation) {\r\n      if (track.animation === this) {\r\n        return this;\r\n      } else {\r\n        console.error('Track is already in another animation');\r\n        return this;\r\n      }\r\n    }\r\n    const blendId = track.getBlendId();\r\n    const tracks = this._tracks.get(target);\r\n    if (tracks && tracks.findIndex((track) => track.getBlendId() === blendId) >= 0) {\r\n      console.error('Tracks with same BlendId could not be added to same animation');\r\n      return this;\r\n    }\r\n    track.animation = this;\r\n    let trackInfo = this._tracks.get(target);\r\n    if (!trackInfo) {\r\n      trackInfo = [];\r\n      this._tracks.set(target, trackInfo);\r\n    }\r\n    trackInfo.push(track);\r\n    this._duration = Math.max(this._duration, track.getDuration() ?? 0);\r\n    track.reset(target);\r\n    return this;\r\n  }\r\n  /*\r\n  resample(frames: number, callback: (frame: number) => void) {\r\n    for (let frame = 0; frame <= frames; frame++) {\r\n      const t = frame / this.timeDuration;\r\n      for (const [k, v] of this.tracks) {\r\n        for (const track of v) {\r\n          const state = track.calculateState(k, t);\r\n          track.applyState(k, state);\r\n        }\r\n      }\r\n      for (const sk of this.skeletons) {\r\n        const skeleton = this._animationSet.model.findSkeletonById(sk);\r\n        if (skeleton) {\r\n          skeleton.computeJoints();\r\n        }\r\n      }\r\n      callback(frame);\r\n    }\r\n  }\r\n  */\r\n}\r\n"],"names":["AnimationClip","Disposable","_weight","name","animationSet","embedded","_name","_animationSet","_embedded","_tracks","Map","_duration","_autoPlay","_skeletons","Set","weight","val","autoPlay","tracks","skeletons","timeDuration","addSkeleton","skeletonId","add","deleteTrack","track","animation","console","error","k","keys","get","index","indexOf","splice","addTrack","target","blendId","getBlendId","findIndex","trackInfo","set","push","Math","max","getDuration","reset"],"mappings":"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"}
+{"version":3,"file":"animation.js","sources":["../../src/animation/animation.ts"],"sourcesContent":["import { Disposable } from '@zephyr3d/base';\r\nimport type { AnimationSet } from './animationset';\r\nimport type { AnimationTrack } from './animationtrack';\r\n\r\n/**\r\n * A serializable reference to a point on an animation clip timeline.\r\n * @public\r\n */\r\nexport type AnimationTimeRef =\r\n  | number\r\n  | {\r\n      time: number;\r\n    }\r\n  | {\r\n      frame: number;\r\n      fps?: number;\r\n    }\r\n  | {\r\n      marker: string;\r\n    };\r\n\r\n/**\r\n * Timeline marker metadata stored on an animation clip.\r\n *\r\n * Markers are data, not callbacks. Runtime systems may dispatch events when a\r\n * playback cursor crosses the marker.\r\n * @public\r\n */\r\nexport type AnimationMarker = {\r\n  /** Stable marker id for editor and blueprint references. */\r\n  id?: string;\r\n  /** Display/event name. */\r\n  name: string;\r\n  /** Marker time in seconds. */\r\n  time?: number;\r\n  /** Marker frame. Converted with `fps` or the owning clip's `frameRate`. */\r\n  frame?: number;\r\n  /** Optional frame rate used for `frame` conversion. */\r\n  fps?: number;\r\n  /** Serializable user payload. */\r\n  payload?: unknown;\r\n};\r\n\r\n/**\r\n * Animation clip\r\n *\r\n * Represents a named animation composed of multiple tracks targeting various objects/properties,\r\n * with an overall duration, weight, and optional auto-play behavior. Tracks may target different\r\n * objects and are grouped by a per-target array. Skeletons used by this clip are tracked for\r\n * lifecycle and application during playback.\r\n *\r\n * Typical workflow:\r\n * - Create a clip via `AnimationSet.createAnimation(name)`.\r\n * - Add one or more `AnimationTrack`s via `addTrack(target, track)`.\r\n * - Optionally register skeletons via `addSkeleton(...)`.\r\n * - Start playback through the owning `AnimationSet.playAnimation(name, options)`.\r\n *\r\n * @public\r\n */\r\nexport class AnimationClip extends Disposable {\r\n  /** @internal */\r\n  protected _name: string;\r\n  /** @internal */\r\n  protected _animationSet: AnimationSet;\r\n  /** @internal */\r\n  protected _embedded: boolean;\r\n  /** @internal */\r\n  protected _duration: number;\r\n  /** @internal */\r\n  protected _autoPlay: boolean;\r\n  /** @internal */\r\n  protected _tracks: Map<object, AnimationTrack[]>;\r\n  protected _weight: number;\r\n  /** @internal */\r\n  protected _skeletons: Set<string>;\r\n  /** @internal */\r\n  protected _frameRate: number;\r\n  /** @internal */\r\n  protected _markers: AnimationMarker[];\r\n  /**\r\n   * Creates an animation instance\r\n   * @param name - Name of the animation\r\n   * @param model - Parent node if this is a skeleton animation\r\n   */\r\n  constructor(name: string, animationSet: AnimationSet, embedded = false) {\r\n    super();\r\n    this._name = name;\r\n    this._animationSet = animationSet;\r\n    this._embedded = embedded;\r\n    this._tracks = new Map();\r\n    this._duration = 0;\r\n    this._weight = 1;\r\n    this._autoPlay = false;\r\n    this._skeletons = new Set();\r\n    this._frameRate = 30;\r\n    this._markers = [];\r\n  }\r\n  /**\r\n   * Whether this clip is embedded (owned inline by its container/resource).\r\n   */\r\n  get embedded() {\r\n    return this._embedded;\r\n  }\r\n  /**\r\n   * The `AnimationSet` that owns this clip.\r\n   */\r\n  get animationSet() {\r\n    return this._animationSet;\r\n  }\r\n  /**\r\n   * Global blend weight for the clip.\r\n   *\r\n   * Used by the animation system when combining multiple active clips.\r\n   */\r\n  get weight() {\r\n    return this._weight;\r\n  }\r\n  set weight(val: number) {\r\n    this._weight = val;\r\n  }\r\n  /**\r\n   * Whether this clip should start playing automatically when loaded/instantiated.\r\n   */\r\n  get autoPlay() {\r\n    return this._autoPlay;\r\n  }\r\n  set autoPlay(val: boolean) {\r\n    this._autoPlay = val;\r\n  }\r\n  /**\r\n   * The unique name of this clip.\r\n   */\r\n  get name() {\r\n    return this._name;\r\n  }\r\n  /**\r\n   * All animation tracks grouped by target object.\r\n   *\r\n   * Key: target object; Value: list of `AnimationTrack`s affecting that target.\r\n   */\r\n  get tracks() {\r\n    return this._tracks;\r\n  }\r\n  /**\r\n   * All skeletons referenced by this clip.\r\n   */\r\n  get skeletons() {\r\n    return this._skeletons;\r\n  }\r\n  set skeletons(val: Set<string>) {\r\n    this._skeletons = val;\r\n  }\r\n  /**\r\n   * Default frame rate used to convert frame-based marker references.\r\n   */\r\n  get frameRate() {\r\n    return this._frameRate;\r\n  }\r\n  set frameRate(val: number) {\r\n    if (Number.isFinite(val) && val > 0) {\r\n      this._frameRate = val;\r\n    }\r\n  }\r\n  /**\r\n   * Timeline markers stored on this clip.\r\n   */\r\n  get markers() {\r\n    return this._markers;\r\n  }\r\n  /**\r\n   * Total time span of the clip in seconds.\r\n   *\r\n   * Automatically extended when adding tracks with longer duration.\r\n   */\r\n  get timeDuration() {\r\n    return this._duration;\r\n  }\r\n  set timeDuration(val) {\r\n    this._duration = val;\r\n  }\r\n  /**\r\n   * Add a serializable marker to this clip.\r\n   *\r\n   * @param marker - Marker metadata. If `id` is omitted, `name` is used as the id.\r\n   * @returns The normalized marker.\r\n   */\r\n  addMarker(marker: AnimationMarker): AnimationMarker | null {\r\n    if (!marker?.name) {\r\n      console.error('Animation marker must have a name');\r\n      return null;\r\n    }\r\n    const normalized: AnimationMarker = {\r\n      ...marker,\r\n      id: marker.id || marker.name\r\n    };\r\n    if (this.resolveMarkerTime(normalized) === null) {\r\n      console.error('Animation marker must have either time or frame');\r\n      return null;\r\n    }\r\n    this._markers.push(normalized);\r\n    this._markers.sort((a, b) => (this.resolveMarkerTime(a) ?? 0) - (this.resolveMarkerTime(b) ?? 0));\r\n    return normalized;\r\n  }\r\n  /**\r\n   * Remove markers matching the marker id or name.\r\n   */\r\n  removeMarker(idOrName: string) {\r\n    const oldLength = this._markers.length;\r\n    this._markers = this._markers.filter((marker) => marker.id !== idOrName && marker.name !== idOrName);\r\n    return this._markers.length !== oldLength;\r\n  }\r\n  /**\r\n   * Get the first marker matching the marker id or name.\r\n   */\r\n  getMarker(idOrName: string) {\r\n    return this._markers.find((marker) => marker.id === idOrName || marker.name === idOrName) ?? null;\r\n  }\r\n  /**\r\n   * Resolve a marker to seconds on this clip's timeline.\r\n   */\r\n  resolveMarkerTime(marker: AnimationMarker): number | null {\r\n    if (typeof marker.time === 'number' && Number.isFinite(marker.time)) {\r\n      return marker.time;\r\n    }\r\n    if (typeof marker.frame === 'number' && Number.isFinite(marker.frame)) {\r\n      const fps = marker.fps ?? this._frameRate;\r\n      return fps > 0 ? marker.frame / fps : null;\r\n    }\r\n    return null;\r\n  }\r\n  /**\r\n   * Resolve a time reference to seconds on this clip's timeline.\r\n   */\r\n  resolveTimeRef(ref: AnimationTimeRef | null | undefined): number | null {\r\n    if (ref === null || ref === undefined) {\r\n      return null;\r\n    }\r\n    if (typeof ref === 'number') {\r\n      return Number.isFinite(ref) ? ref : null;\r\n    }\r\n    if ('time' in ref) {\r\n      return Number.isFinite(ref.time) ? ref.time : null;\r\n    }\r\n    if ('frame' in ref) {\r\n      const fps = ref.fps ?? this._frameRate;\r\n      return Number.isFinite(ref.frame) && fps > 0 ? ref.frame / fps : null;\r\n    }\r\n    if ('marker' in ref) {\r\n      const marker = this.getMarker(ref.marker);\r\n      return marker ? this.resolveMarkerTime(marker) : null;\r\n    }\r\n    return null;\r\n  }\r\n  /**\r\n   * Add a skeleton used by this clip.\r\n   *\r\n   * @param skeletonId - Persistent ID of Skeleton to register for this clip.\r\n   */\r\n  addSkeleton(skeletonId: string) {\r\n    this._skeletons.add(skeletonId);\r\n  }\r\n  /**\r\n   * Remove a specific track from this clip.\r\n   *\r\n   * Errors if the track does not belong to this clip. Does nothing if not found.\r\n   *\r\n   * @param track - The track instance to remove.\r\n   * @returns This clip (for chaining).\r\n   */\r\n  deleteTrack(track: AnimationTrack) {\r\n    if (track?.animation !== this) {\r\n      console.error('Cannot delete animation track which is not belongs to THIS animation');\r\n    }\r\n    for (const k of this._tracks.keys()) {\r\n      const tracks = this._tracks.get(k)!;\r\n      const index = tracks.indexOf(track);\r\n      if (index >= 0) {\r\n        tracks.splice(index, 1);\r\n      }\r\n    }\r\n    return this;\r\n  }\r\n  /**\r\n   * Add a track to this clip for a specific target object.\r\n   *\r\n   * Constraints:\r\n   * - The track must not already belong to another clip.\r\n   * - Only one track with the same blendId may exist per target in a single clip.\r\n   *\r\n   * Side effects:\r\n   * - Assigns this clip to `track.animation`.\r\n   * - Extends `timeDuration` to cover the track duration if longer.\r\n   * - Calls `track.reset(target)` to initialize the target state if needed.\r\n   *\r\n   * @param target - Target object controlled by the track.\r\n   * @param track - Track to add.\r\n   * @returns This clip (for chaining).\r\n   */\r\n  addTrack(target: object, track: AnimationTrack) {\r\n    if (!track) {\r\n      return this;\r\n    }\r\n    if (track.animation) {\r\n      if (track.animation === this) {\r\n        return this;\r\n      } else {\r\n        console.error('Track is already in another animation');\r\n        return this;\r\n      }\r\n    }\r\n    const blendId = track.getBlendId();\r\n    const tracks = this._tracks.get(target);\r\n    if (tracks && tracks.findIndex((track) => track.getBlendId() === blendId) >= 0) {\r\n      console.error('Tracks with same BlendId could not be added to same animation');\r\n      return this;\r\n    }\r\n    track.animation = this;\r\n    let trackInfo = this._tracks.get(target);\r\n    if (!trackInfo) {\r\n      trackInfo = [];\r\n      this._tracks.set(target, trackInfo);\r\n    }\r\n    trackInfo.push(track);\r\n    this._duration = Math.max(this._duration, track.getDuration() ?? 0);\r\n    track.reset(target);\r\n    return this;\r\n  }\r\n  /*\r\n  resample(frames: number, callback: (frame: number) => void) {\r\n    for (let frame = 0; frame <= frames; frame++) {\r\n      const t = frame / this.timeDuration;\r\n      for (const [k, v] of this.tracks) {\r\n        for (const track of v) {\r\n          const state = track.calculateState(k, t);\r\n          track.applyState(k, state);\r\n        }\r\n      }\r\n      for (const sk of this.skeletons) {\r\n        const skeleton = this._animationSet.model.findSkeletonById(sk);\r\n        if (skeleton) {\r\n          skeleton.computeJoints();\r\n        }\r\n      }\r\n      callback(frame);\r\n    }\r\n  }\r\n  */\r\n}\r\n"],"names":["AnimationClip","Disposable","_weight","name","animationSet","embedded","_name","_animationSet","_embedded","_tracks","Map","_duration","_autoPlay","_skeletons","Set","_frameRate","_markers","weight","val","autoPlay","tracks","skeletons","frameRate","Number","isFinite","markers","timeDuration","addMarker","marker","console","error","normalized","id","resolveMarkerTime","push","sort","a","b","removeMarker","idOrName","oldLength","length","filter","getMarker","find","time","frame","fps","resolveTimeRef","ref","undefined","addSkeleton","skeletonId","add","deleteTrack","track","animation","k","keys","get","index","indexOf","splice","addTrack","target","blendId","getBlendId","findIndex","trackInfo","set","Math","max","getDuration","reset"],"mappings":"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"}

package/dist/vendor/zephyr3d/scene/dist/animation/animationcontroller.js

@@ -0,0 +1,503 @@
+import { Observable } from '@zephyr3d/base';
+import { AnimationTimeline } from './animationtimeline.js';
+
+/**
+ * Event-driven animation state controller.
+ *
+ * Each state owns one serializable timeline. External gameplay events are dispatched to the
+ * current timeline first, then to the current state's response table, so different states can
+ * respond to the same event differently.
+ * @public
+ */ class AnimationController extends Observable {
+    /**
+   * Animation set used to create playbacks for all state timelines.
+   */ animationSet;
+    _states;
+    _currentState;
+    _runner;
+    _onRunnerComplete;
+    _onRunnerEmit;
+    /**
+   * Create a controller for an animation set.
+   *
+   * @param animationSet - Animation set that owns the clips and active playbacks.
+   */ constructor(animationSet){
+        super();
+        this.animationSet = animationSet;
+        this._states = new Map();
+        this._currentState = null;
+        this._runner = null;
+        this._onRunnerComplete = null;
+        this._onRunnerEmit = null;
+    }
+    /**
+   * Current state name.
+   *
+   * @returns The active state name, or null when the controller is stopped or has not entered a state.
+   */ get currentState() {
+        return this._currentState;
+    }
+    /**
+   * Current timeline runner.
+   *
+   * @returns The active timeline runner, or null when no state is running.
+   */ get runner() {
+        return this._runner;
+    }
+    /**
+   * Register or replace a named state definition.
+   *
+   * @param name - Unique state name.
+   * @param definition - Timeline and event response configuration for the state.
+   * @returns This controller for chaining.
+   */ addState(name, definition) {
+        if (this._states.has(name)) {
+            console.warn(`AnimationController state ${name} already exists; overwriting`);
+        }
+        this._states.set(name, definition);
+        return this;
+    }
+    /**
+   * Test whether a state has been registered.
+   *
+   * @param name - State name to look up.
+   * @returns True if the controller contains a state with the given name; otherwise false.
+   */ hasState(name) {
+        return this._states.has(name);
+    }
+    /**
+   * Enter a registered state.
+   *
+   * If the requested state is already current and `options.force` is not set, this returns the
+   * existing runner without restarting the timeline. When a transition duration is provided, the
+   * previous runner fades out while the entry plays of the new state fade in.
+   *
+   * @param name - State name to enter.
+   * @param options - Optional transition, re-entry, and stop behavior.
+   * @returns The active runner for the entered state, or null if the state does not exist.
+   */ setState(name, options) {
+        const definition = this._states.get(name);
+        if (!definition) {
+            console.error(`AnimationController state ${name} not exists`);
+            return null;
+        }
+        if (!options?.force && this._currentState === name) {
+            return this._runner;
+        }
+        const previousState = this._currentState;
+        const transition = Math.max(options?.transition ?? definition.transition ?? 0, 0);
+        const returnTarget = this.resolveReturnTarget(options?.returnTo, previousState, options?.returnTransition);
+        this.detachRunner();
+        if (transition > 0) {
+            this._runner?.stop({
+                fadeOut: transition,
+                reason: 'interrupted'
+            });
+        } else {
+            this._runner?.stop(options?.stop ?? {
+                reason: 'interrupted'
+            });
+        }
+        const timeline = new AnimationTimeline(prepareTimelineForTransition(definition.timeline, transition, returnTarget?.transition, options?.sync));
+        this._runner = timeline.createRunner(this.animationSet);
+        const runner = this._runner;
+        this.attachRunner(runner, name, returnTarget);
+        // Enter the new state *before* starting the runner: start() flushes synchronously, so any
+        // initial `emit`/`statecomplete` must observe the controller already in `name`. Otherwise a
+        // listener calling dispatch() would route against the previous state.
+        this._currentState = name;
+        this.dispatchEvent('statechange', name, previousState);
+        // The statechange listener may have re-entered (stop() or another setState()), swapping out or
+        // clearing `_runner`. Only start the runner we created if it is still the active one.
+        if (this._runner === runner && this._currentState === name) {
+            runner.start();
+        }
+        // If a reentrant listener superseded us, `_runner` is the now-active runner (or null after a
+        // reentrant stop()); return that rather than a runner we never started.
+        return this._runner;
+    }
+    /**
+   * Dispatch a gameplay event to the active state.
+   *
+   * The active timeline receives the event first. If it does not handle the event, the current
+   * state's response table may consume it, enqueue or run steps, or transition to another state.
+   *
+   * @param event - Event name to dispatch.
+   * @param payload - Optional event payload passed through result notifications.
+   * @returns The resolved handling result for the event.
+   */ dispatch(event, payload) {
+        if (!this._currentState || !this._runner) {
+            return this.emitResult({
+                handled: false,
+                policy: 'none',
+                event,
+                payload
+            });
+        }
+        const timelineResult = this._runner.dispatch(event, payload);
+        if (timelineResult.handled) {
+            return this.emitResult(timelineResult);
+        }
+        const response = this._states.get(this._currentState)?.responses?.find((item)=>item.event === event);
+        if (!response || response.target.ignore) {
+            return this.emitResult({
+                handled: false,
+                policy: response ? 'ignore' : 'none',
+                event,
+                payload
+            });
+        }
+        if (response.target.consume) {
+            return this.emitResult({
+                handled: true,
+                policy: 'consume',
+                event,
+                payload
+            });
+        }
+        if (response.target.targetState !== undefined) {
+            const transition = typeof response.onActive === 'object' ? response.onActive.fadeOut : undefined;
+            const runner = this.setState(response.target.targetState, {
+                transition,
+                returnTo: response.target.returnTo,
+                returnTransition: response.target.returnTransition
+            });
+            // setState returns null when the target state is not registered: a config error must not be
+            // reported as a successfully handled transition.
+            if (!runner) {
+                return this.emitResult({
+                    handled: false,
+                    policy: 'transition',
+                    event,
+                    payload
+                });
+            }
+            return this.emitResult({
+                handled: true,
+                policy: 'transition',
+                event,
+                payload
+            });
+        }
+        const steps = response.target.steps;
+        if (!steps?.length) {
+            return this.emitResult({
+                handled: false,
+                policy: 'none',
+                event,
+                payload
+            });
+        }
+        if (response.enqueue) {
+            this._runner.enqueue(steps);
+            return this.emitResult({
+                handled: true,
+                policy: 'enqueue',
+                event,
+                payload
+            });
+        }
+        const disposition = response.onActive ?? 'stop';
+        if (disposition === 'keep') {
+            this._runner.runConcurrent(steps);
+        } else {
+            const stopOptions = typeof disposition === 'object' ? {
+                ...disposition,
+                reason: 'interrupted'
+            } : undefined;
+            this.detachRunner();
+            this._runner.stop(stopOptions);
+            this._runner = new AnimationTimeline(steps).createRunner(this.animationSet);
+            this.attachRunner(this._runner, this._currentState);
+            this._runner.start();
+        }
+        return this.emitResult({
+            handled: true,
+            policy: 'steps',
+            event,
+            payload
+        });
+    }
+    /**
+   * Stop the active state and clear the current state.
+   *
+   * @param options - Optional stop behavior applied to playbacks owned by the active runner.
+   * @returns void
+   */ stop(options) {
+        const previousState = this._currentState;
+        this.detachRunner();
+        this._runner?.stop(options);
+        this._runner = null;
+        this._currentState = null;
+        if (previousState !== null) {
+            this.dispatchEvent('statechange', null, previousState);
+        }
+    }
+    /**
+   * Stop playback and remove all registered states.
+   *
+   * @returns void
+   */ dispose() {
+        this.stop();
+        this._states.clear();
+    }
+    emitResult(result) {
+        this.dispatchEvent('event', result.event, result.payload, result);
+        return result;
+    }
+    resolveReturnTarget(returnTo, previousState, returnTransition) {
+        if (returnTo === undefined) {
+            return null;
+        }
+        const state = returnTo === true ? previousState : returnTo;
+        if (!state) {
+            return null;
+        }
+        const definition = this._states.get(state);
+        if (!definition) {
+            console.error(`AnimationController return state ${state} not exists`);
+            return null;
+        }
+        return {
+            state,
+            transition: returnTransition ?? definition.transition
+        };
+    }
+    attachRunner(runner, state, returnTarget) {
+        this._onRunnerComplete = ()=>{
+            this.dispatchEvent('statecomplete', state);
+            if (returnTarget && this._runner === runner && this._currentState === state) {
+                const sync = returnTarget.transition && runner.lastCompletedPlaybackId ? {
+                    target: runner.lastCompletedPlaybackId,
+                    mode: 'normalized'
+                } : undefined;
+                this.setState(returnTarget.state, {
+                    transition: returnTarget.transition,
+                    sync
+                });
+            }
+        };
+        this._onRunnerEmit = (event, payload)=>{
+            this.dispatchEvent('emit', event, payload);
+        };
+        runner.on('complete', this._onRunnerComplete);
+        runner.on('emit', this._onRunnerEmit);
+    }
+    detachRunner() {
+        if (this._runner) {
+            if (this._onRunnerComplete) {
+                this._runner.off('complete', this._onRunnerComplete);
+            }
+            if (this._onRunnerEmit) {
+                this._runner.off('emit', this._onRunnerEmit);
+            }
+        }
+        this._onRunnerComplete = null;
+        this._onRunnerEmit = null;
+    }
+}
+function prepareTimelineForTransition(definition, entryTransition, returnTransition, entrySync) {
+    let timeline = definition;
+    if (entrySync) {
+        timeline = withEntrySync(timeline, entrySync);
+    }
+    const completionFadeOut = Math.max(returnTransition ?? 0, 0);
+    if (completionFadeOut > 0) {
+        timeline = withCompletionFadeOut(timeline, completionFadeOut);
+    }
+    return entryTransition > 0 ? withFadeIn(timeline, entryTransition) : timeline;
+}
+/**
+ * Return a copy of the timeline definition whose entry plays use `sync` unless they already
+ * declare a more specific synchronization source.
+ */ function withEntrySync(definition, sync) {
+    const def = Array.isArray(definition) ? {
+        steps: definition
+    } : definition;
+    return {
+        steps: injectEntrySync(def.steps, sync).steps,
+        responses: def.responses
+    };
+}
+function injectEntrySync(steps, sync) {
+    let blocked = false;
+    const out = steps.map((step)=>{
+        if (blocked) {
+            return step;
+        }
+        switch(step.type){
+            case 'play':
+                if (step.wait === 'complete') {
+                    blocked = true;
+                }
+                return {
+                    ...step,
+                    options: {
+                        ...step.options,
+                        sync: step.options?.sync ?? sync
+                    }
+                };
+            case 'sequence':
+                {
+                    const result = injectEntrySync(step.steps, sync);
+                    blocked = result.blocked;
+                    return {
+                        ...step,
+                        steps: result.steps
+                    };
+                }
+            case 'parallel':
+                {
+                    let anyBranchBlocked = false;
+                    const branches = step.steps.map((branch)=>{
+                        const result = injectEntrySync([
+                            branch
+                        ], sync);
+                        anyBranchBlocked = anyBranchBlocked || result.blocked;
+                        return result.steps[0];
+                    });
+                    blocked = anyBranchBlocked;
+                    return {
+                        ...step,
+                        steps: branches
+                    };
+                }
+            case 'wait':
+            case 'waitEvent':
+            case 'waitMarker':
+            case 'waitFrame':
+                blocked = true;
+                return step;
+            default:
+                return step;
+        }
+    });
+    return {
+        steps: out,
+        blocked
+    };
+}
+/**
+ * Return a copy of the timeline definition whose entry plays fade in over `duration`, so a state
+ * transition cross-fades against the previous state's fade-out.
+ *
+ * "Entry plays" are every `play` that starts before the control flow first blocks: plays before a
+ * `wait`/`waitEvent`/`waitMarker`/`waitFrame`, before a blocking `play` (`wait: 'complete'`), and
+ * every branch of a leading `parallel` (all branches start simultaneously). This covers parallel
+ * states whose branches would otherwise snap in at full weight while only the first faded.
+ */ function withFadeIn(definition, duration) {
+    const def = Array.isArray(definition) ? {
+        steps: definition
+    } : definition;
+    return {
+        steps: injectEntryFadeIn(def.steps, duration).steps,
+        responses: def.responses
+    };
+}
+/**
+ * Inject `fadeIn` into every entry play in `steps`. Returns the rewritten steps and whether the
+ * flow blocks before reaching the end (so callers stop injecting into later, non-entry steps).
+ */ function injectEntryFadeIn(steps, duration) {
+    let blocked = false;
+    const out = steps.map((step)=>{
+        if (blocked) {
+            return step;
+        }
+        switch(step.type){
+            case 'play':
+                if (step.wait === 'complete') {
+                    blocked = true;
+                }
+                return {
+                    ...step,
+                    options: {
+                        ...step.options,
+                        fadeIn: duration
+                    }
+                };
+            case 'sequence':
+                {
+                    const result = injectEntryFadeIn(step.steps, duration);
+                    blocked = result.blocked;
+                    return {
+                        ...step,
+                        steps: result.steps
+                    };
+                }
+            case 'parallel':
+                {
+                    // Every branch starts simultaneously, so inject into all of them. The parallel join only
+                    // blocks the steps that follow it if at least one branch blocks; if all branches are
+                    // non-blocking they drain in the same flush, so the following steps are still entry plays.
+                    let anyBranchBlocked = false;
+                    const branches = step.steps.map((branch)=>{
+                        const result = injectEntryFadeIn([
+                            branch
+                        ], duration);
+                        anyBranchBlocked = anyBranchBlocked || result.blocked;
+                        return result.steps[0];
+                    });
+                    blocked = anyBranchBlocked;
+                    return {
+                        ...step,
+                        steps: branches
+                    };
+                }
+            case 'wait':
+            case 'waitEvent':
+            case 'waitMarker':
+            case 'waitFrame':
+                blocked = true;
+                return step;
+            default:
+                return step;
+        }
+    });
+    return {
+        steps: out,
+        blocked
+    };
+}
+/**
+ * Return a copy of the timeline definition whose play steps keep completed playbacks alive long
+ * enough to cross-fade into the automatic return state.
+ */ function withCompletionFadeOut(definition, duration) {
+    const def = Array.isArray(definition) ? {
+        steps: definition
+    } : definition;
+    return {
+        steps: injectCompletionFadeOut(def.steps, duration),
+        responses: def.responses
+    };
+}
+function injectCompletionFadeOut(steps, duration) {
+    return steps.map((step)=>{
+        switch(step.type){
+            case 'play':
+                return {
+                    ...step,
+                    options: {
+                        ...step.options,
+                        completionFadeOut: step.options?.completionFadeOut ?? duration
+                    }
+                };
+            case 'sequence':
+                return {
+                    ...step,
+                    steps: injectCompletionFadeOut(step.steps, duration)
+                };
+            case 'parallel':
+                return {
+                    ...step,
+                    steps: step.steps.map((branch)=>injectCompletionFadeOut([
+                            branch
+                        ], duration)[0])
+                };
+            default:
+                return step;
+        }
+    });
+}
+
+export { AnimationController };
+//# sourceMappingURL=animationcontroller.js.map