Struct Animation 

#[repr(C)]
pub struct Animation {
    pub sheet: SpriteSheet,
    pub first: u32,
    pub frames: u32,
    pub fps: f32,
    pub looping: bool,
    pub time: f32,
}

Plays frames of a SpriteSheet on an entity’s Sprite. The built-in animate_sprites system advances it every frame.

ctx.world.spawn((
    Transform2D::at(vec2(200.0, 200.0)),
    sheet.sprite(0),
    Animation::new(sheet, 0..8, 12.0), // frames 0-7 at 12 frames per second, looping
));

Fields

sheet: SpriteSheet

The frames come from this sheet.

first: u32

First frame and how many frames to play.

frames: u32

How many frames to play, from first.

fps: f32

Frames per second.

looping: bool

Start over at the end (default), or stop on the last frame.

time: f32

Seconds played so far.

Implementations

impl Animation

pub fn new(sheet: SpriteSheet, frames: Range<u32>, fps: f32) -> Self

Plays frames of sheet at fps, looping.

Examples found in repository

examples/tiles.rs (line 103)

fn setup(ctx: &mut Ctx, side: u32) {
    let tiles = tileset(ctx);
    let mut map = TileMap::new(tiles, side, side);
    for y in 0..side {
        for x in 0..side {
            map.set(x, y, Some(terrain(x as f32, y as f32)));
        }
    }
    ctx.world.spawn((Transform2D::default(), map));

    let blob = creature(ctx);
    let mut rng = Rng::new(7);
    let world = (side * TILE) as f32;
    ctx.world.spawn_batch((0..20_000).map(|_| {
        let at = vec2(rng.range(0.0, world), rng.range(0.0, world));
        let mut walk = Animation::new(blob, 0..8, rng.range(6.0, 12.0));
        walk.time = rng.f32(); // out of step with each other
        (
            Transform2D::at(at),
            blob.sprite(0),
            walk,
            Wander(rng.unit_vec2() * 20.0),
        )
    }));
    ctx.camera.zoom = 2.0;
    ctx.camera.look_at(vec2(world, world) / 2.0);
}

pub fn once(self) -> Self

Same animation, played once and then held on its last frame.

let explode = Animation::new(sheet, 8..16, 24.0).once();

pub fn current_frame(&self) -> u32

The frame showing now (an index into the sheet).

let walk = Animation::new(sheet, 4..8, 10.0);
assert_eq!(walk.current_frame(), 4);

pub fn finished(&self) -> bool

true once an animation made with once reached its last frame (never for looping ones).

let done: Vec<Entity> = ctx.world.query::<(Entity, &Animation)>().iter()
    .filter(|(_, a)| a.finished())
    .map(|(e, _)| e)
    .collect();
for e in done { ctx.world.despawn(e); }

Trait Implementations

impl Clone for Animation

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Animation

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

Formats the value using the given formatter.

impl PartialEq for Animation

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Animation