Struct MusicTime

pub struct MusicTime { /* private fields */ }

Data structure that holds music time and logic when advancing beats and beat intervals.

Implementations

impl MusicTime

pub fn new(bar: u16, beat: u8, beat_interval: u8) -> MusicTime

Create a new MusicTime.

Arguments

• bar - The musical bar.
• beat - The musical beat.
• beat - The musical beat interval, the subdivisions of a beat.

Example

let time = music_timer::music_time::MusicTime::new(1, 1, 1);

Examples found in repository

examples/event_performance.rs (line 45)

fn main() {
    use std::thread;

    // Create the performer_state with bunch of events
    let mut performer_state = PerformanceState {
        is_playing: true,
        performance_end: MusicTime::new(4, 3, 8),
        events: vec![
            MusicTime::new(1, 1, 1),
            MusicTime::new(2, 2, 5),
            MusicTime::new(4, 3, 8),
        ],
        event_head: 0,
    };

    // Run our main loop
    let mut performer = music_timer::create_performance_engine(3, 4, 155.0);

    // We can set the delay to be half the trigger target. This will give
    // us a resonable cycle speed with enough buffer to keep an accurate time.
    // This of course is not needed if the application is managing thread sleeping.
    // The shorter the sleep duration of the thread, the more accurate the
    // time triggering will be. In most cases setting the sleep to 60fps is recommended for
    // < 180bpm @ 4/4.
    let sleep_duration = performer.get_beat_interval_duration() / 2;
    println!("SLEEP_DURATION: {:?}", sleep_duration);

    while performer_state.is_playing {
        // Pass in our performance state to trigger our on event callback functions
        performer.pulse(&mut performer_state);
        thread::sleep(sleep_duration);
    }
}

pub fn get_bar(&self) -> u16

Get the bar number.

Examples found in repository

examples/event_performance.rs (line 23)

    fn on_beat_interval(&mut self, current_time: &MusicTime) {
        let event_triggered =
            self.event_head < self.events.len() && *current_time == self.events[self.event_head];

        // Advance the event head
        if event_triggered {
            self.event_head += 1;
        }

        // Print out esoteric data
        println!(
            "{:02}.{}.{} = {}",
            current_time.get_bar(),
            current_time.get_beat(),
            current_time.get_beat_interval(),
            event_triggered
        );

        // Check to end the performance
        self.is_playing = *current_time < self.performance_end;
    }

pub fn get_beat(&self) -> u8

Get the beat number.

Examples found in repository

examples/event_performance.rs (line 24)

    fn on_beat_interval(&mut self, current_time: &MusicTime) {
        let event_triggered =
            self.event_head < self.events.len() && *current_time == self.events[self.event_head];

        // Advance the event head
        if event_triggered {
            self.event_head += 1;
        }

        // Print out esoteric data
        println!(
            "{:02}.{}.{} = {}",
            current_time.get_bar(),
            current_time.get_beat(),
            current_time.get_beat_interval(),
            event_triggered
        );

        // Check to end the performance
        self.is_playing = *current_time < self.performance_end;
    }

pub fn get_beat_interval(&self) -> u8

Get the interval between the beat.

Examples found in repository

examples/event_performance.rs (line 25)

    fn on_beat_interval(&mut self, current_time: &MusicTime) {
        let event_triggered =
            self.event_head < self.events.len() && *current_time == self.events[self.event_head];

        // Advance the event head
        if event_triggered {
            self.event_head += 1;
        }

        // Print out esoteric data
        println!(
            "{:02}.{}.{} = {}",
            current_time.get_bar(),
            current_time.get_beat(),
            current_time.get_beat_interval(),
            event_triggered
        );

        // Check to end the performance
        self.is_playing = *current_time < self.performance_end;
    }

pub fn advance_beat(&mut self, time_signature: &TimeSignature)

Advance the beat by 1. The bar number will increase if the beat exceeds the TimeSignature numerator.

Arguments

• time_signature - The time signature to constrain the music time by.

Example

use music_timer::{time_signature::TimeSignature, music_time::MusicTime};
let time_signature = TimeSignature::new(4, 4);
let mut a = MusicTime::default();
assert_eq!(a.get_bar() == 1 && a.get_beat() == 1, true);
a.advance_beat(&time_signature);
assert_eq!(a.get_bar() == 1 && a.get_beat() == 2, true);
a.advance_beat(&time_signature);
assert_eq!(a.get_bar() == 1 && a.get_beat() == 3, true);
a.advance_beat(&time_signature);
assert_eq!(a.get_bar() == 1 && a.get_beat() == 4, true);
a.advance_beat(&time_signature);
assert_eq!(a.get_bar() == 2 && a.get_beat() == 1, true);

pub fn advance_beat_interval(&mut self, time_signature: &TimeSignature)

Advance the beat interval by 1. The beat number will increase if the beat interval exceeds the the interval resolution of 8. Then The bar number will increase if the beat exceeds the TimeSignature numerator.

Arguments

• time_signature - The time signature to constrain the music time by.

Example

use music_timer::{time_signature::TimeSignature, music_time::MusicTime};
let time_signature = TimeSignature::new(4, 4);
let mut a = MusicTime::default();
assert_eq!(a, MusicTime::new(1, 1, 1));
a.advance_beat_interval(&time_signature);
assert_eq!(a, MusicTime::new(1, 1, 2));
a.advance_beat_interval(&time_signature);
a.advance_beat_interval(&time_signature);
a.advance_beat_interval(&time_signature);
a.advance_beat_interval(&time_signature);
a.advance_beat_interval(&time_signature);
a.advance_beat_interval(&time_signature);
assert_eq!(a, MusicTime::new(1, 1, 8));
a.advance_beat_interval(&time_signature);
assert_eq!(a, MusicTime::new(1, 2, 1));

Trait Implementations

impl Clone for MusicTime

fn clone(&self) -> MusicTime

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MusicTime

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

Formats the value using the given formatter.

impl Default for MusicTime

fn default() -> MusicTime

Default is MusicTime::new(1,1,1)

impl Ord for MusicTime

fn cmp(&self, other: &MusicTime) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for MusicTime

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for MusicTime

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for MusicTime

impl Eq for MusicTime