X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=vg.h;h=6aeadc9a0032a8c678d2a052bc750f134afae1e8;hb=13737a7a9faa5b31696c711f153b7de4201c404e;hp=141bea392b8c18b16226629f311ab12127b6b99a;hpb=089fba852677a7c7d9269d000f1f811c3ba8a0bf;p=vg.git

diff --git a/vg.h b/vg.h
index 141bea3..6aeadc9 100644
--- a/vg.h
+++ b/vg.h
@@ -45,60 +45,50 @@
 |IMP| |   vg_ui(void)
 |   | |      |
 |   |  '----'
-'___'
-
- .-.
-| ? |
-|   |  .-------------------------------------.
-|API| | vg_fatal_exit_loop( const char *err ) |
-|   |  '-------------------------------------'
-|   |         |
-|   |  .------+.
-|   | |         |
-|   | |         v
-|IMP|  '- vg_framebuffer_resize(void)
 '___'
 
 */
 
-#ifdef VG_RELEASE
- #define VG_STATIC static
-#else
- #define VG_STATIC
-#endif
-
-/* API */
-VG_STATIC void vg_enter( int argc, char *argv[], const char *window_name );
-
-/* Thread 1 */
-VG_STATIC void vg_preload(void);
-VG_STATIC void vg_load(void);
-
-/* Main thread */
-VG_STATIC void vg_launch_opt(void);
-VG_STATIC void vg_start(void);
-
-VG_STATIC void vg_framebuffer_resize(int w, int h);
-VG_STATIC void vg_update(void);
-VG_STATIC void vg_update_fixed(void);
-VG_STATIC void vg_update_post(void);
-
-VG_STATIC void vg_render(void);
-VG_STATIC void vg_ui(void);
-
 #ifndef VG_HEADER_H
   #define VG_HEADER_H
 
+  const char *vg_get_basepath(void);
+
   #include "vg_platform.h"
   #include "vg_mem.h"
 
   #ifndef _WIN32
     #include <execinfo.h>
   #endif
+
+VG_STATIC void vg_print_backtrace(void)
+{
+#ifndef _WIN32
+
+   void *array[20];
+   char **strings;
+   int size, i;
+
+   size = backtrace( array, 20 );
+   strings = backtrace_symbols( array, size );
+
+   if( strings != NULL ){
+      vg_error( "---------------- gnu backtrace -------------\n" );
+
+      for( int i=0; i<size; i++ )
+         vg_info( "%s\n", strings[i] );
+
+      vg_error( "---------------- gnu backtrace -------------\n" );
+   }
+
+   free( strings );
+
+#endif
+}
   
   #ifdef VG_GAME
     #include "dep/glad/glad.h"
-    #include "submodules/SDL/include/SDL.h"
+    #include "dep/sdl/include/SDL.h"
     #include "vg_stdint.h"
     
     void vg_register_exit( void( *funcptr )(void), const char *name );
@@ -116,33 +106,46 @@ VG_STATIC void vg_ui(void);
     #define VG_SYNC_LOG(...)
   #endif
 
-struct vg
-{
+/* API */
+VG_STATIC void vg_enter( int argc, char *argv[], const char *window_name );
+
+/* Thread 1 */
+VG_STATIC void vg_preload(void);
+VG_STATIC void vg_load(void);
+
+/* Main thread */
+VG_STATIC void vg_launch_opt(void);
+VG_STATIC void vg_start(void);
+
+VG_STATIC void vg_framebuffer_resize(int w, int h);
+VG_STATIC void vg_update(void);
+VG_STATIC void vg_update_fixed(void);
+VG_STATIC void vg_update_post(void);
+
+VG_STATIC void vg_render(void);
+VG_STATIC void vg_gui(void);
+
+struct vg{
    /* Engine sync */
    SDL_Window     *window;
    SDL_GLContext  gl_context;
+   const char     *base_path;
 
-   SDL_SpinLock  sl_context;
-   SDL_sem      *sem_allow_exec,
-                *sem_exec_finished,
-                *sem_loader;
+   SDL_sem *sem_loader;        /* allows only one loader at a time */
+   jmp_buf env_loader_exit;
 
    SDL_threadID  thread_id_main,
-                 thread_id_loader,
-                 thread_id_with_opengl_context;
-   int           context_ownership_depth;
-
-   int exec_context;
+                 thread_id_loader;
+   void         *thread_data;
 
-   enum engine_status
-   {
+   SDL_SpinLock sl_status;
+   enum engine_status{
       k_engine_status_none,
+      k_engine_status_load_internal,
       k_engine_status_running,
       k_engine_status_crashed
    }
    engine_status;
-   const char *str_const_engine_err;
-   int         is_loaded;
 
    /* Window information */
    int window_x,
@@ -150,7 +153,16 @@ struct vg
        samples,
        window_should_close;
 
-   float refresh_rate;
+   int display_refresh_rate,
+       fps_limit;             /* 0: use vsync, >0: cap fps to this, no vsync */
+
+   enum vsync_feature{
+      k_vsync_feature_disabled=0,
+      k_vsync_feature_enabled=1,
+      k_vsync_feature_enabled_adaptive=2,
+      k_vsync_feature_error=3
+   }
+   vsync_feature;
 
    double mouse_pos[2];
    v2f mouse_delta,
@@ -159,16 +171,17 @@ struct vg
    /* Runtime */
    double time,
           time_delta,
-          frame_delta,
-          time_real,
-          time_real_last,
           time_rate,
-          accumulator;
+
+          time_fixed_accumulator,
+          time_fixed_extrapolate,
+          time_frame_delta;
+
+   u64 time_hp, time_hp_last, time_spinning;
 
    int fixed_iterations;
 
-   enum engine_stage
-   {
+   enum engine_stage{
       k_engine_stage_none,
       k_engine_stage_update,
       k_engine_stage_update_fixed,
@@ -179,14 +192,18 @@ struct vg
 
    /* graphics */
    m4x4f pv;
-   enum quality_profile
-   {
+   enum quality_profile{
       k_quality_profile_high = 0,
       k_quality_profile_low = 1,
    }
    quality_profile;
+
+   float loader_ring;
 }
 VG_STATIC vg = { .time_rate = 1.0 };
+const char *vg_get_basepath(void){
+   return vg.base_path;
+}
 
 enum vg_thread_purpose
 {
@@ -195,132 +212,33 @@ enum vg_thread_purpose
    k_thread_purpose_loader
 };
 
-VG_STATIC void vg_fatal_exit_loop( const char *error );
+#include "vg_async.h"
 
-/*
- * Checks if the engine is running
- */
-VG_STATIC void _vg_ensure_engine_running(void)
+VG_STATIC enum engine_status _vg_engine_status(void)
 {
-   /* Check if the engine is no longer running */
-   SDL_AtomicLock( &vg.sl_context );
+   SDL_AtomicLock( &vg.sl_status );
    enum engine_status status = vg.engine_status;
-   SDL_AtomicUnlock( &vg.sl_context );
+   SDL_AtomicUnlock( &vg.sl_status );
 
-   if( status != k_engine_status_running ){
-      while(1) {
-         VG_SYNC_LOG( "[%d] No longer running...\n");
-         SDL_Delay(1000);
-      }
-   }
+   return status;
 }
 
 VG_STATIC enum vg_thread_purpose vg_thread_purpose(void)
 {
-   SDL_AtomicLock( &vg.sl_context );
+   SDL_AtomicLock( &vg.sl_status );
 
    if( vg.thread_id_main == SDL_GetThreadID(NULL) ){
-      SDL_AtomicUnlock( &vg.sl_context );
+      SDL_AtomicUnlock( &vg.sl_status );
       return k_thread_purpose_main;
    }
    else{
-      SDL_AtomicUnlock( &vg.sl_context );
+      SDL_AtomicUnlock( &vg.sl_status );
       return k_thread_purpose_loader;
    }
 }
 
-/*
- * Sync execution so that the OpenGL context is switched onto this thread.
- * Anything after this call will be in a valid context.
- */
-VG_STATIC void vg_acquire_thread_sync(void)
-{
-   /* We dont want to do anything if this is the main thread */
-
-   if( vg_thread_purpose() == k_thread_purpose_loader ){
-      VG_SYNC_LOG( "[%d] vg_acquire_thread_sync()\n" );
-      _vg_ensure_engine_running();
-
-      SDL_AtomicLock( &vg.sl_context );
-      if( vg.context_ownership_depth == 0 ){
-         vg.context_ownership_depth ++;
-         vg.exec_context = 1;
-         SDL_AtomicUnlock( &vg.sl_context );
-         
-         /* wait until told we can go */
-         VG_SYNC_LOG( "[%d] Waiting to acuire sync.\n" );
-         SDL_SemWait( vg.sem_allow_exec );
-         
-         _vg_ensure_engine_running();
-
-         SDL_GL_MakeCurrent( vg.window, vg.gl_context );
-         VG_SYNC_LOG( "[%d] granted\n" );
-      }
-      else{
-         vg.context_ownership_depth ++;
-         VG_SYNC_LOG( "[%d] granted\n" );
-         SDL_AtomicUnlock( &vg.sl_context );
-      }
-   }
-}
-
-/*
- * Signify that we are done with the OpenGL context in this thread.
- * Anything after this call will be in an undefined context.
- */
-VG_STATIC void vg_release_thread_sync(void)
-{
-   if( vg_thread_purpose() == k_thread_purpose_loader ){
-      VG_SYNC_LOG( "[%d] vg_release_thread_sync()\n" );
-
-      SDL_AtomicLock( &vg.sl_context );
-      vg.context_ownership_depth --;
-
-      if( vg.context_ownership_depth == 0 ){
-         SDL_AtomicUnlock( &vg.sl_context );
-         VG_SYNC_LOG( "[%d] Releasing context.\n" );
-         SDL_GL_MakeCurrent( NULL, NULL );
-         SDL_SemPost( vg.sem_exec_finished );
-      }
-      else
-         SDL_AtomicUnlock( &vg.sl_context );
-   }
-}
-
-VG_STATIC void _vg_run_synced(void)
-{
-   SDL_AtomicLock( &vg.sl_context );
-
-   if( vg.exec_context != 0 ){
-      VG_SYNC_LOG( "[%d] _vg_run_synced() (%d).\n", vg.exec_context );
-      vg.exec_context = 0;
-      SDL_AtomicUnlock( &vg.sl_context );
-
-      /* allow operations to go */
-      SDL_GL_MakeCurrent( NULL, NULL );
-      SDL_SemPost( vg.sem_allow_exec );
-
-      /* wait for operations to complete */
-      VG_SYNC_LOG( "[%d] Waiting for content.\n" );
-      SDL_SemWait( vg.sem_exec_finished );
-      
-      /* check if we killed the engine */
-      _vg_ensure_engine_running();
-      
-      /* re-engage main thread */
-      VG_SYNC_LOG( "[%d] Re-engaging.\n" );
-      SDL_GL_MakeCurrent( vg.window, vg.gl_context );
-   }
-   else{
-      VG_SYNC_LOG( "[%d] Nothing to do.\n" );
-      SDL_AtomicUnlock( &vg.sl_context );
-   }
-}
-
 VG_STATIC void _vg_opengl_sync_init(void)
 {
-   vg.sem_allow_exec = SDL_CreateSemaphore(0);
-   vg.sem_exec_finished = SDL_CreateSemaphore(0);
    vg.sem_loader = SDL_CreateSemaphore(1);
 }
 
@@ -335,13 +253,15 @@ VG_STATIC void vg_checkgl( const char *src_info );
 #include "vg_tex.h"
 #include "vg_input.h"
 #include "vg_ui.h"
+#include "vg_imgui.h"
 #include "vg_lines.h"
 #include "vg_loader.h"
 #include "vg_opt.h"
 
 /* Diagnostic */
 VG_STATIC struct vg_profile vg_prof_update = {.name="update()"},
-                            vg_prof_render = {.name="render()"};
+                            vg_prof_render = {.name="render()"},
+                            vg_prof_swap   = {.name="swap"};
 
 VG_STATIC void vg_checkgl( const char *src_info )
 {
@@ -354,19 +274,37 @@ VG_STATIC void vg_checkgl( const char *src_info )
    }
 
    if( fail )
-      vg_fatal_exit_loop( "OpenGL Error" );
+      vg_fatal_error( "OpenGL Error" );
+}
+
+VG_STATIC void async_vg_bake_shaders( void *payload, u32 size )
+{
+   vg_shaders_compile();
 }
 
 VG_STATIC void vg_bake_shaders(void)
 {
-   vg_acquire_thread_sync();
    vg_console_reg_cmd( "reload_shaders", vg_shaders_live_recompile, NULL );
+   vg_async_call( async_vg_bake_shaders, NULL, 0 );
+}
 
-   vg_shaders_compile();
-   vg_release_thread_sync();
+void async_internal_complete( void *payload, u32 size )
+{
+   vg_success( "Internal async setup complete\n" );
+   SDL_AtomicLock( &vg.sl_status );
+
+   if( vg.engine_status == k_engine_status_crashed ){
+      SDL_AtomicUnlock( &vg.sl_status );
+      return;
+   }
+   else{
+      vg.engine_status = k_engine_status_running;
+   }
+
+   SDL_AtomicUnlock( &vg.sl_status );
 }
 
-VG_STATIC void _vg_load_full(void)
+VG_STATIC void _vg_load_full( void *data )
 {
    vg_preload();
 
@@ -376,36 +314,63 @@ VG_STATIC void _vg_load_full(void)
    vg_loader_step( vg_audio_init, vg_audio_free );
    vg_loader_step( vg_profiler_init, NULL );
 
+   vg_async_call( async_internal_complete, NULL, 0 );
+
    /* client */
    vg_load();
 }
 
 VG_STATIC void _vg_process_events(void)
 {
-   /* Update timers */
-   vg.time_real_last = vg.time_real;
-   vg.time_real = (double)SDL_GetTicks64() / 1000.0;
-   vg.frame_delta = vg.time_real-vg.time_real_last;
-   
    v2_zero( vg.mouse_wheel );
    v2_zero( vg.mouse_delta );
 
+   /* Update input */
+   vg_process_inputs();
+
    /* SDL event loop */
    SDL_Event event;
    while( SDL_PollEvent( &event ) ){
       if( event.type == SDL_KEYDOWN ){
-         console_proc_key( event.key.keysym );
+         if( vg_console.enabled ){
+            if( event.key.keysym.sym == SDLK_ESCAPE ||
+                event.key.keysym.sym == SDLK_BACKQUOTE ){
+               vg_console.enabled = 0;
+               ui_defocus_all();
+            }
+            else if( (event.key.keysym.mod & KMOD_CTRL) && 
+                      event.key.keysym.sym == SDLK_n ){
+               _console_suggest_next();
+            }
+            else if( (event.key.keysym.mod & KMOD_CTRL ) &&
+                      event.key.keysym.sym == SDLK_p ){
+               _console_suggest_prev();
+            }
+            else{
+               _ui_proc_key( event.key.keysym );
+            }
+         }
+         else{
+            if( event.key.keysym.sym == SDLK_BACKQUOTE ){
+               vg_console.enabled = 1;
+            }
+            else {
+               _ui_proc_key( event.key.keysym );
+            }
+         }
       }
       else if( event.type == SDL_MOUSEWHEEL ){
          vg.mouse_wheel[0] += event.wheel.preciseX;
          vg.mouse_wheel[1] += event.wheel.preciseY;
       }
+      else if( event.type == SDL_CONTROLLERDEVICEADDED ||
+               event.type == SDL_CONTROLLERDEVICEREMOVED )
+      {
+         vg_input_device_event( &event );
+      }
       else if( event.type == SDL_CONTROLLERAXISMOTION ||
                event.type == SDL_CONTROLLERBUTTONDOWN ||
-               event.type == SDL_CONTROLLERBUTTONUP ||
-               event.type == SDL_CONTROLLERDEVICEADDED ||
-               event.type == SDL_CONTROLLERDEVICEREMOVED
-               )
+               event.type == SDL_CONTROLLERBUTTONUP )
       {
          vg_input_controller_event( &event );
       }
@@ -434,15 +399,12 @@ VG_STATIC void _vg_process_events(void)
          }
       }
       else if( event.type == SDL_TEXTINPUT ){
-         console_proc_utf8( event.text.text );
+         ui_proc_utf8( event.text.text );
       }
    }
 
    vg.mouse_pos[0] += vg.mouse_delta[0];
    vg.mouse_pos[1] += vg.mouse_delta[1];
-
-   /* Update input */
-   vg_update_inputs();
 }
 
 VG_STATIC void _vg_gameloop_update(void)
@@ -454,16 +416,17 @@ VG_STATIC void _vg_gameloop_update(void)
 
    /* Fixed update loop */
    vg.engine_stage = k_engine_stage_update_fixed;
-   vg.accumulator += vg.time_delta;
 
    vg.fixed_iterations = 0;
    vg_lines.allow_input = 1;
-   while( vg.accumulator >= (VG_TIMESTEP_FIXED-0.00125) ){
+   vg.time_fixed_accumulator += vg.time_delta;
+
+   while( vg.time_fixed_accumulator >= VG_TIMESTEP_FIXED ){
       vg_update_fixed();
       vg_lines.allow_input = 0;
 
-      vg.accumulator -= VG_TIMESTEP_FIXED;
-      vg.accumulator  = VG_MAX( 0.0, vg.accumulator );
+      vg.time_fixed_accumulator -= VG_TIMESTEP_FIXED;
+      //vg.accumulator  = VG_MAX( 0.0, vg.accumulator );
 
       vg.fixed_iterations ++;
       if( vg.fixed_iterations == 8 ){
@@ -471,6 +434,7 @@ VG_STATIC void _vg_gameloop_update(void)
       }
    }
    vg_lines.allow_input = 1;
+   vg.time_fixed_extrapolate = vg.time_fixed_accumulator / VG_TIMESTEP_FIXED;
 
    vg.engine_stage = k_engine_stage_update;
    vg_update_post();
@@ -481,85 +445,228 @@ VG_STATIC void _vg_gameloop_render(void)
 {
    vg_profile_begin( &vg_prof_render );
 
-   if( vg.is_loaded ){
-      /* render */
-      vg.engine_stage = k_engine_stage_rendering;
-      vg_render();
+   /* render */
+   vg.engine_stage = k_engine_stage_rendering;
+   vg_render();
 
-      /* ui */
-      vg.engine_stage = k_engine_stage_ui;
-      {
-         ui_begin( vg.window_x, vg.window_y );
+   /* ui */
+   vg.engine_stage = k_engine_stage_ui;
+   {
+      ui_prerender();
+      if( vg_console.enabled ){ 
+         vg_ui.ignore_input_frames = 10;
+         vg_gui();
+         vg_ui.ignore_input_frames = 0;
+         vg_ui.wants_mouse = 1;
+         _vg_console_draw();
+      }
+      else vg_gui();
 
-         /* TODO */
-         ui_set_mouse( vg.mouse_pos[0], vg.mouse_pos[1], 0 );
-         
-         vg_profile_drawn( 
-               (struct vg_profile *[]){&vg_prof_update,&vg_prof_render}, 2,
-               (1.0f/(float)vg.refresh_rate)*1000.0f, 
-               (ui_rect){ 4, 4, 250, 0 }, 0
-         );
-
-         if( vg_profiler ){
-            char perf[128];
-            
-            snprintf( perf, 127, 
-                  "x: %d y: %d\n"
-                  "refresh: %.1f (%.1fms)\n"
-                  "samples: %d\n"
-                  "iterations: %d (acc: %.3fms%%)\n",
-                  vg.window_x, vg.window_y, 
-                  vg.refresh_rate, (1.0f/vg.refresh_rate)*1000.0f,
-                  vg.samples, 
-                  vg.fixed_iterations, 
-                  (vg.accumulator/VG_TIMESTEP_FIXED)*100.0f );
-
-            ui_text( (ui_rect){258, 4+24+12,0,0},perf, 1,0);
-         }
+      /* vg tools */
+      audio_debug_ui( vg.pv );
 
-         /* FIXME */
-         audio_debug_ui( vg.pv );
-         vg_ui();
-         _vg_console_draw();
+      ui_postrender();
+#if 0
+      ui_begin( vg.window_x, vg.window_y );
+
+      /* TODO */
+      ui_set_mouse( vg.mouse_pos[0], vg.mouse_pos[1], 0 );
+
+      int frame_target = vg.display_refresh_rate;
+
+      if( vg.fps_limit > 0 ){
+         frame_target = vg.fps_limit;
+      }
+      
+      vg_profile_drawn( 
+            (struct vg_profile *[]){
+               &vg_prof_update,&vg_prof_render,&vg_prof_swap}, 3,
+            (1.0f/(float)frame_target)*1000.0f, 
+            (ui_rect){ 4, 4, 250, 0 }, 0
+      );
+
+      if( vg_profiler ){
+         char perf[256];
          
-         ui_resolve();
-         ui_draw( NULL );
+         snprintf( perf, 255, 
+               "x: %d y: %d\n"
+               "refresh: %d (%.1fms)\n"
+               "samples: %d\n"
+               "iterations: %d (acc: %.3fms%%)\n"
+               "time: real(%.2f) delta(%.2f) rate(%.2f)\n"
+#ifdef _WIN32
+               "      extrap(%.2f) frame(%.2f) spin( %llu )\n",
+#else
+               "      extrap(%.2f) frame(%.2f) spin( %lu )\n",
+#endif
+               vg.window_x, vg.window_y, 
+               frame_target, (1.0f/(float)frame_target)*1000.0f,
+               vg.samples, 
+               vg.fixed_iterations, 
+               (vg.time_fixed_accumulator/VG_TIMESTEP_FIXED)*100.0f,
+               vg.time, vg.time_delta, vg.time_rate,
+               vg.time_fixed_extrapolate, vg.time_frame_delta,
+               vg.time_spinning );
+
+         ui_text( (ui_rect){258, 4+24+12+12,0,0},perf, 1,0);
       }
+
+      /* FIXME */
+      vg_gui();
+      
+      ui_resolve();
+      ui_draw( NULL );
+#endif
    }
 
    vg_profile_end( &vg_prof_render );
 }
 
+VG_STATIC int vg_framefilter( double dt )
+{
+   if( (vg.fps_limit <= 0) && (vg.vsync_feature != k_vsync_feature_error) ){
+      /* turn on vsync if not enabled */
+
+      enum vsync_feature requested = k_vsync_feature_enabled;
+      if( vg.fps_limit < 0 ) requested = k_vsync_feature_enabled_adaptive;
+
+      if( vg.vsync_feature != requested ){
+         vg_info( "Setting swap interval\n" );
+
+         int swap_interval = 1;
+         if( requested == k_vsync_feature_enabled_adaptive ) swap_interval = -1;
+
+         if( SDL_GL_SetSwapInterval( swap_interval ) == -1 ){
+            if( requested == k_vsync_feature_enabled ){
+               vg_error( "Vsync is not supported by your system\n" );
+               vg_warn( "You may be overriding it in your"
+                        " graphics control panel.\n" );
+            }
+            else{
+               vg_error( "Adaptive Vsync is not supported by your system\n" );
+            }
+
+            vg.vsync_feature = k_vsync_feature_error;
+            vg.fps_limit = vg.display_refresh_rate;
+
+            /* TODO: Make popup to notify user that this happened */
+            return 1;
+         }
+         else{
+            vg_success( "Vsync enabled (%d)\n", requested );
+            vg.vsync_feature = requested;
+         }
+      }
+
+      return 0;
+   }
+
+   if( vg.vsync_feature != k_vsync_feature_disabled ){
+      SDL_GL_SetSwapInterval( 0 );
+      vg.vsync_feature = k_vsync_feature_disabled;
+   }
+   
+   if( vg.fps_limit < 25 ) vg.fps_limit = 25;
+   if( vg.fps_limit > 300 ) vg.fps_limit = 300;
+
+   double min_frametime = 1.0/(double)vg.fps_limit;
+   if( vg.time_frame_delta < min_frametime ){
+      /* TODO: we can use high res nanosleep on Linux here */
+      double sleep_ms = (min_frametime-vg.time_frame_delta) * 1000.0;
+      u32 ms = (u32)floor( sleep_ms );
+
+      if( ms ){
+         SDL_Delay( ms );
+      }
+      else{
+         vg.time_spinning ++;
+      }
+
+      return 1;
+   }
+
+   return 0;
+}
+
+VG_STATIC int _vg_crashscreen(void)
+{
+#if 0
+   if( vg_getkey( SDLK_ESCAPE ) )
+      return 1;
+#endif
+
+   glBindFramebuffer( GL_FRAMEBUFFER, 0 );
+   glEnable(GL_BLEND);
+   glDisable(GL_DEPTH_TEST);
+   glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_DST_ALPHA);
+   glBlendEquation(GL_FUNC_ADD);
+
+   glClearColor( 0.15f + sinf(vg.time)*0.1f, 0.0f, 0.0f,1.0f );
+   glClear( GL_COLOR_BUFFER_BIT );
+   glViewport( 0,0, vg.window_x, vg.window_y );
+
+   _vg_render_log();
+
+   return 0;
+}
+
 VG_STATIC void _vg_gameloop(void)
 {
-   vg.accumulator = 0.75f * (1.0f/60.0f);
+   //vg.time_fixed_accumulator = 0.75f * (1.0f/60.0f);
+
+   vg.time_hp = SDL_GetPerformanceCounter();
+   vg.time_hp_last = vg.time_hp;
 
    int post_start = 0;
    while(1){
+   
+      vg.time_hp = SDL_GetPerformanceCounter();
+      u64 udt = vg.time_hp - vg.time_hp_last;
+      vg.time_hp_last = vg.time_hp;
+
+      double dt = (double)udt / (double)SDL_GetPerformanceFrequency();
+
+      vg.time_frame_delta += dt;
+
+      if( vg_framefilter( dt ) )
+         continue;
+
+      vg_profile_begin( &vg_prof_swap );
+      SDL_GL_SwapWindow( vg.window );
+      vg_profile_end( &vg_prof_swap );
+
+      enum engine_status status = _vg_engine_status();
+
+      vg.time_delta = vg.time_frame_delta * vg.time_rate;
+      vg.time += vg.time_delta;
+
+      vg_run_async_checked();
       _vg_process_events();
 
       if( vg.window_should_close )
          break;
-
-      /* scaled time */
-      vg.time_delta = vg.frame_delta * vg.time_rate;
-      vg.time += vg.time_delta;
-      
-      if( vg.is_loaded ){
-         if( !post_start ){
-            vg_start();
-            post_start = 1;
-         }
+         
+      if( status == k_engine_status_crashed ){
+         if( _vg_crashscreen() )
+            break;
       }
       else{
-         _vg_loader_render();
+         if( status == k_engine_status_running ){
+            _vg_gameloop_update();
+            _vg_gameloop_render();
+         }
+         else{
+            _vg_loader_render();
+         }
       }
 
-      _vg_gameloop_update();
-      _vg_gameloop_render();
+      if( vg.loader_ring > 0.01f ){
+         vg.loader_ring -= vg.time_frame_delta * 0.5f;
+         _vg_loader_render_ring( vg.loader_ring );
+      }
 
-      SDL_GL_SwapWindow( vg.window );
-      _vg_run_synced();
+      vg.time_frame_delta = 0.0;
+      vg.time_spinning = 0;
    }
 }
 
@@ -603,6 +710,15 @@ VG_STATIC void _vg_init_window( const char *window_name )
    SDL_InitSubSystem( SDL_INIT_AUDIO );
    SDL_InitSubSystem( SDL_INIT_GAMECONTROLLER );
 
+   char *exe_basepath = SDL_GetBasePath();
+   u32 len = vg_align8( strlen(exe_basepath)+1 );
+   char *dest  = vg_linear_alloc( vg_mem.rtmemory, len );
+   strcpy( dest, exe_basepath );
+   SDL_free( exe_basepath );
+   vg.base_path = dest;
+
+   vg_info( "Basepath: %s\n", vg.base_path );
+
    SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
    SDL_GL_SetAttribute( SDL_GL_CONTEXT_MAJOR_VERSION, 3 );
    SDL_GL_SetAttribute( SDL_GL_CONTEXT_MINOR_VERSION, 3 );
@@ -622,46 +738,35 @@ VG_STATIC void _vg_init_window( const char *window_name )
     * Get monitor information 
     */
    vg_info( "Getting display count\n" );
-   int display_count = 0, display_index = 0, mode_index = 0;
-   if( (display_count = SDL_GetNumVideoDisplays()) < 1 ){
-      vg_error( "SDL_GetNumVideoDisplays returned: %i\n", display_count );
-      exit(0);
-   }
-
+   int display_count = 0, 
+       display_index = 0, 
+       mode_index = 0;
 
 #ifdef VG_DEVWINDOW
-   vg.refresh_rate = 60;
-   vg.window_x = 1000;
-   vg.window_y = 800;
+   vg.window_x = 1600;
+   vg.window_y = 1000;
 #else
-   /* TODO: Allow chosing the modes at startup */
-   vg_info( "Getting default display mode\n" );
-   SDL_DisplayMode vm_ideal = { 0, 0, 0, 0, 0 };
-   if( SDL_GetDisplayMode( display_index, mode_index, &vm_ideal ) != 0 ){
-      vg_error( "SDL_GetDisplayMode failed: %s", SDL_GetError() );
-      exit(0);
-   }
-
-   if( vg.window_x )
-      vm_ideal.w = vg.window_x;
-
-   if( vg.window_y )
-      vm_ideal.h = vg.window_y;
-
 
-   SDL_DisplayMode vm_best;
-   if( !SDL_GetClosestDisplayMode( display_index, &vm_ideal, &vm_best ) ){
-      vg_error( "SDL_GetClosestDisplayMode failed: %s", SDL_GetError() );
+   SDL_DisplayMode video_mode;
+   if( SDL_GetDesktopDisplayMode( display_index, &video_mode ) ){
+      vg_error( "SDL_GetDesktopDisplayMode failed: %s\n", SDL_GetError() );
+      SDL_Quit();
       exit(0);
    }
 
-   vg.refresh_rate = vm_best.refresh_rate;
-   vg.window_x = vm_best.w;
-   vg.window_y = vm_best.h;
+   vg.display_refresh_rate = video_mode.refresh_rate;
+   vg.window_x = video_mode.w;
+   vg.window_y = video_mode.h;
 #endif
 
-   vg_info( "CreateWindow( %d %d @%.2fhz )\n", vg.window_x, vg.window_y,
-                                               vg.refresh_rate );
+#ifndef _WIN32
+	SDL_SetHint( "SDL_VIDEO_X11_XINERAMA", "1" );
+	SDL_SetHint( "SDL_VIDEO_X11_XRANDR", "0" );
+	SDL_SetHint( "SDL_VIDEO_X11_XVIDMODE", "0" );
+#endif
+
+   vg_info( "CreateWindow( %d %d @%dhz )\n", vg.window_x, vg.window_y,
+                                             vg.display_refresh_rate );
 
    /* TODO: Allow selecting closest video mode from launch opts */
    if((vg.window = SDL_CreateWindow( window_name,
@@ -671,8 +776,7 @@ VG_STATIC void _vg_init_window( const char *window_name )
          SDL_WINDOW_BORDERLESS|SDL_WINDOW_OPENGL|SDL_WINDOW_INPUT_GRABBED
       ))){}
 #else
-                                     SDL_WINDOWPOS_UNDEFINED,
-                                     SDL_WINDOWPOS_UNDEFINED,
+                                     0, 0,
                                      vg.window_x, vg.window_y,
 
                                      SDL_WINDOW_FULLSCREEN_DESKTOP | 
@@ -680,7 +784,7 @@ VG_STATIC void _vg_init_window( const char *window_name )
                                      SDL_WINDOW_INPUT_GRABBED 
                                      )))
    {
-      if( SDL_SetWindowDisplayMode( vg.window, &vm_best ) ){
+      if( SDL_SetWindowDisplayMode( vg.window, &video_mode ) ){
          vg_error( "SDL_SetWindowDisplayMode failed: %s", SDL_GetError() );
          SDL_Quit();
          exit(0);
@@ -692,8 +796,13 @@ VG_STATIC void _vg_init_window( const char *window_name )
       exit(0);
    }
 
+   SDL_RaiseWindow( vg.window );
+
    vg_info( "CreateContext\n" );
 
+   /* ????? */
+   if( SDL_IsTextInputActive() ) SDL_StopTextInput();
+
    /* 
     * OpenGL loading 
     */
@@ -717,59 +826,36 @@ VG_STATIC void _vg_init_window( const char *window_name )
    const unsigned char* glver = glGetString( GL_VERSION );
    vg_success( "Load setup complete, OpenGL version: %s\n", glver );
 
-   vg_info( "Setting swap interval\n" );
-
-   if( SDL_GL_SetSwapInterval( -1 ) == -1 ){
-      vg_warn( "Adaptive Vsync not supported\n" );
-
-      if( SDL_GL_SetSwapInterval( 1 ) == -1 ){
-         vg_fatal_exit_loop( "Cannot enable Vsync! You might be overriding it"
-                             " in your graphics control panel.\n" );
-      }
-      else
-         vg_success( "Using vsync\n" );
-   }
-   else
-      vg_success( "Using adaptive Vsync\n" );
+   SDL_GL_SetSwapInterval(0); /* disable vsync while loading */
 
    SDL_DisplayMode dispmode;
    if( !SDL_GetWindowDisplayMode( vg.window, &dispmode ) ){
       if( dispmode.refresh_rate ){
-         vg.refresh_rate = dispmode.refresh_rate;
-         vg_info( "Refresh rate: %d\n", dispmode.refresh_rate );
+         vg.display_refresh_rate = dispmode.refresh_rate;
       }
    }
-}
-
-VG_STATIC void vg_enter( int argc, char *argv[], const char *window_name )
-{
-   _vg_process_launch_opts_internal( argc, argv );
 
-   /* Systems init */
-   vg_alloc_quota();
-   _vg_log_init();
-   _vg_console_init();
-   _vg_init_window( window_name );
-   
-   SDL_SetRelativeMouseMode(1);
-   vg.thread_id_main = SDL_GetThreadID(NULL);
-   
-   /* Opengl-required systems */
-   _vg_ui_init();
-   _vg_loader_init();
+   if( vg.display_refresh_rate < 25 || vg.display_refresh_rate > 300 ){
+      vg.display_refresh_rate = 60;
+   }
 
-   vg.engine_status = k_engine_status_running;
+   vg_info( "Display refresh rate: %d\n", dispmode.refresh_rate );
 
-   _vg_opengl_sync_init();
-    vg_loader_start( _vg_load_full );
-   _vg_gameloop();
+#if defined(_WIN32) || defined(VG_DEVWINDOW)
+   vg.fps_limit = vg.display_refresh_rate;
+#else
+   vg.fps_limit = 0;
+#endif
+}
 
+VG_STATIC void _vg_terminate(void)
+{
    /* Shutdown */
    _vg_console_write_persistent();
 
-   SDL_AtomicLock( &vg.sl_context );
+   SDL_AtomicLock( &vg.sl_status );
    vg.engine_status = k_engine_status_none;
-   SDL_AtomicUnlock( &vg.sl_context );
+   SDL_AtomicUnlock( &vg.sl_status );
 
    _vg_loader_free();
 
@@ -777,116 +863,69 @@ VG_STATIC void vg_enter( int argc, char *argv[], const char *window_name )
 
    SDL_GL_DeleteContext( vg.gl_context );
    SDL_Quit();
+   exit(0);
 }
 
-void vg_print_backtrace(void)
+VG_STATIC void vg_enter( int argc, char *argv[], const char *window_name )
 {
-#ifndef _WIN32
-
-   void *array[20];
-   char **strings;
-   int size, i;
-
-   size = backtrace( array, 20 );
-   strings = backtrace_symbols( array, size );
+   vg_rand_seed( 461 );
+   _vg_process_launch_opts_internal( argc, argv );
 
-   if( strings != NULL ){
-      vg_error( "---------------- gnu backtrace -------------\n" );
+   /* Systems init */
+   vg_alloc_quota();
+   _vg_console_init();
+   
+   vg_console_reg_var( "fps_limit", &vg.fps_limit, k_var_dtype_i32, 0 );
+   _vg_init_window( window_name );
 
-      for( int i=0; i<size; i++ )
-         vg_info( "%s\n", strings[i] );
+   vg_async_init();
+   SDL_SetRelativeMouseMode(1);
 
-      vg_error( "---------------- gnu backtrace -------------\n" );
-   }
+   vg.thread_id_main = SDL_GetThreadID(NULL);
+   
+   /* Opengl-required systems */
+   _vg_ui_init();
+   _vg_loader_init();
 
-   free( strings );
+   vg.engine_status = k_engine_status_load_internal;
 
-#endif
+   _vg_opengl_sync_init();
+    vg_loader_start( _vg_load_full, NULL );
+   _vg_gameloop();
+   _vg_terminate();
 }
 
-/*
- * Immediately transfer away from calling thread into a safe loop, signal for 
- * others to shutdown, then free everything once the user closes the window.
- *
- * FIXME(bug): glfwWindowShouldClose() never returns 1 in windows via wine, ONLY
- *             when calling the program from outside its normal directory.
- */
-VG_STATIC void vg_fatal_exit_loop( const char *error )
+VG_STATIC void vg_fatal_error( const char *fmt, ... )
 {
-   /* 
-    *    https://www.gnu.org/software/libc/manual/html_node/Backtraces.html
-    *    thanks gnu <3
-    *
-    *    TODO: this on windows?
-    */
+   va_list args;
+   va_start( args, fmt );
+   _vg_log_write( stderr, KRED "  fatal" KWHT "| " KRED, fmt, args );
+   va_end( args );
 
    vg_print_backtrace();
-   vg_error( "Fatal error: %s\n", error );
 
-   SDL_AtomicLock( &vg.sl_context );
-   if( vg.engine_status == k_engine_status_none ){
-      SDL_AtomicUnlock( &vg.sl_context );
+   SDL_AtomicLock( &vg.sl_status );
+   vg.engine_status = k_engine_status_crashed;
+   SDL_AtomicUnlock( &vg.sl_status );
 
-      /* TODO: Correct shutdown before other systems */
-      exit(0);
+   if( vg_thread_purpose() == k_thread_purpose_loader ){
+      longjmp( vg.env_loader_exit, 1 );
    }
    else{
-      SDL_AtomicUnlock( &vg.sl_context );
-      
-      vg_acquire_thread_sync();
-
-      SDL_AtomicLock( &vg.sl_context );
-      vg.engine_status = k_engine_status_crashed;
-      vg.str_const_engine_err = error;
-      SDL_AtomicUnlock( &vg.sl_context );
-
-      /* Notify other thread for curtosey */
-      if( vg_thread_purpose() == k_thread_purpose_main ){
-         SDL_AtomicLock( &vg.sl_context );
-
-         if( vg.exec_context != 0 )
-            SDL_SemPost( vg.sem_allow_exec );
-
-         SDL_AtomicUnlock( &vg.sl_context );
-      }
-
-      vg_audio_free();
-
-      while(1){
-         _vg_process_events();
-         if( vg.window_should_close )
-            break;
-
-         if( vg_getkey( SDLK_ESCAPE ) )
-            break;
-
-         glBindFramebuffer( GL_FRAMEBUFFER, 0 );
-         glEnable(GL_BLEND);
-         glDisable(GL_DEPTH_TEST);
-         glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_DST_ALPHA);
-         glBlendEquation(GL_FUNC_ADD);
-
-         glClearColor( 0.15f + sinf(vg.time_real)*0.1f, 0.0f, 0.0f,1.0f );
-         glClear( GL_COLOR_BUFFER_BIT );
-         glViewport( 0,0, vg.window_x, vg.window_y );
-
-         _vg_render_log();
-         SDL_GL_SwapWindow( vg.window );
-      }
-
-      /* Can now shutdown and EXIT */
-      _vg_loader_free();
-      SDL_GL_DeleteContext( vg.gl_context );
-      SDL_Quit();
-      exit(0);
+      vg_error( "There is no jump to the error runner thing yet! bai bai\n" );
+      _vg_terminate();
    }
 }
 
 #else /* VG_GAME */
 
-VG_STATIC void vg_fatal_exit_loop( const char *error )
+#include "vg_log.h"
+VG_STATIC void vg_fatal_error( const char *fmt, ... )
 {
-   vg_error( "Fatal error: %s\n", error );
+   va_list args;
+   va_start( args, fmt );
+   _vg_log_write( stderr, KRED "  fatal" KWHT "| " KRED, fmt, args );
+   va_end( args );
    exit(0);
 }