1 /* Copyright (C) 2021-2024 Mt.Zero Software - All Rights Reserved */
7 | | .---------------------------------------------------------.
8 |API| | vg_enter( int argc, char *argv[], const char *window_name |
9 | | '---------------------------------------------------------'
12 |IMP| vg_launch_opt(void) <--.
14 | | |'---------------'
16 | | |'-----------------------------------| 1 |------.
19 | | | |IMP| vg_preload(void)
22 | | | | |IMP| vg_load(void)
24 |IMP| | vg_framebuffer_resize(void) |
26 |IMP| | |.------------- vg_start(void) ---------------'
29 |IMP| | vg_pre_update(void)
32 | | | | | called 0x to 8x
34 |IMP| | '- vg_fixed_update(void)
39 |IMP| | vg_post_update(void)
42 |IMP| | vg_render(void)
48 |IMP| | vg_game_settings_init(void)
49 |IMP| | vg_game_settings_gui( ui_rect panel )
50 | | | | (optional: #define VG_GAME_SETTINGS)
60 const char *vg_get_basepath(void);
62 #include "vg_platform.h"
66 #include "dep/glad/glad.h"
67 #include "dep/sdl/include/SDL.h"
68 #include "vg_stdint.h"
70 void vg_register_exit( void( *funcptr
)(void), const char *name
);
79 //#define VG_SYNC_DEBUG
81 #define VG_SYNC_LOG(STR,...) \
82 vg_info(STR,SDL_GetThreadID(NULL),##__VA_ARGS__)
84 #define VG_SYNC_LOG(...)
88 static void vg_enter( int argc
, char *argv
[], const char *window_name
);
91 static void vg_preload(void);
92 static void vg_load(void);
95 static void vg_launch_opt(void);
96 static void vg_start(void);
98 static void vg_framebuffer_resize(int w
, int h
);
99 static void vg_pre_update(void);
100 static void vg_fixed_update(void);
101 static void vg_post_update(void);
103 static void vg_render(void);
104 static void vg_gui(void);
106 enum quality_profile
{
107 k_quality_profile_high
= 0,
108 k_quality_profile_low
= 1,
109 k_quality_profile_min
= 2
115 SDL_GLContext gl_context
;
116 const char *base_path
;
118 SDL_sem
*sem_loader
; /* allows only one loader at a time */
119 jmp_buf env_loader_exit
;
121 SDL_threadID thread_id_main
,
125 SDL_SpinLock sl_status
;
127 k_engine_status_none
,
128 k_engine_status_load_internal
,
129 k_engine_status_running
,
130 k_engine_status_crashed
134 /* Window information */
140 int display_refresh_rate
,
149 k_vsync_feature_disabled
=0,
150 k_vsync_feature_enabled
=1,
151 k_vsync_feature_enabled_adaptive
=2,
152 k_vsync_feature_error
=3
166 time_fixed_accumulator
,
167 time_fixed_extrapolate
,
170 f32 time_fixed_delta
;
172 u64 time_hp
, time_hp_last
, time_spinning
;
174 int fixed_iterations
;
178 k_engine_stage_update
,
179 k_engine_stage_update_fixed
,
180 k_engine_stage_rendering
,
199 static vg
= { .time_rate
= 1.0, .time_fixed_delta
= VG_TIMESTEP_FIXED
};
200 const char *vg_get_basepath(void){
204 enum vg_thread_purpose
206 k_thread_purpose_nothing
,
207 k_thread_purpose_main
,
208 k_thread_purpose_loader
211 #include "vg_async.h"
213 static enum engine_status
_vg_engine_status(void)
215 SDL_AtomicLock( &vg
.sl_status
);
216 enum engine_status status
= vg
.engine_status
;
217 SDL_AtomicUnlock( &vg
.sl_status
);
222 static enum vg_thread_purpose
vg_thread_purpose(void)
224 SDL_AtomicLock( &vg
.sl_status
);
226 if( vg
.thread_id_main
== SDL_GetThreadID(NULL
) ){
227 SDL_AtomicUnlock( &vg
.sl_status
);
228 return k_thread_purpose_main
;
231 SDL_AtomicUnlock( &vg
.sl_status
);
232 return k_thread_purpose_loader
;
236 static void vg_assert_thread( enum vg_thread_purpose required
){
237 enum vg_thread_purpose purpose
= vg_thread_purpose();
239 if( purpose
!= required
){
240 vg_fatal_error( "thread_purpose must be %u not %u\n", required
, purpose
);
244 static void _vg_opengl_sync_init(void)
246 vg
.sem_loader
= SDL_CreateSemaphore(1);
249 static void vg_checkgl( const char *src_info
);
250 #define VG_STRINGIT( X ) #X
251 #define VG_CHECK_GL_ERR() vg_checkgl( __FILE__ ":L" VG_STRINGIT(__LINE__) )
253 #include "vg_console.h"
254 #include "vg_profiler.h"
256 #include "vg_audio.h"
258 #include "vg_shader.h"
260 #include "vg_input.h"
261 #include "vg_imgui.h"
262 #include "vg_lines.h"
263 #include "vg_rigidbody_view.h"
264 #include "vg_loader.h"
266 #include "vg_settings_menu.h"
269 static struct vg_profile vg_prof_update
= {.name
="update()"},
270 vg_prof_render
= {.name
="render()"},
271 vg_prof_swap
= {.name
="swap"};
273 static void vg_checkgl( const char *src_info
)
278 while( (err
= glGetError()) != GL_NO_ERROR
){
279 vg_error( "(%s) OpenGL Error: #%d\n", src_info
, err
);
284 vg_fatal_error( "OpenGL Error" );
287 static void async_vg_bake_shaders( void *payload
, u32 size
)
289 vg_shaders_compile();
292 static void vg_bake_shaders(void)
294 vg_console_reg_cmd( "reload_shaders", vg_shaders_live_recompile
, NULL
);
295 vg_async_call( async_vg_bake_shaders
, NULL
, 0 );
298 void async_internal_complete( void *payload
, u32 size
)
300 vg_success( "Internal async setup complete\n" );
301 SDL_AtomicLock( &vg
.sl_status
);
303 if( vg
.engine_status
== k_engine_status_crashed
){
304 SDL_AtomicUnlock( &vg
.sl_status
);
308 vg
.engine_status
= k_engine_status_running
;
311 SDL_AtomicUnlock( &vg
.sl_status
);
314 static void _vg_load_full( void *data
){
316 vg_tex2d_replace_with_error( &vg
.tex_missing
);
317 vg_ui
.tex_bg
= vg
.tex_missing
;
320 vg_loader_step( vg_input_init
, vg_input_free
);
321 vg_loader_step( vg_lines_init
, NULL
);
322 vg_loader_step( vg_rb_view_init
, NULL
);
324 vg_loader_step( vg_audio_init
, vg_audio_free
);
326 vg_loader_step( vg_profiler_init
, NULL
);
331 vg_async_call( async_internal_complete
, NULL
, 0 );
334 vg_success( "Client loaded in %fs\n", vg
.time_real
);
337 static void _vg_process_events(void)
339 v2_zero( vg
.mouse_wheel
);
340 v2_zero( vg
.mouse_delta
);
347 while( SDL_PollEvent( &event
) ){
348 if( event
.type
== SDL_KEYDOWN
){
349 if( vg_console
.enabled
&&
350 (vg_ui
.focused_control_type
!= k_ui_control_modal
) ){
351 if( event
.key
.keysym
.sym
== SDLK_ESCAPE
||
352 event
.key
.keysym
.scancode
== SDL_SCANCODE_GRAVE
){
353 vg_console
.enabled
= 0;
356 else if( (event
.key
.keysym
.mod
& KMOD_CTRL
) &&
357 event
.key
.keysym
.sym
== SDLK_n
){
358 _console_suggest_next();
360 else if( (event
.key
.keysym
.mod
& KMOD_CTRL
) &&
361 event
.key
.keysym
.sym
== SDLK_p
){
362 _console_suggest_prev();
365 _ui_proc_key( event
.key
.keysym
);
369 if( event
.key
.keysym
.scancode
== SDL_SCANCODE_GRAVE
){
370 vg_console
.enabled
= 1;
373 _ui_proc_key( event
.key
.keysym
);
377 else if( event
.type
== SDL_MOUSEWHEEL
){
378 vg
.mouse_wheel
[0] += event
.wheel
.preciseX
;
379 vg
.mouse_wheel
[1] += event
.wheel
.preciseY
;
381 else if( event
.type
== SDL_CONTROLLERDEVICEADDED
||
382 event
.type
== SDL_CONTROLLERDEVICEREMOVED
)
384 vg_input_device_event( &event
);
386 else if( event
.type
== SDL_CONTROLLERAXISMOTION
||
387 event
.type
== SDL_CONTROLLERBUTTONDOWN
||
388 event
.type
== SDL_CONTROLLERBUTTONUP
)
390 vg_input_controller_event( &event
);
392 else if( event
.type
== SDL_MOUSEMOTION
){
393 vg
.mouse_delta
[0] += event
.motion
.xrel
;
394 vg
.mouse_delta
[1] += event
.motion
.yrel
;
396 else if( event
.type
== SDL_WINDOWEVENT
){
397 if( event
.window
.event
== SDL_WINDOWEVENT_SIZE_CHANGED
){
399 SDL_GL_GetDrawableSize( vg
.window
, &w
, &h
);
402 vg_warn( "Got a invalid framebuffer size: "
403 "%dx%d... ignoring\n", w
, h
);
409 vg_framebuffer_resize(w
,h
);
412 else if( event
.window
.event
== SDL_WINDOWEVENT_CLOSE
){
413 vg
.window_should_close
= 1;
416 else if( event
.type
== SDL_TEXTINPUT
){
417 ui_proc_utf8( event
.text
.text
);
421 SDL_GetMouseState( &vg
.mouse_pos
[0], &vg
.mouse_pos
[1] );
424 static void _vg_gameloop_update(void)
426 vg_profile_begin( &vg_prof_update
);
428 vg
.engine_stage
= k_engine_stage_update
;
431 /* Fixed update loop */
432 vg
.engine_stage
= k_engine_stage_update_fixed
;
434 vg
.fixed_iterations
= 0;
435 vg_lines
.enabled
= vg_lines
.render
;
436 vg
.time_fixed_accumulator
+= vg
.time_delta
;
438 while( vg
.time_fixed_accumulator
>= vg
.time_fixed_delta
){
440 vg_lines
.enabled
= 0;
441 vg
.time_fixed_accumulator
-= vg
.time_fixed_delta
;
443 vg
.fixed_iterations
++;
444 if( vg
.fixed_iterations
== 8 ){
448 vg_lines
.enabled
= vg_lines
.render
;
449 vg
.time_fixed_extrapolate
= vg
.time_fixed_accumulator
/ vg
.time_fixed_delta
;
451 vg
.engine_stage
= k_engine_stage_update
;
453 vg_profile_end( &vg_prof_update
);
456 static void _vg_gameloop_render(void)
458 vg_profile_begin( &vg_prof_render
);
461 vg
.engine_stage
= k_engine_stage_rendering
;
464 vg_profile_end( &vg_prof_render
);
467 vg
.engine_stage
= k_engine_stage_ui
;
470 if( vg_console
.enabled
){
471 vg_ui
.ignore_input_frames
= 10;
473 vg_ui
.ignore_input_frames
= 0;
474 vg_ui
.wants_mouse
= 1;
479 if( vg
.settings_open
)
484 audio_debug_ui( vg
.pv
);
489 int frame_target
= vg
.display_refresh_rate
;
490 if( vg
.fps_limit
> 0 ) frame_target
= vg
.fps_limit
;
492 (struct vg_profile
*[]){
493 &vg_prof_update
,&vg_prof_render
,&vg_prof_swap
}, 3,
494 (1.0f
/(float)frame_target
)*1000.0f
,
495 (ui_rect
){ 4, 4, 250, 0 }, 0, 0
501 "refresh: %d (%.1fms)\n"
503 "iterations: %d (acc: %.3fms%%)\n"
504 "time: real(%.2f) delta(%.2f) rate(%.2f)\n"
505 " extrap(%.2f) frame(%.2f) spin( "PRINTF_U64
" )\n",
506 vg
.window_x
, vg
.window_y
,
507 frame_target
, (1.0f
/(float)frame_target
)*1000.0f
,
510 (vg
.time_fixed_accumulator
/VG_TIMESTEP_FIXED
)*100.0f
,
511 vg
.time_real
, vg
.time_delta
, vg
.time_rate
,
512 vg
.time_fixed_extrapolate
, vg
.time_frame_delta
,
515 ui_text( (ui_rect
){258,4,900,900},perf
,1,0,k_ui_align_left
);
521 static void aaaaaaaaaaaaaaaaa( ui_rect r
){
522 int frame_target
= vg
.display_refresh_rate
;
523 if( !vg
.vsync
) frame_target
= vg
.fps_limit
;
526 (struct vg_profile
*[]){
527 &vg_prof_update
,&vg_prof_render
,&vg_prof_swap
}, 3,
528 (1.0f
/(f32
)frame_target
)*1500.0f
,
532 ui_fill( (ui_rect
){ r
[0], r
[1] + (r
[3]*2)/3, r
[2], 1 }, ui_colour(k_ui_fg
) );
535 static void vg_changevsync(void){
536 if( vg
.vsync
&& (vg
.vsync_feature
!= k_vsync_feature_error
) ){
537 /* turn on vsync if not enabled */
539 enum vsync_feature requested
= k_vsync_feature_enabled
;
540 if( vg
.vsync
< 0 ) requested
= k_vsync_feature_enabled_adaptive
;
542 if( vg
.vsync_feature
!= requested
){
543 vg_info( "Setting swap interval\n" );
545 int swap_interval
= 1;
546 if( requested
== k_vsync_feature_enabled_adaptive
)
549 if( SDL_GL_SetSwapInterval( swap_interval
) == -1 ){
550 if( requested
== k_vsync_feature_enabled
){
551 vg_error( "Vsync is not supported by your system\n" );
552 vg_warn( "You may be overriding it in your"
553 " graphics control panel.\n" );
556 vg_error( "Adaptive Vsync is not supported by your system\n" );
559 vg
.vsync_feature
= k_vsync_feature_error
;
561 /* TODO: Make popup to notify user that this happened */
564 vg_success( "Vsync enabled (%d)\n", requested
);
565 vg
.vsync_feature
= requested
;
570 if( vg
.vsync_feature
!= k_vsync_feature_disabled
){
571 SDL_GL_SetSwapInterval( 0 );
572 vg
.vsync_feature
= k_vsync_feature_disabled
;
577 static int vg_framefilter( double dt
){
578 if( vg
.fps_limit
< 24 ) vg
.fps_limit
= 24;
579 if( vg
.fps_limit
> 300 ) vg
.fps_limit
= 300;
581 double min_frametime
= 1.0/(double)vg
.fps_limit
;
582 if( vg
.time_frame_delta
< min_frametime
){
583 /* TODO: we can use high res nanosleep on Linux here */
584 double sleep_ms
= (min_frametime
-vg
.time_frame_delta
) * 1000.0;
585 u32 ms
= (u32
)floor( sleep_ms
);
588 if( !vg_loader_availible() )
603 static int _vg_crashscreen(void)
606 if( vg_getkey( SDLK_ESCAPE
) )
610 glBindFramebuffer( GL_FRAMEBUFFER
, 0 );
612 glDisable(GL_DEPTH_TEST
);
613 glBlendFunc(GL_ONE_MINUS_DST_ALPHA
, GL_DST_ALPHA
);
614 glBlendEquation(GL_FUNC_ADD
);
616 glClearColor( 0.15f
+ sinf(vg
.time_real
)*0.1f
, 0.0f
, 0.0f
,1.0f
);
617 glClear( GL_COLOR_BUFFER_BIT
);
618 glViewport( 0,0, vg
.window_x
, vg
.window_y
);
625 static void _vg_gameloop(void){
626 //vg.time_fixed_accumulator = 0.75f * (1.0f/60.0f);
628 vg
.time_hp
= SDL_GetPerformanceCounter();
629 vg
.time_hp_last
= vg
.time_hp
;
633 vg
.time_hp
= SDL_GetPerformanceCounter();
634 u64 udt
= vg
.time_hp
- vg
.time_hp_last
;
635 vg
.time_hp_last
= vg
.time_hp
;
637 double dt
= (double)udt
/ (double)SDL_GetPerformanceFrequency();
639 vg
.time_frame_delta
+= dt
;
640 vg_run_async_checked();
642 if( vg_framefilter( dt
) )
647 enum engine_status status
= _vg_engine_status();
648 if( status
== k_engine_status_running
)
649 vg_profile_begin( &vg_prof_swap
);
651 SDL_GL_SwapWindow( vg
.window
);
653 if( status
== k_engine_status_running
)
654 vg_profile_end( &vg_prof_swap
);
656 vg
.time_real
+= vg
.time_frame_delta
;
657 vg
.time_delta
= vg
.time_frame_delta
* vg
.time_rate
;
658 vg
.time
+= vg
.time_delta
;
660 _vg_process_events();
662 if( vg
.window_should_close
)
665 if( status
== k_engine_status_crashed
){
666 if( _vg_crashscreen() )
670 if( status
== k_engine_status_running
){
671 _vg_gameloop_update();
672 _vg_gameloop_render();
679 if( vg
.loader_ring
> 0.01f
){
680 _vg_loader_render_ring( vg
.loader_ring
);
681 vg
.loader_ring
-= vg
.time_frame_delta
* 0.5f
;
684 vg
.time_frame_delta
= 0.0;
685 vg
.time_spinning
= 0;
689 static void _vg_process_launch_opts_internal( int argc
, char *argv
[] )
692 while( vg_argp( argc
, argv
) ){
693 if( (arg
= vg_opt_arg( 'w' )) ){
694 vg
.window_x
= atoi( arg
);
697 if( (arg
= vg_opt_arg( 'h' )) ){
698 vg
.window_y
= atoi( arg
);
701 if( (arg
= vg_long_opt_arg( "samples" )) ){
702 vg
.samples
= VG_MAX( 0, VG_MIN( 8, atoi( arg
) ) );
705 if( vg_long_opt( "use-libc-malloc" ) ){
706 vg_mem
.use_libc_malloc
= 1;
709 if( vg_long_opt( "high-performance" ) ){
710 vg
.quality_profile
= k_quality_profile_low
;
717 static void _vg_init_window( const char *window_name
)
719 vg_info( "SDL_INIT\n" );
721 if( SDL_Init( SDL_INIT_VIDEO
) != 0 ){
722 vg_error( "SDL_Init failed: %s\n", SDL_GetError() );
727 SDL_InitSubSystem( SDL_INIT_AUDIO
);
729 SDL_InitSubSystem( SDL_INIT_GAMECONTROLLER
);
731 char *exe_basepath
= SDL_GetBasePath();
732 u32 len
= vg_align8( strlen(exe_basepath
)+1 );
733 char *dest
= vg_linear_alloc( vg_mem
.rtmemory
, len
);
734 strcpy( dest
, exe_basepath
);
735 SDL_free( exe_basepath
);
738 vg_info( "Basepath: %s\n", vg
.base_path
);
740 SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER
, 1 );
741 SDL_GL_SetAttribute( SDL_GL_CONTEXT_MAJOR_VERSION
, 3 );
742 SDL_GL_SetAttribute( SDL_GL_CONTEXT_MINOR_VERSION
, 3 );
743 SDL_GL_SetAttribute( SDL_GL_CONTEXT_PROFILE_MASK
,
744 SDL_GL_CONTEXT_PROFILE_CORE
);
746 SDL_GL_SetAttribute( SDL_GL_CONTEXT_RELEASE_BEHAVIOR
,
747 SDL_GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH
);
749 SDL_GL_SetAttribute( SDL_GL_RED_SIZE
, 8 );
750 SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE
, 8 );
751 SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE
, 8 );
752 SDL_GL_SetAttribute( SDL_GL_ALPHA_SIZE
, 8 );
753 SDL_GL_SetAttribute( SDL_GL_STENCIL_SIZE
, 0 );
756 * Get monitor information
758 vg_info( "Getting display count\n" );
759 int display_count
= 0,
763 SDL_DisplayMode video_mode
;
764 if( SDL_GetDesktopDisplayMode( display_index
, &video_mode
) ){
765 vg_error( "SDL_GetDesktopDisplayMode failed: %s\n", SDL_GetError() );
770 vg
.display_refresh_rate
= video_mode
.refresh_rate
;
771 vg
.window_x
= video_mode
.w
;
772 vg
.window_y
= video_mode
.h
;
774 if( vg
.screen_mode
== 2 ){
780 SDL_SetHint( "SDL_VIDEO_X11_XINERAMA", "1" );
781 SDL_SetHint( "SDL_VIDEO_X11_XRANDR", "0" );
782 SDL_SetHint( "SDL_VIDEO_X11_XVIDMODE", "0" );
785 u32 flags
= SDL_WINDOW_OPENGL
| SDL_WINDOW_INPUT_GRABBED
|
786 SDL_WINDOW_RESIZABLE
;
788 if( vg
.screen_mode
== 1 )
789 flags
|= SDL_WINDOW_FULLSCREEN
;
790 else if( vg
.screen_mode
== 0 )
791 flags
|= SDL_WINDOW_FULLSCREEN_DESKTOP
;
793 vg_info( "CreateWindow( %d %d %u )\n", vg
.window_x
, vg
.window_y
, flags
);
795 if((vg
.window
= SDL_CreateWindow( window_name
, 0, 0,
796 vg
.window_x
, vg
.window_y
, flags
))){
797 if( vg
.screen_mode
== 2 )
798 SDL_SetWindowPosition( vg
.window
, video_mode
.w
-vg
.window_x
, 0 );
801 vg_error( "SDL_CreateWindow failed: %s", SDL_GetError() );
805 SDL_RaiseWindow( vg
.window
);
806 SDL_SetWindowMinimumSize( vg
.window
, 1280, 720 );
807 SDL_SetWindowMaximumSize( vg
.window
, 4096, 4096 );
809 vg_info( "CreateContext\n" );
812 if( SDL_IsTextInputActive() ) SDL_StopTextInput();
817 if( (vg
.gl_context
= SDL_GL_CreateContext(vg
.window
) )){
818 SDL_GL_GetDrawableSize( vg
.window
, &vg
.window_x
, &vg
.window_y
);
819 vg_success( "Window created (%dx%d)\n", vg
.window_x
, vg
.window_y
);
822 vg_error( "SDL_GL_CreateContext failed: %s\n", SDL_GetError() );
827 if( !gladLoadGLLoader((GLADloadproc
)SDL_GL_GetProcAddress
) ) {
828 vg_error( "Glad Failed to initialize\n" );
829 SDL_GL_DeleteContext( vg
.gl_context
);
834 const unsigned char* glver
= glGetString( GL_VERSION
);
835 vg_success( "Load setup complete, OpenGL version: %s\n", glver
);
837 SDL_GL_SetSwapInterval(0); /* disable vsync while loading */
839 SDL_DisplayMode dispmode
;
840 if( !SDL_GetWindowDisplayMode( vg
.window
, &dispmode
) ){
841 if( dispmode
.refresh_rate
){
842 vg
.display_refresh_rate
= dispmode
.refresh_rate
;
846 if( vg
.display_refresh_rate
< 25 || vg
.display_refresh_rate
> 300 ){
847 vg
.display_refresh_rate
= 60;
850 vg_info( "Display refresh rate: %d\n", dispmode
.refresh_rate
);
851 if( !vg
.fps_limit
) vg
.fps_limit
= vg
.display_refresh_rate
;
854 static void _vg_terminate(void)
857 _vg_console_write_persistent();
859 SDL_AtomicLock( &vg
.sl_status
);
860 vg
.engine_status
= k_engine_status_none
;
861 SDL_AtomicUnlock( &vg
.sl_status
);
865 vg_success( "If you see this it means everything went.. \"well\".....\n" );
867 SDL_GL_DeleteContext( vg
.gl_context
);
872 static void vg_enter( int argc
, char *argv
[], const char *window_name
){
873 vg_rand_seed( &vg
.rand
, 461 );
874 _vg_process_launch_opts_internal( argc
, argv
);
880 vg_console_reg_var( "vg_fps_limit", &vg
.fps_limit
,
881 k_var_dtype_i32
, VG_VAR_PERSISTENT
);
882 vg_console_reg_var( "vg_vsync", &vg
.vsync
,
883 k_var_dtype_i32
, VG_VAR_PERSISTENT
);
884 vg_console_reg_var( "vg_quality", &vg
.quality_profile
,
885 k_var_dtype_i32
, VG_VAR_PERSISTENT
);
886 vg_console_reg_var( "vg_screen_mode", &vg
.screen_mode
,
887 k_var_dtype_i32
, VG_VAR_PERSISTENT
);
889 vg_console_load_autos();
891 vg_console_reg_cmd( "vg_settings", cmd_vg_settings_toggle
, NULL
);
892 _vg_init_window( window_name
);
895 SDL_SetRelativeMouseMode(1);
897 vg
.thread_id_main
= SDL_GetThreadID(NULL
);
899 /* Opengl-required systems */
903 vg
.engine_status
= k_engine_status_load_internal
;
905 _vg_opengl_sync_init();
906 vg_loader_start( _vg_load_full
, NULL
);
911 static void vg_fatal_error( const char *fmt
, ... )
914 va_start( args
, fmt
);
915 _vg_logx_va( stderr
, NULL
, "fatal", KRED
, fmt
, args
);
918 vg_print_backtrace();
920 SDL_AtomicLock( &vg
.sl_status
);
921 vg
.engine_status
= k_engine_status_crashed
;
922 SDL_AtomicUnlock( &vg
.sl_status
);
924 if( vg_thread_purpose() == k_thread_purpose_loader
){
925 longjmp( vg
.env_loader_exit
, 1 );
928 vg_error( "There is no jump to the error runner thing yet! bai bai\n" );
936 static void vg_fatal_error( const char *fmt
, ... )
939 va_start( args
, fmt
);
940 _vg_logx_va( stderr
, NULL
, "fatal", KRED
, fmt
, args
);
948 * Graphic cards will check these to force it to use the GPU
950 u32 NvOptimusEnablement
= 0x00000001;
951 int AmdPowerXpressRequestHighPerformance
= 1;
955 #endif /* VG_HEADER_H */