Struct bevy_spritesheet_animation::stage::AnimationStage

pub struct AnimationStage { /* private fields */ }

A stage of an Animation.

All animations are made of stages. Simple animations may contain a single stage while more complex animations may contain a sequence of stages.

An AnimationStage references an AnimationClip that has been created with SpritesheetLibrary::new_clip.

Parameters like duration, repeat and direction can be optionally specified. If specified, they will override the default parameters of the underlying AnimationClip.

Implementations

impl AnimationStage

pub fn new( clip_id: AnimationClipId, duration: Option<AnimationDuration>, repeat: Option<u32>, direction: Option<AnimationDirection>, easing: Option<Easing> ) -> Self

Creates a new AnimationStage from an AnimationClipId with the given parameters.

Arguments

• clip_id - the ID of the clip referenced by this stage
• duration - the optional duration of this stage
• repeat - the optional number of repetitions of this stage
• direction - the optional direction of this stage
• easing - the optional easing of this stage

Example

let animation_id = library.new_animation(|animation| {
    let mut stage = AnimationStage::new(
        clip_id,
        Some(AnimationDuration::PerCycle(2500)),
        Some(10),
        Some(AnimationDirection::Backwards),
        Some(Easing::Linear)
    );

    animation.add_stage(stage);
});

pub fn new_with<F: Fn(&mut Self)>(clip_id: AnimationClipId, builder: F) -> Self

Creates a new AnimationStage from an AnimationClipId and a builder function.

This is convenient if you prefer chaining calls when composing animations.

Arguments

• clip_id - the ID of the clip referenced by this stage
• builder - a builder function that takes the new stage as an argument so that you can configure it

Example

let animation_id = library.new_animation(|animation| {
    animation
        .add_stage(AnimationStage::new_with(clip1_id, |stage| {
           stage.set_repeat(5);
        }))
        .add_stage(AnimationStage::new_with(clip2_id, |stage| {
           stage.set_direction(AnimationDirection::PingPong);
        }));
});

pub fn from_clip(clip_id: AnimationClipId) -> Self

Creates a new AnimationStage from an AnimationClipId.

The stage will inherit its clip’s default parameters. To override them, use the set_XXX() functions.

Arguments

• clip_id - the ID of the clip referenced by this stage

Example

let animation_id = library.new_animation(|animation| {
    let stage = AnimationStage::from_clip(clip_id);

    animation.add_stage(stage);
});

pub fn clip_id(&self) -> &AnimationClipId

pub fn set_duration(&mut self, duration: AnimationDuration) -> &mut Self

pub fn duration(&self) -> &Option<AnimationDuration>

pub fn set_repeat(&mut self, repeat: u32) -> &mut Self

pub fn repeat(&self) -> &Option<u32>

pub fn set_direction(&mut self, direction: AnimationDirection) -> &mut Self

pub fn direction(&self) -> &Option<AnimationDirection>

pub fn set_easing(&mut self, easing: Easing) -> &mut Self

pub fn easing(&self) -> &Option<Easing>

Trait Implementations

impl Clone for AnimationStage

fn clone(&self) -> AnimationStage

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AnimationStage

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

Formats the value using the given formatter.

impl From<AnimationClipId> for AnimationStage

fn from(clip_id: AnimationClipId) -> Self

Converts to this type from the input type.