Struct PathTrack 

pub struct PathTrack<T: Copy + LerpAnim> {
    pub start_time: f64,
    pub duration: f32,
    pub easing: OverlayEasing,
    pub repeat: RepeatMode,
    pub path: Arc<dyn Fn(f32) -> T + Send + Sync>,
}

Arbitrary-path animation track. path is a closure called with the eased parameter t in [0, 1] and returns the value for the channel.

Use for any motion that’s more than a straight line: Bezier arcs, polylines, lissajous, custom shapes. The bezier and polyline helpers cover the common cases without the consumer writing the curve math.

The closure is stored in an Arc, so cloning the track is cheap (one atomic bump). The Send + Sync + 'static bound is satisfied by closures that capture only owned/by-value data.

Fields

start_time: f64

Absolute time at which the track starts.

duration: f32

Length of one cycle in seconds.

easing: OverlayEasing

Curve applied to the normalised parameter before the closure runs.

repeat: RepeatMode

What happens past the end of one cycle.

path: Arc<dyn Fn(f32) -> T + Send + Sync>

Evaluator for the path. Called with t in [0, 1] after easing and repeat resolution. The closure is shared via Arc so the track is cheap to clone.

Implementations

impl<T: Copy + LerpAnim> PathTrack<T>

pub fn new( start_time: f64, duration: f32, path: impl Fn(f32) -> T + Send + Sync + 'static, ) -> Self

Construct a track that evaluates the supplied closure at each frame. Defaults to Linear easing and Once repeat; chain with_easing or with_repeat to override.

pub fn with_easing(self, easing: OverlayEasing) -> Self

Builder-style easing setter.

pub fn with_repeat(self, repeat: RepeatMode) -> Self

Builder-style repeat-mode setter.

pub fn sample(&self, time: f64) -> T

Resolve the track at the given absolute time.

impl PathTrack<[f32; 2]>

pub fn bezier( start_time: f64, duration: f32, control_points: [[f32; 2]; 4], ) -> Self

Construct a 2D track that walks a single cubic Bezier from p0 to p3 with control handles p1 and p2. Evaluates the standard Bernstein form at the eased parameter.

pub fn polyline(start_time: f64, duration: f32, points: Vec<[f32; 2]>) -> Self

Construct a 2D track that walks a polyline at uniform per-segment parameter. With N points the path spans N - 1 equal-length parameter segments; consumers wanting arc-length-uniform motion should subdivide their polyline ahead of time.

Trait Implementations

impl<T: Clone + Copy + LerpAnim> Clone for PathTrack<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Copy + LerpAnim> Debug for PathTrack<T>

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

Formats the value using the given formatter.