Struct SchedulerHandle 

pub struct SchedulerHandle { /* private fields */ }

A weak handle to the animation scheduler

This is passed to components that need to register animations. It won’t prevent the scheduler from being dropped.

Implementations

impl SchedulerHandle

pub fn register_spring(&self, spring: Spring) -> Option<SpringId>

Register a spring and return its ID

pub fn set_spring_target(&self, id: SpringId, target: f32)

Update a spring’s target

pub fn get_spring_value(&self, id: SpringId) -> Option<f32>

Get current spring value

pub fn is_spring_settled(&self, id: SpringId) -> bool

Check if a spring has settled (at rest at target)

Returns true if the spring exists and has settled, or if the spring doesn’t exist (considered settled since there’s nothing animating).

pub fn remove_spring(&self, id: SpringId)

Remove a spring

pub fn register_keyframe( &self, keyframe: KeyframeAnimation, ) -> Option<KeyframeId>

Register a keyframe animation and return its ID

pub fn get_keyframe_value(&self, id: KeyframeId) -> Option<f32>

Get current keyframe animation value

pub fn get_keyframe_progress(&self, id: KeyframeId) -> Option<f32>

Get keyframe animation progress (0.0 to 1.0)

pub fn is_keyframe_playing(&self, id: KeyframeId) -> bool

Check if keyframe animation is playing

pub fn start_keyframe(&self, id: KeyframeId)

Start a keyframe animation

pub fn stop_keyframe(&self, id: KeyframeId)

Stop a keyframe animation

pub fn remove_keyframe(&self, id: KeyframeId)

Remove a keyframe animation

pub fn register_timeline(&self, timeline: Timeline) -> Option<TimelineId>

Register a timeline and return its ID

pub fn is_timeline_playing(&self, id: TimelineId) -> bool

Check if timeline is playing

pub fn start_timeline(&self, id: TimelineId)

Start a timeline

pub fn stop_timeline(&self, id: TimelineId)

Stop a timeline

pub fn remove_timeline(&self, id: TimelineId)

Remove a timeline

pub fn with_timeline<F, R>(&self, id: TimelineId, f: F) -> Option<R>

where F: FnOnce(&mut Timeline) -> R,

Access a timeline to add entries or get values

The closure receives a mutable reference to the timeline. Returns None if the scheduler is dropped or timeline doesn’t exist.

pub fn is_alive(&self) -> bool

Check if the scheduler is still alive

pub fn register_tick_callback<F>(&self, callback: F) -> Option<TickCallbackId>

where F: FnMut(f32) + Send + Sync + 'static,

Register a tick callback that runs each frame

The callback receives delta time in seconds. Use this to integrate custom systems (like ECS) with the animation scheduler’s background thread.

Returns None if the scheduler has been dropped.

Example

let world = Arc::new(Mutex::new(World::new()));
let world_clone = world.clone();
let id = handle.register_tick_callback(move |dt| {
    let mut world = world_clone.lock().unwrap();
    // Run ECS systems with delta time
    world.run_systems(dt);
});

pub fn remove_tick_callback(&self, id: TickCallbackId)

Remove a tick callback

Trait Implementations

impl AnimationAccess for SchedulerHandle

Implement AnimationAccess for SchedulerHandle

This allows the handle to be used with ValueContext for resolving dynamic animation values at render time.

fn get_spring_value(&self, id: u64, generation: u32) -> Option<f32>

Get a spring’s current value

fn get_keyframe_value(&self, id: u64) -> Option<f32>

Get a keyframe animation’s current value

fn get_timeline_value(&self, _timeline_id: u64, _property: &str) -> Option<f32>

Get a timeline’s current value for a given property

impl Clone for SchedulerHandle

fn clone(&self) -> SchedulerHandle

Returns a duplicate of the value.

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

Performs copy-assignment from source.