Struct AnimationTrack 

pub struct AnimationTrack<T: Lerp> { /* private fields */ }

A sorted collection of keyframes with interpolated value_at(t) lookup.

Keyframes are kept in ascending timestamp order at all times. The easing used for each interval is taken from the preceding keyframe’s easing field; the last keyframe’s easing is never read.

Panics

value_at panics if the track is empty. Always push at least one keyframe before querying.

Implementations

impl<T: Lerp> AnimationTrack<T>

pub fn new() -> Self

Creates an empty track.

pub fn push(self, kf: Keyframe<T>) -> Self

Inserts a keyframe, maintaining timestamp-sorted order.

If a keyframe at the same timestamp already exists it is replaced.

pub fn value_at(&self, t: Duration) -> T

Returns the interpolated value at time t.

• Before the first keyframe: returns the first value (hold).
• After the last keyframe: returns the last value (hold).
• Between two keyframes: uses the preceding keyframe’s easing.

Panics

Panics if the track is empty.

pub fn keyframes(&self) -> &[Keyframe<T>]

Returns all keyframes in sorted (ascending-timestamp) order.

pub fn len(&self) -> usize

Returns the number of keyframes in the track.

pub fn is_empty(&self) -> bool

Returns true if the track has no keyframes.

impl AnimationTrack<f64>

pub fn fade( from: f64, to: f64, start: Duration, end: Duration, easing: Easing, ) -> Self

Creates a two-keyframe track that ramps linearly (or with easing) from from to to between start and end.

• Before start: value is held at from.
• Between start and end: value is interpolated using easing.
• After end: value is held at to.

This is the common-case shorthand for a volume fade, opacity ramp, or position sweep. Equivalent to:

AnimationTrack::new()
    .push(Keyframe::new(Duration::ZERO, 0.0_f64, Easing::Linear))
    .push(Keyframe::new(Duration::from_secs(2), 1.0_f64, Easing::Linear));

pub fn to_ffmpeg_expr(&self, var: &str) -> String

Compiles this track into an FFmpeg expression in terms of var (typically "t", the frame PTS in seconds) that reproduces value_at: the value is held before the first and after the last keyframe, and piecewise-interpolated (with per-segment easing) in between.

For self-animating eval=frame filters (scale, rotate): the same expression is placed in both the preview and export graphs, so the value animates identically without send_command. Commas are \,-escaped for use in a filter argument. Easing::Bezier falls back to linear in the expression.

Trait Implementations

impl<T: Clone + Lerp> Clone for AnimationTrack<T>

fn clone(&self) -> AnimationTrack<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Lerp> Debug for AnimationTrack<T>

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

Formats the value using the given formatter.

impl<T: Lerp> Default for AnimationTrack<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for AnimationTrack<T>

where T: Deserialize<'de> + Lerp,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Serialize for AnimationTrack<T>

where T: Serialize + Lerp,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.