Struct AnimationTransitions

pub struct AnimationTransitions { /* private fields */ }

Manages fade-out of animation blend factors, allowing for smooth transitions between animations.

To use this component, place it on the same entity as the AnimationPlayer and AnimationGraphHandle. It’ll take responsibility for adjusting the weight on the ActiveAnimation in order to fade out animations smoothly.

When using an AnimationTransitions component, you should play all animations through the AnimationTransitions::play method, rather than by directly manipulating the AnimationPlayer. Playing animations through the AnimationPlayer directly will cause the AnimationTransitions component to get confused about which animation is the “main” animation, and transitions will usually be incorrect as a result.

Implementations

impl AnimationTransitions

pub fn new() -> AnimationTransitions

Creates a new AnimationTransitions component, ready to be added to an entity with an AnimationPlayer.

Examples found in repository

examples/stress_tests/many_foxes.rs (line 244)

fn setup_scene_once_loaded(
    animations: Res<Animations>,
    foxes: Res<Foxes>,
    mut commands: Commands,
    mut player: Query<(Entity, &mut AnimationPlayer)>,
    mut done: Local<bool>,
) {
    if !*done && player.iter().len() == foxes.count {
        for (entity, mut player) in &mut player {
            commands
                .entity(entity)
                .insert(AnimationGraphHandle(animations.graph.clone()))
                .insert(AnimationTransitions::new());

            let playing_animation = player.play(animations.node_indices[0]).repeat();
            if !foxes.sync {
                playing_animation.seek_to(entity.index() as f32 / 10.0);
            }
        }
        *done = true;
    }
}

examples/testbed/3d.rs (line 291)

    fn pause_animation_frame(
        trigger: Trigger<SceneInstanceReady>,
        children: Query<&Children>,
        mut commands: Commands,
        animation: Res<Animation>,
        mut players: Query<(Entity, &mut AnimationPlayer)>,
    ) {
        let entity = children.get(trigger.entity()).unwrap()[0];
        let entity = children.get(entity).unwrap()[0];

        let (entity, mut player) = players.get_mut(entity).unwrap();
        let mut transitions = AnimationTransitions::new();
        transitions
            .play(&mut player, animation.animation, Duration::ZERO)
            .seek_to(0.5)
            .pause();

        commands
            .entity(entity)
            .insert(AnimationGraphHandle(animation.graph.clone()))
            .insert(transitions);
    }

examples/animation/animated_fox.rs (line 162)

fn setup_scene_once_loaded(
    mut commands: Commands,
    animations: Res<Animations>,
    feet: Res<FoxFeetTargets>,
    graphs: Res<Assets<AnimationGraph>>,
    mut clips: ResMut<Assets<AnimationClip>>,
    mut players: Query<(Entity, &mut AnimationPlayer), Added<AnimationPlayer>>,
) {
    fn get_clip<'a>(
        node: AnimationNodeIndex,
        graph: &AnimationGraph,
        clips: &'a mut Assets<AnimationClip>,
    ) -> &'a mut AnimationClip {
        let node = graph.get(node).unwrap();
        let clip = match &node.node_type {
            AnimationNodeType::Clip(handle) => clips.get_mut(handle),
            _ => unreachable!(),
        };
        clip.unwrap()
    }

    for (entity, mut player) in &mut players {
        let graph = graphs.get(&animations.graph).unwrap();

        // Send `OnStep` events once the fox feet hits the ground in the running animation.
        let running_animation = get_clip(animations.animations[0], graph, &mut clips);
        // You can determine the time an event should trigger if you know witch frame it occurs and
        // the frame rate of the animation. Let's say we want to trigger an event at frame 15,
        // and the animation has a frame rate of 24 fps, then time = 15 / 24 = 0.625.
        running_animation.add_event_to_target(feet.front_left, 0.625, OnStep);
        running_animation.add_event_to_target(feet.front_right, 0.5, OnStep);
        running_animation.add_event_to_target(feet.back_left, 0.0, OnStep);
        running_animation.add_event_to_target(feet.back_right, 0.125, OnStep);

        let mut transitions = AnimationTransitions::new();

        // Make sure to start the animation via the `AnimationTransitions`
        // component. The `AnimationTransitions` component wants to manage all
        // the animations and will get confused if the animations are started
        // directly via the `AnimationPlayer`.
        transitions
            .play(&mut player, animations.animations[0], Duration::ZERO)
            .repeat();

        commands
            .entity(entity)
            .insert(AnimationGraphHandle(animations.graph.clone()))
            .insert(transitions);
    }
}

pub fn play<'p>( &mut self, player: &'p mut AnimationPlayer, new_animation: NodeIndex, transition_duration: Duration, ) -> &'p mut ActiveAnimation

Plays a new animation on the given AnimationPlayer, fading out any existing animations that were already playing over the transition_duration.

Pass Duration::ZERO to instantly switch to a new animation, avoiding any transition.

Examples found in repository

examples/testbed/3d.rs (line 293)

    fn pause_animation_frame(
        trigger: Trigger<SceneInstanceReady>,
        children: Query<&Children>,
        mut commands: Commands,
        animation: Res<Animation>,
        mut players: Query<(Entity, &mut AnimationPlayer)>,
    ) {
        let entity = children.get(trigger.entity()).unwrap()[0];
        let entity = children.get(entity).unwrap()[0];

        let (entity, mut player) = players.get_mut(entity).unwrap();
        let mut transitions = AnimationTransitions::new();
        transitions
            .play(&mut player, animation.animation, Duration::ZERO)
            .seek_to(0.5)
            .pause();

        commands
            .entity(entity)
            .insert(AnimationGraphHandle(animation.graph.clone()))
            .insert(transitions);
    }

examples/stress_tests/many_foxes.rs (lines 321-325)

fn keyboard_animation_control(
    keyboard_input: Res<ButtonInput<KeyCode>>,
    mut animation_player: Query<(&mut AnimationPlayer, &mut AnimationTransitions)>,
    animations: Res<Animations>,
    mut current_animation: Local<usize>,
    mut foxes: ResMut<Foxes>,
) {
    if keyboard_input.just_pressed(KeyCode::Space) {
        foxes.moving = !foxes.moving;
    }

    if keyboard_input.just_pressed(KeyCode::ArrowUp) {
        foxes.speed *= 1.25;
    }

    if keyboard_input.just_pressed(KeyCode::ArrowDown) {
        foxes.speed *= 0.8;
    }

    if keyboard_input.just_pressed(KeyCode::Enter) {
        *current_animation = (*current_animation + 1) % animations.node_indices.len();
    }

    for (mut player, mut transitions) in &mut animation_player {
        if keyboard_input.just_pressed(KeyCode::Space) {
            if player.all_paused() {
                player.resume_all();
            } else {
                player.pause_all();
            }
        }

        if keyboard_input.just_pressed(KeyCode::ArrowUp) {
            player.adjust_speeds(1.25);
        }

        if keyboard_input.just_pressed(KeyCode::ArrowDown) {
            player.adjust_speeds(0.8);
        }

        if keyboard_input.just_pressed(KeyCode::ArrowLeft) {
            player.seek_all_by(-0.1);
        }

        if keyboard_input.just_pressed(KeyCode::ArrowRight) {
            player.seek_all_by(0.1);
        }

        if keyboard_input.just_pressed(KeyCode::Enter) {
            transitions
                .play(
                    &mut player,
                    animations.node_indices[*current_animation],
                    Duration::from_millis(250),
                )
                .repeat();
        }
    }
}

examples/animation/animated_fox.rs (line 169)

fn setup_scene_once_loaded(
    mut commands: Commands,
    animations: Res<Animations>,
    feet: Res<FoxFeetTargets>,
    graphs: Res<Assets<AnimationGraph>>,
    mut clips: ResMut<Assets<AnimationClip>>,
    mut players: Query<(Entity, &mut AnimationPlayer), Added<AnimationPlayer>>,
) {
    fn get_clip<'a>(
        node: AnimationNodeIndex,
        graph: &AnimationGraph,
        clips: &'a mut Assets<AnimationClip>,
    ) -> &'a mut AnimationClip {
        let node = graph.get(node).unwrap();
        let clip = match &node.node_type {
            AnimationNodeType::Clip(handle) => clips.get_mut(handle),
            _ => unreachable!(),
        };
        clip.unwrap()
    }

    for (entity, mut player) in &mut players {
        let graph = graphs.get(&animations.graph).unwrap();

        // Send `OnStep` events once the fox feet hits the ground in the running animation.
        let running_animation = get_clip(animations.animations[0], graph, &mut clips);
        // You can determine the time an event should trigger if you know witch frame it occurs and
        // the frame rate of the animation. Let's say we want to trigger an event at frame 15,
        // and the animation has a frame rate of 24 fps, then time = 15 / 24 = 0.625.
        running_animation.add_event_to_target(feet.front_left, 0.625, OnStep);
        running_animation.add_event_to_target(feet.front_right, 0.5, OnStep);
        running_animation.add_event_to_target(feet.back_left, 0.0, OnStep);
        running_animation.add_event_to_target(feet.back_right, 0.125, OnStep);

        let mut transitions = AnimationTransitions::new();

        // Make sure to start the animation via the `AnimationTransitions`
        // component. The `AnimationTransitions` component wants to manage all
        // the animations and will get confused if the animations are started
        // directly via the `AnimationPlayer`.
        transitions
            .play(&mut player, animations.animations[0], Duration::ZERO)
            .repeat();

        commands
            .entity(entity)
            .insert(AnimationGraphHandle(animations.graph.clone()))
            .insert(transitions);
    }
}

fn keyboard_animation_control(
    keyboard_input: Res<ButtonInput<KeyCode>>,
    mut animation_players: Query<(&mut AnimationPlayer, &mut AnimationTransitions)>,
    animations: Res<Animations>,
    mut current_animation: Local<usize>,
) {
    for (mut player, mut transitions) in &mut animation_players {
        let Some((&playing_animation_index, _)) = player.playing_animations().next() else {
            continue;
        };

        if keyboard_input.just_pressed(KeyCode::Space) {
            let playing_animation = player.animation_mut(playing_animation_index).unwrap();
            if playing_animation.is_paused() {
                playing_animation.resume();
            } else {
                playing_animation.pause();
            }
        }

        if keyboard_input.just_pressed(KeyCode::ArrowUp) {
            let playing_animation = player.animation_mut(playing_animation_index).unwrap();
            let speed = playing_animation.speed();
            playing_animation.set_speed(speed * 1.2);
        }

        if keyboard_input.just_pressed(KeyCode::ArrowDown) {
            let playing_animation = player.animation_mut(playing_animation_index).unwrap();
            let speed = playing_animation.speed();
            playing_animation.set_speed(speed * 0.8);
        }

        if keyboard_input.just_pressed(KeyCode::ArrowLeft) {
            let playing_animation = player.animation_mut(playing_animation_index).unwrap();
            let elapsed = playing_animation.seek_time();
            playing_animation.seek_to(elapsed - 0.1);
        }

        if keyboard_input.just_pressed(KeyCode::ArrowRight) {
            let playing_animation = player.animation_mut(playing_animation_index).unwrap();
            let elapsed = playing_animation.seek_time();
            playing_animation.seek_to(elapsed + 0.1);
        }

        if keyboard_input.just_pressed(KeyCode::Enter) {
            *current_animation = (*current_animation + 1) % animations.animations.len();

            transitions
                .play(
                    &mut player,
                    animations.animations[*current_animation],
                    Duration::from_millis(250),
                )
                .repeat();
        }

        if keyboard_input.just_pressed(KeyCode::Digit1) {
            let playing_animation = player.animation_mut(playing_animation_index).unwrap();
            playing_animation
                .set_repeat(RepeatAnimation::Count(1))
                .replay();
        }

        if keyboard_input.just_pressed(KeyCode::Digit3) {
            let playing_animation = player.animation_mut(playing_animation_index).unwrap();
            playing_animation
                .set_repeat(RepeatAnimation::Count(3))
                .replay();
        }

        if keyboard_input.just_pressed(KeyCode::Digit5) {
            let playing_animation = player.animation_mut(playing_animation_index).unwrap();
            playing_animation
                .set_repeat(RepeatAnimation::Count(5))
                .replay();
        }

        if keyboard_input.just_pressed(KeyCode::KeyL) {
            let playing_animation = player.animation_mut(playing_animation_index).unwrap();
            playing_animation.set_repeat(RepeatAnimation::Forever);
        }
    }
}

pub fn get_main_animation(&self) -> Option<NodeIndex>

Obtain the currently playing main animation.

Trait Implementations

impl Clone for AnimationTransitions

fn clone(&self) -> AnimationTransitions

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Component for AnimationTransitions

where AnimationTransitions: Send + Sync + 'static,

const STORAGE_TYPE: StorageType = bevy_ecs::component::StorageType::Table

A constant indicating the storage type used for this component.

fn register_required_components( requiree: ComponentId, components: &mut Components, storages: &mut Storages, required_components: &mut RequiredComponents, inheritance_depth: u16, )

Registers required components.

fn register_component_hooks(hooks: &mut ComponentHooks)

Called when registering this component, allowing mutable access to its ComponentHooks.

impl Default for AnimationTransitions

fn default() -> AnimationTransitions

Returns the “default value” for a type.

impl FromArg for &'static AnimationTransitions

where AnimationTransitions: Any + Send + Sync, Option<NodeIndex>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<AnimationTransition>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

type This<'from_arg> = &'from_arg AnimationTransitions

The type to convert into.

fn from_arg( arg: Arg<'_>, ) -> Result<<&'static AnimationTransitions as FromArg>::This<'_>, ArgError>

Creates an item from an argument.

impl FromArg for &'static mut AnimationTransitions

where AnimationTransitions: Any + Send + Sync, Option<NodeIndex>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<AnimationTransition>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

type This<'from_arg> = &'from_arg mut AnimationTransitions

The type to convert into.

fn from_arg( arg: Arg<'_>, ) -> Result<<&'static mut AnimationTransitions as FromArg>::This<'_>, ArgError>

Creates an item from an argument.

impl FromArg for AnimationTransitions

where AnimationTransitions: Any + Send + Sync, Option<NodeIndex>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<AnimationTransition>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

type This<'from_arg> = AnimationTransitions

The type to convert into.

fn from_arg( arg: Arg<'_>, ) -> Result<<AnimationTransitions as FromArg>::This<'_>, ArgError>

Creates an item from an argument.

impl FromReflect for AnimationTransitions

where AnimationTransitions: Any + Send + Sync, Option<NodeIndex>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<AnimationTransition>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn from_reflect( reflect: &(dyn PartialReflect + 'static), ) -> Option<AnimationTransitions>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn PartialReflect>, ) -> Result<Self, Box<dyn PartialReflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl GetOwnership for &AnimationTransitions

where AnimationTransitions: Any + Send + Sync, Option<NodeIndex>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<AnimationTransition>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn ownership() -> Ownership

Returns the ownership of Self.

impl GetOwnership for &mut AnimationTransitions

where AnimationTransitions: Any + Send + Sync, Option<NodeIndex>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<AnimationTransition>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn ownership() -> Ownership

Returns the ownership of Self.

impl GetOwnership for AnimationTransitions

where AnimationTransitions: Any + Send + Sync, Option<NodeIndex>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<AnimationTransition>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn ownership() -> Ownership

Returns the ownership of Self.

impl GetTypeRegistration for AnimationTransitions

where AnimationTransitions: Any + Send + Sync, Option<NodeIndex>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<AnimationTransition>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type.

impl IntoReturn for &AnimationTransitions

where AnimationTransitions: Any + Send + Sync, Option<NodeIndex>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<AnimationTransition>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn into_return<'into_return>(self) -> Return<'into_return>

where &AnimationTransitions: 'into_return,

Converts Self into a Return value.

impl IntoReturn for &mut AnimationTransitions

where AnimationTransitions: Any + Send + Sync, Option<NodeIndex>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<AnimationTransition>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn into_return<'into_return>(self) -> Return<'into_return>

where &mut AnimationTransitions: 'into_return,

Converts Self into a Return value.

impl IntoReturn for AnimationTransitions

where AnimationTransitions: Any + Send + Sync, Option<NodeIndex>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<AnimationTransition>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn into_return<'into_return>(self) -> Return<'into_return>

where AnimationTransitions: 'into_return,

Converts Self into a Return value.

impl PartialReflect for AnimationTransitions

where AnimationTransitions: Any + Send + Sync, Option<NodeIndex>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<AnimationTransition>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

fn clone_value(&self) -> Box<dyn PartialReflect>

Clones the value as a Reflect trait object.

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

Tries to apply a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<AnimationTransitions>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<AnimationTransitions>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

Attempts to cast this type to a fully-reflected value.

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

Attempts to cast this type to a mutable, fully-reflected value.

fn into_partial_reflect( self: Box<AnimationTransitions>, ) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

Casts this type to a mutable, reflected value.

fn reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

Returns a “partial equality” comparison result.

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

Applies a reflected value to this value.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

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

Debug formatter for the value.

fn serializable(&self) -> Option<Serializable<'_>>

Returns a serializable version of the value.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Reflect for AnimationTransitions

where AnimationTransitions: Any + Send + Sync, Option<NodeIndex>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<AnimationTransition>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn into_any(self: Box<AnimationTransitions>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &(dyn Any + 'static)

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<AnimationTransitions>) -> Box<dyn Reflect>

Casts this type to a boxed, fully-reflected value.

fn as_reflect(&self) -> &(dyn Reflect + 'static)

Casts this type to a fully-reflected value.

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

Casts this type to a mutable, fully-reflected value.

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value.

impl Struct for AnimationTransitions

where AnimationTransitions: Any + Send + Sync, Option<NodeIndex>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<AnimationTransition>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn field(&self, name: &str) -> Option<&(dyn PartialReflect + 'static)>

Returns a reference to the value of the field named name as a &dyn PartialReflect.

fn field_mut( &mut self, name: &str, ) -> Option<&mut (dyn PartialReflect + 'static)>

Returns a mutable reference to the value of the field named name as a &mut dyn PartialReflect.

fn field_at(&self, index: usize) -> Option<&(dyn PartialReflect + 'static)>

Returns a reference to the value of the field with index index as a &dyn PartialReflect.

fn field_at_mut( &mut self, index: usize, ) -> Option<&mut (dyn PartialReflect + 'static)>

Returns a mutable reference to the value of the field with index index as a &mut dyn PartialReflect.

fn name_at(&self, index: usize) -> Option<&str>

Returns the name of the field with index index.

fn field_len(&self) -> usize

Returns the number of fields in the struct.

fn iter_fields(&self) -> FieldIter<'_>

Returns an iterator over the values of the reflectable fields for this struct.

fn clone_dynamic(&self) -> DynamicStruct

Clones the struct into a DynamicStruct.

fn get_represented_struct_info(&self) -> Option<&'static StructInfo>

Will return None if TypeInfo is not available.

impl TypePath for AnimationTransitions

where AnimationTransitions: Any + Send + Sync,

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl Typed for AnimationTransitions

where AnimationTransitions: Any + Send + Sync, Option<NodeIndex>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<AnimationTransition>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.