Struct MotionBinding

Source

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

Expand description

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::{
    binding::MotionBinding,
    runtime::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§

Source §

impl<S, T> MotionBinding<S, T>
where S: Clone + PartialEq + 'static, T: Animatable,

Source

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

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

Source

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

Adds or replaces the target associated with state.

Source

pub fn transition<A>( self, from: S, to: S, factory: impl Fn(TransitionContext<S, T>) -> A + 'static, ) -> Self
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.

Source

pub fn fallback<A>( self, factory: impl Fn(TransitionContext<S, T>) -> A + 'static, ) -> Self
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.

Source

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

Returns the initial business state.

Source

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

Returns the target associated with state.

Source

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

Creates independent state tracking for one consumer.

Source

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

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

Source

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.

Source

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.