Move most timing-related code to new module timer.rs

diff --git a/Cargo.toml b/Cargo.toml
index 00a6fc19a682a13d64fc8233d074d063a0f555da..f327b65330466c59a43c329cc5be7cbbd9309657 100644 (file)
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -22,8 +22,10 @@ rand = "*"
 sdl2 = "*"
 
 [features]
-default = ["rust-rocket", "image"]
+default = ["image", "editor", "logging"]
 min = []
+logging = []
+editor = ["rust-rocket"]
 
 [replace]
 "glutin:0.7.4" = { path = "/home/bernie/src/glutin" }

diff --git a/lib.rs b/lib.rs
index a15ea2b86979c6e8ebd6a73fc1c72468b00362f1..765068fb15529fd1ed61ebb010e8857963460943 100644 (file)
--- a/lib.rs
+++ b/lib.rs
@@ -16,6 +16,7 @@ pub mod shaded_cube;
 pub mod sound;
 pub mod support;
 pub mod text;
+pub mod timer;
 
 pub use bounding_box::BoundingBox;
 pub use cube::Cube;

diff --git a/main.rs b/main.rs
index d5f7378f0c98e52b2fd5b1b622e1154462a2440a..9d89c2c4acc6108c7fd64b469d4eba4c7b4d72d5 100644 (file)
--- a/main.rs
+++ b/main.rs
@@ -5,6 +5,9 @@ extern crate cgmath;
 extern crate glium;
 extern crate glutin;
 
+#[cfg(feature = "rust-rocket")]
+extern crate rust_rocket;
+
 use cgmath::{Euler, Matrix4, Rad, SquareMatrix, Vector3, Vector4, Zero};
 use cgmath::conv::array4x4;
 use glium::{DisplayBuild, Surface};
@@ -13,18 +16,20 @@ use glutin::Event::KeyboardInput;
 use glutin::VirtualKeyCode;
 use mandelwow_lib::*;
 use std::f32::consts::PI;
-use std::time::{Duration, Instant};
+use timer::Timer;
 
 #[cfg(target_os = "emscripten")]
 use std::os::raw::{c_int, c_void};
 
 fn gl_info(display : &glium::Display) {
-    let version = *display.get_opengl_version();
-    let api = match version {
-        glium::Version(glium::Api::Gl, _, _) => "OpenGL",
-        glium::Version(glium::Api::GlEs, _, _) => "OpenGL ES"
-    };
-    println!("{} context verson: {}", api, display.get_opengl_version_string());
+    if cfg!(feature = "logging") {
+        let version = *display.get_opengl_version();
+        let api = match version {
+            glium::Version(glium::Api::Gl, _, _) => "OpenGL",
+            glium::Version(glium::Api::GlEs, _, _) => "OpenGL ES"
+        };
+        println!("{} context verson: {}", api, display.get_opengl_version_string());
+    }
 }
 
 #[cfg(target_os = "emscripten")]
@@ -63,6 +68,12 @@ pub fn set_main_loop_callback<F>(callback : F) where F : FnMut() -> support::Act
 fn main() {
     let mut soundplayer = sound::start();
 
+    let mut rocket = rust_rocket::Rocket::new().unwrap();
+    rocket.get_track_mut("test");
+    rocket.get_track_mut("test2");
+    rocket.get_track_mut("a:test2");
+    let mut current_row = 0;
+
     let display = glutin::WindowBuilder::new()
         .with_dimensions(1280, 720)
         .with_gl_profile(glutin::GlProfile::Core)
@@ -82,9 +93,8 @@ fn main() {
     let bounding_box_program = bounding_box::solid_fill_program(&display);
     let shaded_program = shaded_cube::shaded_program(&display);
 
+    let mut timer = Timer::new();
     let mut camera = support::camera::CameraState::new();
-    let mut t: f32 = 0.0;
-    let mut pause = false;
     let mut bounding_box_enabled = true;
     let mut fullscreen = true;
 
@@ -121,15 +131,10 @@ fn main() {
         }
     }
 
-    let mut frame_cnt = 0;
-    let mut last_report_time = Instant::now();
-    let mut last_report_frame_cnt = 0;
-    let mut accum_draw_time = Duration::new(0, 0);
-    let mut accum_idle_time = Duration::new(0, 0);
-
     let mut last_hit = 0.0f32;
     let mut hit_time = 0.0f32;
     set_main_loop_callback(|| {
+        let t = timer.t;
         let new_hit = sound::hit_event(&mut soundplayer);
         if new_hit > last_hit {
             hit_time = t;
@@ -149,10 +154,8 @@ fn main() {
 
         //println!("t={} w={:?} camera={:?}", t, w, camera.get_pos());
 
-        let time_before_swap = Instant::now();
         let mut frame = display.draw();
         frame.clear_color_and_depth((0.0, 0.0, 0.0, 1.0), 1.0);
-        let time_before_draw = Instant::now();
 
         let rotation = Matrix4::from(
             Euler { x: Rad(t.sin() / 3.), y: Rad(t.sin() / 2.), z: Rad(t / 1.5)});
@@ -193,7 +196,6 @@ fn main() {
         text.draw(&mut frame, &perspview);
 
         frame.finish().unwrap();
-        let time_after_draw = Instant::now();
 
         for ev in display.poll_events() {
             match ev {
@@ -206,13 +208,13 @@ fn main() {
                     bounding_box_enabled ^= true;
                 },
                 KeyboardInput(Pressed, _, Some(VirtualKeyCode::P)) => {
-                    pause ^= true;
+                    timer.pause ^= true;
                 },
                 KeyboardInput(Pressed, _, Some(VirtualKeyCode::PageUp)) => {
-                    t += 0.01;
+                    timer.t += 0.01;
                 },
                 KeyboardInput(Pressed, _, Some(VirtualKeyCode::PageDown)) => {
-                    t -= 0.01;
+                    timer.t -= 0.01;
                 },
                 KeyboardInput(Pressed, _, Some(VirtualKeyCode::F10)) => {
                     screenshot(&display);
@@ -234,30 +236,22 @@ fn main() {
             }
         }
 
-        let now = Instant::now();
-        frame_cnt += 1;
-        accum_idle_time += time_before_draw - time_before_swap;
-        accum_draw_time += time_after_draw - time_before_draw;
-        if now - last_report_time > Duration::from_secs(5) {
-            fn millis(d : Duration) -> f32 {
-                d.as_secs() as f32 * 1e3 + d.subsec_nanos() as f32 / 1e6
+        if let Some(event) = rocket.poll_events() {
+            match event {
+                rust_rocket::Event::SetRow(row) => {
+                    println!("SetRow (row: {:?})", row);
+                    current_row = row;
+                }
+                rust_rocket::Event::Pause(_) => {
+                    let track1 = rocket.get_track("test").unwrap();
+                    println!("Pause (value: {:?}) (row: {:?})", track1.get_value(current_row as f32), current_row);
+                }
+                _ => (),
             }
-            let frames_done = frame_cnt - last_report_frame_cnt;
-            let fps = frames_done as f32 / (now - last_report_time).as_secs() as f32;
-            let avg_draw_time = millis(accum_draw_time / frames_done);
-            let avg_idle_time = millis(accum_idle_time / frames_done);
-            println!("fps={:.1} draw={:.1}ms idle={:.1}ms", fps, avg_draw_time, avg_idle_time);
-
-            last_report_time = now;
-            last_report_frame_cnt = frame_cnt;
-            accum_draw_time = Duration::new(0, 0);
-            accum_idle_time = Duration::new(0, 0);
+            println!("{:?}", event);
         }
 
-        if !pause {
-            // Increment time
-            t += 0.01;
-        }
+        timer.update();
 
         support::Action::Continue
     });

diff --git a/timer.rs b/timer.rs
new file mode 100644 (file)
index 0000000..defc9e8
--- /dev/null
+++ b/timer.rs
@@ -0,0 +1,67 @@
+use std::time::{Duration, Instant};
+
+#[derive(Debug)]
+pub struct Timer {
+    pub t: f32,
+
+    frame: u32,
+
+    last_report_time: Instant,
+    last_report_frame: u32,
+
+    accum_draw_time: Duration,
+    accum_idle_time: Duration,
+
+    pub pause: bool,
+}
+
+impl Timer {
+    pub fn new() -> Self {
+        let now = Instant::now();
+        Timer {
+            t: 0.0,
+            frame: 0,
+            last_report_time: now,
+            last_report_frame: 0,
+            accum_draw_time: Duration::default(),
+            accum_idle_time: Duration::default(),
+            pause: false,
+        }
+    }
+
+    pub fn update(&mut self) {
+        let now = Instant::now();
+        if !self.pause {
+            // Increment time
+            self.t += 0.01;
+            self.frame += 1;
+        }
+        self.maybe_report(now);
+    }
+
+    #[cfg(not(feature = "logging"))]
+    fn maybe_report(&mut self, _: Instant) {}
+
+    #[cfg(feature = "logging")]
+    fn maybe_report(&mut self, now: Instant) {
+        if now - self.last_report_time > Duration::from_secs(5) {
+            self.report(now);
+            self.last_report_time = now;
+            self.last_report_frame = self.frame;
+            self.accum_draw_time = Duration::new(0, 0);
+            self.accum_idle_time = Duration::new(0, 0);
+        }
+    }
+
+    #[cfg(feature = "logging")]
+    fn report(&self, now: Instant) {
+        fn millis(d : Duration) -> f32 {
+            d.as_secs() as f32 * 1e3 + d.subsec_nanos() as f32 / 1e6
+        }
+        let frames_done = self.frame - self.last_report_frame;
+        let fps = frames_done as f32 / (now - self.last_report_time).as_secs() as f32;
+        let avg_draw_time = millis(self.accum_draw_time / frames_done);
+        let avg_idle_time = millis(self.accum_idle_time / frames_done);
+        println!("fps={:.1} draw={:.1}ms idle={:.1}ms", fps, avg_draw_time, avg_idle_time);
+    }
+}