Struct Keyframes 

pub struct Keyframes<Value> { /* private fields */ }

A nonempty track starting at zero, with absolute destinations and relative holds.

Exact timestamps return stored values. Intervals use the arriving point’s easing, while holds clone their value without invoking interpolation. Sampling is stateless and uses integer ticks for interval selection before f64 progress.

This is the canonical crate::Keyframes type.

use motion_core::prelude::*;
use motion_core::{
    DisplayList, RasterLimits, ResourceStore, ValidatedDisplayList, MAX_PATH_VERBS,
    MAX_STROKE_VERBS, MAX_SVG_PATH_BYTES, sample_offsets,
};
let track = Keyframes::new(0.0_f64)
    .to(1.seconds(), 10.0, Easing::QuadraticIn)
    .hold(500.milliseconds())
    .to(2.5.seconds(), 20.0, Easing::Linear);
assert_eq!(track.sample(500.milliseconds().after_origin()), 2.5);
assert_eq!(track.sample(1250.milliseconds().after_origin()), 10.0);
assert_eq!(track.sample(2.seconds().after_origin()), 15.0);
assert_eq!(track.duration(), 2.5.seconds());

Implementations

impl<Value> Keyframes<Value>

pub fn new(value: Value) -> Self

Starts with a value at zero. Without further points the finite duration is zero and every sample returns this value.

pub fn to(self, at: Duration, value: Value, easing: Easing) -> Self

Appends a destination at an absolute local time, not an added duration. The easing controls the segment arriving at this value.

Panics

Panics unless at is strictly later than the previous point, including any appended hold. Equal and descending times are not sorted or converted into instantaneous jumps.

pub fn try_to( self, at: Duration, value: Value, easing: Easing, ) -> Result<Self, ValidationError>

Appends a destination like Self::to, reporting non-increasing times.

impl<Value: Clone> Keyframes<Value>

pub fn hold(self, duration: Duration) -> Self

Holds the last value for an additional duration, without interpolation. Zero is a no-op, leaving the last timestamp unchanged.

Panics

Panics on signed tick overflow; see Self::try_hold.

pub fn try_hold(self, duration: Duration) -> Result<Self, ValidationError>

Holds like Self::hold, reporting tick overflow.

Trait Implementations

impl<Value: Clone> Clone for Keyframes<Value>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Value: Debug> Debug for Keyframes<Value>

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

Formats the value using the given formatter.

impl<Value: Interpolate + Send + Sync> FiniteAnimation<Value> for Keyframes<Value>

fn duration(&self) -> Duration

Returns the nonnegative duration.

fn delay(self, offset: Duration) -> Delay<Self>

where Self: Sized,

Delays the animation, holding its initial value before the offset.

fn try_delay(self, offset: Duration) -> Result<Delay<Self>, ValidationError>

where Self: Sized,

Delays like Self::delay, reporting duration overflow.

fn speed(self, factor: f64) -> Speed<Self>

where Self: Sized,

Changes playback speed by a finite, strictly positive factor. Durations round to the nearest tick; a collapsed animation becomes instantaneous.

fn try_speed(self, factor: f64) -> Result<Speed<Self>, ValidationError>

where Self: Sized,

Changes speed like Self::speed, reporting an invalid factor or unrepresentable duration.

fn then<Next: FiniteAnimation<Value>>(self, next: Next) -> Then<Self, Next>

where Self: Sized,

Runs two animations in sequence. The second owns their shared boundary. Duration overflow panics at construction.

fn reverse(self) -> Reverse<Self>

where Self: Sized,

Reverses the animation.

fn repeat(self, count: u32) -> Repeat<Self>

where Self: Sized,

Plays the animation count times. Intermediate boundaries restart; the final boundary holds the target. Zero repeats hold the initial value. Duration overflow panics at construction.

fn ping_pong(self) -> PingPong<Self>

where Self: Sized,

Plays the animation forward then backward, ending at its initial value. Duration overflow panics at construction.

fn boxed_finite(self) -> Arc<dyn FiniteAnimation<Value>>

where Self: Sized + 'static,

Shares a type-erased animation, retaining sampling, duration and combinators.

impl<Value: Interpolate + Send + Sync> Signal<Value> for Keyframes<Value>

fn sample(&self, time: Time) -> Value

Samples without advancing a clock or changing playback state.

fn sample_at(&self, elapsed: Duration) -> Value

Samples elapsed after the time origin, shorthand for sample(elapsed.after_origin()).

fn map<Output, Function>(self, function: Function) -> Map<Self, Function, Value>

where Self: Sized, Function: Fn(Value) -> Output + Send + Sync,

Transforms values without changing timing.

fn zip<OtherValue, Other>(self, other: Other) -> Zip<Self, Other>

where Self: Sized, Other: Signal<OtherValue>,

Samples in parallel; the result is finite only if both inputs are finite.

fn boxed(self) -> Arc<dyn Signal<Value>>

where Self: Sized + 'static,

Shares a type-erased signal.