tek/engine/time/time_moment.rs

use crate::*;

#[derive(Debug, Clone)]
pub enum Moment2 {
    None,
    Zero,
    Usec(Microsecond),
    Sample(SampleCount),
    Pulse(Pulse),
}

/// A point in time in all time scales (microsecond, sample, MIDI pulse)
#[derive(Debug, Default, Clone)]
pub struct Moment {
    pub timebase: Arc<Timebase>,
    /// Current time in microseconds
    pub usec:   Microsecond,
    /// Current time in audio samples
    pub sample: SampleCount,
    /// Current time in MIDI pulses
    pub pulse:  Pulse,
}

impl Moment {
    pub fn zero (timebase: &Arc<Timebase>) -> Self {
        Self { usec: 0.into(), sample: 0.into(), pulse: 0.into(), timebase: timebase.clone() }
    }
    pub fn from_usec (timebase: &Arc<Timebase>, usec: f64) -> Self {
        Self {
            usec:     usec.into(),
            sample:   timebase.sr.usecs_to_sample(usec).into(),
            pulse:    timebase.usecs_to_pulse(usec).into(),
            timebase: timebase.clone(),
        }
    }
    pub fn from_sample (timebase: &Arc<Timebase>, sample: f64) -> Self {
        Self {
            sample:   sample.into(),
            usec:     timebase.sr.samples_to_usec(sample).into(),
            pulse:    timebase.samples_to_pulse(sample).into(),
            timebase: timebase.clone(),
        }
    }
    pub fn from_pulse (timebase: &Arc<Timebase>, pulse: f64) -> Self {
        Self {
            pulse:    pulse.into(),
            sample:   timebase.pulses_to_sample(pulse).into(),
            usec:     timebase.pulses_to_usec(pulse).into(),
            timebase: timebase.clone(),
        }
    }
    #[inline] pub fn update_from_usec (&self, usec: f64) {
        self.usec.set(usec);
        self.pulse.set(self.timebase.usecs_to_pulse(usec));
        self.sample.set(self.timebase.sr.usecs_to_sample(usec));
    }
    #[inline] pub fn update_from_sample (&self, sample: f64) {
        self.usec.set(self.timebase.sr.samples_to_usec(sample));
        self.pulse.set(self.timebase.samples_to_pulse(sample));
        self.sample.set(sample);
    }
    #[inline] pub fn update_from_pulse (&self, pulse: f64) {
        self.usec.set(self.timebase.pulses_to_usec(pulse));
        self.pulse.set(pulse);
        self.sample.set(self.timebase.pulses_to_sample(pulse));
    }
    #[inline] pub fn format_beat (&self) -> Arc<str> {
        self.timebase.format_beats_1(self.pulse.get()).into()
    }
}