Struct AnimationController 

pub struct AnimationController {
    pub states: HashMap<String, AnimationState>,
    pub transitions: Vec<AnimationTransition>,
    pub parameters: HashMap<String, AnimParam>,
    pub current_state: String,
    pub transition_progress: Option<TransitionProgress>,
}

ECS component that manages animation state machine logic.

The controller holds a set of named states, transitions between them, and parameters that drive transition conditions. Pair with a SpriteAnimator component and the update_animation_controllers system.

Example

use goud_engine::ecs::components::sprite_animator::AnimationClip;
use goud_engine::ecs::components::animation_controller::{
    AnimationController, TransitionCondition,
};
use goud_engine::core::math::Rect;

let idle_clip = AnimationClip::new(
    vec![Rect::new(0.0, 0.0, 32.0, 32.0)],
    0.1,
);
let run_clip = AnimationClip::new(
    vec![Rect::new(32.0, 0.0, 32.0, 32.0)],
    0.1,
);

let controller = AnimationController::new("idle")
    .with_state("idle", idle_clip)
    .with_state("run", run_clip)
    .with_transition(
        "idle", "run", 0.1,
        vec![TransitionCondition::BoolEquals {
            param: "running".to_string(),
            value: true,
        }],
    );

assert_eq!(controller.current_state_name(), "idle");

Fields

states: HashMap<String, AnimationState>

Named animation states.

transitions: Vec<AnimationTransition>

Transitions between states.

parameters: HashMap<String, AnimParam>

Parameters driving transition conditions.

current_state: String

Name of the currently active state.

transition_progress: Option<TransitionProgress>

Active transition, if any.

Implementations

impl AnimationController

pub fn new(initial_state: &str) -> AnimationController

Creates a new controller with the given initial state name.

The controller starts with no states, transitions, or parameters. Use the builder methods to add them.

Precondition: initial_state should name a state that will be registered via with_state before the controller is used. If the state is never added, lookups such as current_clip will return None.

pub fn with_state(self, name: &str, clip: AnimationClip) -> AnimationController

Adds an animation state with the given name and clip (builder pattern).

pub fn with_transition( self, from: &str, to: &str, blend_duration: f32, conditions: Vec<TransitionCondition>, ) -> AnimationController

Adds a transition between two states (builder pattern).

pub fn set_bool(&mut self, name: &str, value: bool)

Sets a boolean parameter value.

pub fn set_float(&mut self, name: &str, value: f32)

Sets a float parameter value.

pub fn get_param(&self, name: &str) -> Option<&AnimParam>

Returns a reference to the parameter with the given name, if it exists.

pub fn current_state_name(&self) -> &str

Returns the name of the current state.

pub fn current_clip(&self) -> Option<&AnimationClip>

Returns a reference to the current state’s animation clip, if the current state exists in the states map.

Trait Implementations

impl Clone for AnimationController

fn clone(&self) -> AnimationController

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AnimationController

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

Formats the value using the given formatter.

impl Component for AnimationController