Struct TnuaAnimatingState

pub struct TnuaAnimatingState<State> { /* private fields */ }

Utility for deciding which animation to play.

Add TnuaAnimatingState<State> as a component, where State is a data type - usually an enum - that determines which animation to play. Each frame, decide (with the help of TnuaController) which animation should be played and the animation’s parameters (like speed) and feed it to the TnuaAnimatingState. Use the emitted TnuaAnimatingStateDirective to determine if this is a new animation or an existing one (possibly with different parameters), and use that information to work the actual animation player.

enum AnimationState {
    Standing,
    Running(Float),
}

fn animating_system(
    mut query: &mut Query<(
        &mut TnuaAnimatingState<AnimationState>,
        &TnuaController,
        &mut AnimationPlayer,
    )>,
    animation_nodes: Res<AnimationNodes>,
) {
    for (mut animating_state, controller, mut animation_player) in query.iter_mut() {
        match animating_state.update_by_discriminant({
            let Some((_, basis_state)) = controller.concrete_basis::<TnuaBuiltinWalk>()
            else {
                continue;
            };
            let speed = basis_state.running_velocity.length();
            if 0.01 < speed {
                AnimationState::Running(speed)
            } else {
                AnimationState::Standing
            }
        }) {
            TnuaAnimatingStateDirective::Maintain { state } => {
                if let AnimationState::Running(speed) = state {
                    if let Some(active_animation) = animation_player.animation_mut(animation_nodes.running) {
                        active_animation.set_speed(*speed);
                    }
                }
            }
            TnuaAnimatingStateDirective::Alter {
                // We don't need the old state here, but it's available for transition
                // animations.
                old_state: _,
                state,
            } => {
                animation_player.stop_all();
                match state {
                    AnimationState::Standing => {
                        animation_player
                            .start(animation_nodes.standing)
                            .set_speed(1.0)
                            .repeat();
                    }
                    AnimationState::Running(speed) => {
                        animation_player
                            .start(animation_nodes.running)
                            .set_speed(*speed)
                            .repeat();
                    }
                }
            }
        }
    }
}

Implementations

impl<State> TnuaAnimatingState<State>

pub fn update_by( &mut self, new_state: State, comparison: impl FnOnce(&State, &State) -> bool, ) -> TnuaAnimatingStateDirective<'_, State>

Consider a new animation to play.

The comparison function decides if its the same animation (possibly with different parameters) or a different animation.

pub fn update_by_value( &mut self, new_state: State, ) -> TnuaAnimatingStateDirective<'_, State>

where State: PartialEq,

Consider a new animation to play.

The new animation is considered the same if and only if it is equal to the old animation.

pub fn update_by_discriminant( &mut self, new_state: State, ) -> TnuaAnimatingStateDirective<'_, State>

Consider a new animation to play.

The new animation is considered the same if it is the same variant of the enum as the old animation.

If the State is not an enum, using this method will not result in undefined behavior, but the behavior is unspecified.

pub fn get(&self) -> Option<&State>

Get the current state.

Can provide no information about the previous state.

Trait Implementations

impl<State> Component for TnuaAnimatingState<State>

where Self: Send + Sync + 'static,

const STORAGE_TYPE: StorageType = bevy::ecs::component::StorageType::Table

A constant indicating the storage type used for this component.

fn register_required_components( requiree: ComponentId, components: &mut Components, storages: &mut Storages, required_components: &mut RequiredComponents, inheritance_depth: u16, )

Registers required components.

fn register_component_hooks(hooks: &mut ComponentHooks)

Called when registering this component, allowing mutable access to its ComponentHooks.

impl<State> Default for TnuaAnimatingState<State>

fn default() -> Self

Returns the “default value” for a type.