Struct tetra::graphics::animation::Animation

source · [−]

pub struct Animation { /* private fields */ }

Expand description

An animation, cycling between regions of a texture at a regular interval.

Calling advance or advance within State::draw will drive the animation, switching the texture region once the specified time has passed.

Examples

The animation example demonstrates basic usage of an Animation with a spritesheet.

The animation_controller example demonstrates how multiple Animations can be combined using a simple state machine.

Implementations

source

impl Animation

source

pub fn new(
 texture: Texture,
 frames: Vec<Rectangle>,
 frame_length: Duration
) -> Animation

Creates a new looping animation.

source

pub fn once(
 texture: Texture,
 frames: Vec<Rectangle>,
 frame_length: Duration
) -> Animation

Creates a new animation that does not repeat once all of the frames have been displayed.

source

pub fn draw(&self, ctx: &mut Context, params: P) where
P: Into<DrawParams>,

Draws the current frame to the screen (or to a canvas, if one is enabled).

source

pub fn advance(&mut self, ctx: &Context)

Advances the animation’s timer, switching the texture region if required.

This method uses the current delta time to calculate how much time has passed.

source

pub fn advance_by(&mut self, duration: Duration)

Advances the animation’s timer by a specified amount, switching the texture region if required.

If the specified duration is longer than the frame length, frames will be skipped.

source

pub fn restart(&mut self)

Restarts the animation from the first frame.

source

pub fn texture(&self) -> &Texture

Returns a reference to the texture currently being used by the animation.

source

pub fn set_texture(&mut self, texture: Texture)

Sets the texture that will be used by the animation.

This method will not change the frame definitions or current state of the animation, so it can be used for e.g. swapping spritesheets. If you need to change the slicing for the new texture, call set_frames.

source

pub fn frames(&self) -> &[Rectangle ]

Gets the sections of the texture being displayed for each frame of the animation.

source

pub fn set_frames(&mut self, new_frames: Vec<Rectangle>)

Sets the sections of the texture being displayed for each frame of the animation.

This method will reset the animation back to frame zero.

source

pub fn frame_length(&self) -> Duration

Gets the amount of time that each frame of the animation lasts for.

source

pub fn set_frame_length(&mut self, new_frame_length: Duration)

Sets the amount of time that each frame of the animation lasts for.

source

pub fn repeating(&self) -> bool

Gets whether or not the animation is currently set to repeat when it reaches the end of the frames.

source

pub fn set_repeating(&mut self, repeating: bool)

Sets whether or not the animation should repeat when it reaches the end of the frames.

source

pub fn current_frame_index(&self) -> usize

Gets the index of the frame that is currently being displayed.

This index is zero-based, and can be used in combination with the frames method in order to track the progress of the animation.

source

pub fn set_current_frame_index(&mut self, index: usize)

Sets which frame of the animation should be displayed.

Usually you will want to control the animation by calling advance or advance, but this method can be useful for more fine-grained control.

Panics

The index is zero-based, and must be within the bounds of the animation’s frames, otherwise this method will panic.

source

pub fn current_frame_time(&self) -> Duration

Gets the duration that the current frame has been visible.

This can be used in combination with the frame_length method in order to track the progress of the animation.

source

pub fn set_current_frame_time(&mut self, duration: Duration)

Sets the duration that the current frame has been visible.

Usually you will want to control the animation by calling advance or advance,but this method can be useful for more fine-grained control.

The animation will not advance past the end of the current frame until the next call to advance or advance. If a value is given that is larger than frame_length, this animation may skip frames.