Struct MotionBinding 

pub struct MotionBinding<S, T>
where
    T: Animatable,
{ /* private fields */ }

Reusable configuration that maps business states to motion targets.

A binding contains no mutable playback state. Call MotionBinding::state once per consumer, then pass that state to MotionBinding::set_state. Exact (from, to) factories take precedence over the fallback factory.

Examples

use aura_anim_core::{MotionBinding, MotionRuntime, timing::{Duration, Timing}};

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum ButtonState {
    Idle,
    Hovered,
}

let binding = MotionBinding::new(ButtonState::Idle, 0.8_f32)
    .when(ButtonState::Hovered, 1.0)
    .transition(ButtonState::Idle, ButtonState::Hovered, |context| {
        context.tween(Timing::ease_out(120.0))
    })
    .fallback(|context| context.tween(Timing::linear(100.0)));

let mut runtime = MotionRuntime::new();
let (motion, mut state) = binding.create_motion(&mut runtime);
let playback = binding
    .set_state_tracked(
        &mut state,
        ButtonState::Hovered,
        motion,
        &mut runtime,
    )
    .unwrap()
    .unwrap();
runtime.tick(Duration::from_millis(120.0));

assert_eq!(motion.value(&runtime).unwrap(), 1.0);
assert!(runtime.take_events()[0].is_completed_for(playback));

Implementations

impl<S, T> MotionBinding<S, T>

where S: Clone + PartialEq + 'static, T: Animatable,

pub fn new(initial_state: S, initial_target: T) -> MotionBinding<S, T>

Creates a binding with its initial business state and target value.

pub fn when(self, state: S, target: T) -> MotionBinding<S, T>

Adds or replaces the target associated with state.

pub fn transition<A>( self, from: S, to: S, factory: impl Fn(TransitionContext<S, T>) -> A + 'static, ) -> MotionBinding<S, T>

where A: Animation<T>,

Adds or replaces an exact (from, to) transition factory.

The factory may return any concrete Animation; the binding handles type erasure internally.

pub fn fallback<A>( self, factory: impl Fn(TransitionContext<S, T>) -> A + 'static, ) -> MotionBinding<S, T>

where A: Animation<T>,

Sets the factory used when no exact transition is configured.

The factory may return any concrete Animation; the binding handles type erasure internally.

pub const fn initial_state(&self) -> &S

Returns the initial business state.

pub fn target(&self, state: &S) -> Result<&T, MotionBindingError<S>>

Returns the target associated with state.

pub fn state(&self) -> MotionBindingState<S>

Creates independent state tracking for one consumer.

pub fn create_motion( &self, runtime: &mut MotionRuntime, ) -> (Motion<T>, MotionBindingState<S>)

Creates a motion at the initial target and its independent state tracker.

pub fn set_state( &self, binding_state: &mut MotionBindingState<S>, next_state: S, motion: Motion<T>, runtime: &mut MotionRuntime, ) -> Result<bool, MotionBindingError<S>>

Applies next_state to an existing motion.

Returns Ok(false) when the requested state is already current. Use MotionBinding::set_state_tracked when the concrete playback ID is needed for event matching.

pub fn set_state_tracked( &self, binding_state: &mut MotionBindingState<S>, next_state: S, motion: Motion<T>, runtime: &mut MotionRuntime, ) -> Result<Option<PlaybackId>, MotionBindingError<S>>

Applies next_state and returns the concrete playback ID.

Returns Ok(None) when the requested state is already current. Target and transition lookup happen before the motion is modified. The state tracker is updated only after motion.play_tracked succeeds.

Trait Implementations

impl<S, T> Clone for MotionBinding<S, T>

where S: Clone, T: Clone + Animatable,

fn clone(&self) -> MotionBinding<S, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.