Struct AnimationPlayer 

#[non_exhaustive]
pub struct AnimationPlayer {
    pub clip: Option<Arc<AnimationClip>>,
    pub elapsed_time: f32,
    pub speed: f32,
    pub playing: bool,
    pub looping: bool,
    pub target_entities: HashMap<String, Entity>,
}

Component that drives an AnimationClip over time.

Attach this to the root entity of a hierarchy; the animation system advances Self::elapsed_time, resolves each track’s target_name to a child entity (caching the result in Self::target_entities), and writes the sampled transform values to those entities.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

clip: Option<Arc<AnimationClip>>

The clip currently being played, if any.

elapsed_time: f32

Current playback position, in seconds.

speed: f32

Playback speed multiplier (1.0 is real time).

playing: bool

Whether playback is currently advancing.

looping: bool

Whether the clip restarts from the beginning when it ends.

target_entities: HashMap<String, Entity>

Cache mapping each track’s target_name to the resolved entity.

Implementations

impl AnimationPlayer

pub fn new() -> AnimationPlayer

Creates a player with default settings (equivalent to Default::default).

pub fn play(&mut self, clip: Arc<AnimationClip>) -> &mut AnimationPlayer

Starts playing clip from the beginning, clearing any cached target entities.

pub fn pause(&mut self) -> &mut AnimationPlayer

Pauses playback, leaving Self::elapsed_time untouched.

pub fn resume(&mut self) -> &mut AnimationPlayer

Resumes playback from the current position.

pub fn with_speed(self, speed: f32) -> AnimationPlayer

Builder: sets the playback Self::speed multiplier.

A non-finite speed (NaN/±∞) is rejected and falls back to 1.0 so it cannot poison Self::elapsed_time during playback.

pub fn looping(self, looping: bool) -> AnimationPlayer

Builder: sets whether playback Self::looping.

pub fn advance(&mut self, dt: f32, duration: f32)

Advances playback by dt seconds against a clip of duration seconds.

A non-finite Self::speed (NaN/±∞) falls back to 1.0 so it cannot poison Self::elapsed_time. When Self::looping, elapsed_time wraps within the clip length; otherwise it is clamped to [0, duration] and playback stops the instant it reaches an end, so a non-looping clip does not overshoot its final frame by one tick.

Reverse playback (speed < 0) is supported: looping wraps with rem_euclid (a plain % keeps the dividend’s sign, so a negative time stays negative and the sampler pins the pose at frame 0 — see the sibling skeletal fix in gizmo-renderer::animation_system); non-looping reverse completes at the clip start (elapsed_time <= 0) instead of running unbounded-negative with playing stuck true.

Trait Implementations

impl Clone for AnimationPlayer

fn clone(&self) -> AnimationPlayer

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Component for AnimationPlayer

fn storage_type() -> StorageType

impl Debug for AnimationPlayer

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for AnimationPlayer

fn default() -> AnimationPlayer

Returns the “default value” for a type.