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

[mandelwow.git] / main.rs

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
     });