Struct Motion 

pub struct Motion<C: Clip> { /* private fields */ }

What a state plays: one clip, two of them blended, or one a value of the game’s own scrubs.

Every clip runs on its own timeline, so a pace of 1.0 plays it as long as its source states.

Implementations

impl<C: Clip> Motion<C>

pub fn looping(clip: C) -> Self

Plays clip over and over, wrapping from its last key to its first.

Examples found in repository

examples/animation.rs (line 353)

    fn motion(&self, input: &ElfInput) -> Motion<ElfClip> {
        match self {
            Self::Idle => Motion::looping(ElfClip::Idle),
            Self::Locomotion => {
                Motion::blend(ElfClip::Walk, ElfClip::Jog, input.speed).paced(input.speed)
            }
            Self::Attack => Motion::once(ElfClip::Attack),
            Self::Hit => Motion::once(ElfClip::Hit),
            Self::Death => Motion::once(ElfClip::Death),
            Self::SitDown => Motion::once(ElfClip::SitDown),
            Self::Sit => Motion::looping(ElfClip::Sit),
            Self::StandUp => Motion::once(ElfClip::StandUp),
            Self::Jump => Motion::once(ElfClip::Jump),
            Self::Dance => Motion::looping(ElfClip::Dance),
        }
    }

    fn next(&self, input: &ElfInput, at: Progress) -> Option<Transition<Self>> {
        match (self, input) {
            (Self::Death, _) => None,
            (_, ElfInput { dying: true, .. }) => Some(Self::Death.fade(DEATH_FADE)),
            (_, ElfInput { hit: true, .. }) if *self != Self::Hit => {
                Some(Self::Hit.fade(HIT_ENTER_FADE))
            }
            (Self::Hit, _) if at.ended() => Some(ElfState::grounded(input).fade(HIT_EXIT_FADE)),
            (Self::Attack, ElfInput { attack: true, .. }) if at.past(ATTACK_RELEASE) => Some(
                Self::Attack
                    .restarted()
                    .entering_at(ATTACK_CHAIN_ENTRY)
                    .fade(ATTACK_CHAIN_FADE),
            ),
            (Self::Attack, _) if at.past(ATTACK_RELEASE) => {
                Some(ElfState::grounded(input).fade(ATTACK_EXIT_FADE))
            }
            (Self::SitDown | Self::Sit | Self::StandUp, i) if i.speed > WALK_THRESHOLD => {
                Some(Self::Locomotion.fade(STAND_EXIT_FADE))
            }
            (Self::SitDown | Self::Sit | Self::StandUp, ElfInput { attack: true, .. }) => {
                Some(Self::Attack.fade(ATTACK_ENTER_FADE))
            }
            (Self::SitDown | Self::Sit | Self::StandUp, ElfInput { jump: true, .. }) => {
                Some(Self::Jump.fade(JUMP_ENTER_FADE))
            }
            (Self::SitDown, _) if at.ended() => Some(Self::Sit.at_once()),
            (Self::Sit, ElfInput { interact: true, .. }) => Some(Self::StandUp.fade(STAND_UP_FADE)),
            (Self::StandUp, _) if at.ended() => Some(Self::Idle.fade(STAND_EXIT_FADE)),
            (Self::Jump, ElfInput { landed: true, .. }) => {
                Some(ElfState::grounded(input).fade(JUMP_EXIT_FADE))
            }
            (Self::Jump, _) if at.ended() => Some(ElfState::grounded(input).fade(JUMP_EXIT_FADE)),
            (
                Self::Idle | Self::Locomotion,
                ElfInput {
                    interact: true,
                    near_seat: true,
                    ..
                },
            ) => Some(Self::SitDown.fade(SIT_DOWN_FADE)),
            (Self::Idle | Self::Locomotion, ElfInput { attack: true, .. }) => {
                Some(Self::Attack.fade(ATTACK_ENTER_FADE))
            }
            (Self::Idle | Self::Locomotion, ElfInput { jump: true, .. }) => {
                Some(Self::Jump.fade(JUMP_ENTER_FADE))
            }
            (Self::Idle, ElfInput { dance: true, .. }) => Some(Self::Dance.fade(DANCE_FADE)),
            (Self::Dance, i) if i.speed > WALK_THRESHOLD => {
                Some(Self::Locomotion.fade(IDLE_LOCOMOTION_FADE))
            }
            (Self::Idle, i) if i.speed > WALK_THRESHOLD => {
                Some(Self::Locomotion.fade(IDLE_LOCOMOTION_FADE))
            }
            (Self::Locomotion, i) if i.speed <= WALK_THRESHOLD => {
                Some(Self::Idle.fade(IDLE_LOCOMOTION_FADE))
            }
            _ => None,
        }
    }
}

/// A machine of one state, posed by nothing but the value it scrubs.
#[derive(Clone, Copy, Eq, PartialEq, Debug)]
enum ScrubbedState {
    SitDown,
}

/// What the game fills each tick to move `ScrubbedState` on.
#[derive(Default)]
struct ScrubbedInput {
    /// How far into sitting down the second elf reads, a fraction in
    /// `0.0..=1.0`.
    settled: f32,
}

impl AnimationStates for ScrubbedState {
    type Clip = ElfClip;
    type Input = ScrubbedInput;

    fn entry() -> Self {
        Self::SitDown
    }

    fn motion(&self, input: &ScrubbedInput) -> Motion<ElfClip> {
        Motion::scrubbed(ElfClip::SitDown, input.settled)
    }

    fn next(&self, _input: &ScrubbedInput, _at: Progress) -> Option<Transition<Self>> {
        None
    }
}

#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Butterfly;

/// The one clip `FlyingState` plays, named as the source names it.
#[derive(Clip, Clone, Debug, PartialEq, Eq, Hash)]
enum ButterflyClip {
    #[clip("fly")]
    Fly,
}

impl Mesh<NoParts, ButterflyClip> for Butterfly {
    fn build(&self, assets: &Assets) -> MeshData<NoParts, ButterflyClip> {
        assets.model(BUTTERFLY_ROOT)
    }
}

/// A machine of one state, looping the butterfly's only clip.
#[derive(Clone, Copy, Eq, PartialEq, Debug)]
enum FlyingState {
    Flying,
}

impl AnimationStates for FlyingState {
    type Clip = ButterflyClip;
    type Input = ();

    fn entry() -> Self {
        Self::Flying
    }

    fn motion(&self, _input: &()) -> Motion<ButterflyClip> {
        Motion::looping(ButterflyClip::Fly)
    }

pub fn once(clip: C) -> Self

Plays clip once and holds its last key.

Examples found in repository

examples/animation.rs (line 357)

    fn motion(&self, input: &ElfInput) -> Motion<ElfClip> {
        match self {
            Self::Idle => Motion::looping(ElfClip::Idle),
            Self::Locomotion => {
                Motion::blend(ElfClip::Walk, ElfClip::Jog, input.speed).paced(input.speed)
            }
            Self::Attack => Motion::once(ElfClip::Attack),
            Self::Hit => Motion::once(ElfClip::Hit),
            Self::Death => Motion::once(ElfClip::Death),
            Self::SitDown => Motion::once(ElfClip::SitDown),
            Self::Sit => Motion::looping(ElfClip::Sit),
            Self::StandUp => Motion::once(ElfClip::StandUp),
            Self::Jump => Motion::once(ElfClip::Jump),
            Self::Dance => Motion::looping(ElfClip::Dance),
        }
    }

pub fn blend(from: C, to: C, weight: f32) -> Self

Plays from and to together, weight of the way to to, as a fraction held inside 0.0..=1.0 and read as 0.0 where it is not a number.

Each is read at the same fraction of its own timeline and both count cycles together, so a walk and a run of different lengths keep their steps together.

Examples found in repository

examples/animation.rs (line 355)

    fn motion(&self, input: &ElfInput) -> Motion<ElfClip> {
        match self {
            Self::Idle => Motion::looping(ElfClip::Idle),
            Self::Locomotion => {
                Motion::blend(ElfClip::Walk, ElfClip::Jog, input.speed).paced(input.speed)
            }
            Self::Attack => Motion::once(ElfClip::Attack),
            Self::Hit => Motion::once(ElfClip::Hit),
            Self::Death => Motion::once(ElfClip::Death),
            Self::SitDown => Motion::once(ElfClip::SitDown),
            Self::Sit => Motion::looping(ElfClip::Sit),
            Self::StandUp => Motion::once(ElfClip::StandUp),
            Self::Jump => Motion::once(ElfClip::Jump),
            Self::Dance => Motion::looping(ElfClip::Dance),
        }
    }

pub fn scrubbed(clip: C, fraction: f32) -> Self

Holds clip at fraction of the way along it, a fraction held inside 0.0..=1.0 and read as 0.0 where it is not a number.

Required if you want a value of the game’s own to pose a mesh: no clock moves it, so a door opens as far as the game states and no further.

Examples found in repository

examples/animation.rs (line 453)

    fn motion(&self, input: &ScrubbedInput) -> Motion<ElfClip> {
        Motion::scrubbed(ElfClip::SitDown, input.settled)
    }

pub fn paced(self, rate: f32) -> Self

Runs at rate of the pace its source states, a fraction that is 1.0 until set.

A rate of nothing or less holds the motion where it is, and one that is not a number reads as 1.0. The last call is the one used.

Examples found in repository

examples/animation.rs (line 355)

    fn motion(&self, input: &ElfInput) -> Motion<ElfClip> {
        match self {
            Self::Idle => Motion::looping(ElfClip::Idle),
            Self::Locomotion => {
                Motion::blend(ElfClip::Walk, ElfClip::Jog, input.speed).paced(input.speed)
            }
            Self::Attack => Motion::once(ElfClip::Attack),
            Self::Hit => Motion::once(ElfClip::Hit),
            Self::Death => Motion::once(ElfClip::Death),
            Self::SitDown => Motion::once(ElfClip::SitDown),
            Self::Sit => Motion::looping(ElfClip::Sit),
            Self::StandUp => Motion::once(ElfClip::StandUp),
            Self::Jump => Motion::once(ElfClip::Jump),
            Self::Dance => Motion::looping(ElfClip::Dance),
        }
    }

Trait Implementations

impl<C: Clone + Clip> Clone for Motion<C>

fn clone(&self) -> Motion<C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C: Debug + Clip> Debug for Motion<C>

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

Formats the value using the given formatter.

impl<C: PartialEq + Clip> PartialEq for Motion<C>

fn eq(&self, other: &Motion<C>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<C: PartialEq + Clip> StructuralPartialEq for Motion<C>