Struct MusicTimerEngine

pub struct MusicTimerEngine { /* private fields */ }

The engine uses all of this crate’s utilities to allow to use of a music performance state system that triggers callbacks. Its aims are to allow for an easy interface for changes in music time.

Implementations

impl MusicTimerEngine

pub fn new(time_signature: TimeSignature, bpm: f32) -> Self

Create a new MusicTimerEngine with a TimeSignature and bpm.

Arguments

• time_signature - The time signature for the performance.
• bpm - The beats per minute used for the performance.

Example

use music_timer::{music_timer_engine::MusicTimerEngine, time_signature::TimeSignature};
let mut performer = MusicTimerEngine::new(TimeSignature::new(3, 4), 155.0);

pub fn pulse<TimerState: MusicTimerState>(&mut self, state: &mut TimerState)

Pulse the engine. The time since the last pulse is used to evaluate if there is a change in music time. It is suggested to call this from a loop.

Arguments

• state - The trait MusicTimerState used for changes in music time callbacks.TimeSignature

Example

use music_timer::{music_timer_engine::{MusicTimerEngine, MusicTimerState}, music_time::MusicTime};
struct PerformanceState;
impl MusicTimerState for PerformanceState {
    fn on_beat_interval(&mut self, current_time: &MusicTime) {
      // Do something on the beat interval
    }
    fn on_beat(&mut self, current_time: &MusicTime) {
        // Do something on the beat
    }
    fn on_bar(&mut self, current_time: &MusicTime) {
        // Do something on the bar
    }
}
let mut performer_state = PerformanceState{};
let mut performer = music_timer::create_performance_engine(3, 4, 155.0);
performer.pulse(&mut performer_state);

Examples found in repository

examples/event_performance.rs (line 68)

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_beat_interval_duration(&self) -> Duration

Gets the duration of time between beat intervals. Handy for sleeping threads.

Example

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 reasonable 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);
std::thread::sleep(sleep_duration);

Examples found in repository

examples/event_performance.rs (line 63)

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_current_time(&self) -> &MusicTime

Gets the current music time of the performance.

pub fn set_music_timer(&mut self, time: MusicTime) -> &mut Self

Sets the current music time.

Arguments

• time - The new music time to set.