simple: Add more set row message filtering

Author: gustafla

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "rust-rocket"
-version = "0.13.0"
+version = "0.13.1"
 authors = [
   "Tim Peters <mail@darksecond.nl>",
   "Lauri Gustafsson <lauri.gustafsson@iki.fi>",

Cargo.toml

@@ -46,44 +46,36 @@ impl TimeSource {
 fn main() {
     let mut rocket = Rocket::new("tracks.bin", 60.).unwrap();
     let mut time_source = TimeSource::new();
-    let mut previous_time = Duration::ZERO;
+    let mut previous_print_time = Duration::ZERO;
 
     'main: loop {
-        // <Handle other event sources such as SDL here>
+        // <Handle other event sources such as SDL or winit here>
 
-        // Get current frame's time
-        let time = time_source.get_time();
-
-        // Keep the rocket tracker in sync.
-        // It's recommended to combine consecutive seek events to a single seek.
-        let mut seek = None;
+        // Handle events from the rocket tracker
         while let Some(event) = rocket.poll_events().ok().flatten() {
             match event {
-                Event::Seek(to) => seek = Some(to),
+                Event::Seek(to) => time_source.seek(to),
                 Event::Pause(state) => time_source.pause(state),
-                Event::NotConnected => /* Alternatively: break the loop here and keep rendering frames */ {
+                Event::NotConnected =>
+                /* Alternatively: break the loop here and keep rendering frames */
+                {
                     std::thread::sleep(Duration::from_millis(10));
                     continue 'main;
                 }
             }
         }
-        // It's recommended to call set_time only when necessary.
-        // This ensures the smoothest scrolling in the editor.
-        match seek {
-            Some(to) => {
-                time_source.seek(to);
-                continue;
-            }
-            None => rocket.set_time(&time),
-        }
+
+        // Get current frame's time and keep the tracker updated
+        let time = time_source.get_time();
+        rocket.set_time(&time);
 
         // <In a full demo you would render a frame here>
 
         // Filter redundant output
-        if time != previous_time {
+        if time != previous_print_time {
             println!("{:?}: test = {}", time, rocket.get_value("test"));
         }
-        previous_time = time;
+        previous_print_time = time;
         thread::sleep(Duration::from_millis(10));
     }
 }

examples/simple.rs

@@ -63,25 +63,23 @@
 //!         let time = music.get_time();
 //!         let row = time_to_row(time);
 //!
-//!         // Keep the rocket tracker in sync
-//!         // It's recommended to combine consecutive seek events to a single seek.
+//!         // Keep the rocket tracker in sync.
+//!         // When using the low level API, it's recommended to combine consecutive seek events to a single seek.
 //!         // This ensures the smoothest scrolling in editor.
 //!         let mut seek = None;
 //!         while let Some(event) = rocket.poll_events()? {
 //!             match event {
 //!                 Event::SetRow(to) => seek = Some(to),
 //!                 Event::Pause(state) => music.pause(state),
-//!                 Event::SaveTracks => {/* Call save_tracks and serialize to a file */}
+//!                 Event::SaveTracks => {/* Call save_tracks and write to a file */}
 //!             }
 //!         }
-//!         // It's recommended to call set_time only when the not seeking.
-//!         match seek {
-//!             Some(to_row) => {
-//!                 music.seek(row_to_time(to_row));
-//!                 continue;
-//!             }
-//!             None => rocket.set_row(row as u32)?,
+//!         // When using the low level API, it's recommended to call set_time only when the not seeking.
+//!         if let Some(seek) = seek {
+//!             music.seek(row_to_time(seek));
+//!             continue;
 //!         }
+//!         rocket.set_row(row as u32)?;
 //!
 //!         // Render frame and read values with Track's get_value function
 //!         let _ = get(&mut rocket, "track0", row);

src/client.rs

@@ -50,28 +50,18 @@
 //!     // Create window, render resources etc...
 //!
 //!     loop {
-//!         // Get current frame's time
-//!         let time = music.get_time();
-//!
-//!         // Keep the rocket tracker in sync.
-//!         // It's recommended to combine consecutive seek events to a single seek.
-//!         let mut seek = None;
+//!         // Handle events from the rocket tracker
 //!         while let Some(event) = rocket.poll_events().ok().flatten() {
 //!             match dbg!(event) {
-//!                 Event::Seek(to) => seek = Some(to),
+//!                 Event::Seek(to) => music.seek(to),
 //!                 Event::Pause(state) => music.pause(state),
 //!                 Event::NotConnected => break,
 //!             }
 //!         }
-//!         // It's recommended to call set_time only when the not seeking.
-//!         // This ensures the smoothest scrolling in editor.
-//!         match seek {
-//!             Some(to) => {
-//!                 music.seek(to);
-//!                 continue;
-//!             }
-//!             None => rocket.set_time(&time),
-//!         }
+//!
+//!         // Get current frame's time and keep the tracker updated
+//!         let time = music.get_time();
+//!         rocket.set_time(&time);
 //!
 //!         // Read values with Rocket's get_value function while rendering the frame
 //!         let _ = rocket.get_value("track0");
@@ -132,7 +122,8 @@ pub enum Event {
     Seek(Duration),
     /// The tracker pauses or unpauses.
     Pause(bool),
-    /// The client is not connected. Next call to `poll_events` will attempt a reconnection.
+    /// The client is not connected. Next calls to [`poll_events`](Rocket::poll_events) will eventually attempt to
+    /// reconnect.
     ///
     /// There are three equally sensible ways to handle this variant:
     ///
@@ -144,22 +135,22 @@ pub enum Event {
     ///
     /// Options 2 and 3 result is a busy wait, e.g. waste a lot of CPU time.
     /// It's better to combine them with `std::thread::sleep` for at least a few milliseconds in order to mitigate that.
-    /// 
-    /// See [module documentation](crate::simple#Examples) and [`poll_events`](Rocket::poll_events).
+    ///
+    /// See `simple.rs` in the `examples`-directory.
     NotConnected,
 }
 
 /// Provides sync values.
 ///
 /// # Usage
 ///
-/// See [module-level documentation](crate::simple#Usage).
+/// See [module documentation](crate::simple#Usage).
 pub struct Rocket<P: AsRef<Path>> {
     path: P,
     bps: f32,
     row: f32,
     #[cfg(not(feature = "player"))]
-    sent_row: u32,
+    tracker_row: u32,
     #[cfg(not(feature = "player"))]
     connected: bool,
     #[cfg(not(feature = "player"))]
@@ -175,7 +166,7 @@ impl<P: AsRef<Path>> Rocket<P> {
     ///
     /// # Without `player` feature
     ///
-    /// Attemps to connect to a rocket tracker, and retries indefinitely every 1s if connection can't be established,
+    /// Attempts to connect to a rocket tracker, and retries indefinitely every 1s if connection can't be established,
     /// during which the function doesn't return and the caller is **blocked**.
     ///
     /// # With `player` feature
@@ -235,7 +226,7 @@ impl<P: AsRef<Path>> Rocket<P> {
             bps: bpm / SECS_PER_MINUTE,
             row: 0.,
             #[cfg(not(feature = "player"))]
-            sent_row: 0,
+            tracker_row: 0,
             #[cfg(not(feature = "player"))]
             connected: true,
             #[cfg(not(feature = "player"))]
@@ -284,12 +275,14 @@ impl<P: AsRef<Path>> Rocket<P> {
         #[cfg(not(feature = "player"))]
         {
             let row = self.row as u32;
-            if self.connected && row != self.sent_row {
-                while let Err(ref e) = self.rocket.set_row(row) {
-                    print_errors(PREFIX, e);
-                    self.connected = false;
+            if self.connected && row != self.tracker_row {
+                match self.rocket.set_row(row) {
+                    Ok(()) => self.tracker_row = row,
+                    Err(ref e) => {
+                        print_errors(PREFIX, e);
+                        self.connected = false;
+                    }
                 }
-                self.sent_row = row;
             }
         }
     }
@@ -371,6 +364,7 @@ impl<P: AsRef<Path>> Rocket<P> {
                 Ok(Some(event)) => {
                     let handled = match event {
                         crate::client::Event::SetRow(row) => {
+                            self.tracker_row = row;
                             let beat = row as f32 / ROWS_PER_BEAT;
                             Event::Seek(Duration::from_secs_f32(beat / self.bps))
                         }