Use nanoseconds for time measurements

1 files changed, 32 insertions, 31 deletions

diff --git a/src/core/src/loop.c b/src/core/src/loop.c
index db2033d..fab79fa 100644
--- a/src/core/src/loop.c
+++ b/src/core/src/loop.c
@@ -51,14 +51,14 @@ i32 nproc(void) {
   return get_nprocs();
 }
 
-void delay( uint64_t ms )
+void delay( uint64_t ns )
 {
 #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
     Sleep( ms );
 #else
     struct timespec ts = {
-      .tv_sec = ms / 1000,
-      .tv_nsec = ms * 1000000
+      .tv_sec = ns / 1000000000,
+      .tv_nsec = ns
     };
     struct timespec rem = {0,0};
     while(nanosleep(&ts, &rem)) {
@@ -66,7 +66,6 @@ void delay( uint64_t ms )
       ts = rem;
       rem = (struct timespec){0,0};
     }
-    //usleep( ms * 1000 );
 #endif
 }
 
@@ -291,34 +290,34 @@ i32 engine_run(Platform* p, StateType initial_state, void* state_arg) {
   StateType state = initial_state;
 
   {
-    f64 state_init_time = get_time();
+    u64 state_init_time = get_time();
     State_init(state, mem, state_arg);
-    INFO("Initializing state \"%s\" took %.1fms", StateTypeStr[state],
-         (get_time() - state_init_time) * 1000.0);
+    INFO("Initializing state \"%s\" took %.1fns", StateTypeStr[state],
+         (get_time() - state_init_time));
   }
 
-  f64 time = get_time();
+  u64 time = get_time();
 
   // Update ticks
   u64 ticks = 0;
 
   StateType (*update_func)(f64, void*) = State_updateFunc(state);
 
-  f64 last_fps_measurement = time;
+  u64 last_fps_measurement = time;
   u64 last_fps_ticks = 0;
 
   /* The target frametime measured in milliseconds */
-  const f64 fps_cap = p->fps_target > 0 ? 1000.0 / (f64)p->fps_target : 0;
+  const u32 fps_cap = p->fps_target > 0 ? 1000000000 / p->fps_target : 0;
 
   /* Main loop */
   do {
     /* frame_start is milliseconds since engine was initialized */
-    const f64 now = get_time();
+    const u64 now = get_time();
 
     /* dt measured in milliseconds */
-    const f64 dt = now - time;
+    const u64 dt = now - time;
 
-    const f64 delta = dt / fps_cap;
+    const f64 delta = (f64)dt / (f64)fps_cap;
 
     time = now;
 
@@ -369,38 +368,39 @@ i32 engine_run(Platform* p, StateType initial_state, void* state_arg) {
       state = next_state;
       update_func = State_updateFunc(state);
       {
-        f64 state_init_time = get_time();
+        u64 state_init_time = get_time();
         State_init(state, mem, retval);
-        INFO("Initializing state \"%s\" took %.1fms", StateTypeStr[state],
-             (get_time() - state_init_time) * 1000.0);
+        INFO("Initializing state \"%s\" took %.1fns", StateTypeStr[state],
+             (get_time() - state_init_time));
       }
     } else {
 
-      // Render
-      const f64 rendertime_begin  = get_time();
+      /* Render */
+      const u64 rendertime_begin  = get_time();
       render_begin(p->window);
       render_present(p->window);
-      const f64 rendertime_dt = get_time() - rendertime_begin;
+      const u64 rendertime_dt = get_time() - rendertime_begin;
 
       /* Regulate FPS */
-      f64 frame_end = get_time();
-      const f64 fps_diff = fps_cap - (frame_end - now);
+      u64 frame_end = get_time();
+      const u64 fps_diff = fps_cap - (frame_end - now);
 
       if (fps_cap >= (frame_end - now)) {
         delay(fps_diff);
       }
 
       /* Print stats */
-      const f64 dt_measurement = frame_end - last_fps_measurement;
+      const u64 dt_measurement = frame_end - last_fps_measurement;
+
       /* only make measurements once a second */
-      if (dt_measurement > 1000.0) {
+      if (dt_measurement > 1000000000) {
 
         printf("  FPS: %.1f"
                "\tticks: %lu"
-               "\tframetime: %.1fms"
-               "\trendertime: %.2fms"
+               "\tframetime: %luns"
+               "\trendertime: %luns"
                "\n"
-            , ((f64)(ticks - last_fps_ticks)) / (dt_measurement / 1000.0)
+            , ((f64)(ticks - last_fps_ticks)) / (dt_measurement / 1000000000.0)
             , ticks
             , dt
             , rendertime_dt
@@ -411,13 +411,11 @@ i32 engine_run(Platform* p, StateType initial_state, void* state_arg) {
       }
     }
 
-
-
-
     ticks++;
   } while(
       !glfwWindowShouldClose(p->window->window)
-      && state != STATE_quit);
+      && state != STATE_quit
+  );
 
   return 0;
 }
@@ -444,7 +442,10 @@ void engine_stop(Platform* p) {
 }
 
 /* Set the maximum framerate */
-void engine_fps_max(Platform* p, u16 cap) { LOG("Setting max fps to %llu", cap); p->fps_target = cap; }
+void engine_fps_max(Platform* p, u16 cap) {
+  LOG("Setting max fps to %llu", cap);
+  p->fps_target = cap;
+}
 
 isize f_get_sz(FILE* f) {
   if (f == NULL) {