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.

type Mutability = Mutable

A marker type to assist Bevy with determining if this component is mutable, or immutable. Mutable components will have [Component<Mutability = Mutable>], while immutable components will instead have [Component<Mutability = Immutable>].

fn register_required_components( requiree: ComponentId, components: &mut ComponentsRegistrator<'_>, required_components: &mut RequiredComponents, inheritance_depth: u16, recursion_check_stack: &mut Vec<ComponentId>, )

Registers required components.

fn clone_behavior() -> ComponentCloneBehavior

Called when registering this component, allowing to override clone function (or disable cloning altogether) for this component.

fn register_component_hooks(hooks: &mut ComponentHooks)

👎Deprecated since 0.16.0: Use the individual hook methods instead (e.g., Component::on_add, etc.)

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

fn on_add() -> Option<for<'w> fn(_: DeferredWorld<'w>, _: HookContext)>

Gets the on_add ComponentHook for this Component if one is defined.

fn on_insert() -> Option<for<'w> fn(_: DeferredWorld<'w>, _: HookContext)>

Gets the on_insert ComponentHook for this Component if one is defined.

fn on_replace() -> Option<for<'w> fn(_: DeferredWorld<'w>, _: HookContext)>

Gets the on_replace ComponentHook for this Component if one is defined.

fn on_remove() -> Option<for<'w> fn(_: DeferredWorld<'w>, _: HookContext)>

Gets the on_remove ComponentHook for this Component if one is defined.

fn on_despawn() -> Option<for<'w> fn(_: DeferredWorld<'w>, _: HookContext)>

Gets the on_despawn ComponentHook for this Component if one is defined.

fn map_entities<E>(_this: &mut Self, _mapper: &mut E)

where E: EntityMapper,

Maps the entities on this component using the given EntityMapper. This is used to remap entities in contexts like scenes and entity cloning. When deriving Component, this is populated by annotating fields containing entities with #[entities]

impl<State> Default for TnuaAnimatingState<State>

fn default() -> Self

Returns the “default value” for a type.