Enum bevy_spritesheet_animation::events::AnimationEvent

pub enum AnimationEvent {
    MarkerHit {
        entity: Entity,
        marker_id: AnimationMarkerId,
        animation_id: AnimationId,
        stage_index: usize,
    },
    ClipCycleEnd {
        entity: Entity,
        animation_id: AnimationId,
        stage_index: usize,
    },
    ClipEnd {
        entity: Entity,
        animation_id: AnimationId,
        stage_index: usize,
    },
    AnimationCycleEnd {
        entity: Entity,
        animation_id: AnimationId,
    },
    AnimationEnd {
        entity: Entity,
        animation_id: AnimationId,
    },
}

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

• when a clip cycle ends
• when a clip ends (if the clip repeats multiple times, only occurs at the end of the last cycle)
• when an animation cycle ends
• when an animation ends (if the animation repeats multiple times, only occurs at the end of the last cycle)
• 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<SpritesheetLibrary>
) {
    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_id = library.new_clip(|clip| {
    clip
        .push_frame_indices([10, 11, 15, 16, 17])
        // The character shoots their gun on the fourth frame
        .add_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<SpritesheetLibrary>
) {
    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

stage_index: usize

ClipCycleEnd

A cycle of a clip has ended

Fields

entity: Entity

animation_id: AnimationId

stage_index: usize

ClipEnd

An clip ended

Fields

entity: Entity

animation_id: AnimationId

stage_index: usize

AnimationCycleEnd

A cycle of an animation has ended

Fields

entity: Entity

animation_id: AnimationId

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 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

This method tests for self and other values to be equal, and is used by ==.

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

This method 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 Event for AnimationEvent

where Self: Send + Sync + 'static,

impl StructuralPartialEq for AnimationEvent