Struct SpriteSheetAnimation

pub struct SpriteSheetAnimation<T>
where
    T: SpriteSheetTexture,
{ /* private fields */ }

Sprite sheet animation is an animation based on key frames, where each key frame is packed into single image. Usually, all key frames have the same size, but this is not mandatory.

Implementations

impl<T> SpriteSheetAnimation<T>

where T: SpriteSheetTexture,

pub const FRAMES_CONTAINER: &'static str = "frames_container"

pub const CURRENT_FRAME: &'static str = "current_frame"

pub const SPEED: &'static str = "speed"

pub const STATUS: &'static str = "status"

pub const LOOPING: &'static str = "looping"

pub const SIGNALS: &'static str = "signals"

pub const TEXTURE: &'static str = "texture"

pub const MAX_EVENT_CAPACITY: &'static str = "max_event_capacity"

impl<T> SpriteSheetAnimation<T>

where T: SpriteSheetTexture,

pub fn new() -> SpriteSheetAnimation<T>

Creates new empty animation.

pub fn new_from_image_parameters( params: ImageParameters, ) -> SpriteSheetAnimation<T>

Creates sprite sheet animation using given image parameters. The method is used to create animation for particular range in an image. For example, you have the following sprite sheet:

128 pixels wide
_________________
| 0 | 1 | 2 | 3 |
|___|___|___|___|
| 4 | 5 | 6 | 7 |  128 pixels tall
|___|___|___|___|
| 8 | 9 |10 |11 |
|___|___|___|___|

Let’s assume that there could be three animations:

• 0..3 - run
• 4..6 - idle
• 7..11 - attack

and you want to extract all three animations as separate animations. In this case you could do something like this:

#[derive(PartialEq, Clone, Reflect, Visit, Debug)]
struct MyTexture {}

fn extract_animations() {
    let run = SpriteSheetAnimation::<MyTexture>::new_from_image_parameters(ImageParameters {
        width: 128,
        height: 128,
        frame_width: 32,
        frame_height: 32,
        first_frame: 0,
        last_frame: 4,
        column_major: false,
    });

    let idle = SpriteSheetAnimation::<MyTexture>::new_from_image_parameters(ImageParameters {
        width: 128,
        height: 128,
        frame_width: 32,
        frame_height: 32,
        first_frame: 4,
        last_frame: 7,
        column_major: false,
    });

    let attack = SpriteSheetAnimation::<MyTexture>::new_from_image_parameters(ImageParameters {
        width: 128,
        height: 128,
        frame_width: 32,
        frame_height: 32,
        first_frame: 7,
        last_frame: 12,
        column_major: false,
    });
 }

If frames if your sprite sheet are ordered in column-major fashion (when you count them from top-left corner to bottom-left corner and then starting from new column, etc.), you should set column_major parameter to true.

pub fn with_container( container: SpriteSheetFramesContainer<T>, ) -> SpriteSheetAnimation<T>

Creates new animation with given frames container.

pub fn set_texture(&mut self, texture: Option<T>) -> Option<T>

Sets new texture for the animation.

pub fn texture(&self) -> Option<T>

Returns current texture of the animation.

pub fn get_max_event_capacity(&self) -> usize

Gets the maximum capacity of events.

pub fn set_max_event_capacity(&mut self, max_event_capacity: usize)

Sets the maximum capacity of events.

pub fn frames(&self) -> &SpriteSheetFramesContainer<T>

Returns a shared reference to inner frames container.

pub fn frames_mut(&mut self) -> &mut SpriteSheetFramesContainer<T>

Returns a mutable reference to inner frames container.

pub fn add_frame( &mut self, frame: Matrix<u32, Const<2>, Const<1>, ArrayStorage<u32, 2, 1>>, )

Adds new frame.

pub fn remove_frame( &mut self, index: usize, ) -> Option<Matrix<u32, Const<2>, Const<1>, ArrayStorage<u32, 2, 1>>>

Remove a frame at given index.

pub fn update(&mut self, dt: f32)

Updates animation playback using given time step.

pub fn current_frame(&self) -> usize

Returns current frame index.

pub fn frame_uv_rect(&self, i: usize) -> Option<Rect<f32>>

Tries to fetch UV rectangle at given frame. Returns None if animation is empty.

pub fn current_frame_uv_rect(&self) -> Option<Rect<f32>>

Tries to fetch UV rectangle at current frame. Returns None if animation is empty.

pub fn set_current_frame(&mut self, current_frame: usize)

Sets current frame of the animation. Input value will be clamped to [0; frame_count] range.

pub fn is_looping(&self) -> bool

Returns true if the animation is looping, false - otherwise.

pub fn set_looping(&mut self, looping: bool)

Continue animation from beginning (or end in case of negative speed) when ended or stop.

pub fn speed(&self) -> f32

Returns playback speed in frames per second.

pub fn set_speed(&mut self, speed: f32)

Sets playback speed in frames per second. The speed can be negative, in this case animation will play in reverse.

pub fn rewind_to_beginning(&mut self)

Sets current frame index to the first frame in the animation.

pub fn rewind_to_end(&mut self)

Sets current frame index to the last frame in the animation.

pub fn status(&self) -> Status

Returns current status of the animation.

pub fn play(&mut self)

Starts animation playback.

pub fn is_playing(&self) -> bool

Returns true if the animation is playing, false - otherwise.

pub fn stop(&mut self)

Stops animation playback, rewinds animation to the beginning.

pub fn is_stopped(&self) -> bool

Returns true if the animation is stopped, false - otherwise.

pub fn pause(&mut self)

Puts animation playback on pause.

pub fn is_paused(&self) -> bool

Returns true if the animation is paused, false - otherwise.

pub fn add_signal(&mut self, signal: Signal)

Adds new animation signal to the animation.

pub fn remove_signal(&mut self, id: u64)

Removes animation signal by given id.

pub fn pop_event(&mut self) -> Option<Event>

Pops animation event from internal queue.

Trait Implementations

impl<T> Clone for SpriteSheetAnimation<T>

where T: Clone + SpriteSheetTexture,

fn clone(&self) -> SpriteSheetAnimation<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for SpriteSheetAnimation<T>

where T: Debug + SpriteSheetTexture,

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

Formats the value using the given formatter.

impl<T> Default for SpriteSheetAnimation<T>

where T: SpriteSheetTexture,

fn default() -> SpriteSheetAnimation<T>

Returns the “default value” for a type.

impl<T> PartialEq for SpriteSheetAnimation<T>

where T: SpriteSheetTexture,

fn eq(&self, other: &SpriteSheetAnimation<T>) -> 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<T> Reflect for SpriteSheetAnimation<T>

where T: SpriteSheetTexture, SpriteSheetAnimation<T>: 'static, SpriteSheetFramesContainer<T>: Reflect, f32: Reflect, Status: Reflect, bool: Reflect, Vec<Signal>: Reflect, Option<T>: Reflect, usize: Reflect,

fn source_path() -> &'static str

fn type_name(&self) -> &'static str

fn doc(&self) -> &'static str

fn assembly_name(&self) -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn type_assembly_name() -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn fields_info(&self, func: &mut dyn FnMut(&[FieldInfo<'_, '_>]))

fn into_any(self: Box<SpriteSheetAnimation<T>>) -> Box<dyn Any>

fn set( &mut self, value: Box<dyn Reflect>, ) -> Result<Box<dyn Reflect>, Box<dyn Reflect>>

fn set_field( &mut self, name: &str, value: Box<dyn Reflect>, func: &mut dyn FnMut(Result<Box<dyn Reflect>, Box<dyn Reflect>>), )

Calls user method specified with #[reflect(setter = ..)] or falls back to Reflect::field_mut

fn as_any(&self, func: &mut dyn FnMut(&(dyn Any + 'static)))

fn as_any_mut(&mut self, func: &mut dyn FnMut(&mut (dyn Any + 'static)))

fn as_reflect(&self, func: &mut dyn FnMut(&(dyn Reflect + 'static)))

fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut (dyn Reflect + 'static)))

fn fields(&self, func: &mut dyn FnMut(&[&(dyn Reflect + 'static)]))

fn fields_mut( &mut self, func: &mut dyn FnMut(&mut [&mut (dyn Reflect + 'static)]), )

fn field( &self, name: &str, func: &mut dyn FnMut(Option<&(dyn Reflect + 'static)>), )

fn field_mut( &mut self, name: &str, func: &mut dyn FnMut(Option<&mut (dyn Reflect + 'static)>), )

fn as_array(&self, func: &mut dyn FnMut(Option<&(dyn ReflectArray + 'static)>))

fn as_array_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectArray + 'static)>), )

fn as_list(&self, func: &mut dyn FnMut(Option<&(dyn ReflectList + 'static)>))

fn as_list_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectList + 'static)>), )

fn as_inheritable_variable( &self, func: &mut dyn FnMut(Option<&(dyn ReflectInheritableVariable + 'static)>), )

fn as_inheritable_variable_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectInheritableVariable + 'static)>), )

fn as_hash_map( &self, func: &mut dyn FnMut(Option<&(dyn ReflectHashMap + 'static)>), )

fn as_hash_map_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectHashMap + 'static)>), )

impl<T> TypeUuidProvider for SpriteSheetAnimation<T>

where T: SpriteSheetTexture,

fn type_uuid() -> Uuid

Return type UUID.

impl<T> Visit for SpriteSheetAnimation<T>

where T: SpriteSheetTexture, SpriteSheetFramesContainer<T>: Visit, f32: Visit, Status: Visit, bool: Visit, Vec<Signal>: Visit, Option<T>: Visit, usize: Visit,

fn visit(&mut self, name: &str, visitor: &mut Visitor) -> Result<(), VisitError>

Read or write this value, depending on whether Visitor::is_reading() is true or false.