Struct bevy_animations::SingleFrameAnimation

pub struct SingleFrameAnimation {
    pub blocking: bool,
    pub blocking_priority: i32,
    pub blocking_timer: AnimationTimer,
    pub blocking_finished: bool,
    pub frame: Vec2,
    /* private fields */
}

Single Frame Animations. These are easy versatile animations to add to any entity or FX animation

Example

fn init_animation(
    mut animations: ResMut<Animations>,
    mut commands: Commands,
    asset_server: ResMut<AssetServer>,
    mut texture_atlases: ResMut<Assets<TextureAtlas>>,
) {
    let asset = asset_server.load("path/to/your/sprite_sheet");

    let texture_atlas = TextureAtlas::from_grid(asset, Vec2::new(16.0, 16.0), 10, 1, None, None);

    let texture_atlas_handle = texture_atlases.add(texture_atlas);

    let entity = commands
        .spawn(AnimationDirection::default())
        .insert(SpriteSheetBundle {
            texture_atlas: texture_atlas_handle.clone(),
            ..Default::default()
        })
        .id();
    animations.insert_animation(
        NewAnimation {
            handle: texture_atlas_handle.clone(), /* the handle for the TextureAtlas */
            animation: AnimationType::SingleFrame(
                SingleFrameAnimation::new(
                    0, /* x_index_pos */
                    AnimationDirectionIndexes::IndexBased(FlipBased {
                        /* direction_indexes */
                        x_direction_is_flipped: true,
                        x_direction_index: 0,
                    }),
                    true,              /* blocking */
                    1,                 /* blocking_priority */
                    0.25,              /* blocking_duration_in_sec */
                    Vec2::new(4., 4.), /* frame */
                ),
                "jump_start", /* AnimationName */
            ),
        },
        Some(entity), /* specify an entity to add the animation to now instead of later */
    )
}

Fields

blocking: bool

blocking_priority: i32

blocking_timer: AnimationTimer

blocking_finished: bool

frame: Vec2

Implementations

impl SingleFrameAnimation

pub fn new( x_index_pos: usize, direction_indexes: AnimationDirectionIndexes, blocking: bool, blocking_priority: i32, blocking_duration_in_sec: f32, frame: Vec2 ) -> Self

pub fn cycle_animation( &mut self, sprite: Mut<'_, Sprite>, texture_atlas: Mut<'_, TextureAtlas>, direction: &AnimationDirection, delta: Duration )

pub fn sprite_index(&self, direction: &AnimationDirection) -> usize

pub fn reset_animation( &mut self, sprite: Option<Mut<'_, Sprite>>, _direction: Option<&AnimationDirection> )

Trait Implementations

impl Clone for SingleFrameAnimation

fn clone(&self) -> SingleFrameAnimation

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SingleFrameAnimation

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

Formats the value using the given formatter.

impl Default for SingleFrameAnimation

fn default() -> SingleFrameAnimation

Returns the “default value” for a type.