@zephyr3d/scene 0.6.1 → 0.7.1

package/dist/animation/animationset.js.map

@@ -1 +1 @@
-{"version":3,"file":"animationset.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"animationset.js","sources":["../../src/animation/animationset.ts"],"sourcesContent":["import { weightedAverage, Disposable } from '@zephyr3d/base';\r\nimport type { DRef, IDisposable } from '@zephyr3d/base';\r\nimport type { SceneNode } from '../scene';\r\nimport { AnimationClip } from './animation';\r\nimport type { AnimationTrack } from './animationtrack';\r\nimport type { Skeleton } from './skeleton';\r\n\r\n/**\r\n * Options for playing an animation.\r\n *\r\n * Controls looping, playback speed (including reverse), and fade-in blending.\r\n * @public\r\n **/\r\nexport type PlayAnimationOptions = {\r\n  /**\r\n   * Number of loops to play.\r\n   *\r\n   * - 0: infinite looping (default).\r\n   * - n \\> 0: play exactly n loops (each loop is one full duration of the clip).\r\n   */\r\n  repeat?: number;\r\n  /**\r\n   * Playback speed multiplier.\r\n   *\r\n   * - 1: normal speed (default).\r\n   * - \\>1: faster; \\<1: slower.\r\n   * - Negative values play the clip in reverse. The initial `currentTime` will be set to the end.\r\n   */\r\n  speedRatio?: number;\r\n  /**\r\n   * Fade-in duration in seconds.\r\n   *\r\n   * Interpolates the animation weight from 0 to the clip's configured weight over this time.\r\n   * Use together with `stopAnimation(..., { fadeOut })` for smooth cross-fading.\r\n   * Default is 0 (no fade-in).\r\n   */\r\n  fadeIn?: number;\r\n  /**\r\n   * Weight of the animation clip.\r\n   *\r\n   * Used during blending when multiple animations affect the same property.\r\n   * Default is the clip's configured weight.\r\n   */\r\n  weight?: number;\r\n};\r\n\r\n/**\r\n * Options for stopping an animation.\r\n *\r\n * Allows a graceful fade-out instead of abrupt stop.\r\n * @public\r\n */\r\nexport type StopAnimationOptions = {\r\n  /**\r\n   * Fade-out duration in seconds.\r\n   *\r\n   * Interpolates the current animation weight down to 0 over this time.\r\n   * Default is 0 (immediate stop).\r\n   */\r\n  fadeOut?: number;\r\n};\r\n\r\n/**\r\n * Animation set\r\n *\r\n * Manages a collection of named animation clips for a model and orchestrates:\r\n * - Playback state (time, loops, speed, weights, fade-in/out).\r\n * - Blending across multiple tracks targeting the same property via weighted averages.\r\n * - Skeleton usage and application for clips that drive skeletal animation.\r\n * - Active track registration and cleanup as clips start/stop.\r\n *\r\n * Usage:\r\n * - Create or retrieve `AnimationClip`s by name.\r\n * - Start playback with `playAnimation(name, options)`.\r\n * - Advance animation with `update(deltaSeconds)`.\r\n * - Optionally adjust weight while playing with `setAnimationWeight(name, weight)`.\r\n *\r\n * Lifetime:\r\n * - Disposing the set releases references to the model, clips, and clears active state.\r\n *\r\n * @public\r\n */\r\nexport class AnimationSet extends Disposable implements IDisposable {\r\n  /** @internal */\r\n  private _model: SceneNode;\r\n  /** @internal */\r\n  private _animations: Partial<Record<string, AnimationClip>>;\r\n  /** @internal */\r\n  private _skeletons: DRef<Skeleton>[];\r\n  /** @internal */\r\n  private readonly _activeTracks: Map<object, Map<unknown, AnimationTrack[]>>;\r\n  /** @internal */\r\n  private readonly _activeSkeletons: Map<Skeleton, number>;\r\n  /** @internal */\r\n  private readonly _activeAnimations: Map<\r\n    AnimationClip,\r\n    {\r\n      currentTime: number;\r\n      repeat: number;\r\n      repeatCounter: number;\r\n      weight: number;\r\n      speedRatio: number;\r\n      firstFrame: boolean;\r\n      fadeIn: number;\r\n      fadeOut: number;\r\n      fadeOutStart: number;\r\n      animateTime: number;\r\n    }\r\n  >;\r\n  /**\r\n   * Create an AnimationSet controlling the provided model.\r\n   *\r\n   * @param model - The SceneNode (model root) controlled by this animation set.\r\n   */\r\n  constructor(model: SceneNode) {\r\n    super();\r\n    this._model = model;\r\n    this._animations = {};\r\n    this._activeTracks = new Map();\r\n    this._activeSkeletons = new Map();\r\n    this._activeAnimations = new Map();\r\n    this._skeletons = [];\r\n  }\r\n  /**\r\n   * The model (SceneNode) controlled by this animation set.\r\n   */\r\n  get model() {\r\n    return this._model;\r\n  }\r\n  /**\r\n   * Number of animation clips registered in this set.\r\n   */\r\n  get numAnimations() {\r\n    return Object.getOwnPropertyNames(this._animations).length;\r\n  }\r\n  /**\r\n   * The skeletons used by animations in this set.\r\n   */\r\n  get skeletons() {\r\n    return this._skeletons;\r\n  }\r\n  /**\r\n   * Retrieve an animation clip by name.\r\n   *\r\n   * @param name - Name of the animation.\r\n   * @returns The clip if present; otherwise null.\r\n   */\r\n  get(name: string) {\r\n    return this._animations[name] ?? null;\r\n  }\r\n  /**\r\n   * Create and register a new animation clip.\r\n   *\r\n   * @param name - Unique name for the animation clip.\r\n   * @param embedded - Whether the clip is embedded/owned (implementation-specific). Default false.\r\n   * @returns The created clip, or null if the name is empty or not unique.\r\n   */\r\n  createAnimation(name: string, embedded = false) {\r\n    if (!name || this._animations[name]) {\r\n      console.error('Animation must have unique name');\r\n      return null;\r\n    } else {\r\n      const animation = new AnimationClip(name, this, embedded);\r\n      this._animations[name] = animation;\r\n      this._model.scene?.queueUpdateNode(this._model);\r\n      return animation;\r\n    }\r\n  }\r\n  /**\r\n   * Delete and dispose an animation clip by name.\r\n   *\r\n   * - If the animation is currently playing, it is first stopped (immediately).\r\n   *\r\n   * @param name - Name of the animation to remove.\r\n   */\r\n  deleteAnimation(name: string) {\r\n    const animation = this._animations[name];\r\n    if (animation) {\r\n      this.stopAnimation(name);\r\n      delete this._animations[name];\r\n      animation.dispose();\r\n    }\r\n  }\r\n  /**\r\n   * Get the list of all registered animation names.\r\n   *\r\n   * @returns An array of clip names.\r\n   */\r\n  getAnimationNames() {\r\n    return Object.keys(this._animations);\r\n  }\r\n  /**\r\n   * Advance and apply active animations.\r\n   *\r\n   * Responsibilities per call:\r\n   * - Update time cursor for each active clip (respecting speedRatio and looping).\r\n   * - Enforce repeat limits and apply fade-out termination if configured.\r\n   * - For each animated target, blend active tracks (weighted by clip weight × fade-in × fade-out)\r\n   *   and apply the resulting state to the target.\r\n   * - Apply all active skeletons to update skinning transforms.\r\n   *\r\n   * @param deltaInSeconds - Time step in seconds since last update.\r\n   */\r\n  update(deltaInSeconds: number) {\r\n    this._activeAnimations.forEach((v, k) => {\r\n      if (v.fadeOut > 0 && v.fadeOutStart < 0) {\r\n        v.fadeOutStart = v.animateTime;\r\n      }\r\n      // Update animation time\r\n      if (v.firstFrame) {\r\n        v.firstFrame = false;\r\n      } else {\r\n        const timeAdvance = deltaInSeconds * v.speedRatio;\r\n        v.currentTime += timeAdvance;\r\n        v.animateTime += timeAdvance;\r\n        if (v.currentTime > k.timeDuration) {\r\n          v.repeatCounter++;\r\n          v.currentTime = 0;\r\n        } else if (v.currentTime < 0) {\r\n          v.repeatCounter++;\r\n          v.currentTime = k.timeDuration;\r\n        }\r\n        if (v.repeat !== 0 && v.repeatCounter >= v.repeat) {\r\n          this.stopAnimation(k.name);\r\n        } else if (v.fadeOut > 0) {\r\n          if (v.animateTime - v.fadeOutStart >= v.fadeOut) {\r\n            this.stopAnimation(k.name);\r\n          }\r\n        }\r\n      }\r\n    });\r\n    // Update tracks\r\n    this._activeTracks.forEach((v, k) => {\r\n      v.forEach((alltracks) => {\r\n        // Only deal with tracks which have not been removed\r\n        const tracks = alltracks.filter(\r\n          (track) => track.animation && this.isPlayingAnimation(track.animation.name)\r\n        );\r\n        if (tracks.length > 0) {\r\n          const weights = tracks.map((track) => {\r\n            const info = this._activeAnimations.get(track.animation!)!;\r\n            const weight = info.weight;\r\n            const fadeIn = info.fadeIn === 0 ? 1 : Math.min(1, info.animateTime / info.fadeIn);\r\n            let fadeOut = 1;\r\n            if (info.fadeOut !== 0) {\r\n              fadeOut = 1 - (info.animateTime - info.fadeOutStart) / info.fadeOut;\r\n            }\r\n            return weight * fadeIn * fadeOut;\r\n          });\r\n          const states = tracks.map((track) => {\r\n            const info = this._activeAnimations.get(track.animation!)!;\r\n            const t = (info.currentTime / track.animation!.timeDuration) * track.getDuration();\r\n            return track.calculateState(k, t);\r\n          });\r\n          const state = weightedAverage(weights, states, (a, b, t) => {\r\n            return tracks[0].mixState(a, b, t);\r\n          });\r\n          tracks[0].applyState(k, state);\r\n        }\r\n      });\r\n    });\r\n    // Update skeletons\r\n    this._activeSkeletons.forEach((v, k) => {\r\n      k.apply();\r\n    });\r\n  }\r\n  /**\r\n   * Check whether an animation is currently playing.\r\n   *\r\n   * @param name - Optional animation name. If omitted, returns true if any animation is playing.\r\n   * @returns True if playing; otherwise false.\r\n   */\r\n  isPlayingAnimation(name?: string) {\r\n    if (name) {\r\n      const animation = this._animations[name];\r\n      return !!animation && this._activeAnimations.has(animation);\r\n    }\r\n    return this._activeAnimations.size > 0;\r\n  }\r\n  /**\r\n   * Get an animation clip by name.\r\n   *\r\n   * Alias of `get(name)` returning a nullable type.\r\n   *\r\n   * @param name - Name of the animation.\r\n   * @returns The clip if present; otherwise null.\r\n   */\r\n  getAnimationClip(name: string) {\r\n    return this._animations[name] ?? null;\r\n  }\r\n  /**\r\n   * Set the runtime blend weight for a currently playing animation.\r\n   *\r\n   * Has no effect if the clip is not active.\r\n   *\r\n   * @param name - Name of the playing animation.\r\n   * @param weight - New weight value used during blending.\r\n   */\r\n  setAnimationWeight(name: string, weight: number) {\r\n    const ani = this._animations[name];\r\n    if (!ani) {\r\n      console.error(`Animation ${name} not exists`);\r\n      return;\r\n    }\r\n    const info = this._activeAnimations.get(ani);\r\n    if (info) {\r\n      info.weight = weight;\r\n    }\r\n  }\r\n  /**\r\n   * Start (or update) playback of an animation clip.\r\n   *\r\n   * Behavior:\r\n   * - If the clip is already playing, updates its fade-in (resets fade-out).\r\n   * - Otherwise initializes playback state (repeat counter, speed, weight, initial time).\r\n   * - Registers clip tracks and skeletons into the active sets for blending and application.\r\n   *\r\n   * @param name - Name of the animation to play.\r\n   * @param options - Playback options (repeat, speedRatio, fadeIn).\r\n   */\r\n  playAnimation(name: string, options?: PlayAnimationOptions) {\r\n    const ani = this._animations[name];\r\n    if (!ani) {\r\n      console.error(`Animation ${name} not exists`);\r\n      return;\r\n    }\r\n    const fadeIn = Math.max(options?.fadeIn ?? 0, 0);\r\n    const info = this._activeAnimations.get(ani);\r\n    if (info) {\r\n      info.fadeOut = 0;\r\n      info.fadeIn = fadeIn;\r\n    } else {\r\n      const repeat = options?.repeat ?? 0;\r\n      const speedRatio = options?.speedRatio ?? 1;\r\n      const weight = options?.weight ?? ani.weight ?? 1;\r\n      this._activeAnimations.set(ani, {\r\n        repeat,\r\n        weight,\r\n        speedRatio,\r\n        fadeIn,\r\n        fadeOut: 0,\r\n        repeatCounter: 0,\r\n        currentTime: speedRatio < 0 ? ani.timeDuration : 0,\r\n        animateTime: 0,\r\n        fadeOutStart: 0,\r\n        firstFrame: true\r\n      });\r\n      ani.tracks?.forEach((v, k) => {\r\n        let nodeTracks = this._activeTracks.get(k);\r\n        if (!nodeTracks) {\r\n          nodeTracks = new Map();\r\n          this._activeTracks.set(k, nodeTracks);\r\n        }\r\n        for (const track of v) {\r\n          const blendId = track.getBlendId();\r\n          let blendedTracks = nodeTracks.get(blendId);\r\n          if (!blendedTracks) {\r\n            blendedTracks = [];\r\n            nodeTracks.set(blendId, blendedTracks);\r\n          }\r\n          blendedTracks.push(track);\r\n        }\r\n      });\r\n      ani.skeletons?.forEach((v, k) => {\r\n        const skeleton = this.model.findSkeletonById(k);\r\n        if (skeleton) {\r\n          const refcount = this._activeSkeletons.get(skeleton);\r\n          if (refcount) {\r\n            this._activeSkeletons.set(skeleton, refcount + 1);\r\n          } else {\r\n            this._activeSkeletons.set(skeleton, 1);\r\n          }\r\n          skeleton.playing = true;\r\n        }\r\n      });\r\n    }\r\n  }\r\n  /**\r\n   * Stop playback of an animation clip.\r\n   *\r\n   * Behavior:\r\n   * - If `options.fadeOut > 0`, marks the clip for fade-out; actual removal occurs after fade completes.\r\n   * - If `fadeOut` is 0 or omitted, immediately:\r\n   *   - Removes the clip from active animations.\r\n   *   - Unregisters its tracks from active track maps.\r\n   *   - Decrements skeleton reference counts; resets and removes skeletons when refcount reaches 0.\r\n   *\r\n   * @param name - Name of the animation to stop.\r\n   * @param options - Optional fade-out configuration.\r\n   */\r\n  stopAnimation(name: string, options?: StopAnimationOptions) {\r\n    const ani = this._animations[name];\r\n    if (!ani) {\r\n      console.error(`Animation ${name} not exists`);\r\n      return;\r\n    }\r\n    const info = this._activeAnimations.get(ani);\r\n    if (info) {\r\n      const fadeOut = Math.max(options?.fadeOut ?? 0, 0);\r\n      if (fadeOut !== 0) {\r\n        info.fadeOut = fadeOut;\r\n        info.fadeOutStart = -1;\r\n      } else {\r\n        this._activeAnimations.delete(ani);\r\n        this._activeTracks.forEach((v) => {\r\n          v.forEach((tracks, id) => {\r\n            v.set(\r\n              id,\r\n              tracks.filter((track) => track.animation !== ani)\r\n            );\r\n          });\r\n        });\r\n        ani.skeletons?.forEach((v, k) => {\r\n          const skeleton = this.model.findSkeletonById(k);\r\n          if (skeleton) {\r\n            const refcount = this._activeSkeletons.get(skeleton)!;\r\n            if (refcount === 1) {\r\n              skeleton.reset();\r\n              this._activeSkeletons.delete(skeleton);\r\n            } else {\r\n              this._activeSkeletons.set(skeleton, refcount - 1);\r\n            }\r\n          }\r\n        });\r\n      }\r\n    }\r\n  }\r\n  /**\r\n   * Dispose the animation set and release owned resources.\r\n   *\r\n   * - Disposes the weak reference to the model.\r\n   * - Disposes all registered animation clips.\r\n   * - Clears active animations, tracks, and skeleton references.\r\n   */\r\n  protected onDispose() {\r\n    super.onDispose();\r\n    for (const k in this._animations) {\r\n      this._animations[k]!.dispose();\r\n    }\r\n    this._animations = {};\r\n    this._activeAnimations.clear();\r\n    this._activeSkeletons.clear();\r\n    this._activeTracks.clear();\r\n  }\r\n}\r\n"],"names":["AnimationSet","Disposable","model","_model","_animations","_activeTracks","Map","_activeSkeletons","_activeAnimations","_skeletons","numAnimations","Object","getOwnPropertyNames","length","skeletons","get","name","createAnimation","embedded","console","error","animation","AnimationClip","scene","queueUpdateNode","deleteAnimation","stopAnimation","dispose","getAnimationNames","keys","update","deltaInSeconds","forEach","v","k","fadeOut","fadeOutStart","animateTime","firstFrame","timeAdvance","speedRatio","currentTime","timeDuration","repeatCounter","repeat","alltracks","tracks","filter","track","isPlayingAnimation","weights","map","info","weight","fadeIn","Math","min","states","t","getDuration","calculateState","state","weightedAverage","a","b","mixState","applyState","apply","has","size","getAnimationClip","setAnimationWeight","ani","playAnimation","options","max","set","nodeTracks","blendId","getBlendId","blendedTracks","push","skeleton","findSkeletonById","refcount","playing","delete","id","reset","onDispose","clear"],"mappings":"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"}

package/dist/animation/animationtrack.js

@@ -1,25 +1,81 @@
 /**
- * Base class for any kind of animation track
+ * Base class for animation tracks.
+ *
+ * A track produces time-varying state for a specific target and defines how to:
+ * - Compute state at a given time (`calculateState`)
+ * - Apply that state to a target (`applyState`)
+ * - Blend between two states (`mixState`)
+ * - Report its blend compatibility (`getBlendId`)
+ * - Report its intrinsic duration (`getDuration`)
+ *
+ * Generic:
+ * - `StateType` is the shape of the computed/applied state (e.g., number, vector, pose).
+ *
  * @public
  */ class AnimationTrack {
-    /** @internal */ _interpolator;
+    /** @internal */ _name;
+    /** @internal */ _embedded;
     /** @internal */ _animation;
+    /** @internal */ _target;
+    /** @internal */ _jointIndex;
     /**
-   * Creates a new animation track
-   * @param interpolator - Interpolator for the track
-   */ constructor(interpolator){
-        this._interpolator = interpolator;
+   * Construct a new animation track.
+   *
+   * @param embedded - Whether this track is embedded/owned inline by its container. Default false.
+   */ constructor(embedded){
+        this._name = 'noname';
+        this._animation = null;
+        this._embedded = !!embedded;
+        this._target = '';
+        this._jointIndex = -1;
     }
-    /** Gets the interpolator of the track */ get interpolator() {
-        return this._interpolator;
+    /**
+   * Human-readable name of the track.
+   */ get name() {
+        return this._name;
+    }
+    set name(val) {
+        this._name = val;
+    }
+    /**
+   * Whether this track is embedded (owned inline by a resource/container).
+   */ get embedded() {
+        return this._embedded;
     }
-    /** Animation this track belongs to */ get animation() {
+    /**
+   * The `AnimationClip` that owns this track.
+   */ get animation() {
         return this._animation;
     }
     set animation(ani) {
         this._animation = ani;
     }
-    /** Stops playing the track and rewind to the first frame */ reset(node) {}
+    /**
+   * Logical target identifier for this track (optional metadata).
+   *
+   * This does not affect application; it can be used by tooling or higher-level
+   * systems to label/group tracks.
+   */ get target() {
+        return this._target;
+    }
+    set target(val) {
+        this._target = val;
+    }
+    /**
+   * Joint index if this track controls a joint, otherwise -1
+   */ get jointIndex() {
+        return this._jointIndex;
+    }
+    set jointIndex(index) {
+        this._jointIndex = index;
+    }
+    /**
+   * Reset the track to its initial state for the given target.
+   *
+   * Intended to stop playback and rewind the target to the first frame or default state.
+   *
+   * @param _target - The animated object to reset.
+   */ reset(_target) {}
 }
 
 export { AnimationTrack };

package/dist/animation/animationtrack.js.map

@@ -1 +1 @@
-{"version":3,"file":"animationtrack.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"animationtrack.js","sources":["../../src/animation/animationtrack.ts"],"sourcesContent":["import type { Nullable } from '@zephyr3d/base';\r\nimport type { AnimationClip } from './animation';\r\n\r\n/**\r\n * Base class for animation tracks.\r\n *\r\n * A track produces time-varying state for a specific target and defines how to:\r\n * - Compute state at a given time (`calculateState`)\r\n * - Apply that state to a target (`applyState`)\r\n * - Blend between two states (`mixState`)\r\n * - Report its blend compatibility (`getBlendId`)\r\n * - Report its intrinsic duration (`getDuration`)\r\n *\r\n * Generic:\r\n * - `StateType` is the shape of the computed/applied state (e.g., number, vector, pose).\r\n *\r\n * @public\r\n */\r\nexport abstract class AnimationTrack<StateType = unknown> {\r\n  /** @internal */\r\n  protected _name: string;\r\n  /** @internal */\r\n  protected _embedded: boolean;\r\n  /** @internal */\r\n  protected _animation: Nullable<AnimationClip>;\r\n  /** @internal */\r\n  protected _target: string;\r\n  /** @internal */\r\n  protected _jointIndex: number;\r\n  /**\r\n   * Construct a new animation track.\r\n   *\r\n   * @param embedded - Whether this track is embedded/owned inline by its container. Default false.\r\n   */\r\n  constructor(embedded?: boolean) {\r\n    this._name = 'noname';\r\n    this._animation = null;\r\n    this._embedded = !!embedded;\r\n    this._target = '';\r\n    this._jointIndex = -1;\r\n  }\r\n  /**\r\n   * Human-readable name of the track.\r\n   */\r\n  get name() {\r\n    return this._name;\r\n  }\r\n  set name(val: string) {\r\n    this._name = val;\r\n  }\r\n  /**\r\n   * Whether this track is embedded (owned inline by a resource/container).\r\n   */\r\n  get embedded() {\r\n    return this._embedded;\r\n  }\r\n  /**\r\n   * The `AnimationClip` that owns this track.\r\n   */\r\n  get animation() {\r\n    return this._animation;\r\n  }\r\n  set animation(ani) {\r\n    this._animation = ani;\r\n  }\r\n  /**\r\n   * Logical target identifier for this track (optional metadata).\r\n   *\r\n   * This does not affect application; it can be used by tooling or higher-level\r\n   * systems to label/group tracks.\r\n   */\r\n  get target() {\r\n    return this._target;\r\n  }\r\n  set target(val: string) {\r\n    this._target = val;\r\n  }\r\n  /**\r\n   * Joint index if this track controls a joint, otherwise -1\r\n   */\r\n  get jointIndex() {\r\n    return this._jointIndex;\r\n  }\r\n  set jointIndex(index: number) {\r\n    this._jointIndex = index;\r\n  }\r\n  /**\r\n   * Reset the track to its initial state for the given target.\r\n   *\r\n   * Intended to stop playback and rewind the target to the first frame or default state.\r\n   *\r\n   * @param _target - The animated object to reset.\r\n   */\r\n  reset(_target: object) {}\r\n  /**\r\n   * Compute the animation state at the specified time.\r\n   *\r\n   * Implementations should be pure with respect to inputs: given the same `target` and\r\n   * `currentTime`, return the same `StateType`.\r\n   *\r\n   * @param target - The animated object (used to resolve current baseline if needed).\r\n   * @param currentTime - Time cursor in seconds within the track's timeline.\r\n   * @returns The computed state at `currentTime`.\r\n   */\r\n  abstract calculateState(target: object, currentTime: number): StateType;\r\n  /**\r\n   * Apply a previously computed animation state to the target.\r\n   *\r\n   * @param target - The animated object to modify.\r\n   * @param state - The state to apply.\r\n   */\r\n  abstract applyState(target: object, state: StateType): unknown;\r\n  /**\r\n   * Blend two states into a new state using a weight.\r\n   *\r\n   * @param a - First state.\r\n   * @param b - Second state.\r\n   * @param t - Blend weight in \\[0, 1\\], where 0 yields `a` and 1 yields `b`.\r\n   * @returns The blended state.\r\n   */\r\n  abstract mixState(a: StateType, b: StateType, t: number): StateType;\r\n  /**\r\n   * Get the blend identifier for this track.\r\n   *\r\n   * Tracks with the same blend ID are considered compatible for blending on the\r\n   * same target channel/property.\r\n   *\r\n   * @returns An identifier used to group compatible tracks for blending.\r\n   */\r\n  abstract getBlendId(): unknown;\r\n  /**\r\n   * Get the intrinsic duration of this track in seconds.\r\n   *\r\n   * Used by clips to determine overall clip duration and looping behavior.\r\n   *\r\n   * @returns Track duration (seconds).\r\n   */\r\n  abstract getDuration(): number;\r\n}\r\n"],"names":["AnimationTrack","embedded","_name","_animation","_embedded","_target","_jointIndex","name","val","animation","ani","target","jointIndex","index","reset"],"mappings":"AAGA;;;;;;;;;;;;;;AAcC,IACM,MAAeA,cAAAA,CAAAA;qBAEpB,KAAwB;qBAExB,SAA6B;qBAE7B,UAA8C;qBAE9C,OAA0B;qBAE1B,WAA8B;AAC9B;;;;MAKA,WAAA,CAAYC,QAAkB,CAAE;QAC9B,IAAI,CAACC,KAAK,GAAG,QAAA;QACb,IAAI,CAACC,UAAU,GAAG,IAAA;AAClB,QAAA,IAAI,CAACC,SAAS,GAAG,CAAC,CAACH,QAAAA;QACnB,IAAI,CAACI,OAAO,GAAG,EAAA;QACf,IAAI,CAACC,WAAW,GAAG,EAAC;AACtB;AACA;;AAEC,MACD,IAAIC,IAAO,GAAA;QACT,OAAO,IAAI,CAACL,KAAK;AACnB;IACA,IAAIK,IAAAA,CAAKC,GAAW,EAAE;QACpB,IAAI,CAACN,KAAK,GAAGM,GAAAA;AACf;AACA;;AAEC,MACD,IAAIP,QAAW,GAAA;QACb,OAAO,IAAI,CAACG,SAAS;AACvB;AACA;;AAEC,MACD,IAAIK,SAAY,GAAA;QACd,OAAO,IAAI,CAACN,UAAU;AACxB;IACA,IAAIM,SAAAA,CAAUC,GAAG,EAAE;QACjB,IAAI,CAACP,UAAU,GAAGO,GAAAA;AACpB;AACA;;;;;AAKC,MACD,IAAIC,MAAS,GAAA;QACX,OAAO,IAAI,CAACN,OAAO;AACrB;IACA,IAAIM,MAAAA,CAAOH,GAAW,EAAE;QACtB,IAAI,CAACH,OAAO,GAAGG,GAAAA;AACjB;AACA;;AAEC,MACD,IAAII,UAAa,GAAA;QACf,OAAO,IAAI,CAACN,WAAW;AACzB;IACA,IAAIM,UAAAA,CAAWC,KAAa,EAAE;QAC5B,IAAI,CAACP,WAAW,GAAGO,KAAAA;AACrB;AACA;;;;;;MAOAC,KAAAA,CAAMT,OAAe,EAAE;AA6CzB;;;;"}

package/dist/animation/eulerrotationtrack.js

@@ -5,39 +5,59 @@ const tmpVec3 = new Vector3();
 /**
  * Euler angle rotation animation track
  * @public
- */ class EulerRotationTrack extends AnimationTrack {
+ */ class NodeEulerRotationTrack extends AnimationTrack {
     _state;
-    /**
-   * Create an instance of EulerRotationTrack from keyframe values
-   * @param mode - The interpolation mode of keyframes
-   * @param keyFrames - Keyframe values
-   */ constructor(mode, keyFrames){
-        const inputs = new Float32Array(keyFrames.map((val)=>val.time));
-        const outputs = new Float32Array(keyFrames.length * 3);
-        for(let i = 0; i < keyFrames.length; i++){
-            outputs[i * 3 + 0] = keyFrames[i].value.x;
-            outputs[i * 3 + 1] = keyFrames[i].value.y;
-            outputs[i * 3 + 2] = keyFrames[i].value.z;
+    _interpolator;
+    constructor(modeOrInterpolator, keyFramesOrEmbedded, embedded){
+        if (modeOrInterpolator === undefined) {
+            super(false);
+        } else if (modeOrInterpolator instanceof Interpolator) {
+            if (modeOrInterpolator.target !== 'vec3') {
+                throw new Error(`EulerRotationTrack(): interpolator target must be 'vec3'`);
+            }
+            super(keyFramesOrEmbedded ?? false);
+            this._interpolator = modeOrInterpolator;
+        } else {
+            const keyFrames = keyFramesOrEmbedded;
+            const inputs = new Float32Array(keyFrames.map((val)=>val.time));
+            const outputs = new Float32Array(keyFrames.length * 3);
+            for(let i = 0; i < keyFrames.length; i++){
+                outputs[i * 3 + 0] = keyFrames[i].value.x;
+                outputs[i * 3 + 1] = keyFrames[i].value.y;
+                outputs[i * 3 + 2] = keyFrames[i].value.z;
+            }
+            super(embedded ?? false);
+            this._interpolator = new Interpolator(modeOrInterpolator, 'vec3', inputs, outputs);
         }
-        const interpolator = new Interpolator(mode, 'vec3', inputs, outputs);
-        super(interpolator);
         this._state = new Quaternion();
     }
-    calculateState(currentTime) {
+    get interpolator() {
+        return this._interpolator;
+    }
+    set interpolator(interp) {
+        if (interp && interp.target !== 'vec3') {
+            throw new Error(`EulerRotationTrack(): interpolator target must be 'vec3'`);
+        }
+        this._interpolator = interp ?? null;
+    }
+    /** {@inheritDoc AnimationTrack.calculateState} */ calculateState(target, currentTime) {
         this._interpolator.interpolate(currentTime, tmpVec3);
-        this._state.fromEulerAngle(tmpVec3.x, tmpVec3.y, tmpVec3.z, 'ZYX');
+        this._state.fromEulerAngle(tmpVec3.x, tmpVec3.y, tmpVec3.z);
         return this._state;
     }
-    applyState(node, state) {
+    /** {@inheritDoc AnimationTrack.applyState} */ applyState(node, state) {
         node.rotation.set(state);
     }
-    mixState(a, b, t) {
+    /** {@inheritDoc AnimationTrack.mixState} */ mixState(a, b, t) {
         return Quaternion.slerp(a, b, t);
     }
-    getBlendId() {
+    /** {@inheritDoc AnimationTrack.getBlendId} */ getBlendId() {
         return 'node-rotation';
     }
+    /** {@inheritDoc AnimationTrack.getDuration} */ getDuration() {
+        return this._interpolator.maxTime;
+    }
 }
 
-export { EulerRotationTrack };
+export { NodeEulerRotationTrack };
 //# sourceMappingURL=eulerrotationtrack.js.map

package/dist/animation/eulerrotationtrack.js.map

@@ -1 +1 @@
-{"version":3,"file":"eulerrotationtrack.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"eulerrotationtrack.js","sources":["../../src/animation/eulerrotationtrack.ts"],"sourcesContent":["import type { InterpolationMode } from '@zephyr3d/base';\r\nimport { Interpolator, Quaternion, Vector3 } from '@zephyr3d/base';\r\nimport { AnimationTrack } from './animationtrack';\r\nimport type { SceneNode } from '../scene';\r\n\r\nconst tmpVec3 = new Vector3();\r\n\r\n/**\r\n * Euler angle rotation animation track\r\n * @public\r\n */\r\nexport class NodeEulerRotationTrack extends AnimationTrack<Quaternion> {\r\n  private readonly _state: Quaternion;\r\n  private _interpolator!: Interpolator;\r\n  /**\r\n   * Create an instance of EulerRotationTrack\r\n   */\r\n  constructor();\r\n  /**\r\n   * Create an instance of EulerRotationTrack from keyframe values\r\n   * @param interpolator - Interpolator object that contains the keyframe values\r\n   * @param embedded - Whether this track be an embedded track\r\n   */\r\n  constructor(interpolator: Interpolator, embedded?: boolean);\r\n  /**\r\n   * Create an instance of EulerRotationTrack from keyframe values\r\n   * @param mode - The interpolation mode of keyframes\r\n   * @param keyFrames - Keyframe values\r\n   * @param embedded - Whether this track be an embedded track\r\n   */\r\n  constructor(mode: InterpolationMode, keyFrames: { time: number; value: Vector3 }[], embedded?: boolean);\r\n  constructor(\r\n    modeOrInterpolator?: Interpolator | InterpolationMode,\r\n    keyFramesOrEmbedded?: { time: number; value: Vector3 }[] | boolean,\r\n    embedded?: boolean\r\n  ) {\r\n    if (modeOrInterpolator === undefined) {\r\n      super(false);\r\n    } else if (modeOrInterpolator instanceof Interpolator) {\r\n      if (modeOrInterpolator.target !== 'vec3') {\r\n        throw new Error(`EulerRotationTrack(): interpolator target must be 'vec3'`);\r\n      }\r\n      super((keyFramesOrEmbedded as boolean) ?? false);\r\n      this._interpolator = modeOrInterpolator;\r\n    } else {\r\n      const keyFrames = keyFramesOrEmbedded as { time: number; value: Vector3 }[];\r\n      const inputs = new Float32Array(keyFrames.map((val) => val.time));\r\n      const outputs = new Float32Array(keyFrames.length * 3);\r\n      for (let i = 0; i < keyFrames.length; i++) {\r\n        outputs[i * 3 + 0] = keyFrames[i].value.x;\r\n        outputs[i * 3 + 1] = keyFrames[i].value.y;\r\n        outputs[i * 3 + 2] = keyFrames[i].value.z;\r\n      }\r\n      super(embedded ?? false);\r\n      this._interpolator = new Interpolator(modeOrInterpolator, 'vec3', inputs, outputs);\r\n    }\r\n    this._state = new Quaternion();\r\n  }\r\n  get interpolator() {\r\n    return this._interpolator;\r\n  }\r\n  set interpolator(interp: Interpolator) {\r\n    if (interp && interp.target !== 'vec3') {\r\n      throw new Error(`EulerRotationTrack(): interpolator target must be 'vec3'`);\r\n    }\r\n    this._interpolator = interp ?? null;\r\n  }\r\n  /** {@inheritDoc AnimationTrack.calculateState} */\r\n  calculateState(target: object, currentTime: number) {\r\n    this._interpolator.interpolate(currentTime, tmpVec3);\r\n    this._state.fromEulerAngle(tmpVec3.x, tmpVec3.y, tmpVec3.z);\r\n    return this._state;\r\n  }\r\n  /** {@inheritDoc AnimationTrack.applyState} */\r\n  applyState(node: SceneNode, state: Quaternion) {\r\n    node.rotation.set(state);\r\n  }\r\n  /** {@inheritDoc AnimationTrack.mixState} */\r\n  mixState(a: Quaternion, b: Quaternion, t: number) {\r\n    return Quaternion.slerp(a, b, t);\r\n  }\r\n  /** {@inheritDoc AnimationTrack.getBlendId} */\r\n  getBlendId() {\r\n    return 'node-rotation';\r\n  }\r\n  /** {@inheritDoc AnimationTrack.getDuration} */\r\n  getDuration() {\r\n    return this._interpolator.maxTime;\r\n  }\r\n}\r\n"],"names":["tmpVec3","Vector3","NodeEulerRotationTrack","AnimationTrack","_state","_interpolator","modeOrInterpolator","keyFramesOrEmbedded","embedded","undefined","Interpolator","target","Error","keyFrames","inputs","Float32Array","map","val","time","outputs","length","i","value","x","y","z","Quaternion","interpolator","interp","calculateState","currentTime","interpolate","fromEulerAngle","applyState","node","state","rotation","set","mixState","a","b","t","slerp","getBlendId","getDuration","maxTime"],"mappings":"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"}

package/dist/animation/morphtarget.js

@@ -1,34 +1,21 @@
-import { PBStructTypeInfo, PBArrayTypeInfo, PBPrimitiveTypeInfo, PBPrimitiveType } from '@zephyr3d/device';
-import { Application } from '../app.js';
-import { MAX_MORPH_ATTRIBUTES, MAX_MORPH_TARGETS, MORPH_WEIGHTS_VECTOR_COUNT, MORPH_ATTRIBUTE_VECTOR_COUNT } from '../values.js';
-import { ShaderHelper } from '../material/shader/helper.js';
-import '../material/lambert.js';
-import '../material/blinn.js';
-import '../material/unlit.js';
-import '../material/meshmaterial.js';
-import '../material/grassmaterial.js';
-import '../material/terrainmaterial.js';
-import '../material/pbrmr.js';
-import '../material/pbrsg.js';
-import '@zephyr3d/base';
-import '../utility/pmrem.js';
-import '../utility/panorama.js';
-import '../utility/shprojection.js';
+import { MAX_MORPH_ATTRIBUTES, MAX_MORPH_TARGETS } from '../values.js';
 import { BoundingBox } from '../utility/bounding_volume.js';
+import { getDevice } from '../app/api.js';
 
-function processMorphData(subMesh, morphWeights) {
+/** @internal */ function processMorphData(subMesh, morphWeights) {
+    const device = getDevice();
     const numTargets = subMesh.numTargets;
     if (numTargets === 0) {
         return;
     }
     const attributes = Object.getOwnPropertyNames(subMesh.targets);
-    const numVertices = subMesh.primitive.getNumVertices();
+    const numVertices = subMesh.primitive.get().getNumVertices();
     const weightsAndOffsets = new Float32Array(4 + MAX_MORPH_TARGETS + MAX_MORPH_ATTRIBUTES);
     for(let i = 0; i < numTargets; i++){
         weightsAndOffsets[4 + i] = morphWeights?.[i] ?? 0;
     }
     const textureSize = Math.ceil(Math.sqrt(numVertices * attributes.length * numTargets));
-    if (textureSize > Application.instance.device.getDeviceCaps().textureCaps.maxTextureSize) {
+    if (textureSize > device.getDeviceCaps().textureCaps.maxTextureSize) {
         // TODO: reduce morph attributes
         throw new Error(`Morph target data too large`);
     }
@@ -59,30 +46,25 @@ function processMorphData(subMesh, morphWeights) {
             }
         }
     }
-    const morphTexture = Application.instance.device.createTexture2D('rgba32f', textureSize, textureSize, {
-        samplerOptions: {
-            minFilter: 'nearest',
-            magFilter: 'nearest',
-            mipFilter: 'none'
-        }
-    });
-    morphTexture.update(textureData, 0, 0, textureSize, textureSize);
-    const bufferType = new PBStructTypeInfo('dummy', 'std140', [
-        {
-            name: ShaderHelper.getMorphInfoUniformName(),
-            type: new PBArrayTypeInfo(new PBPrimitiveTypeInfo(PBPrimitiveType.F32VEC4), 1 + MORPH_WEIGHTS_VECTOR_COUNT + MORPH_ATTRIBUTE_VECTOR_COUNT)
-        }
-    ]);
-    const morphUniformBuffer = Application.instance.device.createStructuredBuffer(bufferType, {
-        usage: 'uniform'
-    }, weightsAndOffsets);
     const morphBoundingBox = new BoundingBox();
     calculateMorphBoundingBox(morphBoundingBox, subMesh.targetBox, weightsAndOffsets.subarray(4, 4 + MAX_MORPH_TARGETS), numTargets);
     const meshAABB = subMesh.mesh.getBoundingVolume().toAABB();
     morphBoundingBox.minPoint.addBy(meshAABB.minPoint);
     morphBoundingBox.maxPoint.addBy(meshAABB.maxPoint);
-    subMesh.mesh.setMorphData(morphTexture);
-    subMesh.mesh.setMorphInfo(morphUniformBuffer);
+    const names = {};
+    for(let i = 0; i < numTargets; i++){
+        const name = `Target${i}`;
+        names[name] = i;
+    }
+    subMesh.mesh.setMorphData({
+        width: textureSize,
+        height: textureSize,
+        data: textureData
+    });
+    subMesh.mesh.setMorphInfo({
+        data: weightsAndOffsets,
+        names
+    });
     subMesh.mesh.setAnimatedBoundingBox(morphBoundingBox);
 }
 /** @internal */ function calculateMorphBoundingBox(morphBoundingBox, keyframeBoundingBox, weights, numTargets) {

package/dist/animation/morphtarget.js.map

@@ -1 +1 @@
-{"version":3,"file":"morphtarget.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"morphtarget.js","sources":["../../src/animation/morphtarget.ts"],"sourcesContent":["import type { AssetSubMeshData } from '../asset';\r\nimport { MAX_MORPH_ATTRIBUTES, MAX_MORPH_TARGETS } from '../values';\r\nimport { BoundingBox } from '../utility/bounding_volume';\r\nimport { getDevice } from '../app/api';\r\n\r\n/** @internal */\r\nexport function processMorphData(subMesh: AssetSubMeshData, morphWeights: number[]) {\r\n  const device = getDevice();\r\n  const numTargets = subMesh.numTargets;\r\n  if (numTargets === 0) {\r\n    return;\r\n  }\r\n  const attributes = Object.getOwnPropertyNames(subMesh.targets);\r\n  const numVertices = subMesh.primitive.get()!.getNumVertices();\r\n  const weightsAndOffsets = new Float32Array(4 + MAX_MORPH_TARGETS + MAX_MORPH_ATTRIBUTES);\r\n  for (let i = 0; i < numTargets; i++) {\r\n    weightsAndOffsets[4 + i] = morphWeights?.[i] ?? 0;\r\n  }\r\n  const textureSize = Math.ceil(Math.sqrt(numVertices * attributes.length * numTargets));\r\n  if (textureSize > device.getDeviceCaps().textureCaps.maxTextureSize) {\r\n    // TODO: reduce morph attributes\r\n    throw new Error(`Morph target data too large`);\r\n  }\r\n  weightsAndOffsets[0] = textureSize;\r\n  weightsAndOffsets[1] = textureSize;\r\n  weightsAndOffsets[2] = numVertices;\r\n  weightsAndOffsets[3] = numTargets;\r\n  let offset = 0;\r\n  const textureData = new Float32Array(textureSize * textureSize * 4);\r\n  for (let attrib = 0; attrib < MAX_MORPH_ATTRIBUTES; attrib++) {\r\n    const index = attributes.indexOf(String(attrib));\r\n    if (index < 0) {\r\n      weightsAndOffsets[4 + MAX_MORPH_TARGETS + attrib] = -1;\r\n      continue;\r\n    }\r\n    weightsAndOffsets[4 + MAX_MORPH_TARGETS + attrib] = offset >> 2;\r\n    const info = subMesh.targets![attrib]!;\r\n    if (info.data.length !== numTargets) {\r\n      console.error(`Invalid morph target data`);\r\n      return;\r\n    }\r\n    for (let t = 0; t < numTargets; t++) {\r\n      const data = info.data[t];\r\n      for (let i = 0; i < numVertices; i++) {\r\n        for (let j = 0; j < 4; j++) {\r\n          textureData[offset++] = j < info.numComponents ? data[i * info.numComponents + j] : 1;\r\n        }\r\n      }\r\n    }\r\n  }\r\n  const morphBoundingBox = new BoundingBox();\r\n  calculateMorphBoundingBox(\r\n    morphBoundingBox,\r\n    subMesh.targetBox!,\r\n    weightsAndOffsets.subarray(4, 4 + MAX_MORPH_TARGETS),\r\n    numTargets\r\n  );\r\n  const meshAABB = subMesh.mesh!.getBoundingVolume()!.toAABB();\r\n  morphBoundingBox.minPoint.addBy(meshAABB.minPoint);\r\n  morphBoundingBox.maxPoint.addBy(meshAABB.maxPoint);\r\n\r\n  const names: Record<string, number> = {};\r\n  for (let i = 0; i < numTargets; i++) {\r\n    const name = `Target${i}`;\r\n    names[name] = i;\r\n  }\r\n\r\n  subMesh.mesh!.setMorphData({ width: textureSize, height: textureSize, data: textureData });\r\n  subMesh.mesh!.setMorphInfo({ data: weightsAndOffsets, names });\r\n  subMesh.mesh!.setAnimatedBoundingBox(morphBoundingBox);\r\n}\r\n\r\n/** @internal */\r\nexport function calculateMorphBoundingBox(\r\n  morphBoundingBox: BoundingBox,\r\n  keyframeBoundingBox: BoundingBox[],\r\n  weights: Float32Array,\r\n  numTargets: number\r\n) {\r\n  morphBoundingBox.minPoint.setXYZ(0, 0, 0);\r\n  morphBoundingBox.maxPoint.setXYZ(0, 0, 0);\r\n  for (let i = 0; i < numTargets; i++) {\r\n    const weight = weights[i];\r\n    const keyframeBox = keyframeBoundingBox[i];\r\n    morphBoundingBox.minPoint.x += keyframeBox.minPoint.x * weight;\r\n    morphBoundingBox.minPoint.y += keyframeBox.minPoint.y * weight;\r\n    morphBoundingBox.minPoint.y += keyframeBox.minPoint.z * weight;\r\n    morphBoundingBox.maxPoint.x += keyframeBox.maxPoint.x * weight;\r\n    morphBoundingBox.maxPoint.y += keyframeBox.maxPoint.y * weight;\r\n    morphBoundingBox.maxPoint.y += keyframeBox.maxPoint.z * weight;\r\n  }\r\n}\r\n"],"names":["processMorphData","subMesh","morphWeights","device","getDevice","numTargets","attributes","Object","getOwnPropertyNames","targets","numVertices","primitive","get","getNumVertices","weightsAndOffsets","Float32Array","MAX_MORPH_TARGETS","MAX_MORPH_ATTRIBUTES","i","textureSize","Math","ceil","sqrt","length","getDeviceCaps","textureCaps","maxTextureSize","Error","offset","textureData","attrib","index","indexOf","String","info","data","console","error","t","j","numComponents","morphBoundingBox","BoundingBox","calculateMorphBoundingBox","targetBox","subarray","meshAABB","mesh","getBoundingVolume","toAABB","minPoint","addBy","maxPoint","names","name","setMorphData","width","height","setMorphInfo","setAnimatedBoundingBox","keyframeBoundingBox","weights","setXYZ","weight","keyframeBox","x","y","z"],"mappings":"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"}

package/dist/animation/morphtrack.js

@@ -1,13 +1,8 @@
 import { AnimationTrack } from './animationtrack.js';
-import '../utility/pmrem.js';
-import '../utility/panorama.js';
-import '../utility/shprojection.js';
-import { Vector3 } from '@zephyr3d/base';
 import { BoundingBox } from '../utility/bounding_volume.js';
-import '../app.js';
-import '@zephyr3d/device';
 import { MAX_MORPH_TARGETS } from '../values.js';
 import { calculateMorphBoundingBox } from './morphtarget.js';
+import { Vector3 } from '@zephyr3d/base';
 
 /**
  * Morph target track
@@ -17,33 +12,72 @@ import { calculateMorphBoundingBox } from './morphtarget.js';
     _originBox;
     _boundingBox;
     _defaultWeights;
+    _interpolator;
     /**
    * Create an instance of MorphTargetTrack
-   */ constructor(assetTrack, subMesh){
-        super(assetTrack.interpolator);
-        this._state = {
-            numTargets: assetTrack.interpolator.stride,
+   */ constructor(interpolator, defaultMorphWeights, targetBox, originBox, embedded){
+        super(embedded);
+        if (interpolator === undefined) {
+            this._interpolator = null;
+            this._state = null;
+            this._boundingBox = null;
+            this._originBox = null;
+            this._defaultWeights = null;
+        } else {
+            this._interpolator = interpolator;
+            this._state = {
+                numTargets: interpolator.stride,
+                boundingBox: new BoundingBox(),
+                weights: new Float32Array(MAX_MORPH_TARGETS)
+            };
+            this._boundingBox = targetBox ?? null;
+            this._originBox = originBox ?? null;
+            this._defaultWeights = defaultMorphWeights ?? Array.from({
+                length: this._state.numTargets
+            }).map(()=>0);
+        }
+    }
+    get interpolator() {
+        return this._interpolator;
+    }
+    set interpolator(interp) {
+        this._interpolator = interp ?? null;
+        this._state = this._interpolator ? {
+            numTargets: this._interpolator.stride,
             boundingBox: new BoundingBox(),
             weights: new Float32Array(MAX_MORPH_TARGETS)
-        };
-        this._boundingBox = subMesh.targetBox;
-        this._originBox = subMesh.mesh.getBoundingVolume().toAABB();
-        this._defaultWeights = assetTrack.defaultMorphWeights ?? Array.from({
-            length: this._state.numTargets
-        }).map(()=>0);
+        } : null;
+    }
+    get boundingBox() {
+        return this._boundingBox;
     }
-    calculateState(currentTime) {
+    set boundingBox(box) {
+        this._boundingBox = box;
+    }
+    get defaultWeights() {
+        return this._defaultWeights;
+    }
+    set defaultWeights(value) {
+        this._defaultWeights = value;
+    }
+    get originBoundingBox() {
+        return this._originBox;
+    }
+    set originBoundingBox(box) {
+        this._originBox = box;
+    }
+    /** {@inheritDoc AnimationTrack.calculateState} */ calculateState(target, currentTime) {
         this._interpolator.interpolate(currentTime, this._state.weights);
         calculateMorphBoundingBox(this._state.boundingBox, this._boundingBox, this._state.weights, this._state.numTargets);
         return this._state;
     }
-    applyState(node, state) {
-        node.getMorphInfo().bufferSubData(4 * 4, state.weights);
+    /** {@inheritDoc AnimationTrack.applyState} */ applyState(node, state) {
+        node.getMorphInfo().buffer.get().bufferSubData(4 * 4, state.weights);
         state.boundingBox.minPoint.addBy(this._originBox.minPoint);
         state.boundingBox.maxPoint.addBy(this._originBox.maxPoint);
         node.setAnimatedBoundingBox(state.boundingBox);
     }
-    mixState(a, b, t) {
+    /** {@inheritDoc AnimationTrack.mixState} */ mixState(a, b, t) {
         const state = {
             weights: new Float32Array(a.numTargets),
             boundingBox: new BoundingBox(),
@@ -56,10 +90,13 @@ import { calculateMorphBoundingBox } from './morphtarget.js';
         }
         return state;
     }
-    getBlendId() {
+    /** {@inheritDoc AnimationTrack.getBlendId} */ getBlendId() {
         return 'node-morph';
     }
-    reset(node) {
+    /** {@inheritDoc AnimationTrack.getDuration} */ getDuration() {
+        return this._interpolator?.maxTime ?? 0;
+    }
+    /** {@inheritDoc AnimationTrack.reset} */ reset(node) {
         // apply default weights
         this._state.weights.set(this._defaultWeights);
         this.applyState(node, this._state);

package/dist/animation/morphtrack.js.map

@@ -1 +1 @@
-{"version":3,"file":"morphtrack.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"morphtrack.js","sources":["../../src/animation/morphtrack.ts"],"sourcesContent":["import { AnimationTrack } from './animationtrack';\r\nimport type { Mesh, SceneNode } from '../scene';\r\nimport { BoundingBox } from '../utility/bounding_volume';\r\nimport { MAX_MORPH_TARGETS } from '../values';\r\nimport { calculateMorphBoundingBox } from './morphtarget';\r\nimport type { AABB, Interpolator, Nullable } from '@zephyr3d/base';\r\nimport { Vector3 } from '@zephyr3d/base';\r\n\r\n/**\r\n * Morph animation state\r\n *\r\n * @public\r\n **/\r\nexport type MorphState = {\r\n  numTargets: number;\r\n  weights: Float32Array<ArrayBuffer>;\r\n  boundingBox: BoundingBox;\r\n};\r\n\r\n/**\r\n * Morph target track\r\n * @public\r\n */\r\nexport class MorphTargetTrack extends AnimationTrack<MorphState> {\r\n  private _state: Nullable<MorphState>;\r\n  private _originBox: Nullable<AABB>;\r\n  private _boundingBox: Nullable<BoundingBox[]>;\r\n  private _defaultWeights: Nullable<number[]>;\r\n  private _interpolator: Nullable<Interpolator>;\r\n  /**\r\n   * Create an instance of MorphTargetTrack\r\n   */\r\n  constructor();\r\n  /**\r\n   * Create an instance of MorphTargetTrack from morph parameters\r\n   */\r\n  constructor(\r\n    interpolator?: Interpolator,\r\n    defaultMorphWeights?: number[],\r\n    targetBox?: BoundingBox[],\r\n    originBox?: AABB,\r\n    embedded?: boolean\r\n  );\r\n  /**\r\n   * Create an instance of MorphTargetTrack\r\n   */\r\n  constructor(\r\n    interpolator?: Interpolator,\r\n    defaultMorphWeights?: number[],\r\n    targetBox?: BoundingBox[],\r\n    originBox?: AABB,\r\n    embedded?: boolean\r\n  ) {\r\n    super(embedded);\r\n    if (interpolator === undefined) {\r\n      this._interpolator = null;\r\n      this._state = null;\r\n      this._boundingBox = null;\r\n      this._originBox = null;\r\n      this._defaultWeights = null;\r\n    } else {\r\n      this._interpolator = interpolator;\r\n      this._state = {\r\n        numTargets: interpolator.stride,\r\n        boundingBox: new BoundingBox(),\r\n        weights: new Float32Array(MAX_MORPH_TARGETS)\r\n      };\r\n      this._boundingBox = targetBox ?? null;\r\n      this._originBox = originBox ?? null;\r\n      this._defaultWeights =\r\n        defaultMorphWeights ?? Array.from({ length: this._state.numTargets }).map(() => 0);\r\n    }\r\n  }\r\n  get interpolator() {\r\n    return this._interpolator;\r\n  }\r\n  set interpolator(interp: Nullable<Interpolator>) {\r\n    this._interpolator = interp ?? null;\r\n    this._state = this._interpolator\r\n      ? {\r\n          numTargets: this._interpolator.stride,\r\n          boundingBox: new BoundingBox(),\r\n          weights: new Float32Array(MAX_MORPH_TARGETS)\r\n        }\r\n      : null;\r\n  }\r\n  get boundingBox() {\r\n    return this._boundingBox;\r\n  }\r\n  set boundingBox(box: Nullable<BoundingBox[]>) {\r\n    this._boundingBox = box;\r\n  }\r\n  get defaultWeights() {\r\n    return this._defaultWeights;\r\n  }\r\n  set defaultWeights(value: Nullable<number[]>) {\r\n    this._defaultWeights = value;\r\n  }\r\n  get originBoundingBox() {\r\n    return this._originBox;\r\n  }\r\n  set originBoundingBox(box: Nullable<AABB>) {\r\n    this._originBox = box;\r\n  }\r\n  /** {@inheritDoc AnimationTrack.calculateState} */\r\n\r\n  calculateState(target: object, currentTime: number) {\r\n    this._interpolator!.interpolate(currentTime, this._state!.weights);\r\n    calculateMorphBoundingBox(\r\n      this._state!.boundingBox,\r\n      this._boundingBox!,\r\n      this._state!.weights,\r\n      this._state!.numTargets\r\n    );\r\n    return this._state!;\r\n  }\r\n  /** {@inheritDoc AnimationTrack.applyState} */\r\n  applyState(node: SceneNode, state: MorphState) {\r\n    (node as Mesh)\r\n      .getMorphInfo()!\r\n      .buffer!.get()!\r\n      .bufferSubData(4 * 4, state.weights);\r\n    state.boundingBox.minPoint.addBy(this._originBox!.minPoint);\r\n    state.boundingBox.maxPoint.addBy(this._originBox!.maxPoint);\r\n    (node as Mesh).setAnimatedBoundingBox(state.boundingBox);\r\n  }\r\n  /** {@inheritDoc AnimationTrack.mixState} */\r\n  mixState(a: MorphState, b: MorphState, t: number) {\r\n    const state: MorphState = {\r\n      weights: new Float32Array(a.numTargets),\r\n      boundingBox: new BoundingBox(),\r\n      numTargets: a.numTargets\r\n    };\r\n    for (let i = 0; i < a.numTargets; i++) {\r\n      state.weights[i] = a.weights[i] + (b.weights[i] - a.weights[i]) * t;\r\n      state.boundingBox.minPoint = Vector3.min(a.boundingBox.minPoint, b.boundingBox.minPoint);\r\n      state.boundingBox.maxPoint = Vector3.max(a.boundingBox.maxPoint, b.boundingBox.maxPoint);\r\n    }\r\n    return state;\r\n  }\r\n  /** {@inheritDoc AnimationTrack.getBlendId} */\r\n  getBlendId() {\r\n    return 'node-morph';\r\n  }\r\n  /** {@inheritDoc AnimationTrack.getDuration} */\r\n  getDuration() {\r\n    return this._interpolator?.maxTime ?? 0;\r\n  }\r\n  /** {@inheritDoc AnimationTrack.reset} */\r\n  reset(node: SceneNode) {\r\n    // apply default weights\r\n    this._state!.weights.set(this._defaultWeights!);\r\n    this.applyState(node, this._state!);\r\n  }\r\n}\r\n"],"names":["MorphTargetTrack","AnimationTrack","_state","_originBox","_boundingBox","_defaultWeights","_interpolator","interpolator","defaultMorphWeights","targetBox","originBox","embedded","undefined","numTargets","stride","boundingBox","BoundingBox","weights","Float32Array","MAX_MORPH_TARGETS","Array","from","length","map","interp","box","defaultWeights","value","originBoundingBox","calculateState","target","currentTime","interpolate","calculateMorphBoundingBox","applyState","node","state","getMorphInfo","buffer","get","bufferSubData","minPoint","addBy","maxPoint","setAnimatedBoundingBox","mixState","a","b","t","i","Vector3","min","max","getBlendId","getDuration","maxTime","reset","set"],"mappings":"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"}