Enum AnimationEvent

pub enum AnimationEvent {
    MarkerHit {
        entity: Entity,
        marker_id: AnimationMarkerId,
        animation_id: AnimationId,
        animation_repetition: usize,
        clip_id: ClipId,
        clip_repetition: usize,
    },
    ClipRepetitionEnd {
        entity: Entity,
        animation_id: AnimationId,
        clip_id: ClipId,
        clip_repetition: usize,
    },
    ClipEnd {
        entity: Entity,
        animation_id: AnimationId,
        clip_id: ClipId,
    },
    AnimationRepetitionEnd {
        entity: Entity,
        animation_id: AnimationId,
        animation_repetition: usize,
    },
    AnimationEnd {
        entity: Entity,
        animation_id: AnimationId,
    },
}

A Bevy event emitted when an animation reaches a point of interest

• when a clip repetition ends
• when a clip ends (if the clip repeats multiple times, only occurs at the end of the last repetition)
• when an animation repetition ends
• when an animation ends (if the animation repeats multiple times, only occurs at the end of the last repetition)
• when an animation marker is hit

Example

You can use those events to be notified of a clip/animation ending.

fn death_transition_system(
    mut events: EventReader<AnimationEvent>,
    library: Res<AnimationLibrary>
) {
    for event in events.read() {
        match event {
            // Some animation just ended...
            AnimationEvent::AnimationEnd { animation_id, .. } => {
                // ... it was the main character's death animation,
                // we can go back to the main menu

                if library.is_animation_name(*animation_id, "character dies") {
                    go_to_main_menu();
                }
            }
            // Ignore other events
            _ => (),
        }
    }
}

Example

You can also add markers to specific frames of a clip to be notified of an animation reaching points of interest.

// Let's create a marker to be notified when the exact frame
// of the character shooting their gun is played
let marker_id = library.new_marker();

// Naming a marker is not required but it can be convenient to refer to it later
// if you don't want to keep its ID around
library.name_marker(marker_id, "bullet goes out");

let clip = Clip::from_frames([10, 11, 15, 16, 17])
    // The character shoots their gun on the fourth frame
    .with_marker(marker_id, 3);

// We can watch events from any system and react to them
fn spawn_visual_effects_system(
    mut events: EventReader<AnimationEvent>,
    library: Res<AnimationLibrary>
) {
    for event in events.read() {
        match event {
            // Some marker was just hit...
            AnimationEvent::MarkerHit { marker_id, .. } => {
                // ... it was our "bullet goes out" marker, let's spawn a bullet.

                if library.is_marker_name(*marker_id, "bullet goes out") {
                    spawn_bullet();
                }
            }
            // Ignore other events
            _ => (),
        }
    }
}

Variants

MarkerHit

An animation marker has been hit

Fields

entity: Entity

marker_id: AnimationMarkerId

animation_id: AnimationId

animation_repetition: usize

clip_id: ClipId

clip_repetition: usize

ClipRepetitionEnd

A repetition of a clip has ended

Fields

entity: Entity

animation_id: AnimationId

clip_id: ClipId

clip_repetition: usize

ClipEnd

An clip ended

Fields

entity: Entity

animation_id: AnimationId

clip_id: ClipId

AnimationRepetitionEnd

A repetition of an animation has ended

Fields

entity: Entity

animation_id: AnimationId

animation_repetition: usize

AnimationEnd

An animation has ended

Fields

entity: Entity

animation_id: AnimationId

Trait Implementations

impl Clone for AnimationEvent

fn clone(&self) -> AnimationEvent

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AnimationEvent

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

Formats the value using the given formatter.

impl Event for AnimationEvent

where Self: Send + Sync + 'static,

const AUTO_PROPAGATE: bool = false

When true, this event will always attempt to propagate when triggered, without requiring a call to Trigger::propagate.

type Traversal = ()

The component that describes which Entity to propagate this event to next, when propagation is enabled.

fn register_component_id(world: &mut World) -> ComponentId

Generates the ComponentId for this event type.

fn component_id(world: &World) -> Option<ComponentId>

Fetches the ComponentId for this event type, if it has already been generated.

impl Hash for AnimationEvent

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for AnimationEvent

fn eq(&self, other: &AnimationEvent) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for AnimationEvent

impl Eq for AnimationEvent

impl StructuralPartialEq for AnimationEvent