Struct EditorPlayer 

pub struct EditorPlayer {
    driver: Driver,
    fps: u32,
    duration_frames: u64,
    in_frame: u64,
    out_frame: u64,
    looping: bool,
}

A frame-indexed playback clock over a fixed-length project.

Time is measured in project frames at fps. The playhead is constrained to [in_frame, out_frame); out of those, in/out points scope playback + export, and looping wraps back to in_frame.

Fields

driver: Driver

fps: u32

duration_frames: u64

in_frame: u64

out_frame: u64

Exclusive end of the playable range (defaults to duration_frames).

looping: bool

Implementations

impl EditorPlayer

pub fn new(fps: u32, duration_frames: u64) -> Self

A realtime player for a project of duration_frames at fps. Starts paused at frame 0 with no in/out trim and looping off.

pub fn fixed(fps: u32, duration_frames: u64) -> Self

A fixed-step player (one frame per tick at rate 1×) for deterministic, reproducible stepping — the export clock.

fn with_driver(driver: Driver, fps: u32, duration_frames: u64) -> Self

pub fn play(&mut self)

Begin advancing. If the playhead is parked at the end of a non-looping range, restart from the in-point first.

pub fn pause(&mut self)

Pause advancing.

pub fn toggle_play(&mut self)

Toggle play/pause.

pub const fn is_playing(&self) -> bool

Whether the clock is currently advancing.

pub fn seek(&mut self, frame: u64)

Seek to an exact frame (clamped to the playable range).

pub fn step(&mut self, delta: i64)

Step delta frames (negative = back) and pause. Clamps at the range boundaries.

pub fn set_rate(&mut self, rate: f32)

Set the playback rate (1.0 = realtime, 2.0 = 2×, 0.5 = half). Negative rates clamp to 0 (reverse playback is a future ticket).

pub const fn rate(&self) -> f32

Current playback rate.

pub fn tick(&mut self, dt: Duration)

Advance the clock by dt (realtime mode) or one fixed step (fixed mode). At the end of the range: loop back to the in-point if looping, otherwise clamp to the last frame and pause. No-op while paused.

pub fn set_in_out(&mut self, a: u64, b: u64)

Set the in/out points (order-independent). The out-point is the exclusive end; the range is clamped to the project and forced non-empty. The playhead is re-clamped into the new range.

pub fn clear_in_out(&mut self)

Clear in/out points back to the full project range.

pub fn set_duration(&mut self, duration_frames: u64)

Update the project length after an edit changed it (split / ripple delete / undo). If the range was untrimmed (out at the old end) the out-point tracks the new length; otherwise it’s clamped. The playhead is re-clamped into the new range.

pub const fn in_frame(&self) -> u64

In-point (inclusive).

pub const fn out_frame(&self) -> u64

Out-point (exclusive).

pub const fn set_looping(&mut self, looping: bool)

Enable / disable looping over the in/out range.

pub const fn looping(&self) -> bool

Whether looping is enabled.

pub fn current_frame(&self) -> u64

The current playhead frame (clamped to the playable range).

pub const fn fps(&self) -> u32

Project frame rate.

pub const fn duration_frames(&self) -> u64

Total project length in frames.

pub const fn driver(&self) -> &Driver

Borrow the underlying [Driver] — e.g. for the zoom engine (ED.16) to sample animation Tracks against the same clock as the playhead.

pub fn progress(&self) -> f32

Normalised progress through the in/out range, 0.0..=1.0.

fn last_frame(&self) -> u64

Last playable frame index (out_frame - 1, never below in_frame).

fn raw_frame(&self) -> u64

Frame implied by the driver’s elapsed time, before range clamping.

fn frame_to_elapsed(&self, frame: u64) -> Duration

Trait Implementations

impl Clone for EditorPlayer

fn clone(&self) -> EditorPlayer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EditorPlayer

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

Formats the value using the given formatter.